Hãy xem xét một chuỗi các số tự nhiên mà N xuất hiện dưới dạng một chuỗi con trong N ^ 2. A018834

Xuất nphần tử thứ của chuỗi này.

Quy tắc

Chương trình chỉ lấy nlàm đầu vào và đầu ra chỉ một số - N.

Trình tự có thể là 0 chỉ mục hoặc 1 chỉ mục.

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

Đây là mã golf nên mã ngắn nhất sẽ thắng.

05AB1E , 6 byte

1 chỉ mục

µNNnNå

Hãy thử trực tuyến!

Giải trình

µ         # 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 byte

-2 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Giải trình:

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

Hãy thử trực tuyến!

Phiên bản không đệ quy, 47 byte

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

Hãy thử trực tuyến!

MathGolf , 8 byte (hoạt động cho mọi đầu vào trong lý thuyết, nhưng chỉ n<10trong thực tế)

úrgɲï╧§

Hãy thử trực tuyến!

Thay thế (hoạt động n<49trong thực tế và lý thuyết)

►rgɲï╧§

Sự khác biệt duy nhất là thay vì tạo một danh sách với 10^(input)các giá trị, tôi tạo một danh sách với 10^6các mục. Điều này cần một chút thời gian để chạy, vì vậy bạn có thể hoán đổi byte đầu tiên sang bất kỳ chữ 1 byte nào khác để kiểm tra nó.

Giải trình

ú          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

Lý do tại sao giải pháp này không xử lý đầu vào lớn là vì tôi nhận thấy rằng chuỗi tăng trưởng ít hơn theo cấp số nhân, nhưng nhiều hơn bất kỳ đa thức nào. Đó là lý do tại sao tôi sử dụng 10**ntoán tử (tôi muốn sử dụng 2**nnhưng không thành công cho đầu vào 1). Điều đó có nghĩa là tôi tạo ra một mảng cực lớn ngay cả đối với các đầu vào nhỏ, chỉ để lọc phần lớn của nó, và sau đó lấy một trong các phần tử đầu tiên. Điều đó thật lãng phí, nhưng tôi không thể tìm ra cách nào khác để làm điều đó mà không tăng số byte.

Lisp thông thường, 95 byte

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

Hãy thử trực tuyến!

Sạch , 83 byte

import StdEnv,Text

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

Hãy thử trực tuyến!

(!!)                               // 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
 ]

Thạch , 6 byte

1ẇ²$#Ṫ

1 chỉ mục.

Hãy thử trực tuyến!

Làm sao?

Tìm đầu tiên ncủa chuỗi dưới dạng một danh sách và sau đó mang lại đuôi , 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

Nếu 0được coi là số tự nhiên, chúng ta có thể sử dụng chương trình đầy đủ 1 chỉ mục ẇ²$#Ṫcho 5.

Japt, 12 11 byte

@aJ±X²søY}f

Thử nó

ȲsøY «U´}a

Thử nó

Ruby , 45 byte

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

Hãy thử trực tuyến!

Java 8, 66 65 63 byte

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

-1 byte nhờ @Shaggy .
-2 byte nhờ @Arnauld .

1 chỉ mục.

Hãy thử trực tuyến.

Giải trình:

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 byte

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

Hãy thử trực tuyến! (Thật không may, TIO dường như không hỗ trợ thư viện chuỗi tiêu chuẩn của Clojure)

Nếu Clojure có cú pháp nhập ngắn hơn hoặc có một includes?phương thức trong thư viện lõi, thì điều này thực sự có thể cạnh tranh. clojure.string/includes?một mình dài hơn một số câu trả lời ở đây: /

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

Vì liên kết TIO bị hỏng, đây là một lần chạy thử. Số ở bên trái là chỉ mục ( n) và kết quả ( N) ở bên phải:

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

Điều này sẽ có thể hỗ trợ bất kỳ giá trị nào của n; cung cấp cho bạn sẵn sàng chờ đợi nó kết thúc (việc tìm số nguyên thứ 50 đến 100 trong chuỗi mất khoảng 15 phút). Clojure hỗ trợ số học số nguyên lớn tùy ý, vì vậy một khi số bắt đầu trở nên lớn, nó bắt đầu sử dụng BigInts.

Than , 25 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉ số 0. Giải trình:

Ｎθ

Đầu vào n.

≔¹η

Bắt đầu Ntừ 1. (Hoặc, điều này có thể bắt đầu đếm từ 0đó sẽ làm cho đầu vào 1 được lập chỉ mục.)

Ｗθ«

Lặp lại cho đến khi chúng tôi đã tìm thấy nsố trong chuỗi.

≦⊕η

Tăng N.

¿№Ｉ×ηηＩη

Nếu N*Ncó N, thì ...

≦⊖θ»

... giảm giá n.

Ｉη

In N.

Những nỗ lực của tôi trong việc chơi gôn này đã bị cản trở bởi Char than a) không có if..thenngoại trừ ở cuối một khối (tốn 2 byte) b) không có Containstoán tử (chuyển đổi đầu ra Findhoặc Countthành boolean mà tôi có thể trừ đi nchi phí một lần nữa 2 byte).

Chỉnh sửa (phản hồi ý kiến): Python 2, 76 byte

Muốn thử cho một phương pháp không đệ quy. (Mới chơi golf, bất kỳ lời khuyên nào cũng sẽ rất tuyệt!)

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

Cảm ơn cả BMO và Vedant Kandoi!

Haskell, 60 byte

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

Hãy thử trực tuyến!

      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 byte

^{-4 byte nhờ Dennis (thêm 1 vào cuộc gọi đệ quy thay vì trả về n-1)}

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

Hãy thử trực tuyến!

Giải thích / Ungolfed

Hàm đệ quy lấy hai đối số $c,n$; $n$ được tính lên $1,2,3\dots$ và mọi lúc $n \texttt{ in } n^2$ nó giảm $c$. Đệ quy kết thúc ngay khi$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 mở rộng) , 31 30 byte

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

Hãy thử trực tuyến!

Chỉ số 0.

Perl 5 -p , 33 byte

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

Hãy thử trực tuyến!

Lua , 137 123 79 byte

-thanks @Jo King cho 44 byte

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)

Hãy thử trực tuyến!

Tcl , 82 byte

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

Hãy thử trực tuyến!

Gọn gàng , 24 byte

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

Hãy thử trực tuyến!

Trả về một danh sách lười biếng, khi được gọi như một hàm, trả về nphần tử thứ trong chuỗi.

Giải trình

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