Definition

Wenn Sie die Folge positiver ganzzahliger Quadrate nehmen und zu einer Folge von Ziffern verketten (dh 149162536496481100...), befindet sich ein "Early Bird" -Quadrat in dieser Folge vor seiner natürlichen Position.

Zum Beispiel kann 7 ² (die Zahl 49) mit einem Versatz von 2 in der Zeichenfolge gefunden werden, obwohl die natürliche Position bei Versatz 10 liegt. Somit ist 7 das erste "Early Bird" -Quadrat.

Beachten Sie, dass, um als "Early Bird" -Quadrat zu gelten, alle Ziffern des Quadrats vor dem Start der natürlichen Position vorkommen müssen. Eine Übereinstimmung, die die natürliche Position teilweise überlappt, zählt nicht.

a(n)ist die n-te positive ganze Zahl k, so dass k ² ein "Early Bird" -Quadrat ist.

Aufgabe

Bei einer positiven Ganzzahl nwird ausgegeben a(n).

Sie können eine 1-basierte oder eine 0-basierte Indizierung verwenden. Wenn Sie jedoch eine 0-basierte Indizierung verwenden, geben Sie dies bitte in Ihrer Antwort an.

Ihre Lösung sollte mindestens so hoch sein wie a(53)(oder wenn Sie eine 0-basierte Indizierung verwenden a(52)).

Testfälle

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

Verweise

• OEIS A181585

05AB1E , 10 9 Bytes

Dank Adnan 1 Byte gespeichert .

µNL<nJNnå

Probieren Sie es online!

Erläuterung

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

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

Formatiert und kommentiert

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

Nicht rekursive Version, 53 Bytes

Dieser hängt nicht von Ihrer Motorstapelgröße ab.

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

Probieren Sie es online!

Pyth , 12 Bytes

e.f/jk^R2Z`*

Probieren Sie es hier aus!

Wie es funktioniert

ef / jk ^ R2Z` * ~ Volles Programm. Q sei unser Input.

 .f ~ Erste Q positive ganze Zahlen mit wahrheitsgemäßen Ergebnissen. Verwendet die Variable Z.
      ^ R2Z ~ Quadriere jede ganze Zahl im Bereich [0, Z).
    jk ~ In eine einzelne Zeichenfolge verketten.
   / ~ Zähle die Vorkommen von ...
          `* ~ Die Zeichenfolgendarstellung von Z im Quadrat.
               Ergibt 0 wenn falsch und ≥ 1 wenn wahr.
e ~ Holen Sie sich das letzte Element (Qth truthy integer). Implizit ausgeben.

Perl 5 , 34 Bytes

33 Byte Code + 1 für -p.

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

Probieren Sie es online!

APL (Dyalog) , 53 42 Bytes

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

Probieren Sie es online!

Wie?

⍷ - Vorkommen von finden

⍕×⍨⍵+1- verstrichenes Quadrat x+1in der

⍕×⍨⍳⍵ - stringierter Bereich von Quadraten x

' '~⍨ - ohne Zwischenraum

+/ - Summe

0<- Wenn die Summe positiv ist (Vorkommen sind vorhanden), wird sie zurückgegeben x+1, andernfalls

∇⍵+1- Rekurs mit x+1.

⍣⍵- nmal anwenden .

Haskell , 73 Bytes

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

Probieren Sie es online! Null indexiert.

Erläuterung

Hilfsmittel:

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

Hauptfunktion:

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

Jelly , 13 11 Bytes

R²DµṪẇF
Ç#Ṫ

Probieren Sie es online!

Alternativ ist dies eine 10-Byte-Lösung, die die nersten Werte der Sequenz ausgibt : Probieren Sie es online aus!

Python 2 , 62 61 Bytes

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

Probieren Sie es online!

Jelly , 11 Bytes

Ḷ²DFɓ²ẇ
Ç#Ṫ

Probieren Sie es online!

Eine Alternative zur Lösung von user202729 .

Wie es funktioniert

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

Probieren Sie es online!

Das verschwenderische Layout dieses Abschnitts des Ordinal-Modus nervt mich wirklich, aber alles, was ich versuche, um ein paar Bytes zu sparen, kommt länger raus ...

Erläuterung

/
\io/...@...

Nur das übliche dezimale E / A-Framework mit den ound @in leicht ungewöhnlichen Positionen. Das Fleisch des Programms ist folgendes:

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

Schale , 13 Bytes

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

Probieren Sie es online!

Erläuterung

Die zweite Zeile ist eine Hilfsfunktion, die die Dezimalstellen des Quadrats einer Zahl angibt:

 □    Square.
d     Base-10 digits.

Wir können diese Funktion im Hauptprogramm mit aufrufen ₁.

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 75 Byte

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

Probieren Sie es online!

Wie es funktioniert

nbehält die Anzahl der gefundenen Frühaufsteher bei, kdie zuletzt überprüfte Anzahl sdie Zeichenfolge "1491625...". Während nes zu klein ist, wenn es sdas nächste Quadrat enthält, wurde ein weiterer Frühaufsteher gefunden, sodass wir inkrementieren n. In jedem Fall verlängern wir s.

Sobald ndie Eingabe erreicht ist #, kehren wir zurück k, die letzte Nummer überprüft und damit der letzte frühe Vogel gefunden.

Auf meinem Laptop dauert es ungefähr 53 Sekunden, um den 53. Term der Sequenz zu berechnen.

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

Probieren Sie es online!

Schlag, 76 69 Bytes

Angenommen, nwird in Variable (dh n=10 foo.sh) gegeben. Verwendet Paket grep. Es wird ein beliebiger mittlerer Wert ausgegeben (falls zulässig, -3 Byte).

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

Wie funktioniert es?

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