Ogni termine nella sequenza di quadratura, x _n , viene creato prendendo x _n-1 , quadrandolo e rimuovendo tutte tranne le prime quattro cifre.

La sequenza inizia sempre con x ₁ = 1111 . La quadratura produce 1234321, quindi x ₂ = 1234

I primi termini sono:

1111
1234
1522
2316
5363
...

La sfida

Il tuo compito è, dato un numero intero non negativo n , calcolare x _n . È possibile inviare un programma completo che esegue I / O o una funzione che accetta n come parametro.

La soluzione può essere zero o una indicizzata, purché si specifichi quale.

Poiché tutti i termini di questa sequenza sono più brevi di 5 cifre, anche il codice dovrebbe essere il più breve possibile. Si applicano scappatoie standard per il golf da codice .

Che vinca il migliore golfista!

Casi test

Nota: sono 1 indicizzati.

1   -> 1111
8   -> 6840
15  -> 7584
20  -> 1425
80  -> 4717

05AB1E , 8 7 byte

Codice:

$Fn4×4£

Spiegazione:

$        # Push 1 and the input
 F       # Input times do...
  n      #   Square the number
   4×    #   Repeat that string 4 times
     4£  #   Take the first four characters
         # Output the last computed number

Utilizza la codifica CP-1252 . Provalo online!

JavaScript (ES7), 44 43 36 byte

f=n=>--n?(f(n)**2+f).slice(0,4):1111

Questo è un ottimo esempio di abuso della coercizione di tipo: **converte entrambi i suoi argomenti in numeri e +converte entrambi i suoi argomenti in stringhe a meno che non siano entrambi numeri. Ciò significa che f(n)**2+fprima converte f(n)in un numero e lo piazza, quindi concatena il risultato con la rappresentazione di stringa di f. Possiamo quindi usare .sliceper recuperare i primi 4 caratteri della stringa.

Ecco alcuni approcci alternativi che non usano le stringhe:

f=(n,x=1111)=>x<1e4?--n?f(n,x*x):x:f(n,x/10|0)
f=n=>--n?(x=f(n))*x/(x>3162?1e4:1e3)|0:1111

Snippet di prova

let f=n=>--n?(Math.pow(f(n),2)+f).slice(0,4):1111

<input id=I type="number" step="1" min="1" value="1"><button onclick="console.log(f(I.value))">Run</button>

Nota: utilizza Math.powperché **non è supportato in tutti i browser.

Haskell, 40 byte

((iterate(read.take 4.show.(^2))1111)!!)

È una sequenza basata su 0. Esempio di utilizzo: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Come funziona:

iterate (   ) 1111               -- repeatedly apply a function starting
                                 -- with 1111 and collect the results in a list
                                 -- the function is
           (^2)                  -- square
        show                     -- turn into string
     take 4                      -- take the first 4 chars
  read                           -- turn back to number
                     !!          -- finally pick the nth element from the list         

Mathematica, 48 byte

Nest[⌊10^(3-⌊t=2Log[10,#]⌋+t)⌋&,1111,#]&

Funzione senza nome che accetta un argomento intero; 0-indicizzati. Utilizza quattro caratteri a tre byte ⌊⌊⌋⌋: Mathematica usa Floor[x]o ⌊x⌋per arrotondare un numero reale a un numero intero, e quest'ultimo è generalmente un byte in meno. I nomi dei comandi in Mathematica per convertire numeri interi in stringhe sono troppo lunghi, quindi facciamo un calcolo matematico per trovare le prime quattro cifre di x ^ 2: prendiamo il logaritmo in base 10 di x ^ 2, sottraggiamo la sua parte intera, rilancia 10 di nuovo a quel potere, e moltiplicare per 1000 e arrotondare per difetto.

tl; dr: logarithms ftw

Python 2, 51 46 44 byte

Mi piacerebbe sbarazzarmi del grosso ifse possibile, ma penso che un execpotrebbe essere più corto .. Risulta per il momento che execè più breve. Sbagliato di nuovo! La funzione ricorsiva ritorna. Questo è uno indicizzato.

f=lambda n:1111*(n<2)or int(`f(n-1)**2`[:4])

Una soluzione alternativa a 46 byte con exec:

s=1111;exec's=int(`s*s`[:4]);'*input();print s

Una soluzione ricorsiva alternativa a 49 byte:

f=lambda n,s=1111:s*0**n or f(n-1,int(`s*2`[:4]))

^{Grazie a Flp.Tkc per aver salvato un byte ricordandomi che la quadratura non ha bisogno di esponenziazione :)}

V , 19 byte

4é1Àñ|C="*"
5|D

Provalo online!

Questo utilizza l'indicizzazione basata su 0.

Naturalmente, dal momento che i numeri non sono proprio del V forte , questo non è molto Golfy. Tuttavia, mostra un bel vantaggio che V ha rispetto a Vim. Puoi eseguire una macro 0 volte, il che non è possibile in Vim poiché '0' è un comando non un conteggio.

Questo contiene molti caratteri non stampabili, quindi ecco un hexdump:

0000000: 34e9 31c0 f17c 4312 3d12 222a 1222 0a1b  4.1..|C.=."*."..
0000010: 357c 44                                  5|D

Ed ecco una versione leggibile:

4é1Àñ|C<C-r>=<C-r>"*<C-r>"
<esc>5|D

Spiegazione:

4                           " 4 times:
 é1                         " Insert a '1'
   Àñ                       " Arg1 times:
     |                      "   Move to the first character on this line
      C                     "   Delete this whole line and enter insert mode
       <C-r>=               "   Insert the following evaluated as vimscript:
             <C-r>"         "     Insert what we just deleted
                   *        "     Times
                    <C-r>"  "     What we just deleted
<esc>                       "   Escape to normal mode
     5|                     "   Move to the fifth column on this line
       D                    "   And delete until the end of this line
                            " The second 'ñ' is added implicitly

Gelatina , 12 9 byte

-3 byte grazie a Dennis usando l'indicizzazione basata su 1 e l' ṁatomo muffa / rimodella. Suggerimenti di golf benvenuti! Provalo online!

²Dṁ4Ḍ
1Ç¡

Ungolfing

Helper link
²       Square.
 D      Integer to decimal (a list of digits).
  ṁ4    Mold/reshape list_of_digits to be 4 digits long.
    Ḍ   Decimal to integer.

Main link: implicit left argument n
1     Start with the nilad 1.
 Ç¡   Call the helper link n times.

Perl, 37 byte

36 byte di codice + -pflag.

$\=1x4;$\=substr$\*$\,0,4while--$_}{

Per eseguirlo:

perl -pe '$\=1x4;$\=substr$\*$\,0,4while--$_}{' <<< 80

Powershell, 73 55 byte

Enorme grazie a TimmyD per aver rasato 18 byte!

Codice:

for($A=1111;$args[0]---1;$A=-join"$(+$A*$A)"[0..3]){}$A

$A=1111;1..($n=2)|%{[string]$B=[math]::pow($A,2);$A=$B.substring(0,4)};$A

$nè n in x _n-1

Spiegazione e codice esploso:

$A=1111                            #starting number
$n=4                               #n in formula
for($i=0; $i -lt $n;$i++)          #loop n times
{
    [string]$B=[math]::pow($A,2)   #create a new string $B and set it to $A raised to the power of 2
    $A=$B.substring(0,4)           #set $A to the first 4 characters of $B
}
$A                             #print $A

Alcune note:

• Powershell ti consente di assegnare variabili nelle stesse istruzioni in cui le fai riferimento. Ad esempio, 1..($n=4)|%imposterà $ n su 4 e quindi avvierà un ciclo che esegue $ n volte. 1può essere modificato in qualsiasi numero intero e eseguirà il ciclo $ n- [il tuo numero intero] +1 volte.
• Il tipo di dati predefinito quando si utilizza [math]::in Powershell è un doppio. Nel codice sopra, dobbiamo eseguire il cast esplicito $Bsu una stringa in modo che possiamo chiamarla .substring()perché non c'è alcuna .substring()funzione per i doppi in Powershell.

Python 2,  44  41 byte

-3 byte grazie a xnor (usare una divisione intera per evitare and)

f=lambda n:int(1/n*1111or`f(n-1)**2`[:4])

repl.it

Funzione ricorsiva basata su 1.

Quando n>1la divisione intera 1/n, risulta 0, allora 0*1111=0qual è la falsità, quindi orviene valutato il diritto della , che accetta i primi quattro caratteri della rappresentazione del quadrato del n-1th risultato; questo viene quindi lanciato in un int.

Quando n=1la divisione intera 1/n, risulta 1, allora 1*1111=1111, il che è veritiero, e il int 1111cast di un intè 1111.

Groovy, 49 byte

{x=1111;(it-1).times{x="${x**2}"[0..3] as int};x}

Pyke, 10 byte

1RVX`4*4<b

Provalo qui!

MATL , 14 , 13 byte

1111G:"UV4:)U

Provalo online!

Spiegazione:

1111            % Push 1111
    G           % Push input
     :"         % Input times:
       U        %   Square the top of the stack
        V       %   Convert it to a string
         4:)    %   Take the first four digits
            U   %   Convert it back to a number
                % Implictly display

R, 58 56 55 53 byte

x=3334;for(e in N<-scan():1)x=x^2%/%10^(3+(x>3162));x

Prende Nda stdin. 3334 è praticamente X_0, che è necessario perché il for-loop deve essere eseguito almeno una volta (sarebbe più lungo da saltare).

R è davvero un linguaggio terribile per prendere le prime quattro cifre di un numero, ma poiché il numero di casi è limitato, dobbiamo solo preoccuparci dei quadrati di x<3163e x>3162, il primo produce un numero di 6 cifre, il secondo un numero di 7 cifre .

Il resto è piuttosto semplice, %/%divide e ignora il resto. xviene stampato su stdout.

Salvato 2 byte grazie a @ETHproductions

Javagony - 153 byte

Javagony è una versione limitata di Java, che non consente alcun flusso di controllo tranne la ricorsione e try-catch, no per i loop, mentre i loop o if. La codifica è un esercizio piuttosto divertente, ma frustrante. Java non è così frustrante da solo.

int a(int i){return a(i-1,1111);}int a(int i,int n){try{int x=1/i;return a(i-1,Integer.parseInt((n*n+"").substring(0,4)));}catch(Exception e){return n;}}

PHP, 55 52 byte

3 byte salvati grazie a @ user59178

for($i=1111;$argv[1]--;)$i=substr($i**2,0,4);echo$i;

Esegui dalla riga di comando, indicizzato a zero.

Grazie per non preoccuparti di che tipo sono le mie variabili, PHP! Qui semplicemente quadriamo il numero e tagliamo tutto oltre le prime 4 cifre, alternando casualmente tra numero e stringa senza preoccuparsi del mondo.

Brachylog , 18 byte

,1111:?:{^@[.l4,}i

Provalo online!

Questa risposta è indicizzata 0.

Spiegazione

,1111:?:{       }i      Iteratively call Input times the predicate in brackets starting with
                          input 1111:

         ^                  Square
          @[.               Output is a prefix of the square
            .l4,            Its length is 4

C, 56 byte

a;s(n){for(a=1111;--n;)a=a*a/(a>3162?1e4:1e3);return a;}

One-indicizzato.

Clojure, 76 byte

(defn s[n](if(= n 1)1111(read-string(subs(str(*(s(dec n))(s(dec n))))0 4))))

Primo Clojure golf (sembra una bella lingua). Questo è 1-indicizzato.

Spiegherà il codice in seguito.

C #, 64 60 byte

Hai salvato 4 byte seguendo il commento di Olivier Grégoire su una risposta Java!

n=>{int x=1111;for(;n-->1;)for(x*=x;x>1e4;x/=10);return x;};

Versione precedente ( 64 byte ):

n=>{int x=1111;while(n-->1){x*=x;while(x>9999)x/=10;}return x;};

Programma completo con metodo non golfizzato e casi di test:

using System;

namespace SquaringSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int, int> f = n =>
            {
                int x = 1111;
                while (n-- > 1)
                {
                    x *= x;
                    while (x > 9999)
                        x /= 10;
                }
                return x;
            };

            // test cases:
            Console.WriteLine(f(1));    // 1111
            Console.WriteLine(f(8));    // 6840
            Console.WriteLine(f(15));   // 7584
            Console.WriteLine(f(20));   // 1425
            Console.WriteLine(f(80));   // 4717
        }
    }
}

Rubino, 47 byte

Primo golf! Salva i byte con l' -nopzione (ma conta comunque come 1! :)).

a=1111;$_.to_i.times{a="#{a*a}"[0,4].to_i};p a

0-indicizzati. Per eseguirlo:

ruby -ne 'a=1111;$_.to_i.times{a="#{a*a}"[0,4].to_i};p a' <<< 80

Pyth, 13 12 byte

Grazie a @Jakube per -1 byte

us<*4`*GG4Q1

Un programma che accetta l'input di un numero intero con 1 indice e stampa il risultato.

Suite di test

Questo utilizza un approccio simile alla risposta di @ Adnan .

Come funziona

us<*4`*GG4Q1  Program. Input: Q
u         Q1  Execute the following Q times, starting at 1, with variable G:
      *GG      Yield G*G
     `          Convert to string
   *4           Repeat 4 times
  <      4      Yield first 4 characters
 s              Convert to integer
              Implicitly print

CJam , 15 byte

'14*ri{i2#s4<}*

Utilizza l'indicizzazione basata su 0.

Provalo online!

Lotto, 82 byte

@set n=1111
@for /l %%i in (1,1,%1)do @set/an*=n&call set n=%%n:~0,4%%
@echo %n%

Come Perl, gli interi sono stringhe, ma a differenza del Perl posso prendere solo la sottostringa di una variabile e prendere sottostringhe all'interno di un ciclo è alquanto imbarazzante.

Perl 6 , 36 byte

{(1111,{+$_².substr(0,4)}...*)[$_]}

Spiegazione:

{                                 } # bare block lambda
  1111,                  ...        # sequence generator
                            *       # without a limit
       {                }           # lambda used to generate the next value
         $_²                        # start by squaring the previous value
            .substr(0,4)            # take only the first four digits
        +                           # make it numeric ( not necessary )
 (                           )[$_]  # return the requested value

Test:

say {(1111,{+$_².substr(0,4)}...*)[$_]}( 1,8,15,20,80 X- 1 ).perl
# (1111, 6840, 7584, 1425, 4717)

Matlab, 79 , 78 byte

function a=s(n)
if n<2;a=1111; else f=s(n-1);a=fix(f^2/10^(3+(f>1e7^.5)));end

Casi test:

s(79) = 2172
s(49) = 8059
s(6)  = 2876

Non è una soluzione straordinaria. Sono sicuro che ci deve essere un modo migliore per troncare a 4 cifre, ma non lo so oggi.

Modifica: rasato un byte impostando 0,5 -> .5

Java 8, 77 93 74 71 69 78 byte

int n=1111;int m=1;while(x>m++){n=Integer.parseInt((n*n+"").substring(0,4));}

x->{int n=1111;int m=1;while(x>m++){n=Integer.parseInt((n*n+"").substring(0,4))‌​;}return n;}

x->{int n=1111;for(;--x>0;){n=Integer.parseInt((n*n+"").substring(0,4));}}

x->{long n=1111;for(;--x>0;){n=Long.valueOf((n*n+"").substring(0,4));}}

x->{long n=1111;for(;--x>0;)n=Long.valueOf((n*n+"").substring(0,4));return n;}

Ogni ripetizione crea ni primi 4 caratteri di n*n.

Prova Java online !

Cronologia dei post:

• 77 byte: codice iniziale (incompleto)

• +16 byte, di Olivier Grégoire: codice completato rendendolo una funzione Lambda.

• -19 byte: sostituire whilecon forciclo.

• -4 byte: usato longs invece di ints

• -2 byte, di Roman Gräf: rimosse le parentesi non necessarie

• +9 byte, returnistruzione mancante

Grazie a @ OlivierGrégoire e @ RomanGräf per aver segnalato alcuni problemi!

Aspetta, ritmi Java ... (rullo di tamburi) Clojure e Matlab qui! Un grande applauso a Java, per favore!

Perl, 36 byte

Un approccio diverso dall'altra soluzione Perl, portando a un codice leggermente più breve. Non sono necessari argomenti da riga di comando (a parte il solito argomento di selezione della versione -M5.010, che non conta per il conteggio dei byte), il che significa che si tratta della stessa quantità di codice ma con meno penalità, con un punteggio complessivo migliore.

say+eval'($&*$&||1x4)=~/(....)/;'x<>

Creiamo un ciclo sottocarico stile ripetendo e eval-ing una stringa; Ho sperimentato l'avvio della stringa nel mezzo, ma avviarla all'inizio risulta essere la più breve. Moltiplichiamo $&(il risultato dell'ultima regex match) da solo per quadrarlo; se il risultato è zero, usiamo 1x4(cioè 1111; Perl ha un operatore per ripetere cose, incluse le cifre di un numero) invece del risultato. Quindi regexiamo i primi quattro personaggi. Il tutto viene eseguito nel contesto dell'elenco a causa dell'essere all'interno say, quindi il risultato finale della evalsarà il contenuto delle parentesi della corrispondenza finale.

Java, 79 67 66 64 byte

• Versione 2.2 / 64 byte:

Grazie a @Oliver Grégoire.

int a(int i){i=i<2?1111:a(--i);for(i*=i;i>1e4;)i/=10;return i;}

• Versione 2.1 / 66 byte:

Grazie a @ETHProduction.

long a(long i){i=i<2?1111:a(--i);for(i*=i;i>1e4;)i/=10;return i;}

• Versione 2.0 / 67 byte:

Sostituito sottostringa e roba del genere con l'idea di @Xanderhall

long a(long i){i=i<2?1111:a(--i);i*=i;for(;i>1e4;)i/=10;return i;}

• Versione 1.0 / 79 byte:

Anche se ci sono soluzioni più brevi, ho voluto postarne uno ricorsivo :). E io sono la funzione "reale" più breve :). Modifica: sembra che io sia il più corto ora :)))

long a(long i){i=i<2?1111:a(--i);return Long.valueOf((i*i+"").substring(0,4));}

Pushy , 26 20 byte

1111@:2esL4-:.;Kjk;#

Fornisci argomenti sulla riga di comando: $ pushy sqseq.pshy 79 .

Ben formattato, con spiegazione:

            % Implicit: N is on stack
1111@       % Push 1111, and then reverse stack to get [1111, n]
:           % N times do: (this consumes N)
 2e         %   Square last term
 s          %   Split into individual digits
 L4-:.;     %   Get stack length -4, pop that many times
 Kj         %   Join remaining digits (Uses flag "K" for whole stack)
 k          %   Set "K" flag to false, so operations only affect last item
;           % End loop.       
#           % Output final calculated term