Setiap istilah dalam urutan kuadrat, x _n , dibuat dengan mengambil x _n-1 , mengkuadratkannya, dan menghapus semua kecuali empat digit pertama.

Urutan selalu dimulai dengan x ₁ = 1111 . Mengkuadratkan ini menghasilkan 1234321, jadi x ₂ = 1234

Beberapa istilah pertama adalah:

1111
1234
1522
2316
5363
...

Tantangan

Tugas Anda adalah, dengan bilangan bulat n -negatif , hitung x _n . Anda dapat mengirimkan program lengkap yang menjalankan I / O, atau fungsi yang menggunakan n sebagai parameter.

Solusi Anda bisa nol atau satu diindeks, selama Anda menentukan yang mana.

Karena semua istilah dalam urutan ini lebih pendek dari 5 digit, kode Anda juga harus sesingkat mungkin. Lubang kode standar golf berlaku.

Semoga pegolf terbaik menang!

Uji Kasus

Catatan: Ini adalah 1-diindeks.

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

05AB1E , 8 7 byte

Kode:

$Fn4×4£

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

JavaScript (ES7), 44 43 36 byte

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

Ini adalah contoh yang bagus dari penyalahgunaan tipe paksaan: **mengonversi kedua argumennya menjadi angka, dan +mengonversi kedua argumennya menjadi string kecuali keduanya adalah angka. Ini berarti bahwa f(n)**2+fpertama mengkonversi f(n)ke nomor dan kuadratkan, kemudian menyatukan hasilnya dengan representasi string f. Kita kemudian dapat menggunakan .sliceuntuk mengambil 4 karakter pertama dari string.

Berikut adalah beberapa pendekatan alternatif yang tidak menggunakan string:

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

Cuplikan tes

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>

Catatan: ini digunakan Math.powkarena **tidak didukung di semua browser.

Haskell, 40 byte

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

Ini adalah urutan berbasis 0. Contoh penggunaan: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Bagaimana itu bekerja:

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

Fungsi tanpa nama mengambil argumen integer; Diindeks 0. Menggunakan empat karakter tiga byte ⌊⌊⌋⌋: Mathematica menggunakan salah satu Floor[x]atau ⌊x⌋untuk membulatkan bilangan real ke integer, dan yang terakhir umumnya satu byte lebih sedikit. Nama perintah di Mathematica untuk mengonversi bilangan bulat menjadi string terlalu panjang, jadi alih-alih kami melakukan perhitungan matematis untuk menemukan empat digit pertama x ^ 2: kami mengambil basis-10 logaritma x ^ 2, kurangi bagian bilangan bulatnya, naikkan 10 kembali ke kekuatan itu, dan kalikan dengan 1000 dan bulatkan.

tl; dr: logaritma ftw

Python 2, 51 46 44 Bytes

Saya ingin menyingkirkan kikuk ifjika memungkinkan, tapi saya pikir execbisa lebih pendek .. Ternyata untuk saat execini lebih pendek. Salah lagi! Fungsi rekursif kembali. Ini satu-diindeks.

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

Solusi 46 byte alternatif dengan exec:

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

Solusi rekursif 49 byte alternatif:

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

^{Terima kasih kepada Flp.Tkc untuk menyimpan byte dengan mengingatkan saya bahwa mengkuadratkan tidak perlu eksponensial :)}

V , 19 byte

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

Cobalah online!

Ini menggunakan pengindeksan berbasis 0.

Tentu saja, karena angka bukan keahlian V , ini bukan golf. Namun, itu memang menunjukkan satu keunggulan bagus yang V miliki lebih dari vim. Anda dapat menjalankan makro 0 kali, yang tidak dimungkinkan dalam vim karena '0' adalah perintah bukan hitungan.

Ini mengandung banyak karakter yang tidak patut dicetak, jadi ini adalah hexdump:

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

Dan ini adalah versi yang dapat dibaca:

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

Penjelasan:

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

Jelly , 12 9 byte

-3 byte berkat Dennis menggunakan pengindeksan berbasis 1 dan ṁatom cetakan / pembentukan kembali. Selamat datang saran bermain golf! Cobalah online!

²Dṁ4Ḍ
1Ç¡

Tidak melakukanolf

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 kode + -pbendera.

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

Untuk menjalankannya:

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

Powershell, 73 55 byte

Terima kasih banyak kepada TimmyD karena telah memangkas 18 byte!

Kode:

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

$nadalah n dalam x _n-1

Penjelasan dan kode yang meledak:

$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

Beberapa catatan:

• Powershell memungkinkan Anda menetapkan variabel dalam pernyataan yang sama di mana Anda mereferensikannya. Sebagai contoh, 1..($n=4)|%akan menetapkan $ n ke 4 dan kemudian memulai loop yang berjalan $ n kali. 1dapat diubah ke integer apa saja dan itu akan mengulang $ n- [integer Anda] +1 kali.
• Tipe data default saat menggunakan [math]::di Powershell adalah ganda. Dalam kode di atas, kita harus secara eksplisit melemparkan $Bke string sehingga kita dapat memanggilnya .substring()karena tidak ada .substring()fungsi untuk ganda di Powershell.

Python 2,  44  41 byte

-3 byte terima kasih kepada xnor (gunakan divisi integer untuk menghindari and)

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

repl.it

Fungsi rekursif 1 berbasis.

Ketika n>1pembagian bilangan bulat 1/n,, menghasilkan 0, maka 0*1111=0yang falsey, sehingga hak ordievaluasi, yang mengambil empat karakter pertama dari representasi kuadrat dari n-1hasil th; ini kemudian dilemparkan ke sebuah int.

Ketika n=1pembagian bilangan bulat 1/n,, menghasilkan 1, maka 1*1111=1111, yang benar, dan int 1111dilemparkan ke sebuah intadalah 1111.

Groovy, 49 byte

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

Pyke, 10 byte

1RVX`4*4<b

Coba di sini!

MATL , 14 , 13 byte

1111G:"UV4:)U

Cobalah online!

Penjelasan:

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

Dibutuhkan N dari stdin. 3334 bisa dibilang X_0, yang diperlukan karena for-loop perlu dijalankan setidaknya sekali (akan lebih lama untuk melewati).

R benar-benar bahasa yang mengerikan untuk mengambil empat digit angka pertama, tetapi karena jumlah kasus terbatas, kita hanya perlu khawatir tentang kuadrat dari angka. x<3163 dan x>3162, yang pertama menghasilkan angka 6 digit, yang terakhir angka 7 digit .

Sisanya cukup mudah, %/%membagi dan mengabaikan sisanya.xdicetak ke stdout.

Disimpan 2 byte berkat produk @ETH

Javagony - 153 byte

Javagony adalah versi terbatas dari Java, yang tidak mengizinkan aliran kontrol apa pun kecuali rekursi dan try-catch, tidak untuk loop, saat loop, atau jika. Pengkodean di dalamnya adalah latihan yang cukup menyenangkan, tetapi membuat frustrasi. Bukan berarti Java biasa hampir tidak frustasi dengan sendirinya.

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

Disimpan 3 byte berkat @ user59178

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

Jalankan dari baris perintah, diindeks nol.

Terima kasih karena tidak peduli apa jenis variabel saya, PHP! Di sini kita cukup menguadratkan angka dan memotong semuanya melewati 4 digit pertama, dengan santai berganti-ganti antara angka dan string tanpa peduli di dunia.

Brachylog , 18 byte

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

Cobalah online!

Jawaban ini diindeks 0.

Penjelasan

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

Diindeks satu.

Clojure, 76 byte

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

Golf Clojure pertama (sepertinya bahasa yang bagus). Ini 1-diindeks.

Akan dijelaskan kodenya nanti.

C #, 64 60 byte

Disimpan 4 byte dengan mengikuti Olivier Grégoire 's komentar pada jawaban Java!

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

Versi sebelumnya ( 64 byte ):

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

Program lengkap dengan metode ungolfed dan uji kasus:

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 byte

Golf pertama! Menghemat byte dengan-n opsi (tetapi masih dihitung sebagai 1! :)).

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

Diindeks 0. Untuk menjalankannya:

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

Pyth, 13 12 byte

Berkat @ Jakube untuk -1 byte

us<*4`*GG4Q1

Suatu program yang mengambil input dari integer 1-indexed dan mencetak hasilnya.

Suite uji

Ini menggunakan pendekatan yang mirip dengan jawaban @ Adnan .

Bagaimana itu bekerja

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

Menggunakan pengindeksan berbasis 0.

Cobalah online!

Batch, 82 byte

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

Seperti Perl, integer adalah string, tetapi tidak seperti Perl, saya hanya bisa mengambil substring dari variabel, dan mengambil substring di dalam sebuah loop agak canggung.

Perl 6 , 36 byte

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

Penjelasan:

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

Uji:

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

Kasus uji:

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

Bukan solusi yang luar biasa. Saya yakin pasti ada cara yang lebih baik untuk memotong hingga 4 digit tapi saya tidak tahu hari ini.

Sunting: Mencukur satu byte dengan mengatur 0,5 -> 0,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;}

Setiap pengulangan membuat n4 karakter pertaman*n .

Coba Java online !

Posting sejarah:

• 77 byte: kode awal (tidak lengkap)

• +16 byte, oleh Olivier Grégoire: kode lengkap dengan menjadikannya fungsi Lambda.

• -19 byte: ganti whiledengan forcycle.

• -4 byte: digunakan longs bukan ints

• -2 byte, oleh Roman Gräf: menghapus tanda kurung yang tidak perlu

• +9 byte, returnpernyataan tidak ada

Terima kasih kepada @ OlivierGrégoire dan @ RomanGräf karena telah menunjukkan beberapa masalah!

Tunggu, Java beats ... (drumroll) Clojure dan Matlab di sini! Tepuk tangan meriah untuk Jawa!

Perl, 36 byte

Pendekatan yang berbeda dari solusi Perl lainnya, mengarah ke kode yang sedikit lebih pendek. Tidak ada argumen baris perintah yang diperlukan (selain argumen pemilihan versi biasa -M5.010,, yang tidak dihitung terhadap jumlah byte), yang berarti bahwa ini adalah jumlah kode yang sama tetapi dengan penalti yang lebih sedikit, memberikan skor keseluruhan yang lebih baik.

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

Kami membuat loop Underload-style melalui pengulangan dan eval-ing sebuah string; Saya bereksperimen dengan memulai string di tengah, tetapi memulainya di awal ternyata menjadi yang terpendek. Kami mengalikannya $&(hasil dari pertandingan regex terakhir) dengan sendirinya untuk membuatnya kuadrat; jika hasilnya nol, kami menggunakan 1x4(yaitu 1111; Perl memiliki operator untuk mengulangi hal-hal, termasuk angka angka) alih-alih hasilnya. Kemudian kita regex empat karakter pertama. Semuanya berjalan dalam konteks daftar karena berada di dalam say, dengan demikian hasil akhir dari evalakan menjadi tanda kurung pertandingan final.

Java, 79 67 66 64 byte

• Versi 2.2 / 64 byte:

Terima kasih kepada @Oliver Grégoire.

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

• Versi 2.1 / 66 byte:

Terima kasih kepada @ETHProduction.

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

• Versi 2.0 / 67 byte:

Substring diganti dan hal-hal dengan ide dari @Xanderhall

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

• Versi 1.0 / 79 byte:

Meskipun ada solusi yang lebih pendek saya ingin memposting satu rekursif :). Dan saya adalah fungsi "nyata" terpendek :). Sunting: Sepertinya saya yang terpendek sekarang :)))

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

Berikan argumen pada commandline: $ pushy sqseq.pshy 79.

Diformat dengan baik, dengan penjelasan:

            % 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