Definição

Se você pegar a sequência de quadrados inteiros positivos e concatená-los em uma sequência de dígitos (ou seja 149162536496481100...), um quadrado "madrugador" é aquele que pode ser encontrado nessa sequência antes de sua posição natural.

Por exemplo, 7 ² (o número 49), pode ser encontrado com um deslocamento de 2 na sequência, embora a posição natural esteja no deslocamento 10. Portanto, 7 é o primeiro quadrado "madrugador".

Observe que, para ser considerado um quadrado "madrugador", todos os dígitos do quadrado devem ocorrer antes do início da posição natural. Uma partida que se sobreponha parcialmente à posição natural não conta.

a(n)é o inteiro enésimo k positivo tal que k ² é um quadrado "madrugador".

Tarefa

Dado um número inteiro positivo n, output a(n).

Você pode usar a indexação com base em 1 ou em 0, mas se você usar a indexação com base em 0, diga-o em sua resposta.

Sua solução deve ser capaz de lidar com pelo menos o máximo de a(53)(ou se você estiver usando a indexação baseada em 0 a(52)).

Casos de teste

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

Referências

• OEIS A181585

05AB1E , 10 9 bytes

Guardado 1 byte graças a Adnan .

µNL<nJNnå

Experimente online!

Explicação

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

1 indexado.

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

Demo

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

Formatado e comentado

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

Versão não recursiva, 53 bytes

Este não depende do tamanho da pilha do seu mecanismo.

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

Experimente online!

Pitão , 12 bytes

e.f/jk^R2Z`*

Experimente aqui!

Como funciona

ef / jk ^ R2Z` * ~ Programa completo. Seja Q a nossa entrada.

 .f ~ Primeiros inteiros positivos Q com resultados verdadeiros. Usa a variável Z.
      ^ R2Z ~ Esquadra cada número inteiro no intervalo [0, Z).
    jk ~ Concatena em uma única sequência.
   / ~ Contar as ocorrências de ...
          `* ~ A representação em cadeia de Z ao quadrado.
               Rende 0 se for falso e ≥ 1 se for verdade.
e ~ Obtém o último elemento (Qº número inteiro de verdade). Saída implicitamente.

Perl 5 , 34 bytes

Código de 33 bytes + 1 para -p.

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

Experimente online!

APL (Dyalog) , 53 42 bytes

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

Experimente online!

Quão?

⍷ - encontre ocorrências de

⍕×⍨⍵+1- quadrado stringificado de x+1no

⍕×⍨⍳⍵ - intervalo de quadrados estrito x

' '~⍨ - sem espaços

+/ - soma

0<- se a soma for positiva (existem ocorrências), ela retornará x+1, caso contrário,

∇⍵+1- recursar com x+1.

⍣⍵- aplicar nhorários.

Haskell , 73 bytes

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

Experimente online! Indexado a zero.

Explicação

Auxiliares:

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

Função principal:

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

Geléia , 13 11 bytes

R²DµṪẇF
Ç#Ṫ

Experimente online!

Como alternativa, esta é uma solução de 10 bytes que imprime os nprimeiros valores da sequência: Experimente online!

Python 2 , 62 61 bytes

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

Experimente online!

Gelatina , 11 bytes

Ḷ²DFɓ²ẇ
Ç#Ṫ

Experimente online!

Uma alternativa à solução user202729 .

Como funciona

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 ^^^?

Alice , 32 bytes

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

Experimente online!

O layout desnecessário desse trecho do modo Ordinal está realmente me incomodando, mas tudo o que tento salvar alguns bytes sai por mais tempo ...

Explicação

/
\io/...@...

Apenas a estrutura de E / S decimal usual, com oe @em posições um pouco incomuns. A carne do programa é esta:

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

Casca , 13 bytes

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

Experimente online!

Explicação

A segunda linha é uma função auxiliar que nos fornece os dígitos decimais do quadrado de um número:

 □    Square.
d     Base-10 digits.

Podemos chamar esta função no programa principal usando ₁.

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

Kotlin , 79 bytes

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

Experimente online!

Wolfram Language (Mathematica) , 75 bytes

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

Experimente online!

Como funciona

nmantém o número de madrugadores encontrados até agora, ko último número verificado, sa sequência "1491625...". Embora nseja muito pequeno, se scontiver o próximo quadrado, outro pássaro madrugador foi encontrado, portanto aumentamos n. De qualquer forma, estendemos s.

Uma vez que natinge a entrada #, voltamos k, o último número marcado e, portanto, o último madrugador encontrados.

No meu laptop, leva cerca de 53 segundos para calcular o 53º termo da sequência.

REXX , 66 bytes

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

Experimente online!

Bash, 76 69 bytes

Suponha que né dado em variável (ie n=10 foo.sh). Usa pacote grep. Qualquer valor do meio é gerado (se permitido, -3 bytes).

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

Como funciona?

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