Betrachten Sie eine Folge natürlicher Zahlen, für die N in N ^ 2 als Teilzeichenfolge erscheint. A018834

Geben Sie das ndritte Element dieser Sequenz aus.

Regeln

Programm nimmt nur nals Eingabe und gibt nur eine Zahl aus - N.

Die Sequenz kann 0-indiziert oder 1-indiziert sein.

Sequence: 1 5 6 10 25 50 60 76 100 250 376 500 600 625 760 ...
Squares:  1 25 36 100 625 2500 3600 5776 10000 62500 141376 250000 360000 390625 577600 ...

Das ist Code-Golf, also gewinnt der kürzeste Code.

05AB1E , 6 Bytes

1-indiziert

µNNnNå

Probieren Sie es online!

Erläuterung

µ         # loop over increasing N until counter equals input
 N        # push N (for the output)
  Nn      # push N^2
    N     # push N
     å    # push N in N^2
          # if true, increase counter

Perl 6 , 33 31 Bytes

-2 Bytes dank nwellnhof

{(grep {$^a²~~/$a/},1..*)[$_]}

Probieren Sie es online!

Erläuterung:

{                            }  # Anonymous code block that returns
 (                      )[$_]   # The nth index of
  grep {          },1..*        # Filtering from the natural numbers
        $^a²                    # If the square of the number
            ~~/$a/              # Contains the number

JavaScript (ES6), 43 Byte

f=(n,k=0)=>n?f(n-!!(++k*k+'').match(k),k):k

Probieren Sie es online!

Nicht rekursive Version, 47 Bytes

n=>eval("for(k=0;n-=!!(++k*k+'').match(k););k")

Probieren Sie es online!

MathGolf , 8 Bytes (funktioniert für jede Eingabe in der Theorie, aber nur für n<10in der Praxis)

úrgɲï╧§

Probieren Sie es online!

Alternative (arbeitet für n<49in der Praxis und Theorie)

►rgɲï╧§

Der einzige Unterschied besteht darin, dass stattdessen eine Liste mit erstellt wird 10^(input) ich Werten erstelle eine Liste mit10^6 Elementen. Die Ausführung dauert eine Weile, sodass Sie das erste Byte in ein beliebiges anderes 1-Byte-Literal tauschen können, um es zu testen.

Erläuterung

ú          pop(a), push(10**a)
 r         range(0, n)
  g        filter array by...
   É       start block of length 3
    ²      pop a : push(a*a)
     ï     index of current loop
      ╧    pop a, b, a.contains(b)
           Block ends here
       §   get from array

Der Grund, warum diese Lösung keine großen Eingaben verarbeitet, ist, dass ich festgestellt habe, dass die Sequenz weniger als exponentiell wächst, aber mehr als jedes Polynom. Aus diesem Grund habe ich den 10**nOperator verwendet (ich wollte ihn verwenden 2**n, aber bei Eingabe 1 ist er fehlgeschlagen). Das bedeutet, dass ich selbst für kleine Eingaben ein extrem großes Array erstelle, um den größten Teil herauszufiltern und dann eines der ersten Elemente zu verwenden. Es ist extrem verschwenderisch, aber ich konnte keinen anderen Weg finden, dies zu tun, ohne die Byteanzahl zu erhöhen.

Common Lisp, 95 Bytes

(lambda(n)(do((i 0))((= n 0)i)(if(search(format()"~d"(incf i))(format()"~d"(* i i)))(decf n))))

Probieren Sie es online!

Sauber , 83 Bytes

import StdEnv,Text

(!!)[i\\i<-[1..]|indexOf(""<+i)(""<+i^2)>=0]

Probieren Sie es online!

(!!)                               // index into the list of
 [ i                               // i for every
  \\ i <- [1..]                    // i from 1 upwards
  | indexOf (""<+i) (""<+i^2) >= 0 // where i is in the square of i
 ]

Gelee , 6 Bytes

1ẇ²$#Ṫ

1-indiziert.

Probieren Sie es online!

Wie?

Findet den ersten nTeil der Sequenz als Liste und gibt dann den Schwanz aus N.

1ẇ²$#Ṫ - Link: integer, n (>0)
1      - initialise x to 1
    #  - collect the first n matches, incrementing x, where:
   $   -   last two links as a monad:
  ²    -     square x
 ẇ     -     is (x) a substring of (x²)?
       -     (implicitly gets digits for both left & right arguments when integers)
     Ṫ - tail

Wenn 0wir eine natürliche Zahl wären, könnten wir das 1-indizierte Vollprogramm ẇ²$#Ṫfür 5 verwenden.

Japt, 12 11 Bytes

@aJ±X²søY}f

Versuch es

ȲsøY «U´}a

Versuch es

Ruby, 45 bytes

->n,i=1{/#{i+=1}/=~"#{i*i}"&&n-=1while n>0;i}

Try it online!

Java 8, 66 65 63 bytes

n->{int r=0;for(;!(++r*r+"").contains(r+"")||--n>0;);return r;}

-1 byte thanks to @Shaggy.
-2 bytes thanks to @Arnauld.

1-indexed.

Try it online.

Explanation:

n->{                // Method with integer as both parameter and return-type
  int r=0;          //  Result-integer, starting at 0
  for(;             //  Loop as long as:
       !(++r*r+"")  //    (increase result `r` by 1 first with `++r`)
                    //    If the square of the result `r` (as String) 
        .contains(  //    does not contain
          r+"")||   //    the result `r` itself (as String):
       --n>0;);     //     (decrease input `n` by 1 first with `--n`)
                    //     And continue looping if input `n` is not 0 yet
  return r;}        //  Return the result `r`

Clojure, 81 bytes

(fn[n](nth(filter #(clojure.string/includes?(str(* % %))(str %))(range))n))

Probieren Sie es online! (Leider scheint TIO die Standard-String-Bibliothek von Clojure nicht zu unterstützen.)

Wenn Clojure eine kürzere Importsyntax oder eine includes?Methode in der Kernbibliothek hätte, könnte dies tatsächlich etwas wettbewerbsfähig sein. clojure.string/includes?allein ist hier allerdings länger als einige Antworten: /

(defn nth-sq-subs [n]
  (-> ; Filter from an infinite range of numbers the ones where the square of
      ;  the number contains the number itself
    (filter #(clojure.string/includes? (str (* % %)) (str %))
            (range))

    ; Then grab the "nth" result. Inc(rementing) n so 0 is skipped, since apparently
    ;  that isn't in the sequence
    (nth (inc n))))

Da die TIO-Verbindung unterbrochen ist, ist hier ein Testlauf. Die Zahl links ist der Index ( n) und das Ergebnis ( N) ist rechts:

(mapv #(vector % (nth-sq-subs %)) (range 100))
=>
[[0 1]
 [1 5]
 [2 6]
 [3 10]
 [4 25]
 [5 50]
 [6 60]
 [7 76]
 [8 100]
 [9 250]
 [10 376]
 [11 500]
 [12 600]
 [13 625]
 [14 760]
 [15 1000]
 [16 2500]
 [17 3760]
 [18 3792]
 [19 5000]
 [20 6000]
 [21 6250]
 [22 7600]
 [23 9376]
 [24 10000]
 [25 14651]
 [26 25000]
 [27 37600]
 [28 50000]
 [29 60000]
 [30 62500]
 [31 76000]
 [32 90625]
 [33 93760]
 [34 100000]
 [35 109376]
 [36 250000]
 [37 376000]
 [38 495475]
 [39 500000]
 [40 505025]
 [41 600000]
 [42 625000]
 [43 760000]
 [44 890625]
 [45 906250]
 [46 937600]
 [47 971582]
 [48 1000000]
 [49 1093760]
 [50 1713526]
 [51 2500000]
 [52 2890625]
 [53 3760000]
 [54 4115964]
 [55 5000000]
 [56 5050250]
 [57 5133355]
 [58 6000000]
 [59 6250000]
 [60 6933808]
 [61 7109376]
 [62 7600000]
 [63 8906250]
 [64 9062500]
 [65 9376000]
 [66 10000000]
 [67 10050125]
 [68 10937600]
 [69 12890625]
 [70 25000000]
 [71 28906250]
 [72 37600000]
 [73 48588526]
 [74 50000000]
 [75 50050025]
 [76 60000000]
 [77 62500000]
 [78 66952741]
 [79 71093760]
 [80 76000000]
 [81 87109376]
 [82 88027284]
 [83 88819024]
 [84 89062500]
 [85 90625000]
 [86 93760000]
 [87 100000000]
 [88 105124922]
 [89 109376000]
 [90 128906250]
 [91 146509717]
 [92 177656344]
 [93 200500625]
 [94 212890625]
 [95 250000000]
 [96 250050005]
 [97 289062500]
 [98 370156212]
 [99 376000000]]

Dies sollte in der Lage sein, jeden Wert von zu unterstützen n; vorausgesetzt, Sie sind bereit, auf das Ende zu warten (das Auffinden der 50. bis 100. Ganzzahl in der Sequenz dauerte etwa 15 Minuten). Clojure unterstützt Arithmetik mit beliebig großen Ganzzahlen. Sobald also Zahlen sehr groß werden, wird BigInts verwendet.

Holzkohle , 25 Bytes

Ｎθ≔¹ηＷθ«≦⊕η¿№Ｉ×ηηＩη≦⊖θ»Ｉη

Probieren Sie es online! Link ist eine ausführliche Version des Codes. 0-indiziert. Erläuterung:

Ｎθ

Eingabe n.

≔¹η

Beginnen Sie Nbei 1. (Oder dies könnte zu zählen beginnen, ab 0dem die Eingabe 1-indiziert wird.)

Ｗθ«

Wiederholen, bis wir nZahlen in der Sequenz gefunden haben.

≦⊕η

Inkrementieren N.

¿№Ｉ×ηηＩη

Wenn N*Nenthält N, dann ...

≦⊖θ»

... dekrementieren n.

Ｉη

Drucken N.

Meine weiteren Golfversuche wurden dadurch behindert, dass Charcoal a) keine if..thenAusnahme am Ende eines Blocks hat (was 2 Bytes kostet) b) keinen ContainsOperator hat (die Ausgabe von Findoder Countin einen Booleschen Wert umwandelt, den ich von den nerneuten Kosten abziehen konnte 2 Bytes).

Bearbeiten (Antwort auf Kommentare): Python 2, 76 Bytes

Wollte es mit einer nicht rekursiven Methode versuchen. (Neu beim Golfen, alle Tipps wären toll!)

def f(c,n=0):
    while 1:
        if`n`in`n*n`:
            if c<2:return n
            c-=1
        n+=1

Vielen Dank an BMO und Vedant Kandoi!

Haskell, 60 Bytes

([n^2|n<-[1..],elem(show n)$words=<<mapM(:" ")(show$n^2)]!!)

Probieren Sie es online!

      n<-[1..]              -- loop n through all numbers starting with 1
 [n^2|        ,    ]        -- collect the n^2 in a list where
     elem(show n)           -- the string representation of 'n' is in the list
       words ... (show$n^2) -- which is constructed as follows:

            show$n^2        -- turn n^2 into a string, i.e. a list of characters
          (:" ")            -- a point free functions that appends a space
                            -- to a character, e.g.  (:" ") '1' -> "1 "
        mapM                -- replace each char 'c' in the string (n^2) with
                            -- each char from (:" ") c and make a list of all
                            -- combinations thereof.
                            -- e.g. mapM (:" ") "123" -> ["123","12 ","1 3","1  "," 23"," 2 ","  3","   "]
      words=<<              -- split each element into words and flatten to a single list
                            -- example above -> ["123","12","1","3","1","23","2","3"]

(                      !!)  -- pick the element at the given index

Python 2 , 47 43 Bytes

^{-4 Bytes dank Dennis (1 zum rekursiven Aufruf hinzufügen, anstatt zurückzukehren n-1)}

f=lambda c,n=1:c and-~f(c-(`n`in`n*n`),n+1)

Probieren Sie es online!

Explantion / Ungolfed

Rekursive Funktion mit zwei Argumenten $c,n$; $n$ is counts up $1,2,3\dots$ and everytime $n \texttt{ in } n^2$ it decrements $c$. The recursion ends as soon as $c = 0$:

# Enumerating elements of A018834 in reverse starting with 1
def f(counter, number=1):
    # Stop counting
    if counter == 0:
        return 0
    # Number is in A018834 -> count 1, decrement counter & continue
    elif `number` in `number ** 2`:
        return f(counter-1, number+1) + 1
    # Number is not in A018834 -> count 1, continue
    else:
        return f(counter, number+1) + 1

APL (Dyalog Extended), 31 30 bytes

1∘{>⍵:⍺-1⋄(⍺+1)∇⍵-∨/(⍕⍺)⍷⍕⍺×⍺}

Try it online!

0-indexed.

Perl 5 -p, 33 bytes

map{1while++$\**2!~/${\}/}1..$_}{

Try it online!

Lua, 137 123 79 bytes

-thanks @Jo King for 44 bytes

n=io.read()i=0j=0while(i-n<0)do j=j+1i=i+(n.find(j*j,j)and 1or 0)end
print(j*j)

Try it online!

Tcl, 82 bytes

proc S n {while 1 {if {[regexp [incr i] [expr $i**2]]&&[incr j]==$n} {return $i}}}

Try it online!

Tidy, 24 bytes

{x:str(x)in'~.x^2}from N

Try it online!

Returns a lazy list which, when called like a function, returns the nth element in the series.

Explanation

{x:str(x)in'~.x^2}from N
{x:              }from N       select all natural numbers `x` such that
   str(x)                      the string representation of `x`
         in                    is contained in
           '~.x^2              "~" + str(x^2)