Определение

Если вы возьмете последовательность положительных целочисленных квадратов и объедините их в цепочку цифр (то есть 149162536496481100...), квадрат «ранней пташки» - это тот, который можно найти в этой строке перед ее естественным положением.

Например, 7 ² (число 49) можно найти со смещением 2 в строке, хотя естественная позиция находится со смещением 10. Таким образом, 7 - это первый квадрат «ранней пташки».

Обратите внимание, что для того, чтобы его считали квадратом «ранней пташки», все цифры в квадрате должны появляться до начала естественного положения. Совпадение, которое частично перекрывает естественную позицию, не считается.

a(n)n-е положительное целое число k, такое что k ² является квадратом "ранней пташки".

задача

Учитывая положительное целое число n, выведите a(n).

Вы можете использовать индексацию на основе 1 или 0, но если вы используете индексацию на основе 0, укажите это в своем ответе.

Ваше решение должно быть в состоянии обрабатывать как минимум так же высоко a(53)(или, если вы используете индексацию на основе 0, a(52)).

Testcases

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 байтов

Сохранено 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}

Попробуйте онлайн!

Pyth , 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)

Попробуйте онлайн! Zero-индексироваться.

объяснение

вспомогательные вещества:

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ɓ²ẇ
Ç#Ṫ

Попробуйте онлайн!

Альтернатива решению пользователя 202729 .

Как это устроено

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

Попробуйте онлайн!

Расточительное расположение этого участка в режиме Ordinal действительно доставляет мне неприятности, но все, что я пытаюсь сохранить там в байтах, длится дольше ...

объяснение

/
\io/...@...

Просто обычный десятичный каркас ввода-вывода, с 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 Language (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