N이 N ^ 2에서 하위 문자열로 나타나는 일련의 자연수를 고려하십시오. A018834

n이 순서 의 th 요소를 출력합니다 .

규칙

프로그램은 n입력으로 만 사용 되며 하나의 숫자 만 출력 N합니다.

시퀀스는 0 인덱스 또는 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 ...

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다.

05AB1E , 6 바이트

1- 색인

µNNnNå

온라인으로 사용해보십시오!

설명

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

펄 6 , 33 31 바이트

nwellnhof 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

설명:

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

자바 스크립트 (ES6), 43 바이트

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

온라인으로 사용해보십시오!

비 재귀 버전, 47 바이트

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

온라인으로 사용해보십시오!

MathGolf , 8 바이트 (이론적으로는 모든 입력에 적용되지만 n<10실제로는 사용 가능)

úrgɲï╧§

온라인으로 사용해보십시오!

대안 ( n<49실제와 이론에 적합)

►rgɲï╧§

유일한 차이점은 10^(input)값이 있는 목록을 만드는 대신 10^6항목이 있는 목록을 만드는 것 입니다. 실행하는 데 시간이 걸리므로 첫 번째 바이트를 다른 1 바이트 리터럴로 바꾸어 테스트 할 수 있습니다.

설명

ú          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

이 솔루션이 큰 입력을 처리하지 못하는 이유는 시퀀스가 ​​기하 급수적으로 증가하지만 다항식보다 더 많이 증가한다는 것을 알았습니다. 그래서 10**n연산자를 사용 2**n했습니다 (입력 1에서는 실패했습니다). 즉, 입력이 작은 경우에도 매우 큰 배열을 생성하여 대부분의 항목을 필터링 한 다음 첫 번째 요소 중 하나를 선택합니다. 그것은 매우 낭비이지만 바이트 수를 늘리지 않고 다른 방법을 찾지 못했습니다.

공통 리스프, 95 바이트

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

온라인으로 사용해보십시오!

클린 , 83 바이트

import StdEnv,Text

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

온라인으로 사용해보십시오!

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

젤리 , 6 바이트

1ẇ²$#Ṫ

1- 색인.

온라인으로 사용해보십시오!

어떻게?

n시퀀스 의 첫 번째 를 목록으로 찾은 다음 꼬리를 산출합니다 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

경우 0자연 번호를 고려하고 우리는 1 인덱스 전체 프로그램을 사용할 수 있습니다 ẇ²$#Ṫ5.

apt, 12 11 바이트

@aJ±X²søY}f

시도 해봐

ȲsøY «U´}a

시도 해봐

루비 , 45 바이트

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

온라인으로 사용해보십시오!

자바 8, 66 65 63 바이트

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

@Shaggy 덕분에 -1 바이트 . @Arnauld
덕분에 -2 바이트 .

1- 색인.

온라인으로 사용해보십시오.

설명:

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`

클로저 , 81 바이트

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

온라인으로 사용해보십시오! (불행히도 TIO는 Clojure의 표준 문자열 라이브러리를 지원하지 않는 것 같습니다)

Clojure가 가져 오기 구문이 더 짧거나 includes?코어 라이브러리에 메소드가있는 경우 이는 실제로 다소 경쟁적 일 수 있습니다. clojure.string/includes?홀로 여기에 몇 가지 답변보다 깁니다 : /

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

TIO 링크가 끊어 졌으므로 테스트 실행이 있습니다. 왼쪽의 숫자는 색인 ( n)이고 결과 ( N)는 오른쪽에 있습니다.

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

이것은 모든 값을 지원할 수 있어야합니다 n. 완료 될 때까지 기꺼이 기다립니다 (시퀀스에서 50 ~ 100 번째 정수를 찾는 데 15 분이 걸렸습니다). Clojure는 임의로 큰 정수 산술을 지원하므로 숫자가 커지기 시작하면 BigInts를 사용하기 시작합니다 .

숯 , 25 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 인덱스가 0입니다. 설명:

Ｎθ

입력 n.

≔¹η

N1에서 시작하십시오 . (또는 0입력을 1 색인화하는 계산을 시작할 수 있습니다.)

Ｗθ«

n시퀀스 에서 숫자를 찾을 때까지 반복 하십시오.

≦⊕η

증분 N.

¿№Ｉ×ηηＩη

경우는 N*N포함 N다음, ...

≦⊖θ»

... 감소 n.

Ｉη

인쇄 N.

갖지 않는) 상기 차콜 (a)에 의해 방해를하고이를 골프 나의 시도 if..then갖지 않는) 2 바이트 비용 블록 () (B)의 단부를 제외하고이 Contains출력을 변환 (조작자 Find또는 CountI로부터 뺄 수있는 부울로 n다시 비용 2 바이트).

편집 (의견에 대한 답변) : Python 2, 76 바이트

비재 귀적 인 방법을 시도하고 싶었습니다. (골프를 처음 접한다면 어떤 팁이라도 좋을 것입니다!)

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

BMO와 Vedant Kandoi에게 감사드립니다!

하스켈, 60 바이트

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

온라인으로 사용해보십시오!

      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

파이썬 2 , 47 43 바이트

^{Dennis 덕분에 -4 바이트 (을 반환하는 대신 재귀 호출에 1을 추가 n-1)}

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

온라인으로 사용해보십시오!

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 바이트

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

온라인으로 사용해보십시오!

인덱스가 0입니다.

펄 5 -p , 33 바이트

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

온라인으로 사용해보십시오!

루아 , 137 (123) 79 바이트

-Joy @Jo King, 44 바이트

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)

온라인으로 사용해보십시오!

Tcl , 82 바이트

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

온라인으로 사용해보십시오!

깔끔한 24 바이트

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

온라인으로 사용해보십시오!

함수처럼 호출 될 때 n시리즈 의 th 요소를 리턴하는 지연 목록을 리턴합니다 .

설명

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