Każdy termin w sekwencji kwadratu, x _n , jest tworzony przez pobranie x _n-1 , podniesienie go do kwadratu i usunięcie wszystkich oprócz pierwszych czterech cyfr.

Sekwencja zawsze zaczyna się od x ₁ = 1111 . Kwadrat ten daje 1234321, więc x ₂ = 1234

Pierwsze kilka warunków to:

1111
1234
1522
2316
5363
...

Wyzwanie

Twoim zadaniem jest, biorąc pod uwagę nieujemną liczbę całkowitą n , obliczyć x _n . Możesz przesłać pełny program wykonujący operacje we / wy lub funkcję, która przyjmuje parametr n jako parametr.

Twoje rozwiązanie może mieć zero lub jeden indeks, o ile określisz, które.

Ponieważ wszystkie terminy w tej sekwencji są krótsze niż 5 cyfr, Twój kod powinien być tak krótki, jak to możliwe. Obowiązują standardowe luki w kodzie golfowym .

Niech zwycięży najlepszy golfista!

Przypadki testowe

Uwaga: są one indeksowane 1.

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

05AB1E , 8 7 bajtów

Kod:

$Fn4×4£

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

JavaScript (ES7), 44 43 36 bajtów

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

To świetny przykład nadużywania przymusu typu: **konwertuje oba argumenty na liczby i +konwertuje oba argumenty na ciągi znaków, chyba że oba są liczbami. Oznacza to, że f(n)**2+fnajpierw konwertuje f(n)się na liczbę i podnosi ją do kwadratu, a następnie łączy wynik z reprezentacją ciągu f. Następnie możemy użyć .slicedo pobrania pierwszych 4 znaków ciągu.

Oto kilka alternatywnych podejść, które nie używają ciągów:

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

Testowy fragment kodu

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>

Uwaga: ta funkcja jest używana, Math.powponieważ **nie jest obsługiwana we wszystkich przeglądarkach.

Haskell, 40 bajtów

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

Jest to sekwencja oparta na 0. Przykład użycia: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Jak to działa:

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 bajtów

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

Funkcja bez nazwy przyjmująca argument liczby całkowitej; 0-indeksowane. Wykorzystuje cztery trzy bajtowe znaki ⌊⌊⌋⌋: Mathematica używa albo, Floor[x]albo ⌊x⌋zaokrągla liczbę rzeczywistą w dół do liczby całkowitej, a ta ostatnia jest zazwyczaj o jeden mniej bajta. Nazwy poleceń w Mathematica do konwersji liczb całkowitych na ciągi są zbyt długie, dlatego zamiast tego wykonujemy obliczenia matematyczne, aby znaleźć pierwsze cztery cyfry x ^ 2: bierzemy logarytm dziesiętny x ^ 2, odejmujemy jego część całkowitą, podnosimy 10 z powrotem do tej mocy, pomnóż przez 1000 i zaokrąglaj w dół.

tl; dr: logarithms ftw

Python 2, 51 46 44 bajtów

Chciałbym się pozbyć niezgrabnego, ifjeśli to możliwe, ale myślę, że execmoże być krótszy .. Okazuje się, że moment execjest krótszy. Znowu źle! Funkcja rekurencyjna powraca. Jest to jeden indeks.

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

Alternatywne 46-bajtowe rozwiązanie z exec:

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

Alternatywne 49-bajtowe rozwiązanie rekurencyjne:

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

^{Dziękuję Flp.Tkc za uratowanie bajtu, przypominając mi, że kwadraty nie wymagają potęgowania :)}

V , 19 bajtów

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

Wypróbuj online!

Korzysta z indeksowania opartego na 0.

Oczywiście, ponieważ liczby nie są dokładnie V za forte , to nie jest bardzo Golfy. Jednak pokazuje jedną fajną przewagę V nad vimem. Możesz uruchomić makro 0 razy, co nie jest możliwe w vimie, ponieważ „0” jest poleceniem, a nie liczbą.

Zawiera wiele niedrukowalnych znaków, więc oto zrzut heksowy:

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

A oto czytelna wersja:

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

Wyjaśnienie:

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

Galaretka , 12 9 bajtów

-3 bajty dzięki Dennisowi stosującemu indeksowanie 1 i ṁatomowi formy / zmiany kształtu. Zapraszamy do gry w golfa! Wypróbuj 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 bajtów

36 bajtów kodu + -pflaga.

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

Aby uruchomić:

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

PowerShell, 73 55 bajtów

Ogromne podziękowania dla TimmyD za zmniejszenie liczby 18 bajtów!

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

$njest N w X _N-1

Objaśnienie i rozbity 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

Niektóre uwagi:

• Program PowerShell pozwala przypisywać zmienne w tych samych instrukcjach, do których się odwołują. Na przykład 1..($n=4)|%ustawi $ n na 4, a następnie uruchomi pętlę, która uruchamia $ n razy. 1można zmienić na dowolną liczbę całkowitą, która zapętli $ n- [twoja liczba całkowita] +1 razy.
• Domyślny typ danych podczas używania [math]::w PowerShell jest podwójny. W powyższym kodzie musimy jawnie rzutować $Bna ciąg, abyśmy mogli go wywołać .substring(), ponieważ .substring()w Powershell nie ma funkcji podwójnej.

Python 2,  44  41 bajtów

-3 bajty dzięki xnor (użyj podziału na liczby całkowite, aby uniknąć and)

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

repl.it

Funkcja rekurencyjna oparta na 1.

Kiedy n>1dzielenie przez liczby całkowite 1/npowoduje 0, to 0*1111=0jest falsey, więc oroceniane jest prawo od , która przyjmuje pierwsze cztery znaki reprezentacji kwadratu n-1wyniku; jest to następnie przesyłane do int.

Kiedy n=1podział na liczby całkowite 1/n, skutkuje 1, to 1*1111=1111jest prawdą, a int 1111rzut na an intjest 1111.

Groovy, 49 bajtów

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

Pyke, 10 bajtów

1RVX`4*4<b

Wypróbuj tutaj!

MATL , 14 , 13 bajtów

1111G:"UV4:)U

Wypróbuj online!

Wyjaśnienie:

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 bajtów

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

Bierze Nod standardowego. 3334 to praktycznie X_0, co jest potrzebne, ponieważ pętla for musi zostać wykonana co najmniej raz (dłuższe byłoby pominięcie).

R to naprawdę okropny język do przyjmowania pierwszych czterech cyfr liczby, ale ponieważ liczba przypadków jest ograniczona, musimy się tylko martwić o kwadraty, x<3163a x>3162te pierwsze dają liczbę 6-cyfrową, a druga 7-cyfrową .

Reszta jest dość prosta, %/%dzieli i ignoruje resztę. xjest drukowane na standardowe wyjście.

Zaoszczędź 2 bajty dzięki @ETHproductions

Javagony - 153 bajty

Javagony jest ograniczoną wersją języka Java, która nie zezwala na żaden przepływ sterowania oprócz rekurencji i try-catch, nie dla pętli, while i pętli if. Kodowanie w nim jest zabawnym ćwiczeniem, ale frustrującym. Nie to, że zwykła Java sama w sobie nie jest tak frustrująca.

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 bajtów

Zapisano 3 bajty dzięki @ user59178

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

Uruchom z wiersza poleceń, indeksowany od zera.

Dzięki, że nie dbam o to, jakiego typu są moje zmienne, PHP! Tutaj po prostu poprawiamy liczbę i usuwamy wszystko poza pierwszymi 4 cyframi, od niechcenia na przemian między liczbą i łańcuchem bez opieki na świecie.

Brachylog , 18 bajtów

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

Wypróbuj online!

Ta odpowiedź ma indeks 0.

Wyjaśnienie

,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 bajtów

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

Jeden indeksowany.

Clojure, 76 bajtów

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

Pierwszy golf Clojure (wydaje się fajnym językiem). Jest to indeks 1.

Wyjaśni kod później.

C #, 64 60 bajtów

Zapisane 4 bajty wykonując Olivier Grégoire „s komentarz na odpowiedź Java!

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

Poprzednia wersja ( 64 bajty ):

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

Pełny program z nieprzylepioną metodą i przypadkami testowymi:

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 bajtów

Pierwszy golf! Zapisuje bajty z -nopcją (ale nadal liczy się jako 1! :)).

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

0-indeksowane. Aby uruchomić:

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

Pyth, 13 12 bajtów

Dzięki @Jakube za -1 bajt

us<*4`*GG4Q1

Program, który pobiera liczbę całkowitą zindeksowaną 1 i wypisuje wynik.

Zestaw testowy

Wykorzystuje to podobne podejście do odpowiedzi @ Adnan .

Jak to działa

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 bajtów

'14*ri{i2#s4<}*

Korzysta z indeksowania opartego na 0.

Wypróbuj online!

Partia, 82 bajty

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

Podobnie jak Perl, liczby całkowite są łańcuchami, ale w przeciwieństwie do Perla, mogę jedynie pobierać podłańcuch zmiennej, a pobieranie podciągów w pętli jest nieco niewygodne.

Perl 6 , 36 bajtów

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

Wyjaśnienie:

{                                 } # 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 bajtów

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

Przypadki testowe:

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

Nie jest to niesamowite rozwiązanie. Jestem pewien, że musi istnieć lepszy sposób na obcięcie do 4 cyfr, ale dzisiaj nie wiem.

Edycja: Ogolono bajt, ustawiając 0,5 -> .5

Java 8, 77 93 74 71 69 78 bajtów

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

Każde powtórzenie składa się nz pierwszych 4 znaków n*n.

Wypróbuj Javę online !

Historia postów:

• 77 bajtów: kod początkowy (niekompletny)

• +16 bajtów, autor: Olivier Grégoire: uzupełniał kod, czyniąc go funkcją Lambda.

• -19 bajtów zamienić whilez forcyklu.

• -4 bajty: używane longs zamiast ints

• -2 bajty, autor: Roman Gräf: usunięto niepotrzebne nawiasy

• +9 bajtów, brak returninstrukcji

Dzięki @ OlivierGrégoire i @ RomanGräf za wskazanie niektórych problemów!

Czekaj, Java bije ... (drumroll) Clojure i Matlab tutaj! Wielkie brawa dla Javy, proszę!

Perl, 36 bajtów

Inne podejście niż inne rozwiązanie Perla, co prowadzi do nieco krótszego kodu. Nie są potrzebne argumenty wiersza poleceń (inne niż zwykły argument wyboru wersji -M5.010, który nie jest liczony do liczby bajtów), co oznacza, że ​​jest to ta sama ilość kodu, ale z mniejszą liczbą kar, co daje lepszy ogólny wynik.

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

Tworzymy pętlę typu niedociążenia poprzez powtarzanie i eval-ing łańcucha; Eksperymentowałem z rozpoczynaniem struny na środku, ale rozpoczęcie od początku okazuje się najkrótsze. Mnożymy $&(wynik ostatniego dopasowania wyrażenia regularnego), aby go wyrównać; jeśli wynik jest zerowy, używamy 1x4(tzn. 1111Perl ma operator do powtarzania rzeczy, w tym cyfr liczby) zamiast wyniku. Następnie regexujemy pierwsze cztery znaki. Całość działa w kontekście listy, ponieważ znajduje się w środku say, dlatego końcowym wynikiem evalbędzie zawartość nawiasów końcowego dopasowania.

Java, 79 67 66 64 bajtów

• Wersja 2.2 / 64 bajtów:

Dzięki @Oliver Grégoire.

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

• Wersja 2.1 / 66 bajtów:

Dzięki @ETHProduction.

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

• Wersja 2.0 / 67 bajtów:

Zastąpiłem podciągi i inne rzeczy pomysłem z @Xanderhall

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

• Wersja 1.0 / 79 bajtów:

Chociaż istnieją krótsze rozwiązania, chciałem opublikować jeden rekursywny :). I jestem najkrótszą „prawdziwą” funkcją :). Edycja: Wygląda na to, że jestem teraz najkrótszy :)))

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

Pushy , 26 20 bajtów

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

Dać argumenty w wierszu poleceń: $ pushy sqseq.pshy 79.

Ładnie sformatowany, z wyjaśnieniem:

            % 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