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

Последовательность всегда начинается с x ₁ = 1111 . Возведение в квадрат дает 1234321, поэтому x ₂ = 1234

Первые несколько терминов:

1111
1234
1522
2316
5363
...

Соревнование

Ваша задача состоит в том, чтобы, учитывая неотрицательное целое число n , вычислить x _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         

Mathematica, 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

Python 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» - это команда, а не счетчик.

Это содержит много непечатаемых символов, поэтому вот hexdump:

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это п в х _п-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что falsey, так что правая из orоценивается, который принимает первые четыре символа представления квадрата n-1й результат; это затем приведено к int.

Когда получается n=1целочисленное деление, то , что является правдой, и приведение к есть .1/n11*1111=1111int 1111int1111

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выводится на стандартный вывод.

Сохранено 2 байта благодаря @ETHproductions

Javagony - 153 байта

Javagony - это ограниченная версия Java, которая не допускает какой-либо поток управления, кроме рекурсии и try-catchне для циклов, циклов while или 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 Golf (кажется, хороший язык). Это 1-индексированный.

Поясню код позже.

C #, 64 60 байт

Сохраненные 4 байта, следуя Оливье Грегуар «s комментарий на ответ 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;};

Полная программа с методикой ungolfed и тестовыми примерами:

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-индексированного целого числа и печатает результат.

Тестирование

При этом используется аналогичный подход к ответу @ Adnan .

Как это работает

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)

Matlab, 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

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

Редактировать: побрил байт, установив 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 вместо ints

• -2 байта, автор Roman Gräf: убраны лишние скобки

• +9 байт, пропущенное returnутверждение

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

Подождите, Java бьет ... (барабанная дробь) Clojure и Matlab здесь! Большие аплодисменты Java, пожалуйста!

Perl, 36 байт

Отличный подход от другого решения Perl, приводящий к немного более короткому коду. Не требуются аргументы командной строки (кроме обычного аргумента выбора версии, -M5.010который не учитывается в счетчике байтов), что означает, что это тот же объем кода, но с меньшим количеством штрафов, что дает лучший общий результат.

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

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

Ява, 79 67 66 64 байта

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

Благодаря @ Оливер Грегуар.

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