Rozważ ciąg liczb naturalnych, dla których N pojawia się jako podłańcuch w N ^ 2. A018834

Wyprowadza nelement th tej sekwencji.

Zasady

Program przyjmuje tylko njako dane wejściowe i wyjściowe tylko jedną liczbę - N.

Sekwencja może być indeksowana 0 lub indeksowana 1.

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 ...

To jest golf golfowy, więc wygrywa najkrótszy kod.

05AB1E , 6 bajtów

1-indeksowany

µNNnNå

Wypróbuj online!

Wyjaśnienie

µ         # 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 bajtów

-2 bajty dzięki nwellnhof

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

Wypróbuj online!

Wyjaśnienie:

{                            }  # 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 bajty

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

Wypróbuj online!

Wersja nierekurencyjna, 47 bajtów

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

Wypróbuj online!

MathGolf , 8 bajtów (działa dla dowolnego wkładu w teorii, ale tylko n<10w praktyce)

úrgɲï╧§

Wypróbuj online!

Alternatywa (działa n<49w praktyce i teorii)

►rgɲï╧§

Jedyną różnicą jest to, że zamiast tworzyć listę z 10^(input)wartościami, tworzę listę z 10^6elementami. Uruchomienie zajmuje trochę czasu, więc możesz zamienić pierwszy bajt na dowolny 1-bajtowy literał, aby go przetestować.

Wyjaśnienie

ú          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

Powodem, dla którego to rozwiązanie nie obsługuje dużych danych wejściowych, jest to, że zauważyłem, że sekwencja rośnie mniej niż wykładniczo, ale więcej niż jakikolwiek wielomian. Właśnie dlatego użyłem 10**noperatora (chciałem użyć, 2**nale nie udało się to dla wejścia 1). Oznacza to, że tworzę niezwykle dużą tablicę nawet dla małych danych wejściowych, aby odfiltrować ogromną większość, a następnie wziąć jeden z pierwszych elementów. Jest to bardzo marnotrawstwo, ale nie mogłem znaleźć innego sposobu, aby to zrobić bez zwiększenia liczby bajtów.

Common Lisp, 95 bajtów

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

Wypróbuj online!

Czysty , 83 bajty

import StdEnv,Text

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

Wypróbuj 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
 ]

Galaretka , 6 bajtów

1ẇ²$#Ṫ

1-indeksowany.

Wypróbuj online!

W jaki sposób?

Znajduje pierwszy nz sekwencji listy, a następnie dostarcza się z ogona 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

Gdybyśmy 0zostali uznani za liczbę naturalną, moglibyśmy zastosować pełny program ẇ²$#Ṫz indeksowaniem 1 dla 5.

Japt, 12 11 bajtów

@aJ±X²søY}f

Spróbuj

ȲsøY «U´}a

Spróbuj

Rubinowy , 45 bajtów

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

Wypróbuj online!

Java 8, 66 65 63 bajtów

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

-1 bajt dzięki @Shaggy .
-2 bajty dzięki @Arnauld .

1-indeksowany.

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online! (Niestety, TIO nie wydaje się obsługiwać standardowej biblioteki ciągów Clojure)

Jeśli Clojure miał krótszą składnię importu lub miał includes?metodę w bibliotece podstawowej, mogłoby to być nieco konkurencyjne. clojure.string/includes?sam jest jednak dłuższy niż niektóre odpowiedzi tutaj: /

(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))))

Ponieważ łącze TIO jest zepsute, oto przebieg próbny. Liczba po lewej to indeks ( n), a wynik ( N) znajduje się po prawej stronie:

(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]]

Powinno to być w stanie wesprzeć dowolną wartość n; pod warunkiem, że jesteś gotów czekać na zakończenie (znalezienie 50 do 100 liczb całkowitych w sekwencji zajęło około 15 minut). Clojure obsługuje dowolnie dużą arytmetykę liczb całkowitych, więc gdy liczby stają się ogromne, zaczyna używać BigInts.

Węgiel , 25 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. 0-indeksowane. Wyjaśnienie:

Ｎθ

Wejście n.

≔¹η

Zacznij Nod 1. (Lub może to zacząć liczyć, od 0czego wejście 1-indeksowane).

Ｗθ«

Powtarzaj, dopóki nie znajdziemy nliczb w sekwencji.

≦⊕η

Przyrost N.

¿№Ｉ×ηηＩη

Jeśli N*Nzawiera N, to ...

≦⊖θ»

... zmniejszenie n.

Ｉη

Drukuj N.

Moje próby gry w golfa były dalej utrudnione przez węgiel a) brak posiadania if..thenwyjątku na końcu bloku (który kosztuje 2 bajty) b) brak Containsoperatora (przekształcenie wyniku Findlub Countw wartość logiczną, którą mógłbym odjąć od nkosztów ponownie 2 bajty).

Edycja (odpowiedź na komentarze): Python 2, 76 bajtów

Chciałem wypróbować metodę nierekurencyjną. (Nowy w golfie, wszelkie wskazówki byłyby świetne!)

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

Dzięki zarówno BMO, jak i Vedant Kandoi!

Haskell, 60 bajtów

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

Wypróbuj 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 bajtów

^{-4 bajty dzięki Dennisowi (dodanie 1 do wywołania rekurencyjnego zamiast powrotu n-1)}

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

Wypróbuj online!

Explantion / Ungolfed

$c,n$$n$$1,2,3\dots$$n \texttt{ in } n^2$$c$$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 bajtów

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

Wypróbuj online!

0-indeksowane.

Perl 5 -p , 33 bajtów

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

Wypróbuj online!

Lua , 137 123 79 bajtów

-dziękuje @Jo King za 44 bajty

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)

Wypróbuj online!

Tcl , 82 bajty

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

Wypróbuj online!

Tidy , 24 bajty

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

Wypróbuj online!

Zwraca leniwą listę, która wywołana jak funkcja zwraca n element th z serii.

Wyjaśnienie

{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)