定义

如果采用正整数平方的序列并将它们连接成一串数字（即149162536496481100...），则“早起的鸟儿”平方是可以在此字符串中超出其自然位置的位置。

例如，尽管自然位置在偏移量10处，但是在字符串的偏移量2处可以找到7 ²（数字49）。因此7是第一个“早起的鸟儿”正方形。

请注意，要使其被视为“早起的鸟儿”正方形，正方形中的所有数字必须出现在自然位置开始之前。与自然位置部分重叠的匹配不算在内。

a(n)是第n个正整数k，使得k ²是“早起的鸟儿”正方形。

任务

给定一个正整数n，输出a(n)。

您可以使用基于1或基于0的索引，但是如果您使用基于0的索引，请在回答中说明。

您的解决方案应至少能够处理a(53)（或如果您使用的是基于0的索引a(52)）。

测试用例

n     a(n)
1     7
2     8
3     21
4     25
5     46
6     97
7     129
8     161
9     196
10    221
...
13    277
...
50    30015
51    35000
52    39250
53    46111

参考文献

• OEIS A181585

05AB1E，10 9字节

感谢Adnan节省了1个字节。

µNL<nJNnå

在线尝试！

说明

µ           # loop until counter equals the input
 NL         # push the range [1 ... iteration_no]
   <        # decrement each
    n       # square each
     J      # join to string
      Nnå   # is iteration_no in the string?
            # if true, increase counter

JavaScript（ES6），51 49 45字节

1个索引。

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

演示版

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

for(n = 1; n <= 20; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

格式化和评论

f = (                         // f = recursive function taking:
  n,                          //   n = input
  s = k = ''                  //   s = string of concatenated squares, k = counter
) =>                          //
  n ?                         // if we haven't reached the n-th term yet:
    f(                        //   do a recursive call with:
      n - !!s.match(++k * k), //     n decremented if k² is an early bird square
      s + k * k               //     s updated
    )                         //   end of recursive call
  :                           // else:
    k                         //   return k

非递归版本，53字节

这不取决于您的引擎堆栈大小。

n=>{for(k=s='';n-=!!(s+=k*k).match(++k*k););return k}

在线尝试！

y，12个字节

e.f/jk^R2Z`*

在这里尝试！

怎么运行的

ef / jk ^ R2Z` *〜完整程序。让Q作为我们的输入。

 .f〜具有真实结果的第一个Q正整数。使用变量Z。
      ^ R2Z〜在[0，Z）范围内的每个整数取平方。
    jk〜连接成一个字符串。
   /〜计算...的出现
          `*〜Z的字符串表示形式的平方。
               如果为假，则为0；如果为真，则为≥1。
e〜获取最后一个元素（第Q个真整数）。隐式输出。

Perl 5，34个字节

33个字节的代码+ 1个-p。

$s.=$\*$\while$_-=$s=~(++$\*$\)}{

在线尝试！

APL（Dyalog），53 42字节

{{0<+/(⍕×⍨⍵+1)⍷' '~⍨⍕×⍨⍳⍵:⍵+1⋄∇⍵+1}⍣⍵⊢0}

在线尝试！

怎么样？

⍷ -查找出现的

⍕×⍨⍵+1-字符串化的平方x+1在

⍕×⍨⍳⍵ -平方的范围 x

' '~⍨ -没有空格

+/ -总和

0<-如果总和为正（出现次数），则返回x+1，否则，

∇⍵+1-用递归x+1。

⍣⍵-申请n时间。

Haskell，73个字节

import Data.List
([n|n<-[7..],isInfixOf(g n)$g=<<[1..n-1]]!!)
g=show.(^2)

在线尝试！零索引。

说明

助剂：

import Data.List -- import needed for isInfixOf
g=show.(^2)      -- function short cut to square an int and get the string representation

主功能：

(                                 !!) -- Index into the infinite sequence
 [n|n<-[7..],                    ]    -- of all numbers n greater equal 7
      isInfixOf(g n)$                 -- whose square appears in the string
                     g=<<[1..n-1]     -- of all squares from 1 up to n-1 concatenated.

果冻，13 11字节

R²DµṪẇF
Ç#Ṫ

在线尝试！

另外，这是一个10字节的解决方案，可以打印n序列的第一个值：在线尝试！

Python 2中，62 61个字节

n=input();i=0;s=''
while n:i+=1;n-=`i*i`in s;s+=`i*i`
print i

在线尝试！

果冻，11字节

Ḷ²DFɓ²ẇ
Ç#Ṫ

在线尝试！

是user202729解决方案的替代方案。

怎么运行的

C#Ṫ ~ Main Link.

Ç#  ~ First N positive integers with truthy results.
  Ṫ ~ Tail. Take the last one.

-----------------------------------------------------------

Ḷ²DFɓ²ẇ ~ Helper link. This is the filtering condition.

Ḷ       ~ Lowered range. Yields {x | x ∊ Z and x ∊ [0, N)}.
 ²      ~ Square each.
  D     ~ Convert each to decimal (this gets the list of digits).
   F    ~ Flatten.
    ɓ   ~ Starts a new monadic chain with swapped arguments.
     ²  ~ N²; Yields N squared.
      ẇ ~ Is ^ sublist of ^^^?

爱丽丝，32字节

/
\io/&wd.*\@! d ? ~ ? F $ /WKdt

在线尝试！

那种序数模式的浪费性布局确实困扰着我，但是我尝试在其中保存一些字节的所有内容都变得更长了……

说明

/
\io/...@...

只是通常的十进制I / O框架，带有o和的@位置略有不同。程序的内容是这样的：

&w    Push the current IP address to the return address stack n times.
      This gives us an easy way to write a loop which repeats until we
      explicitly decrement the loop counter n times.

  d     Push the stack depth, which acts as our running iterator through
        the natural numbers.
  .*    Square it.
  \     Switch to Ordinal mode.
  !     Store the square (as a string) on the tape.
  d     Push the concatenation of the entire stack (i.e. of all squares before
        the current one).
  ?~    Retrieve a copy of the current square and put it underneath.
  ?     Retrieve another copy.
  F     Find. If the current square is a substring of the previous squares,
        this results in the current square. Otherwise, this gives an empty
        string.
  $     If the previous string was empty (not an early bird) skip the next
        command.
  /     Switch back to Cardinal. This is NOT a command.
  W     Discard one address from the return address stack, decrementing our
        main loop counter if we've encountered an early bird.
K     Jump back to the beginning of the loop if any copies of the return
      address are left. Otherwise do nothing and exit the loop.

dt    Push the stack depth and decrement it, to get the final result.

外壳，13个字节

!f§€oṁ₁ŀ₁N
d□

在线尝试！

说明

第二行是一个辅助函数，它为我们提供了数字平方的十进制数字：

 □    Square.
d     Base-10 digits.

我们可以使用在主程序上调用此函数₁。

!f§€oṁ₁ŀ₁N
 f§      N    Filter the list of natural numbers by the following fork g(n).
       ŀ        Get [0, 1, ... n-1]
     ṁ₁         Get the decimal digits of each value's square and concatenate
                them into one list. (A)
        ₁       And get the decimal digits of n² itself. (B)
    €           Check whether (A) contains (B) as a sublist.
!             Use the programs input as an index into this filtered list.

科特林，79个字节

{n->var m=n;var i=0;var s="";while(m>0){val k="${++i*i}";if(k in s)m--;s+=k};i}

在线尝试！

Wolfram语言（Mathematica），75个字节

(n=k=0;s="";While[n<#,If[!StringFreeQ[s,t=ToString[++k^2]],n++];s=s<>t];k)&

在线尝试！

怎么运行的

n保留到目前为止找到的早起鸟类的数量，k最后检查s的数字，字符串"1491625..."。虽然n太小，但如果s包含下一个正方形，则会发现另一只早起的鸟儿，因此我们递增n。无论如何，我们都会扩展s。

一旦n输入#，我们返回k，最后的数字核对，因此最后一个早起的鸟儿发现。

在我的笔记本电脑上，大约需要53秒才能计算出序列的第53个项。

REXX，66字节

arg n,a
k=0
do i=1 until k=n
  k=k+(pos(i*i,a)>0)
  a=a||i*i
  end
say i

在线尝试！

巴什，76 69字节

假设n给出变量（即n=10 foo.sh）。使用包grep。将输出任何中间值（如果允许，则为-3字节）。

while((n));do((b=++a*a));grep -q $b<<<$s&&((n--));s=$s$b;done;echo $a

它是如何工作的？

while ((n)); do  # while n != 0 (C-style arithmetic)
  ((b = ++a*a))  # Increment a and let b = a*a
    # Non-existent value is treated as zero
  grep $b<<<$s   # Search for b in s
    && ((n--))   # If found, decrement n
  s=$s$b         # Append b to s
done
echo $a