Chaque terme de la séquence de mise au carré, x _n , est créé en prenant x _n-1 , en le mettant au carré et en supprimant tous sauf les quatre premiers chiffres.

La séquence commence toujours par x ₁ = 1111 . La mise au carré donne 1234321, donc x ₂ = 1234

Les premiers termes sont:

1111
1234
1522
2316
5363
...

Le défi

Votre tâche consiste à, étant donné un entier non négatif n , calculer x _n . Vous pouvez soumettre un programme complet qui effectue des E / S, ou une fonction qui prend n comme paramètre.

Votre solution peut être zéro ou un indexée, tant que vous spécifiez laquelle.

Étant donné que tous les termes de cette séquence sont inférieurs à 5 chiffres, votre code doit également être aussi court que possible. Les échappatoires de code-golf standard s'appliquent.

Que le meilleur golfeur gagne!

Cas de test

Remarque: ils sont indexés 1.

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

05AB1E , 8 7 octets

Code:

$Fn4×4£

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

JavaScript (ES7), 44 43 36 octets

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

C'est un excellent exemple d'abus de coercition de type: **convertit ses deux arguments en nombres et +convertit ses deux arguments en chaînes à moins qu'ils ne soient tous les deux des nombres. Cela signifie que f(n)**2+fconvertit d'abord f(n)un nombre et le met au carré, puis concatène le résultat avec la représentation sous forme de chaîne de f. Nous pouvons ensuite utiliser .slicepour récupérer les 4 premiers caractères de la chaîne.

Voici quelques approches alternatives qui n'utilisent pas de chaînes:

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

Extrait de test

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>

Remarque: cela utilise Math.powcar **n'est pas pris en charge dans tous les navigateurs.

Haskell, 40 octets

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

C'est une séquence basée sur 0. Exemple d'utilisation: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Comment ça marche:

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 octets

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

Fonction sans nom prenant un argument entier; 0 indexé. Utilise quatre caractères de trois octets ⌊⌊⌋⌋: Mathematica utilise soit Floor[x]ou ⌊x⌋pour arrondir un nombre réel à un entier, et ce dernier est généralement un octet de moins. Les noms de commandes dans Mathematica pour convertir des entiers en chaînes sont trop longs, donc à la place nous faisons un calcul mathématique pour trouver les quatre premiers chiffres de x ^ 2: nous prenons le logarithme en base 10 de x ^ 2, soustrayons sa partie entière, augmentons 10 revenir à ce pouvoir, et multiplier par 1000 et arrondir.

tl; dr: logarithmes ftw

Python 2, 51 46 44 octets

J'aimerais me débarrasser du maladroit ifsi possible, mais je pense qu'un execpourrait être plus court. Il s'avère que pour le moment c'est execplus court. Encore faux! La fonction récursive revient. C'est un index.

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

Une solution alternative de 46 octets avec exec:

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

Une solution alternative récursive de 49 octets:

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

^{Merci à Flp.Tkc d'avoir sauvé un octet en me rappelant que la mise au carré n'a pas besoin d'exponentiation :)}

V , 19 octets

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

Essayez-le en ligne!

Cela utilise une indexation basée sur 0.

Bien sûr, puisque les chiffres ne sont pas exactement le fort de V , ce n'est pas très golfique. Cependant, cela montre un bel avantage de V sur Vim. Vous pouvez exécuter une macro 0 fois, ce qui n'est pas possible dans vim car «0» est une commande et non un compte.

Il contient de nombreux caractères non imprimables, voici donc un hexdump:

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

Et voici une version lisible:

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

Explication:

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

Gelée , 12 9 octets

-3 octets grâce à Dennis utilisant l'indexation basée sur 1 et l' ṁatome de moule / remodelage. Suggestions de golf bienvenues! Essayez-le en ligne!

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

36 octets de code + -pindicateur.

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

Pour l'exécuter:

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

Powershell, 73 55 octets

Un grand merci à TimmyD pour avoir rasé 18 octets!

Code:

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

$nest n dans x _n-1

Explication et code éclaté:

$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

Quelques notes:

• Powershell vous permet d'affecter des variables dans les mêmes instructions où vous les référencez. Par exemple, 1..($n=4)|%définira $ n sur 4, puis démarrera une boucle qui exécute $ n fois. 1peut être changé en n'importe quel entier et il bouclera $ n- [votre entier] +1 fois.
• Le type de données par défaut lors de l'utilisation [math]::dans Powershell est un double. Dans le code ci-dessus, nous devons explicitement transtyper $Ben une chaîne afin de pouvoir appeler.substring() car il n'y a pas de .substring()fonction pour les doubles dans Powershell.

Python 2,  44  41 octets

-3 octets grâce à xnor (utilisez une division entière pour éviter and)

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

repl.it

Fonction récursive basée sur 1.

Lorsque n>1la division entière ,, 1/nrésulte en 0, alors 0*1111=0qui est falsey, donc la droite de la orest évaluée, ce qui prend les quatre premiers caractères de la représentation du carré du n-1e résultat; ceci est ensuite jeté à unint .

Lorsque n=1la division entière ,, 1/nrésulte en 1, alors 1*1111=1111, ce qui est vrai, et la int 1111distribution en un intest 1111.

Groovy, 49 octets

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

Pyke, 10 octets

1RVX`4*4<b

Essayez-le ici!

MATL , 14 , 13 octets

1111G:"UV4:)U

Essayez-le en ligne!

Explication:

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 octets

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

Prend Nde stdin. 3334 est pratiquement X_0, ce qui est nécessaire car la boucle for doit être exécutée au moins une fois (il serait plus long de sauter).

R est vraiment un langage terrible pour prendre les quatre premiers chiffres d'un nombre, mais comme le nombre de cas est limité, nous n'avons qu'à nous soucier des carrés de x<3163etx>3162 , les premiers donnent un nombre à 6 chiffres, les seconds un nombre à 7 chiffres .

Le reste est assez simple, se %/%divise et ignore le reste.xest imprimé sur stdout.

Enregistré 2 octets grâce à @ETHproductions

Javagony - 153 octets

Javagony est une version restreinte de Java, qui ne permet aucun flux de contrôle à l'exception de la récursivité et try-catch, pas de boucles, tandis que les boucles, ou si. Le codage est un exercice assez amusant, mais frustrant. Pas que Java ordinaire ne soit pas aussi frustrant en soi.

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 octets

Sauvegardé 3 octets grâce à @ user59178

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

Exécuté à partir de la ligne de commande, indexé zéro.

Merci de ne pas vous soucier du type de mes variables, PHP! Ici, nous quadrillons simplement le nombre et coupons tout au-delà des 4 premiers chiffres, alternant nonchalamment entre le nombre et la chaîne sans souci dans le monde.

Brachylog , 18 octets

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

Essayez-le en ligne!

Cette réponse est indexée 0.

Explication

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

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

Un index.

Clojure, 76 octets

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

Premier golf de Clojure (semble être une langue agréable). Ceci est indexé 1.

Expliquera le code plus tard.

C #, 64 60 octets

Sauvegardé 4 octets en suivant le commentaire d' Olivier Grégoire sur une réponse Java!

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

Version précédente ( 64 octets ):

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

Programme complet avec méthode non golfée et cas de 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
        }
    }
}

Rubis, 47 octets

Premier golf! Enregistre les octets avec -noption (mais compte toujours comme 1! :)).

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

0 indexé. Pour l'exécuter:

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

Pyth, 13 12 octets

Merci à @Jakube pour -1 octet

us<*4`*GG4Q1

Un programme qui prend l'entrée d'un entier indexé 1 et imprime le résultat.

Suite de tests

Cela utilise une approche similaire à la réponse de @ Adnan .

Comment ça marche

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 octets

'14*ri{i2#s4<}*

Utilise l'indexation basée sur 0.

Essayez-le en ligne!

Lot, 82 octets

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

Comme Perl, les entiers sont des chaînes, mais contrairement à Perl, je ne peux prendre que la sous-chaîne d'une variable, et prendre des sous-chaînes à l'intérieur d'une boucle est quelque peu gênant.

Perl 6 , 36 octets

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

Explication:

{                                 } # 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

Tester:

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

Matlab, 79 , 78 octets

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

Cas de test:

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

Pas une solution incroyable. Je suis sûr qu'il doit y avoir une meilleure façon de tronquer à 4 chiffres mais je ne sais pas aujourd'hui.

Modifier: rasé un octet en définissant 0,5 -> 0,5

Java 8, 77 93 74 71 69 78 octets

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

Chaque répétition fait nles 4 premiers caractères de n*n.

Essayez Java en ligne !

Historique de la publication:

• 77 octets: code initial (incomplet)

• +16 octets, par Olivier Grégoire: code complété en en faisant une fonction Lambda.

• -19 octets: remplacer whilepar forcycle.

• -4 octets: utilisé longs au lieu de ints

• -2 octets, par Roman Gräf: suppression des crochets inutiles

• +9 octets, returninstruction manquante

Merci à @ OlivierGrégoire et @ RomanGräf pour avoir signalé certains problèmes!

Attendez, Java bat ... (drumroll) Clojure et Matlab ici! Un grand applaudissement à Java s'il vous plaît!

Perl, 36 octets

Une approche différente de l'autre solution Perl, conduisant à un code légèrement plus court. Aucun argument de ligne de commande n'est nécessaire (autre que l'argument de sélection de version habituel -M5.010, qui ne compte pas contre le nombre d'octets), ce qui signifie que c'est la même quantité de code mais avec moins de pénalités, ce qui donne un meilleur score global.

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

Nous créons une boucle de type Underload en répétant et en evaltapant une chaîne; J'ai expérimenté le démarrage de la chaîne au milieu, mais le démarrage au début s'avère être le plus court. Nous multiplions $&(le résultat de la dernière correspondance d'expressions régulières) par lui-même pour le mettre au carré; si le résultat est zéro, nous utilisons 1x4(c'est-à-dire 1111; Perl a un opérateur pour répéter les choses, y compris les chiffres d'un nombre) au lieu du résultat. Ensuite, nous regex les quatre premiers caractères. Le tout s'exécute dans le contexte de la liste car il est à l'intérieur say, donc le résultat final de evalsera le contenu des parenthèses de la correspondance finale.

Java, 79 67 66 64 octets

• Version 2.2 / 64 octets:

Merci à @Oliver Grégoire.

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

• Version 2.1 / 66 octets:

Merci à @ETHProduction.

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

• Version 2.0 / 67 octets:

Substring et trucs remplacés par l'idée de @Xanderhall

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

• Version 1.0 / 79 octets:

Bien qu'il existe des solutions plus courtes, je voulais publier un récursif :). Et je suis la fonction "réelle" la plus courte :). Edit: On dirait que je suis le plus court maintenant :)))

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

Pushy , 26 20 octets

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

Donner des arguments sur la ligne de commande: $ pushy sqseq.pshy 79.

Joliment formaté, avec explication:

            % 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