Kare alma sırayla her bir terim, x _{, n} , alınarak oluşturulan x _{, n-1} , o karesi, ve tüm ama ilk dört basamak çıkarılması.

Dizi daima x ₁ = 1111 ile başlar . Bunun karesi 1234321 olur, yani x ₂ = 1234

İlk birkaç terim:

1111
1234
1522
2316
5363
...

Meydan okuma

Göreviniz, bir negatif olmayan tamsayı verilir n hesapla, x _n . G / Ç gerçekleştiren tam bir program veya n'yi parametre olarak alan bir işlev gönderebilirsiniz .

Çözümü, hangisini belirttiğiniz sürece sıfır veya bir dizinlenebilir.

Bu dizideki tüm terimler 5 basamaktan kısa olduğundan, kodunuz da mümkün olduğu kadar kısa olmalıdır. Standart kod-golf boşlukları uygulanır.

En iyi golfçü kazansın!

Test Kılıfları

Not: Bunlar 1 indekslidir.

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

05AB1E , 8 7 bayt

Kod:

$Fn4×4£

Açıklama:

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

JavaScript (ES7), 44 43 36 bayt

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

Bu, zorlama tipi baskı uygulamasına harika bir örnektir: **her iki argümanını da sayılara +dönüştürür ve her ikisi de sayı olmadıkça her iki argümanını da dizelere dönüştürür. Bu, f(n)**2+filk önce f(n)bir sayıya dönüşüp karelerin çizildiği, ardından sonucun dize temsili ile bittiği anlamına gelir f. Daha sonra .slicedizenin ilk 4 karakterini almak için kullanabiliriz .

Dizeleri kullanmayan birkaç alternatif yaklaşım:

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

Test pasajı

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>

Not: Bu kullanımları Math.pownedeniyle **tüm tarayıcılarda desteklenmez.

Haskell, 40 bayt

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

0 tabanlı bir dizi. Kullanım örneği: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Nasıl çalışır:

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 bayt

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

Bir tamsayı argüman alarak adlandırılmamış fonksiyon; 0 endeksli. Dört üç baytlık karakter kullanır⌊⌊⌋⌋ kullanır: Mathematica ya bir ya Floor[x]da ⌊x⌋bir tam sayıya gerçek sayıları yuvarlamak için kullanır ya da ikincisi genellikle bir daha az bayttır. Tam sayıların dizgelere dönüştürülmesi için Mathematica'daki komut adları çok uzun, bu yüzden x ^ 2'nin ilk dört basamağını bulmak için matematiksel bir hesaplama yapıyoruz: x ^ 2'nin üs-10 logaritmasını alıyoruz, tamsayı kısmını çıkarıyoruz, 10 bu güce geri dönün ve 1000 ile çarpın ve aşağı yuvarlayın.

tl; dr: logaritmalar ftw

Python 2, 51 46 44 Bayt

ifMümkünse topaktan kurtulmak isterdim , ama bence execdaha kısa olabilir .. Daha kısa bir an için çıkıyor exec. Yine yanlış! Özyinelemeli işlevi döner. Bu bir dizinli.

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

Aşağıdakileri içeren bir araç-46-baytlık çözüm exec:

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

Alternatif bir 49 bayt özyinelemeli çözüm:

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

^{Flp.Tkc'ye, karenin üstelleştirmeye gerek duymadığını hatırlatarak bir bayt tasarrufu için teşekkürler :)}

V , 19 bayt

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

Çevrimiçi deneyin!

Bu 0 tabanlı indeksleme kullanır.

Sayılar tam olarak V'nin olmadıklarından Tabii ki, forte , bu çok Golfy değildir. Bununla birlikte, V'nin çok fazla avantajı olduğu güzel bir avantaj gösteriyor. Makroyu 0 kez çalıştırabilirsiniz , çünkü '0' sayı sayılmaz bir komut olduğundan vim'de mümkün değildir.

Bu, birçok yazdırılamaz karakter içeriyor, bu yüzden burada bir hexdump:

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

Ve işte okunabilir bir sürüm:

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

Açıklama:

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

Jöle , 12 9 bayt

1 tabanlı indeksleme ve ṁkalıp / yeniden şekillendirme atomu kullanan Dennis sayesinde -3 bayt . Golf önerileri hoş geldiniz! Çevrimiçi deneyin!

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

36 bayt kodu + -pbayrak.

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

Çalıştırmak için:

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

Powershell, 73 55 bayt

18 bayt'ı tıraş eden TimmyD'ye çok teşekkürler!

Kod:

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

$nolduğu , n de , x _{, n-1}

Açıklama ve patlamış kod:

$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

Bazı notlar:

• Powershell, değişkenlere referans verdiğiniz ifadelerde aynı atamanıza izin verir. Örneğin, 1..($n=4)|%$ n'yi 4'e ayarlayıp sonra $ n kere çalışan bir döngü başlatacak. 1Herhangi bir tamsayı olarak değiştirilebilir ve $ n- [tamsayı] +1 kez döngü.
• [math]::Powershell'de kullanılırken varsayılan veri türü iki katıdır. Yukarıdaki kodda açıkça $Bbir dizgeye atmamız gerekiyor, böylece .substring()üzerinde çağırabilelim çünkü .substring()Powershell'de çiftler için bir işlev yok .

Python 2,  44  41 bayt

Xnor sayesinde -3 bayt (önlemek için bir tamsayı bölme kullanın and)

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

repl.it

1 tabanlı özyinelemeli fonksiyon.

Zaman n>1tam sayı bölümü 1/nile sonuçlanır 0, daha sonra 0*1111=0, Falsey değildir doğru çok orkaresinin gösterimi ilk dört karakterini alır, değerlendirilir n-1inci sonucu; bu daha sonra birint .

Zaman n=1tam sayı bölümü 1/nsonuçlanır 1sonra 1*1111=1111, truthy olduğu ve hangi int 1111bir dökme intolup 1111.

Groovy, 49 bayt

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

Pyke, 10 bayt

1RVX`4*4<b

Burada dene!

MATL , 14 , 13 bayt

1111G:"UV4:)U

Çevrimiçi deneyin!

Açıklama:

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 bayt

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

Alır Nstdin'den. 3334 pratikte X_0'dur, çünkü for-loop'un en az bir kez çalıştırılması gerekir (atlamak daha uzun sürer).

R gerçekten numaranın ilk dört hanesini almak için korkunç bir dildir, ancak vaka sayısı sınırlı olduğundan, sadece kareler hakkında endişe zorunda x<3163ve x>3162eski verimi 6 haneli numara, ikincisi 7 basamaklı sayı .

Gerisi oldukça basit, %/% kalanları ayırır ve yok sayar.xstdout'a yazdırılır.

@ETHproductions sayesinde 2 bayt kaydedildi

Javagony - 153 bayt

Javagony, Java'nın yinelenen durumlar dışında herhangi bir kontrol akışına izin vermeyen ve try-catchdöngüler için, döngüler sırasında ya da if'ler için izin verilmeyen sınırlı bir sürümüdür . İçinde kodlama oldukça eğlenceli bir egzersiz, ancak sinir bozucu. Düzenli Java, neredeyse kendi başına sinir bozucu değil.

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 bayt

@ User59178 sayesinde 3 bayt kaydedildi

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

Komut satırından çalıştırın, sıfır dizinli.

Thanks for not caring about what type my variables are, PHP! Here we simply square the number and trim off everything past the first 4 digits, casually alternating between number and string without a care in the world.

Brachylog, 18 bytes

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

Try it online!

This answer is 0-indexed.

Explanation

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

One-indexed.

Clojure, 76 bytes

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

First Clojure golf (seems like a nice language). This is 1-indexed.

Will explain the code later.

C#, 64 60 bytes

Saved 4 bytes by following Olivier Grégoire's comment on a Java answer!

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

Previous version (64 bytes):

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

Full program with ungolfed method and test cases:

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

First golf! Saves bytes with -n option (but still count as 1! :)).

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

0-indexed. To run it:

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

Pyth, 13 12 bytes

Thanks to @Jakube for -1 byte

us<*4`*GG4Q1

A program that takes input of a 1-indexed integer and prints the result.

Test suite

This uses a similar approach to @Adnan's answer.

How it works

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

Uses 0-based indexing.

Try it online!

Batch, 82 bytes

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

Like Perl, integers are strings, but unlike Perl I can only take the substring of a variable, and taking substrings inside a loop is somewhat awkward.

Perl 6, 36 bytes

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

Explanation:

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

Test cases:

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

Not an amazing solution. I'm sure there must be a better way to truncate to 4 digits but I don't know today.

Edit: Shaved a byte by setting 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;}

Each repetition makes n the first 4 characters of n*n.

Try Java online!

Post history:

• 77 bytes: initial code (incomplete)

• +16 bytes, by Olivier Grégoire: completed code by making it a Lambda function.

• -19 bytes: replace while with for cycle.

• -4 bytes: used longs instead of ints

• -2 bytes, by Roman Gräf: removed unnecessary brackets

• +9 bytes, missing return statement

Thanks to @OlivierGrégoire and @RomanGräf for pointing out some issues!

Wait, Java beats... (drumroll) Clojure and Matlab here! A big applause to Java please!

Perl, 36 bytes

A different approach from the other Perl solution, leading to slightly shorter code. No command-line arguments are needed (other than the usual version selection argument, -M5.010, which doesn't count against the byte count), meaning that this is the same amount of code but with fewer penalties, giving a better overall score.

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

We create a loop Underload-style via repeating and eval-ing a string; I experimented with starting the string in the middle, but starting it at the start turns out to be shortest. We multiply $& (the result of the last regex match) by itself to square it; if the result's zero, we use 1x4 (i.e. 1111; Perl has an operator for repeating things, including digits of a number) instead of the result. Then we regex the first four characters. The whole thing runs in list context due to being inside say, thus the final result of the eval will be the contents of the parentheses of the final match.

Java, 79 67 66 64 bytes

• Version 2.2/64 bytes:

Thanks to @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 bytes:

Thanks to @ETHProduction.

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

• Version 2.0/67 bytes:

Replaced substring and stuff with the idea from @Xanderhall

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

• Version 1.0/79 bytes:

Although there are shorter solutions I wanted to post one recursive:). And I am the shortest "real" function:). Edit: Seems like I am the shortest now:)))

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

Give arguments on the commandline: $ pushy sqseq.pshy 79.

Nicely formatted, with explanation:

            % 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