Definición

Si toma la secuencia de cuadrados enteros positivos y los concatena en una cadena de dígitos (es decir 149162536496481100...), un cuadrado "temprano" es uno que se puede encontrar en esta cadena antes de su posición natural.

Por ejemplo, 7 ² (el número 49), se puede encontrar en un desplazamiento de 2 en la cadena, aunque la posición natural está en el desplazamiento 10. Por lo tanto, 7 es el primer cuadrado "anticipado".

Tenga en cuenta que para que se considere un cuadrado "anticipado", todos los dígitos en el cuadrado deben aparecer antes del comienzo de la posición natural. Un partido que se superpone parcialmente a la posición natural no cuenta.

a(n)es el enésimo número entero positivo k tal que k ² es un cuadrado "madrugador".

Tarea

Dado un entero positivo n, salida a(n).

Puede usar la indexación basada en 1 o en 0, pero si usa la indexación basada en 0, dígalo en su respuesta.

Su solución debería ser capaz de manejar al menos tan alto como a(53)(o si está utilizando indexación basada en 0 a(52)).

Casos de prueba

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

Referencias

• OEIS A181585

05AB1E , 10 9 bytes

Guardado 1 byte gracias a Adnan .

µNL<nJNnå

Pruébalo en línea!

Explicación

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

Manifestación

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

Formateado y 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

Versión no recursiva, 53 bytes.

Este no depende del tamaño de la pila del motor.

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

Pruébalo en línea!

Pyth , 12 bytes

e.f/jk^R2Z`*

Pruébalo aquí!

Cómo funciona

ef / jk ^ R2Z` * ~ Programa completo. Deje que Q sea nuestra entrada.

 .f ~ Q primeros enteros positivos con resultados verdaderos. Utiliza la variable Z.
      ^ R2Z ~ Cuadra cada número entero en el rango [0, Z).
    jk ~ Concatenar en una sola cadena.
   / ~ Contar las ocurrencias de ...
          `* ~ La representación de cadena de Z al cuadrado.
               Produce 0 si es falso y ≥ 1 si es verdadero.
e ~ Obtener el último elemento (Qth entero verdadero). Salida implícita.

Perl 5 , 34 bytes

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

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

Pruébalo en línea!

APL (Dyalog) , 53 42 bytes

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

Pruébalo en línea!

¿Cómo?

⍷ - encontrar ocurrencias de

⍕×⍨⍵+1- cuadrado de cadena x+1en el

⍕×⍨⍳⍵ - rango de cuadrados en cadena x

' '~⍨ - sin espacios

+/ suma

0<- si la suma es positiva (existen ocurrencias), entonces devuelve x+1, de lo contrario,

∇⍵+1- Recurrir con x+1.

⍣⍵- Aplicar ntiempos.

Haskell , 73 bytes

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

Pruébalo en línea! Indexado a cero.

Explicación

Tropas auxiliares:

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

Función 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.

Jalea , 13 11 bytes

R²DµṪẇF
Ç#Ṫ

Pruébalo en línea!

Alternativamente, esta es una solución de 10 bytes que imprime los nprimeros valores de la secuencia: ¡ Pruébelo en línea!

Python 2 , 62 61 bytes

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

Pruébalo en línea!

Jalea , 11 bytes

Ḷ²DFɓ²ẇ
Ç#Ṫ

Pruébalo en línea!

Una alternativa a la solución de user202729 .

Cómo 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

Pruébalo en línea!

El diseño derrochador de ese tramo del modo Ordinal realmente me está molestando, pero todo lo que trato de guardar algunos bytes sale más tiempo ...

Explicación

/
\io/...@...

Solo el marco de E / S decimal habitual, con oy @en posiciones ligeramente inusuales. La carne del programa es 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.

Casco , 13 bytes

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

Pruébalo en línea!

Explicación

La segunda línea es una función auxiliar que nos da los dígitos decimales del cuadrado de un número:

 □    Square.
d     Base-10 digits.

Podemos invocar esta función en el 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}

Pruébalo en línea!

Wolfram Language (Mathematica) , 75 bytes

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

Pruébalo en línea!

Cómo funciona

nmantiene el número de madrugadores encontrados hasta el momento, kel último número marcado, sla cadena "1491625...". Si bien nes demasiado pequeño, si scontiene el siguiente cuadrado, se ha encontrado otro pájaro temprano, por lo que aumentamos n. En cualquier caso, nos extendemos s.

Una vez que nllega a la entrada #, regresamos k, el último número verificado y, por lo tanto, el último pájaro temprano encontrado.

En mi computadora portátil, toma aproximadamente 53 segundos calcular el término 53 de la secuencia.

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

Pruébalo en línea!

Bash, 76 69 bytes

Asumir nse da en variable (es decir n=10 foo.sh). Utiliza paquete grep. Se emite cualquier valor medio (si está 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