Кожен член у послідовності квадратування, x _n , створюється шляхом взяття x _n-1 , відведення квадрату та видалення всіх, крім перших чотирьох цифр.

Послідовність завжди починається з x ₁ = 1111 . При квадраті цього виходить 1234321, тому х ₂ = 1234

Перші кілька термінів:

1111
1234
1522
2316
5363
...

Змагання

Ваше завдання - задати невід'ємне ціле число n обчислити х _n . Ви можете подати повну програму, яка виконує введення-виведення, або функцію, яка приймає n як параметр.

Ваше рішення може бути нульовим або індексованим, доки ви вкажете, який.

Оскільки всі терміни в цій послідовності коротші, ніж 5 цифр, ваш код також повинен бути максимально коротким. Застосовуються стандартні лазівки з кодовим гольфом .

Нехай переможе найкращий гольфіст!

Випробування

Примітка. Вони є 1-індексованими.

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

05AB1E , 8 7 байт

Код:

$Fn4×4£

Пояснення:

$        # 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 . Спробуйте в Інтернеті!

JavaScript (ES7), 44 43 36 байт

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

Це чудовий приклад зловживання типом примусу: **перетворює обидва його аргументи в числа і +перетворює обидва його аргументи в рядки, якщо вони обидва числа. Це означає, що f(n)**2+fспочатку перетворюється f(n)на число і квадрат його, а потім з'єднує результат із представленням рядка f. Потім ми можемо використовувати .sliceдля отримання перших 4 символів рядка.

Ось кілька альтернативних підходів, які не використовують рядки:

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

Фрагмент тесту

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>

Примітка. Це використовується, Math.powоскільки **підтримується не в усіх браузерах.

Haskell, 40 байт

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

Це послідовність на основі 0. Приклад використання: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717.

Як це працює:

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         

Математика, 48 байт

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

Безіменна функція, що приймає цілий аргумент; 0-індексований. Використовує чотири трибайтові символи ⌊⌊⌋⌋: Mathematica використовує Floor[x]або ⌊x⌋для округлення реального числа до цілого числа, а останній, як правило, на один менший байт. Імена команд у Mathematica для перетворення цілих чисел у рядки занадто довгі, тому замість цього робимо математичний обчислення, щоб знайти перші чотири цифри x ^ 2: беремо логарифм base-10 з x ^ 2, віднімаємо його цілу частину, піднімаємо 10 поверніться до цієї сили і помножте на 1000 і округніть вниз.

tl; dr: логарифми ftw

Пітон 2, 51 46 44 байт

Я хотів би позбутися від незграбного, ifякщо можливо, але я думаю, що execможе бути коротшим. Виходить на той момент, який execкоротший. Неправильно знову! Рекурсивна функція повертається. Це одноіндексований.

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

Алетеративний 46-байтний розчин з exec:

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

Альтернативне 49-байтне рекурсивне рішення:

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

^{Завдяки Flp.Tkc за збереження байта, нагадуючи мені, що квадратик не потребує експоненції :)}

V , 19 байт

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

Спробуйте в Інтернеті!

Для цього використовується індексація на основі 0.

Звичайно, оскільки цифри не точно V- форте , це не дуже сильно. Однак це показує одну приємну перевагу, яку V має над vim. Ви можете запустити макрос 0 разів, що неможливо в vim, оскільки "0" - це команда не рахується.

Тут міститься багато недрукованих символів, тому ось шестинадцять:

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

І ось читана версія:

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

Пояснення:

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

Желе , 12 9 байт

-3 байти завдяки Деннісу, що використовує індексацію на основі 1 та ṁатом форми / переформатування. Пропозиції з гольфу вітаються! Спробуйте в Інтернеті!

²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 байт

36 байт коду + -pпрапор.

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

Щоб запустити його:

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

Powershell, 73 55 байт

Величезне спасибі TimmyD за гоління 18 байт!

Код:

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 в x _n-1

Пояснення та підірваний код:

$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

Деякі примітки:

• Powershell дозволяє призначити змінні тим самим операторам, де ви посилаєтесь на них. Наприклад, 1..($n=4)|%встановить $ n до 4, а потім запустить цикл, який працює $ n разів. 1може бути змінено на будь-яке ціле число, і воно буде циклічно $ n- [ваше ціле число] +1 раз.
• Тип даних за замовчуванням при використанні [math]::в Powershell - подвійний. У наведеному вище коді ми маємо явно $Bпередати рядок, щоб ми могли подзвонити .substring()по ньому, оскільки .substring()в Powershell немає функції для парних.

Python 2,  44  41 байт

-3 байти завдяки xnor (використовуйте ціле ділення, щоб уникнути and)

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

repl.it

1-заснована рекурсивна функція.

Коли n>1ціле ділення, 1/nприводить до того 0, 0*1111=0що є фальсі, тому orоцінюється право значення, яке приймає перші чотири символи подання квадрата- n-1го результату; Потім це передається до int.

Коли n=1ціле ділення, 1/nпризводить до 1, то 1*1111=1111, що є truthy, а відступ int 1111до a intє 1111.

Groovy, 49 байт

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

Пайк, 10 байт

1RVX`4*4<b

Спробуйте тут!

MATL , 14 , 13 байт

1111G:"UV4:)U

Спробуйте в Інтернеті!

Пояснення:

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 байт

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

Бере Nзі стдін. 3334 - це практично X_0, що потрібно, оскільки цикл for-циклу потрібно виконати хоча б один раз (пропустити його було б довше).

R дійсно є жахливою мовою прийняття перших чотирьох цифр числа, але оскільки кількість випадків обмежена, нам залишається лише турбуватися про квадрати x<3163і x>3162, коли перший дає 6-значний номер, другий - 7-значний номер .

Решта досить прямолінійна, %/%розділяє і ігнорує залишок. xдрукується у stdout.

Збережено 2 байти завдяки @ETHproductions

Явагонія - 153 байти

Javagony є обмеженою версією Java, яка не дозволяє контролювати будь-який потік, крім рекурсії і try-catch, ні для циклів, циклів або if. Кодування в ньому - досить весела вправа, але засмучує. Не те, що звичайна Java сама по собі не так розчаровує.

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 байти

Збережено 3 байти завдяки @ user59178

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

Запустити з командного рядка, нульового індексу.

Дякуємо, що не піклуєтесь про тип моїх змінних, PHP! Тут ми просто розбиваємо число і обрізаємо все, що минуло перші 4 цифри, недбало чергуючи число і рядок, не піклуючись про це у світі.

Брахілог , 18 байт

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

Спробуйте в Інтернеті!

Ця відповідь є 0-індексованою.

Пояснення

,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 байт

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

Одноіндексовані.

Clojure, 76 байт

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

Перший гольф Clojure (здається, приємна мова). Це 1-індексований.

Пояснимо код пізніше.

C #, 64 60 байт

Збережено 4 байти, дотримуючись коментаря Олів'є Грегоара щодо відповіді на Java!

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

Попередня версія ( 64 байти ):

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

Повна програма з методом unolfolf та тестовими кейсами:

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

Рубін, 47 байт

Перший гольф! Зберігає байти за допомогою -nпараметра (але все ж рахується як 1! :)).

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

0-індексований. Щоб запустити його:

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

Pyth, 13 12 байт

Дякуємо @Jakube за -1 байт

us<*4`*GG4Q1

Програма, яка приймає введення 1-індексованого цілого числа і друкує результат.

Тестовий набір

Для цього використовується аналогічний підхід до відповіді @ Аднана .

Як це працює

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 байт

'14*ri{i2#s4<}*

Використовує індексацію на основі 0.

Спробуйте в Інтернеті!

Пакет, 82 байти

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

Як і Perl, цілі числа - це рядки, але на відміну від Perl, я можу взяти лише підрядку змінної, а введення підрядків у цикл дещо незручне.

Perl 6 , 36 байт

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

Пояснення:

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

Тест:

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

Матлаб, 79 , 78 байт

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

Тестові приклади:

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

Не дивовижне рішення. Я впевнений, що повинен бути кращий спосіб урізати чотири цифри, але сьогодні я не знаю.

Редагувати: Поголив байт, встановивши 0,5 -> .5

Java 8, 77 93 74 71 69 78 байт

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

Кожне повторення складає nперші 4 символи n*n.

Спробуйте Java онлайн !

Історія публікацій:

• 77 байт: початковий код (неповний)

• +16 байт, Олів'є Грегоар: завершено код, зробивши його функцією "Лямбда".

• -19 байт: замінити while з forциклом.

• -4 байти: використовується longs замістьint s

• -2 байти, автор Роман Гряф: видалено непотрібні дужки

• +9 байт, відсутність returnзаяви

Спасибі @ OlivierGrégoire та @ RomanGräf за вказівку на деякі проблеми!

Зачекайте, Java б'є ... (барабанне) Clojure і Matlab тут! Великі оплески Java будь ласка!

Perl, 36 байт

Інший підхід від іншого рішення Perl, що призводить до дещо коротшого коду. Аргументи командного рядка не потрібні (крім звичайного аргументу вибору версії -M5.010, який не рахується з кількістю байтів), це означає, що це та сама кількість коду, але з меншою кількістю штрафних санкцій, що дає кращу загальну оцінку.

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

Ми створюємо цикл Underload-стилю за допомогою повторення та eval-ing рядка; Я експериментував із початком струни посередині, але запуск її на старті виявляється найкоротшим. Ми множимо $&(результат останнього збігу з регулярними виразами) на себе на квадрат; якщо нуль результату, ми використовуємо 1x4(тобто 1111; Perl має оператор для повторення речей, включаючи цифри числа) замість результату. Потім регексуємо перші чотири символи. Вся справа працює в контексті списку завдяки знаходженню всередині say, таким чином, кінцевим результатом evalзаповіту буде вміст круглих дужок остаточного збігу.

Java, 79 67 66 64 байт

• Версія 2.2 / 64 байти:

Завдяки @Oliver Grégoire

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

• Версія 2.1 / 66 байт:

Завдяки @ETHProduction

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

• Версія 2.0 / 67 байт:

Замінив підрядку та матеріали з ідеєю від @Xanderhall

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

• Версія 1.0 / 79 байт:

Хоча є і більш короткі рішення, я хотів опублікувати один рекурсивний :). І я найкоротша "реальна" функція :). Редагувати: Здається, я зараз найкоротший :)))

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

Пушистий , 26 20 байт

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

Наведіть аргументи в командному рядку: $ pushy sqseq.pshy 79 .

Добре відформатований з поясненням:

            % 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