Definizione

Se prendi la sequenza di quadrati interi positivi e li concateni in una stringa di cifre (cioè 149162536496481100...), un quadrato "early bird" è quello che può essere trovato in questa stringa prima della sua posizione naturale.

Ad esempio, 7 ² (il numero 49), può essere trovato con un offset di 2 nella stringa, sebbene la posizione naturale sia nell'offset 10. Quindi 7 è il primo quadrato "early bird".

Si noti che per essere considerato un quadrato "early bird", tutte le cifre nel quadrato devono essere presenti prima dell'inizio della posizione naturale. Una partita che si sovrappone parzialmente alla posizione naturale non conta.

a(n)è l'ennesimo numero intero positivo k tale che k ² sia un quadrato "early bird".

Compito

Dato un numero intero positivo n, output a(n).

Puoi utilizzare l'indicizzazione in base 1 o in base a 0, ma se usi l'indicizzazione in base 0, ti preghiamo di comunicarlo nella tua risposta.

La soluzione dovrebbe essere in grado di gestire almeno fino a a(53)(o se si utilizza l'indicizzazione basata su 0 a(52)).

Casi test

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

Riferimenti

• OEIS A181585

05AB1E , 10 9 byte

Salvato 1 byte grazie ad Adnan .

µNL<nJNnå

Provalo online!

Spiegazione

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

1-indicizzati.

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

dimostrazione

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

Formattato e commentato

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

Versione non ricorsiva, 53 byte

Questo non dipende dalle dimensioni dello stack del motore.

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

Provalo online!

Pyth , 12 byte

e.f/jk^R2Z`*

Provalo qui!

Come funziona

ef / jk ^ R2Z` * ~ Programma completo. Lascia che Q sia il nostro contributo.

 .f ~ Primi numeri interi Q positivi con risultati veritieri. Utilizza la variabile Z.
      ^ R2Z ~ Quadrato di ciascun numero intero nell'intervallo [0, Z).
    jk ~ Concatena in una singola stringa.
   / ~ Conta le occorrenze di ...
          `* ~ La rappresentazione di stringa di Z al quadrato.
               Produce 0 se falsi e ≥ 1 se veritieri.
e ~ Ottieni l'ultimo elemento (Qth truey integer). Uscita implicita.

Perl 5 , 34 byte

33 byte codice + 1 per -p.

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

Provalo online!

APL (Dyalog) , 53 42 byte

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

Provalo online!

Come?

⍷ - trova occorrenze di

⍕×⍨⍵+1- quadrato stretto di x+1in

⍕×⍨⍳⍵ - gamma ristretta di quadrati x

' '~⍨ - senza spazi

+/ - somma

0<- se la somma è positiva (esistono occorrenze), allora restituisce x+1, altrimenti,

∇⍵+1- ricorrere con x+1.

⍣⍵- applicare i ntempi.

Haskell , 73 byte

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

Provalo online! Zero indicizzati.

Spiegazione

Ausiliari:

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

Funzione principale:

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

Gelatina , 13 11 byte

R²DµṪẇF
Ç#Ṫ

Provalo online!

In alternativa, questa è una soluzione da 10 byte che stampa i nprimi valori della sequenza: provalo online!

Python 2 , 62 61 byte

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

Provalo online!

Gelatina , 11 byte

Ḷ²DFɓ²ẇ
Ç#Ṫ

Provalo online!

Un'alternativa alla soluzione di user202729 .

Come funziona

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 byte

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

Provalo online!

Il layout dispendioso di quel tratto della modalità Ordinale mi sta davvero infastidendo, ma tutto ciò che cerco di salvare alcuni byte viene fuori più a lungo ...

Spiegazione

/
\io/...@...

Solo il solito framework I / O decimale, con oe @in posizioni leggermente insolite. La carne del programma è questa:

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

Buccia , 13 byte

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

Provalo online!

Spiegazione

La seconda riga è una funzione di aiuto che ci dà le cifre decimali del quadrato di un numero:

 □    Square.
d     Base-10 digits.

Possiamo richiamare questa funzione sul programma principale 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 byte

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

Provalo online!

Wolfram Language (Mathematica) , 75 byte

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

Provalo online!

Come funziona

nmantiene il numero di primi uccelli trovati finora, kl'ultimo numero controllato, sla stringa "1491625...". Mentre nè troppo piccolo, se scontiene il quadrato successivo, è stato trovato un altro uccello mattiniero, quindi incrementiamo n. In ogni caso, estendiamos .

Una volta nraggiunto l'input #, torniamok , l'ultimo numero viene controllato e quindi l'ultimo early bird trovato.

Sul mio laptop, ci vogliono circa 53 secondi per calcolare il 53 ° termine della sequenza.

REXX , 66 byte

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

Provalo online!

Bash, 76 69 byte

Supponiamo che nsia dato in variabile (cioè n=10 foo.sh). Usa il pacchetto grep. Viene emesso qualsiasi valore medio (se consentito, -3 byte).

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

Come funziona?

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