平方序列x _n中的每一项都是通过取x _n-1，将其平方，然后除去除前四位以外的所有数字而创建的。

该序列始终以x ₁ = 1111开头。平方得到1234321，所以x ₂ = 1234

前几个术语是：

1111
1234
1522
2316
5363
...

挑战

您的任务是给定非负整数n，计算x _n。您可以提交执行I / O的完整程序，或提交以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的前四个数字：我们以x ^ 2的10为底的对数，减去其整数部分，提高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'是一个命令而不是计数。

它包含许多不可打印的字符，因此这是一个十六进制转储：

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字节

由于使用基于1的索引和ṁDens / reshape原子，Dennis使用了-3个字节。欢迎打高尔夫球！在线尝试！

²Dṁ4Ḍ
1Ç¡

开球

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在x _n-1中为n

说明和分解代码：

$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中使用时，默认数据类型为double。在上面的代码中，我们必须显式$B转换为字符串，以便可以调用.substring()它，因为.substring()Powershell中没有用于double的函数。

Python  2，44  41字节

感谢xnor -3个字节（请使用整数除法以避免and）

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

代表

基于1的递归函数。

当n>1整数除法1/n导致时0，0*1111=0则为，因此是假的，因此求出右边的or值，该值取第n-1n个结果的平方的表示形式的前四个字符；然后将其转换为int。

当n=1该整数除法，1/n，导致1，然后1*1111=1111，这是truthy，并且int 1111铸到int是1111。

Groovy，49个字节

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

Pyke，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<3163and 的平方x>3162，前者会产生6位数字，而后者会产生7位数字。 。

其余的非常简单，%/%划分并忽略其余部分。x打印到标准输出。

@ETHproductions节省了2个字节

Javagony -153字节

Javagony是Java的受限版本，除递归和之外try-catch，不允许任何控制流，禁止for循环，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字节

@ user59178节省了3个字节

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

从命令行运行，索引为零。

感谢您不关心我的变量是什么类型，PHP！在这里，我们简单地对数字求平方，并修剪掉前4位数字之后的所有内容，在数字和字符串之间随意切换而无需担心。

Brachylog，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字节

通过遵循OlivierGrégoire对Java答案的评论节省了4个字节！

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

完整的程序，包含未使用的方法和测试用例：

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个字节

第一次高尔夫！使用-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 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个字节：初始代码（不完整）

• OlivierGrégoire的+16字节：通过使其成为Lambda函数来完成代码。

• -19个字节：替换while为for循环。

• -4个字节：使用longs代替ints

• -2个字节，由RomanGräf撰写：删除了不必要的括号

• +9个字节，缺少return语句

感谢 @OlivierGrégoire和@RomanGräf指出了一些问题！

等等，Java击败了...（鼓声）Clojure 和 Matlab在这里！请为Java鼓掌！

Perl，36个字节

与其他Perl解决方案不同的方法，导致代码略短。不需要命令行参数（除了普通的版本选择参数，-M5.010该参数不会计入字节数），这意味着代码量相同，但是惩罚更少，因此总得分更高。

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

我们通过重复和eval-ing一个字符串来创建一个Underload风格的循环。我尝试过从中间开始字符串，但事实证明，从最开始开始是最短的。我们将$&自身（最后一个正则表达式匹配的结果）相乘以求平方；如果结果为零，则使用1x4（1111而不是结果； Perl有一个用于重复内容（包括数字的数字）的运算符）。然后我们对前四个字符进行正则表达式。整个对象由于位于内部而在列表上下文中运行say，因此的最终结果eval将是最终匹配括号内的内容。

Java，79 67 66 64字节

• 版本2.2 / 64字节：

感谢@OliverGré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));}

Pushy，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