[Question]
  [
Each term in the squaring sequence, \$x\_n\$, is created by taking \$x\_{n-1}\$, squaring it, and removing all but the first four digits.
The sequence always begins with \$x\_1 = 1111\$. Squaring this yields \$1234321\$, so \$x\_2 = 1234\$
The first few terms are:
```
1111
1234
1522
2316
5363
...
```
---
# The Challenge
Your task is to, given a non-negative integer \$n\$, calculate \$x\_n\$. You may submit a full program which performs I/O, or a function which takes \$n\$ as a parameter.
Your solution can be zero or one indexed, as long as you specify which.
Because all the terms in this sequence are shorter than 5 digits, your code should be as short as possible too. Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") loopholes apply.
May the best golfer win!
---
# Test Cases
*Note: These are 1-indexed.*
```
1   -> 1111
8   -> 6840
15  -> 7584
20  -> 1425
80  -> 4717
```
  
[Answer]
# JavaScript (ES7), ~~44~~ ~~43~~ 36 bytes
```
f=n=>--n?(f(n)**2+f).slice(0,4):1111
```
This is a great example of abusing type coercion: `**` converts both its arguments to numbers, and `+` converts both its arguments to strings unless they're both numbers. This means that `f(n)**2+f` first converts `f(n)` to a number and squares it, then concatenates the result with the string representation of `f`. We can then use `.slice` to retrieve the first 4 chars of the string.
Here are a few alternate approaches that don't use strings:
```
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
```
### Test snippet
```
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>
```
Note: this uses `Math.pow` because `**` isn't supported in all browsers.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~8~~ 7 bytes
Code:
```
$Fn4×4£
```
Explanation:
```
$        # 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
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=JEZuNMOXNMKj&input=ODA)
[Answer]
# Python 2, ~~51~~ ~~46~~ 44 Bytes
~~~~I'd like to get rid of the clunky `if` if possible, but I think an `exec` could be shorter..~~ Turns out for the moment that `exec` is shorter.~~ Wrong again! The recursive function returns. This is one-indexed.
```
f=lambda n:1111*(n<2)or int(`f(n-1)**2`[:4])
```
An aleternative 46-byte solution with `exec`:
```
s=1111;exec's=int(`s*s`[:4]);'*input();print s
```
An alternative 49-byte recursive solution:
```
f=lambda n,s=1111:s*0**n or f(n-1,int(`s*2`[:4]))
```
Thanks to Flp.Tkc for saving a byte by reminding me that squaring doesn't need exponentiation :)
[Answer]
## Haskell, 40 bytes
```
((iterate(read.take 4.show.(^2))1111)!!)
```
It's a 0-based sequence. Usage example: `((iterate(read.take 4.show.(^2))1111)!!) 79` -> `4717`.
How it works:
```
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         
```
[Answer]
## Perl, 37 bytes
36 bytes of code + `-p` flag.
```
$\=1x4;$\=substr$\*$\,0,4while--$_}{
```
To run it:
```
perl -pe '$\=1x4;$\=substr$\*$\,0,4while--$_}{' <<< 80
```
[Answer]
# [V](http://github.com/DJMcMayhem/V), 19 bytes
```
4é1Àñ|C="*"
5|D
```
[Try it online!](http://v.tryitonline.net/#code=NMOpMcOAw7F8QxI9EiIqEiIKGzV8RA&input=&args=Mg)
This uses 0-based indexing.
Of course, since numbers aren't exactly V's *forte*, this isn't very golfy. However, it does show one nice advantage V has over vim. You can run a macro *0* times, which is not possible in vim since '0' is a command not a count.
This contains many unprintable characters, so here is a hexdump:
```
0000000: 34e9 31c0 f17c 4312 3d12 222a 1222 0a1b  4.1..|C.=."*."..
0000010: 357c 44                                  5|D
```
And here is a readable version:
```
4é1Àñ|C<C-r>=<C-r>"*<C-r>"
<esc>5|D
```
Explanation:
```
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
```
[Answer]
# Mathematica, 48 bytes
```
Nest[⌊10^(3-⌊t=2Log[10,#]⌋+t)⌋&,1111,#]&
```
Unnamed function taking an integer argument; 0-indexed. Uses four three-byte characters `⌊⌊⌋⌋`: Mathematica uses either `Floor[x]` or `⌊x⌋` to round a real number down to an integer, and the latter is generally one fewer byte. The command names in Mathematica for converting integers to strings are too long, so instead we do a mathematical calculation to find the first four digits of x^2: we take the base-10 logarithm of x^2, subtract its integer part, raise 10 back to that power, and multiply by 1000 and round down.
tl;dr: logarithms ftw
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~12~~ 9 bytes
-3 bytes thanks to Dennis using 1-based indexing and the `ṁ` mold/reshape atom. Golfing suggestions welcome! [Try it online!](http://jelly.tryitonline.net/#code=wrJE4bmBNOG4jAoxw4fCoQ&input=&args=Mg)
```
²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.
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 13 bytes
-2 (changing the input method) thanks to @Razetime
```
{⍎4⍴⍕⍵*2}⍣⎕⊢1
```
Explanation:
```
{⍎4⍴⍕⍵*2}⍣⎕⊢1     ⍝ apply the dfn input times
            1     ⍝ .. with initial argument 1
     ⍵*2          ⍝ current value squared
 ⍎4⍴⍕             ⍝ take first 4 digits
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qKM97X/1o94@k0e9Wx71Tn3Uu1XLqPZR7@JHfVMfdS0yBCng@p/GZcqVxmVkACQsDAA "APL (Dyalog Extended) – Try It Online")
[Answer]
## Powershell, ~~73~~ 55 bytes
Huge thanks to TimmyD for shaving off 18 bytes!
Code:
`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` is **n** in **xn-1**
Explanation and exploded code:
```
$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
```
Some notes:
* Powershell lets you assign variables in the same statements where you reference them. For example, `1..($n=4)|%` will set $n to 4 and then start a loop that runs $n times. `1` can be changed to any integer and it will loop $n-[your integer]+1 times.
* The default data type when using `[math]::` in Powershell is a double. In the code above, we have to explicitly cast `$B` to a string so that we can call `.substring()` on it because there is no `.substring()` function for doubles in Powershell.
[Answer]
# Python 2, ~~44~~ 41 bytes
-3 bytes thanks to xnor (use an integer division to avoid `and`)
```
f=lambda n:int(1/n*1111or`f(n-1)**2`[:4])
```
**[repl.it](https://repl.it/EenM/1)**
1-based recursive function.
When `n>1` the integer division, `1/n`, results in `0`, then `0*1111=0` which is falsey, so the right of the `or` is evaluated, which takes the first four characters of the representation of the square of the `n-1`th result; this is then cast to an `int`.
When `n=1` the integer division, `1/n`, results in `1`, then `1*1111=1111`, which is truthy, and the `int` `1111` cast to an `int` is `1111`.
[Answer]
# Groovy, 49 bytes
```
{x=1111;(it-1).times{x="${x**2}"[0..3] as int};x}
```
[Answer]
## Pyke, 10 bytes
```
1RVX`4*4<b
```
[Try it here!](http://pyke.catbus.co.uk/?code=1RVX%604%2a4%3Cb&input=5)
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~14~~, 13 bytes
```
1111G:"UV4:)U
```
[Try it online!](http://matl.tryitonline.net/#code=MTExMUc6IlVWNDopVQ&input=Nw)
Explanation:
```
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
```
[Answer]
# R, ~~58~~ ~~56~~ ~~55~~ 53 bytes
```
x=3334;for(e in N<-scan():1)x=x^2%/%10^(3+(x>3162));x
```
Takes `N` from stdin. 3334 is practically X\_0, which is needed because the for-loop needs to be executed at least once (it would be longer to skip).
R really is a terrible language for taking the first four digits of a number, but since the number of cases are limited, we only have to worry about the squares of `x<3163` and `x>3162`, the former yield a 6 digit number, the latter a 7 digit number.
The rest is pretty straightforward, `%/%` divides and ignores the remainder. `x` is printed to stdout.
Saved 2 bytes thanks to @ETHproductions
[Answer]
# [Javagony](https://esolangs.org/wiki/Javagony) - 153 bytes
Javagony is a restricted version of Java, that doesn't allow any control flow except recursion and `try-catch`, no for loops, while loops, or if's. Coding in it is a pretty fun exercise, but frustrating. Not that regular Java isn't nearly as frustrating by itself.
```
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;}}
```
[Answer]
# PHP, ~~55~~ 52 bytes
Saved 3 bytes thanks to @user59178
```
for($i=1111;$argv[1]--;)$i=substr($i**2,0,4);echo$i;
```
Run from command line, zero-indexed. 
Thanks for not caring about what type my variables are, PHP! Here we simply square the number and trim off everything past the first 4 digits, casually alternating between number and string without a care in the world.
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 14 bytes
```
=1111:(ZZ)[:4]
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/39YQCKw0oqI0o61MYv//BwA "cQuents – Try It Online")
1-indexed.
## Explanation
```
=1111           first term is 1111
     :          given n, output nth term, otherwise output full sequence
                each term equals
      (ZZ)                       previous term * previous term
          [:4]                                                 [:4] (python slicing)
```
[Answer]
# [Pushy](https://github.com/FTcode/Pushy), 20 bytes
```
1111@:2esL4-:.;Kjk;#
```
[Try it online!](https://tio.run/##Kygtzqj8/98QCBysjFKLfUx0rfSsvbOyrZX///9vbgkA "Pushy – Try It Online")
Note this is 1-indexed.
```
            % 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
```
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 18 bytes
```
,1111:?:{^@[.l4,}i
```
[Try it online!](http://brachylog.tryitonline.net/#code=LDExMTE6Pzp7XkBbLmw0LH1p&input=Nzk&args=Wg)
This answer is 0-indexed.
### Explanation
```
,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
```
[Answer]
## Batch, 82 bytes
```
@set n=1111
@for /l %%i in (1,1,%1)do @set/an*=n&call set n=%%n:~0,4%%
@echo %n%
```
Like Perl, integers are strings, but unlike Perl I can only take the substring of a variable, and taking substrings inside a loop is somewhat awkward.
[Answer]
# C, 56 bytes
```
a;s(n){for(a=1111;--n;)a=a*a/(a>3162?1e4:1e3);return a;}
```
One-indexed.
[Answer]
# Clojure, 76 bytes
```
(defn s[n](if(= n 1)1111(read-string(subs(str(*(s(dec n))(s(dec n))))0 4))))
```
First Clojure golf (seems like a nice language). This is 1-indexed.
Will explain the code later.
[Answer]
# C#, 64 60 bytes
*Saved 4 bytes by following [Olivier Grégoire](https://codegolf.stackexchange.com/users/16236/olivier-gr%C3%A9goire)'s [comment](https://codegolf.stackexchange.com/questions/101961/the-squaring-sequence/101978?noredirect=1#comment247789_101979) on a Java answer!*
```
n=>{int x=1111;for(;n-->1;)for(x*=x;x>1e4;x/=10);return x;};
```
Previous version (**64 bytes**):
```
n=>{int x=1111;while(n-->1){x*=x;while(x>9999)x/=10;}return x;};
```
Full program with ungolfed method and test cases:
```
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
        }
    }
}
```
[Answer]
# Ruby, 47 bytes
First golf! Saves bytes with `-n` option (but still count as 1! :)).
```
a=1111;$_.to_i.times{a="#{a*a}"[0,4].to_i};p a
```
0-indexed.
To run it:
```
ruby -ne 'a=1111;$_.to_i.times{a="#{a*a}"[0,4].to_i};p a' <<< 80
```
[Answer]
# Pyth, ~~13~~ 12 bytes
*Thanks to @Jakube for -1 byte*
```
us<*4`*GG4Q1
```
A program that takes input of a 1-indexed integer and prints the result.
[Test suite](https://pyth.herokuapp.com/?code=us%3C%2a4%60%2aGG4Q1&test_suite=1&test_suite_input=1%0A8%0A15%0A20%0A80&debug=0)
This uses a similar approach to [@Adnan's answer](https://codegolf.stackexchange.com/a/101963/55526).
**How it works**
```
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
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 15 bytes
```
~1111\{.*`4<~}*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v84QCGKq9bQSTGzqarX@/zcAAA "GolfScript – Try It Online")
0-indexed
```
~                 # Parse n to a number
 1111             # Push 1111
     \{      }*   # Execute this block n times
       .*         # Square the number
         `        # Parse it to a string
          4<      # Get the first 4 digits
            ~     # Parse it back to a number
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~6~~ 5 bytes
```
Ṫ(²4Ẏ
```
[Try it online](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuaoowrI04bqOIiwiIiwiOCJd), or [verify all test cases](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwi4bmqKMKyNOG6jiIsIiIsIjFcbjhcbjE1XG4yMFxuODAiXQ==).
Explanation:
```
Ṫ      # Pop, push 1 then the input
 (     # [Input] times:
  ²    #   Square
   4Ẏ  #   Get the first 4 digits
```
[Answer]
# TI-Basic, 31 bytes
```
Input N
1111
For(I,2,N
int(Ans²/₁₀^(-3+int(log(Ans²
End
Ans
```
1-indexed input. `-` represents the negative symbol.
[Answer]
# Excel VBA, 42 bytes
```
v=1111:For i=2To[A1]:v=Left(v^2,4):Next:?v
```
Input is in cell `A1` of the active sheet. Code is run in the immediate window. Output is to the immediate window. Here's the result for `80` as an input:
[![Result](https://i.stack.imgur.com/96mXD.png)](https://i.stack.imgur.com/96mXD.png)
]