Cada termo na sequência quadrática, x _n , é criado tomando x _n-1 , quadrando-o e removendo todos, exceto os quatro primeiros dígitos.

A sequência sempre começa com x ₁ = 1111 . Ao quadrado, isso resulta em 1234321, então x ₂ = 1234

Os primeiros termos são:

1111
1234
1522
2316
5363
...

O desafio

Sua tarefa é, dado um número inteiro não negativo n , calcular x _n . Você pode enviar um programa completo que execute E / S ou uma função que aceite n como parâmetro.

Sua solução pode ser zero ou uma indexada, desde que você especifique qual.

Como todos os termos nesta sequência são menores que 5 dígitos, seu código também deve ser o mais curto possível. Aplicam -se lacunas de código-golfe padrão .

Que ganhe o melhor jogador de golfe!

Casos de teste

Nota: Estes são 1 indexados.

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

05AB1E , 8 7 bytes

Código:

$Fn4×4£

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

JavaScript (ES7), 44 43 36 bytes

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

Este é um ótimo exemplo de abuso de coerção de tipo: ** converte os dois argumentos em números e +converte os dois em seqüências de caracteres, a menos que ambos sejam números. Isso significa que f(n)**2+fprimeiro se converte f(n)em um número e o coloca ao quadrado, depois concatena o resultado com a representação de sequência de f. Em seguida, podemos usar .slicepara recuperar os 4 primeiros caracteres da string.

Aqui estão algumas abordagens alternativas que não usam seqüências de caracteres:

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

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: isso usa Math.powporque** não é suportado em todos os navegadores.

Haskell, 40 bytes

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

É uma sequência baseada em 0. Exemplo de uso:((iterate(read.take 4.show.(^2))1111)!!) 79 -> 4717.

Como 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,#]&

Função sem nome usando um argumento inteiro; Indexado a 0. Usa quatro caracteres de três bytes ⌊⌊⌋⌋: O Mathematica usa Floor[x]ou⌊x⌋ para arredondar um número real para um número inteiro, e o último geralmente é um byte a menos. Os nomes de comando no Mathematica para converter números inteiros em cadeias são muito longos; portanto, fazemos um cálculo matemático para encontrar os quatro primeiros dígitos de x ^ 2: pegamos o logaritmo da base 10 de x ^ 2, subtraímos sua parte inteira, aumentamos 10 de volta a esse poder, e multiplique por 1000 e arredonde para baixo.

tl; dr: logaritmos ftw

Python 2, 51 46 44 bytes

Eu gostaria de me livrar do desajeitado, ifse possível, mas acho que um execpoderia ser mais curto. Acontece que, no momento, execé mais curto. Errado de novo! A função recursiva retorna. Este é um indexado.

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

Uma solução alternativa de 46 bytes com exec:

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

Uma solução recursiva alternativa de 49 bytes:

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

^{Obrigado ao Flp.Tkc por salvar um byte, lembrando-me que o quadrado não precisa de exponenciação :)}

V , 19 bytes

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

Experimente online!

Isso usa indexação baseada em 0.

Obviamente, como os números não são exatamente o forte de V , isso não é muito bom. No entanto, mostra uma boa vantagem que o V possui sobre o vim. Você pode executar uma macro 0 vezes, o que não é possível no vim, pois '0' é um comando e não uma contagem.

Isso contém muitos caracteres não imprimíveis, então aqui está um hexdump:

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

E aqui está uma versão legível:

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

Explicação:

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éia , 12 9 bytes

-3 bytes graças a Dennis usando a indexação baseada em 1 e o ṁátomo de molde / remodelação. Sugestões de golfe são bem-vindas! Experimente 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 bytes

36 bytes de código + -psinalizador.

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

Para executá-lo:

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

Powershell, 73 55 bytes

Um enorme obrigado a TimmyD por remover 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

$né n em x _n-1

Explicação e código explodido:

$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

Algumas notas:

• O PowerShell permite atribuir variáveis ​​nas mesmas instruções em que você as referencia. Por exemplo, 1..($n=4)|%definirá $ n para 4 e iniciará um loop que executa $ n vezes. 1pode ser alterado para qualquer número inteiro e repetirá $ n- [seu número inteiro] +1 vezes.
• O tipo de dados padrão ao usar o [math]::Powershell é duplo. No código acima, temos que converter explicitamente $Bem uma string para podermos chamá .substring()-la, porque não há .substring()função para dobros no Powershell.

Python 2,  44  41 bytes

-3 bytes graças ao xnor (use uma divisão inteira para evitar and)

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

repl.it

Função recursiva baseada em 1.

Quando n>1a divisão inteira 1/n, resulta em 0, então o 0*1111=0que é falsey, então o direito do oré avaliado, o que leva os quatro primeiros caracteres da representação do quadrado do n-1resultado th; isso é então convertido para um int.

Quando n=1a divisão inteira 1/n, resulta em 1, então 1*1111=1111, que é verdade, e a int 1111conversão para um inté 1111.

Groovy, 49 bytes

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

Pyke, 10 bytes

1RVX`4*4<b

Experimente aqui!

MATL , 14 , 13 bytes

1111G:"UV4:)U

Experimente online!

Explicação:

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 é praticamente X_0, o que é necessário porque o loop for precisa ser executado pelo menos uma vez (seria mais demorado).

R é realmente uma linguagem terrível para obter os quatro primeiros dígitos de um número, mas, como o número de casos é limitado, precisamos nos preocupar apenas com os quadrados x<3163e x>3162, o primeiro gera um número de 6 dígitos e o segundo, um número de 7 dígitos. .

O resto é bem direto, %/% divide e ignora o restante.xé impresso em stdout.

Economizou 2 bytes graças a @ETHproductions

Javagony - 153 bytes

Javagony é uma versão restrita do Java, que não permite nenhum fluxo de controle, exceto recursão e try-catch, não para loops, loops ou if. Codificar nele é um exercício bastante divertido, mas frustrante. Não que o Java comum não seja tão frustrante por si só.

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 graças a @ user59178

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

Execute a partir da linha de comando, indexada a zero.

Obrigado por não se importar com o tipo de minhas variáveis, PHP! Aqui, simplesmente esquadrinhamos o número e recortamos tudo além dos 4 primeiros dígitos, alternando casualmente entre número e string sem se preocupar com o mundo.

Braquilog , 18 bytes

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

Experimente online!

Esta resposta é indexada em 0.

Explicação

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

Um indexado.

Clojure, 76 bytes

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

Primeiro golfe de Clojure (parece uma linguagem agradável). Isso é indexado em 1.

Explicará o código mais tarde.

C #, 64 60 bytes

Salvo 4 bytes, seguindo Olivier Gregoire s' comentário de em uma resposta Java!

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

Versão anterior ( 64 bytes ):

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

Programa completo com método não destruído e casos de teste:

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

Primeiro golfe! Salva bytes com a -nopção (mas ainda conta como 1! :)).

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

Indexado a 0. Para executá-lo:

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

Pitão, 13 12 bytes

Obrigado a @Jakube por -1 byte

us<*4`*GG4Q1

Um programa que recebe a entrada de um inteiro indexado em 1 e imprime o resultado.

Suíte de teste

Isso usa uma abordagem semelhante à resposta de @ Adnan .

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

Usa indexação baseada em 0.

Experimente online!

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%

Como o Perl, números inteiros são strings, mas, diferentemente do Perl, só posso pegar a substring de uma variável, e pegar substrings dentro de um loop é um pouco estranho.

Perl 6 , 36 bytes

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

Explicação:

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

Teste:

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 teste:

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

Não é uma solução incrível. Tenho certeza de que deve haver uma maneira melhor de truncar para 4 dígitos, mas não sei hoje.

Editar: Raspou um byte definindo 0,5 -> 0,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 repetição compõe nos 4 primeiros caracteres de n*n.

Experimente o Java online !

Histórico de postagens:

• 77 bytes: código inicial (incompleto)

• +16 bytes, de Olivier Grégoire: código completo, tornando-o uma função Lambda.

• -19 bytes: substitua whilepelo forciclo.

• -4 bytes: longs usados ​​em vez de ints

• -2 bytes, por Roman Gräf: colchetes desnecessários removidos

• +9 bytes, returndeclaração ausente

Agradecemos a @ OlivierGrégoire e @ RomanGräf por apontar alguns problemas!

Espere, Java bate ... (tambor) Clojure e Matlab aqui! Um grande aplauso para Java, por favor!

Perl, 36 bytes

Uma abordagem diferente da outra solução Perl, levando a um código um pouco mais curto. Não são necessários argumentos de linha de comando (exceto o argumento de seleção de versão usual -M5.010, que não conta na contagem de bytes), o que significa que essa é a mesma quantidade de código, mas com menos penalidades, proporcionando uma pontuação geral melhor.

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

Criamos um loop no estilo Underload, repetindo e evalpressionando uma string; Eu experimentei iniciar a corda no meio, mas iniciá-la no início acaba sendo a mais curta. Multiplicamos $&(o resultado da última correspondência de regex) por si só para quadrá-lo; se o resultado for zero, usamos 1x4(ou seja 1111; Perl tem um operador para repetir coisas, incluindo dígitos de um número) em vez do resultado. Em seguida, regexamos os quatro primeiros caracteres. A coisa toda é executada no contexto da lista devido a estar dentro say, portanto, o resultado final do evalserá o conteúdo dos parênteses da partida final.

Java, 79 67 66 64 bytes

• Versão 2.2 / 64 bytes:

Obrigado a @Oliver Grégoire.

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

• Versão 2.1 / 66 bytes:

Graças a @ETHProduction.

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

• Versão 2.0 / 67 bytes:

Substituiu substring e outras coisas pela ideia de @Xanderhall

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

• Versão 1.0 / 79 bytes:

Embora existam soluções mais curtas, eu queria postar uma :) recursiva. E eu sou a menor função "real" :). Edit: Parece que eu sou o mais curto agora :)))

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

Dê argumentos na linha de comando: $ pushy sqseq.pshy 79.

Bem formatado, com explicação:

            % 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