Cada término en la secuencia de cuadratura, x _n , se crea tomando x _n-1 , cuadrándolo y eliminando todos menos los primeros cuatro dígitos.

La secuencia siempre comienza con x ₁ = 1111 . Al cuadrar esto se obtiene 1234321, entonces x ₂ = 1234

Los primeros términos son:

1111
1234
1522
2316
5363
...

El reto

Su tarea es, dado un número entero no negativo n , calcular x _n . Puede enviar un programa completo que realice E / S o una función que tome n como parámetro.

Su solución puede ser cero o una indexada, siempre que especifique cuál.

Como todos los términos en esta secuencia son más cortos que 5 dígitos, su código también debe ser lo más corto posible. Se aplican las lagunas de código estándar de golf .

¡Que gane el mejor golfista!

Casos de prueba

Nota: Estos están indexados en 1.

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

05AB1E , 8 7 bytes

Código:

$Fn4×4£

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

JavaScript (ES7), 44 43 36 bytes

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

Este es un gran ejemplo de abuso de la coerción de tipos: **convierte ambos argumentos en números y +convierte ambos argumentos en cadenas a menos que ambos sean números. Esto significa que f(n)**2+fprimero se convierte f(n)en un número y lo cuadra, luego concatena el resultado con la representación de cadena de f. Luego podemos usar .slicepara recuperar los primeros 4 caracteres de la cadena.

Aquí hay algunos enfoques alternativos que no usan cadenas:

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

Fragmento de prueba

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: esto se usa Math.powporque **no es compatible con todos los navegadores.

Haskell, 40 bytes

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

Es una secuencia basada en 0. Ejemplo de uso: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Cómo funciona:

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 bytes

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

Función sin nombre que toma un argumento entero; 0 indexado. Utiliza cuatro caracteres de tres bytes ⌊⌊⌋⌋: Mathematica usa cualquiera Floor[x]o ⌊x⌋para redondear un número real a un entero, y este último generalmente es un byte menos. Los nombres de comando en Mathematica para convertir enteros en cadenas son demasiado largos, por lo que en su lugar hacemos un cálculo matemático para encontrar los primeros cuatro dígitos de x ^ 2: tomamos el logaritmo de base 10 de x ^ 2, restamos su parte entera, elevamos 10 de vuelta a ese poder, y multiplicar por 1000 y redondear hacia abajo.

tl; dr: logaritmos ftw

Python 2, 51 46 44 Bytes

Me gustaría deshacerme del torpe ifsi es posible, pero creo que un execpodría ser más corto ... Resulta que por el momento execes más corto. ¡Nuevamente incorrecto! La función recursiva regresa. Esto es un índice.

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

Una solución alternativa de 46 bytes con exec:

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

Una solución recursiva alternativa de 49 bytes:

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

^{Gracias a Flp.Tkc por guardar un byte recordándome que la cuadratura no necesita exponenciación :)}

V , 19 bytes

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

Pruébalo en línea!

Esto usa indexación basada en 0.

Por supuesto, dado que los números no son exactamente el fuerte de V , esto no es muy complejo. Sin embargo, muestra una buena ventaja que V tiene sobre vim. Puede ejecutar una macro 0 veces, lo que no es posible en vim ya que '0' es un comando, no un conteo.

Este contiene muchos caracteres no imprimibles, así que aquí hay un hexdump:

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

Y aquí hay una versión legible:

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

Explicación:

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

Jalea , 12 9 bytes

-3 bytes gracias a Dennis que usa la indexación basada en 1 y el ṁátomo de molde / remodelación. Sugerencias de golf bienvenidas! Pruébalo en línea!

²Dṁ4Ḍ
1Ç¡

No golfista

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 bytes

36 bytes de código + -pbandera.

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

Para ejecutarlo:

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

Powershell, 73 55 bytes

¡Muchas gracias a TimmyD por reducir 18 bytes!

Código:

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

$nes n en x _n-1

Explicación y código explotado:

$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

Algunas notas:

• Powershell le permite asignar variables en las mismas declaraciones donde las hace referencia. Por ejemplo, 1..($n=4)|%establecerá $ n en 4 y luego iniciará un ciclo que se ejecuta $ n veces. 1se puede cambiar a cualquier entero y se repetirá $ n- [su entero] +1 veces.
• El tipo de datos predeterminado cuando se usa [math]::en Powershell es un doble. En el código anterior, tenemos que convertir explícitamente $Ba una cadena para poder invocarla .substring()porque no hay .substring()función para los dobles en Powershell.

Python 2,  44  41 bytes

-3 bytes gracias a xnor (use una división entera para evitar and)

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

repl.it

Función recursiva basada en 1.

Cuando n>1la división entera 1/nda como resultado 0, entonces, 0*1111=0que es falsey , entonces se evalúa el derecho del or, que toma los primeros cuatro caracteres de la representación del cuadrado del n-1resultado th; esto luego se lanza a un int.

Cuando n=1la división entera 1/n, resulta 1, entonces 1*1111=1111, que es verdad, y el int 1111elenco a un intes 1111.

Groovy, 49 bytes

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

Pyke, 10 bytes

1RVX`4*4<b

Pruébalo aquí!

MATL , 14 , 13 bytes

1111G:"UV4:)U

Pruébalo en línea!

Explicación:

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 bytes

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

Toma Nde stdin. 3334 es prácticamente X_0, lo cual es necesario porque el bucle for debe ejecutarse al menos una vez (sería más largo omitirlo).

R realmente es un lenguaje terrible para tomar los primeros cuatro dígitos de un número, pero como el número de casos es limitado, solo tenemos que preocuparnos por los cuadrados de x<3163 y x>3162, el primero produce un número de 6 dígitos, el último un número de 7 dígitos .

El resto es bastante sencillo, %/%divide e ignora el resto.xestá impreso en stdout.

Guardado 2 bytes gracias a @ETHproductions

Javagony - 153 bytes

Javagony es una versión restringida de Java, que no permite ningún flujo de control, excepto la recursión y try-catchno para bucles, bucles while o if. Codificarlo es un ejercicio bastante divertido, pero frustrante. No es que Java normal no sea tan frustrante por sí mismo.

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 bytes

Guardado 3 bytes gracias a @ user59178

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

Ejecutar desde la línea de comando, indexado a cero.

¡Gracias por no preocuparte por el tipo de variables que tengo, PHP! Aquí simplemente cuadramos el número y recortamos todo más allá de los primeros 4 dígitos, alternando casualmente entre número y cadena sin importar el mundo.

Brachylog , 18 bytes

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

Pruébalo en línea!

Esta respuesta está indexada a 0.

Explicación

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

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

Un índice.

Clojure, 76 bytes

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

Primero golf Clojure (parece un buen lenguaje). Esto es 1 indexado.

Explicaré el código más tarde.

C #, 64 60 bytes

¡Ahorré 4 bytes siguiendo el comentario de Olivier Grégoire en una respuesta Java!

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

Versión anterior ( 64 bytes ):

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

Programa completo con método no protegido y casos de prueba:

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

Ruby, 47 bytes

Primero golf! Guarda bytes con la -nopción (¡pero aún cuenta como 1! :)).

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

0 indexado. Para ejecutarlo:

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

Pyth, 13 12 bytes

Gracias a @Jakube por -1 byte

us<*4`*GG4Q1

Un programa que toma la entrada de un entero indexado 1 e imprime el resultado.

Banco de pruebas

Esto utiliza un enfoque similar a la respuesta de @ Adnan .

Cómo funciona

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 bytes

'14*ri{i2#s4<}*

Utiliza indexación basada en 0.

Pruébalo en línea!

Lote, 82 bytes

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

Al igual que Perl, los enteros son cadenas, pero a diferencia de Perl, solo puedo tomar la subcadena de una variable, y tomar subcadenas dentro de un bucle es algo incómodo.

Perl 6 , 36 bytes

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

Explicación:

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

Prueba:

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

Matlab, 79 , 78 bytes

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

Casos de prueba:

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

No es una solución asombrosa. Estoy seguro de que debe haber una mejor manera de truncar a 4 dígitos, pero no lo sé hoy.

Editar: afeitó un byte configurando 0.5 -> .5

Java 8, 77 93 74 71 69 78 bytes

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

Cada repetición forma nlos primeros 4 caracteres de n*n.

Prueba Java en línea !

Historial de publicaciones:

• 77 bytes: código inicial (incompleto)

• +16 bytes, por Olivier Grégoire: código completado al convertirlo en una función Lambda.

• -19 bytes: reemplazar whilecon forciclo.

• -4 bytes: longs usado en lugar de ints

• -2 bytes, por Roman Gräf: se eliminaron los corchetes innecesarios

• +9 bytes, returndeclaración faltante

¡Gracias a @ OlivierGrégoire y @ RomanGräf por señalar algunos problemas!

Espera, Java late ... (redoble de tambores) ¡ Clojure y Matlab aquí! Un gran aplauso a Java por favor!

Perl, 36 bytes

Un enfoque diferente de la otra solución de Perl, lo que lleva a un código ligeramente más corto. No se necesitan argumentos de línea de comandos (aparte del argumento de selección de versión habitual -M5.010, que no cuenta para el recuento de bytes), lo que significa que esta es la misma cantidad de código pero con menos penalizaciones, dando una mejor puntuación general.

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

Creamos un estilo de subcarga de bucle mediante la repetición y eval-ing de una cadena; Experimenté comenzando la cadena en el medio, pero comenzarla al principio resulta ser la más corta. Multiplicamos $&(el resultado de la última coincidencia de expresiones regulares) por sí mismo para cuadrarlo; si el resultado es cero, usamos 1x4(es decir 1111, Perl tiene un operador para repetir cosas, incluidos los dígitos de un número) en lugar del resultado. Luego regexamos los primeros cuatro caracteres. Todo se ejecuta en el contexto de la lista debido a que está dentro say, por lo que el resultado final evalserá el contenido de los paréntesis de la coincidencia final.

Java, 79 67 66 64 bytes

• Versión 2.2 / 64 bytes:

Gracias a @Oliver Grégoire.

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

• Versión 2.1 / 66 bytes:

Gracias a @ETHProduction.

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

• Versión 2.0 / 67 bytes:

Subcadena reemplazada y otras cosas con la idea de @Xanderhall

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

• Versión 1.0 / 79 bytes:

Aunque hay soluciones más cortas, quería publicar una recursiva :). Y yo soy la función "real" más corta :). Editar: Parece que soy el más bajo ahora :)))

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

Pushy , 26 20 bytes

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

Da argumentos en la línea de comandos: $ pushy sqseq.pshy 79 .

Bien formateado, con explicación:

            % 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