Définition

Si vous prenez la séquence de carrés entiers positifs et les concaténez en une chaîne de chiffres (c.-à-d. 149162536496481100... ), Un carré «lève-tôt» est celui qui peut être trouvé dans cette chaîne avant sa position naturelle.

Par exemple, 7 ² (le nombre 49), peut être trouvé à un décalage de 2 dans la chaîne, bien que la position naturelle soit au décalage 10. Ainsi 7 est le premier carré "early bird".

Notez que pour qu'il soit considéré comme un carré "lève-tôt", tous les chiffres du carré doivent apparaître avant le début de la position naturelle. Une correspondance qui chevauche partiellement la position naturelle ne compte pas.

a(n)est le nième entier positif k tel que k ² est un carré "early bird".

Tâche

Étant donné un entier positif n, sortie a(n).

Vous pouvez utiliser une indexation basée sur 1 ou 0, mais si vous utilisez une indexation basée sur 0, veuillez le dire dans votre réponse.

Votre solution devrait être capable de gérer au moins aussi haut que a(53)(ou si vous utilisez une indexation basée sur 0, a(52)).

Cas de 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

Les références

• OEIS A181585

05AB1E , 10 9 octets

Enregistré 1 octet grâce à Adnan .

µNL<nJNnå

Essayez-le en ligne!

Explication

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

1 indexé.

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

Démo

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

Formaté et commenté

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

Version non récursive, 53 octets

Celui-ci ne dépend pas de la taille de votre pile de moteur.

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

Essayez-le en ligne!

Pyth , 12 octets

e.f/jk^R2Z`*

Essayez-le ici!

Comment ça fonctionne

ef / jk ^ R2Z` * ~ Programme complet. Soit Q notre entrée.

 .f ~ Premiers nombres positifs Q avec des résultats véridiques. Utilise la variable Z.
      ^ R2Z ~ Place chaque entier dans la plage [0, Z).
    jk ~ Concaténer en une seule chaîne.
   / ~ Comptez les occurrences de ...
          `* ~ La représentation sous forme de chaîne de Z au carré.
               Donne 0 si faux et ≥ 1 si vrai.
e ~ Récupère le dernier élément (Qème entier vrai). Sortie implicitement.

Perl 5 , 34 octets

Code de 33 octets + 1 pour -p.

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

Essayez-le en ligne!

APL (Dyalog) , 53 42 octets

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

Essayez-le en ligne!

Comment?

⍷ - trouver des occurrences de

⍕×⍨⍵+1- carré stratifié de x+1dans le

⍕×⍨⍳⍵ - gamme de carrés stratifié x

' '~⍨ - sans espaces

+/ - somme

0<- si la somme est positive (des occurrences existent), alors elle retourne x+1, sinon,

∇⍵+1- recurse avec x+1.

⍣⍵- appliquer des ntemps.

Haskell , 73 octets

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

Essayez-le en ligne! Zéro indexé.

Explication

Auxiliaires:

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

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

Gelée , 13 11 octets

R²DµṪẇF
Ç#Ṫ

Essayez-le en ligne!

Il s'agit également d'une solution de 10 octets qui imprime les npremières valeurs de la séquence: Essayez-la en ligne!

Python 2 , 62 61 octets

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

Essayez-le en ligne!

Gelée , 11 octets

Ḷ²DFɓ²ẇ
Ç#Ṫ

Essayez-le en ligne!

Une alternative à la solution user202729 .

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

La disposition inutile de ce tronçon du mode Ordinal me dérange vraiment, mais tout ce que j'essaie d'économiser quelques octets sort plus longtemps ...

Explication

/
\io/...@...

Juste le cadre d'E / S décimal habituel, avec oet @dans des positions légèrement inhabituelles. La viande du programme est la suivante:

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

Husk , 13 octets

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

Essayez-le en ligne!

Explication

La deuxième ligne est une fonction d'aide qui nous donne les chiffres décimaux du carré d'un nombre:

 □    Square.
d     Base-10 digits.

Nous pouvons invoquer cette fonction sur le programme principal en utilisant ₁.

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

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 75 octets

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

Essayez-le en ligne!

Comment ça fonctionne

nconserve le nombre de lève-tôt trouvés jusqu'à présent, kle dernier numéro vérifié, sla chaîne "1491625...". Bien qu'il nsoit trop petit, s'il scontient le carré suivant, un autre lève-tôt a été trouvé, alors nous incrémentons n. Dans tous les cas, nous étendonss .

Une fois natteint l'entrée #, nous revenonsk , le dernier numéro vérifié et donc le dernier lève-tôt trouvé.

Sur mon ordinateur portable, il faut environ 53 secondes pour calculer le 53e terme de la séquence.

REXX , 66 octets

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

Essayez-le en ligne!

Bash, 76 69 octets

Supposons nque la variable soit donnée (ie n=10 foo.sh). Utilise le package grep. Toute valeur intermédiaire est sortie (si elle est autorisée, -3 octets).

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

Comment ça marche?

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