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:


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 loopholes apply.

May the best golfer win!

Test Cases

Note: These are 1-indexed.

1   -> 1111
8   -> 6840
15  -> 7584
20  -> 1425
80  -> 4717
  • 2
    \$\begingroup\$ Here's a related link :) \$\endgroup\$
    – FlipTack
    Dec 2, 2016 at 18:56
  • 1
    \$\begingroup\$ This sequence could find use as a pseudo-random number generator (although it's not very secure). \$\endgroup\$
    – user100690
    Mar 11, 2021 at 8:51
  • \$\begingroup\$ May we output as a string? \$\endgroup\$
    – user100690
    Mar 17, 2021 at 16:18
  • \$\begingroup\$ @ophact IO is flexible. \$\endgroup\$
    – FlipTack
    Mar 18, 2021 at 13:14
  • \$\begingroup\$ Any OEIS link for this? \$\endgroup\$
    – Wasif
    Mar 21, 2021 at 8:14

52 Answers 52


JavaScript (ES7), 44 43 36 bytes


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:


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.

  • \$\begingroup\$ If we can output as a string, then n=>n?(''+f(n-1)**2).slice(0,4):1111 should work for 35 bytes \$\endgroup\$
    – user100690
    Mar 17, 2021 at 16:20

05AB1E, 8 7 bytes




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

  • 5
    \$\begingroup\$ Beat me by 20 seconds :(. \$\endgroup\$ Dec 2, 2016 at 19:01

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 :)

  • \$\begingroup\$ Another 46 bytes solution: f=lambda n:1111if n<2else int(`f(n-1)**2`[:4]) \$\endgroup\$
    – acrolith
    Dec 2, 2016 at 19:36
  • \$\begingroup\$ @daHugLenny that can actually be 45: repl.it/EejD \$\endgroup\$
    – FlipTack
    Dec 2, 2016 at 19:47
  • 1
    \$\begingroup\$ @Flp.Tkc And that can actually be 44 ;) \$\endgroup\$
    – Kade
    Dec 5, 2016 at 14:00

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         

Perl, 37 bytes

36 bytes of code + -p flag.


To run it:

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

V, 19 bytes


Try it online!

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

Mathematica, 48 bytes


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


Jelly, 12 9 bytes

-3 bytes thanks to Dennis using 1-based indexing and the mold/reshape atom. Golfing suggestions welcome! Try it online!



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.
  • \$\begingroup\$ This saves 3 bytes with 1-based indexing. \$\endgroup\$
    – Dennis
    Dec 2, 2016 at 19:31
  • \$\begingroup\$ Uh, I don't think you can use 1 instead of ⁽¡n. \$\endgroup\$ Jan 28, 2018 at 10:35
  • \$\begingroup\$ @EriktheOutgolfer How come? \$\endgroup\$
    – Sherlock9
    Jan 28, 2018 at 16:09
  • \$\begingroup\$ @Sherlock9 Oh, you seem to 1-index this sequence? Hm, looks like the code is a bit tricky to understand... \$\endgroup\$ Jan 28, 2018 at 16:18

Powershell, 73 55 bytes

Huge thanks to TimmyD for shaving off 18 bytes!




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

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])


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-1th 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.

  • \$\begingroup\$ Good one, ninja'd me by one byte! \$\endgroup\$
    – FlipTack
    Dec 2, 2016 at 20:51
  • \$\begingroup\$ I just looked for your answer and then realised you wrote the challenge! Nice job. \$\endgroup\$ Dec 2, 2016 at 20:56
  • 1
    \$\begingroup\$ Nice idea with taking the int outside. If you 1-index, you can do the base case shorter with g=lambda n:int(1/n*1111or`g(n-1)**2`[:4]). \$\endgroup\$
    – xnor
    Dec 2, 2016 at 21:51
  • 1
    \$\begingroup\$ "Crossed out 44 still looks like 44 :(" \$\endgroup\$
    – FlipTack
    Dec 2, 2016 at 22:23
  • 1
    \$\begingroup\$ @Flp.Tkc not as much as it does without the &nbsp;s! \$\endgroup\$ Dec 2, 2016 at 22:25

APL (Dyalog Extended), 13 bytes

-2 (changing the input method) thanks to @Razetime



{⍎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!

  • 1
    \$\begingroup\$ -2 \$\endgroup\$
    – Razetime
    Dec 22, 2020 at 9:36

Groovy, 49 bytes

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

Pyke, 10 bytes


Try it here!


MATL, 14, 13 bytes


Try it online!


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
  • 2
    \$\begingroup\$ You can use U (square, for numeric input) insted of t* \$\endgroup\$
    – Luis Mendo
    Dec 2, 2016 at 20:12
  • 1
    \$\begingroup\$ @LuisMendo Thanks for reminding of the function I recommended! :P \$\endgroup\$
    – DJMcMayhem
    Dec 2, 2016 at 21:21

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

  • \$\begingroup\$ This is so notrivial. Brilliant! \$\endgroup\$ Dec 3, 2016 at 2:02
  • 1
    \$\begingroup\$ Nice one! What would happen if you started with 3334 (or perhaps 3333)? \$\endgroup\$ Dec 3, 2016 at 2:16
  • \$\begingroup\$ @ETHproductions 3333^2 = 11108889 so would yield 1110, and .... as im checking this I see 3334 would work :| . Not sure why I didn't check that anymore. \$\endgroup\$
    – JAD
    Dec 3, 2016 at 9:44

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

PHP, 55 52 bytes

Saved 3 bytes thanks to @user59178


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.

  • \$\begingroup\$ You could save 3 bytes by using $argv[1]-- as the loop counter. \$\endgroup\$
    – user59178
    Dec 5, 2016 at 9:36

Brachylog, 18 bytes


Try it online!

This answer is 0-indexed.


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

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


  • 1
    \$\begingroup\$ I have a feeling that you can go for recursion... \$\endgroup\$ Dec 3, 2016 at 9:05

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.


C#, 64 60 bytes

Saved 4 bytes by following Olivier Grégoire's comment 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
  • 1
    \$\begingroup\$ +1 for the dark goes-to-operator n-->1 \$\endgroup\$
    – Karl Napf
    Dec 3, 2016 at 0:43

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
  • \$\begingroup\$ Welcome to the site, and nice first answer! One nitpick though, technically this is 47 bytes because of our policy of counting command line flags towards the byte count. Other than that, it looks good to me! \$\endgroup\$
    – DJMcMayhem
    Dec 3, 2016 at 18:26
  • \$\begingroup\$ Thanks! Didn't know the rules, answer changed! \$\endgroup\$
    – ghivert
    Dec 3, 2016 at 18:29

Pyth, 13 12 bytes

Thanks to @Jakube for -1 byte


A program that takes input of a 1-indexed integer and prints the result.

Test suite

This uses a similar approach to @Adnan's answer.

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
  • 1
    \$\begingroup\$ *GG instead of ^G2<space> \$\endgroup\$
    – Jakube
    Dec 4, 2016 at 20:30

GolfScript, 15 bytes


Try it online!


~                 # 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
  • \$\begingroup\$ Nice answer. Is it not possible to take integer input directly? \$\endgroup\$
    – Razetime
    Oct 11, 2020 at 4:44
  • 1
    \$\begingroup\$ @Razetime No, in the input and output section of golfscript.com/golfscript/tutorial.html , it says: "all input from stdin is read first and placed as a string onto the stack". But this site also doesn't mention that the numbers can be complex, so maybe there is a way. If there is, it cannot be shorter than ~. \$\endgroup\$
    – 2014MELO03
    Oct 11, 2020 at 14:51

Vyxal, 6 5 bytes


Try it online, or verify all test cases.


Ṫ      # Pop, push 1 then the input
 (     # [Input] times:
  ²    #   Square
   4Ẏ  #   Get the first 4 digits
  • \$\begingroup\$ With a newly added overload, 1? can just be . \$\endgroup\$
    – Steffan
    Jul 24 at 2:57
  • \$\begingroup\$ @Steffan Thanks, I was wondering if there wouldd be something like that, I saw that 05AB1E had it. \$\endgroup\$ Jul 24 at 3:02

CJam, 15 bytes


Uses 0-based indexing.

Try it online!


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.

  • \$\begingroup\$ I think you can leave out the space after @for. \$\endgroup\$ Dec 5, 2016 at 13:20
  • \$\begingroup\$ @YourDeathIsComing 'for' is not recognised as an internal or external command, operable program or batch file. \$\endgroup\$
    – Neil
    Dec 5, 2016 at 13:34

Perl 6, 36 bytes



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

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

Test cases:

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

Not an amazing solution. I'm sure there must be a better way to truncate to 4 digits but I don't know today.

Edit: Shaved a byte by setting 0.5 -> .5


Java 8, 77 93 74 71 69 78 bytes

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

Each repetition makes n the first 4 characters of n*n.

Try Java online!

Post history:

  • 77 bytes: initial code (incomplete)

  • +16 bytes, by Olivier Grégoire: completed code by making it a Lambda function.

  • -19 bytes: replace while with for cycle.

  • -4 bytes: used longs instead of ints

  • -2 bytes, by Roman Gräf: removed unnecessary brackets

  • +9 bytes, missing return statement

Thanks to @OlivierGrégoire and @RomanGräf for pointing out some issues!

Wait, Java beats... (drumroll) Clojure and Matlab here! A big applause to Java please!

  • 2
    \$\begingroup\$ This answer is incomplete. x isn't declared. This should be a function or full program. Not a code snippet. \$\endgroup\$ Dec 2, 2016 at 22:04
  • \$\begingroup\$ @NonlinearFruit I was going for the function. Seems I missed this out. Do you mean I should just replace x with a number? \$\endgroup\$
    – user60199
    Dec 3, 2016 at 7:21
  • 1
    \$\begingroup\$ What @NonlinearFruit said is that your answer, with your current code, sould be: x->{int n=1111;int m=1;while(x>m++){n=Integer.parseInt((n*n+"").substring(0,4));}return n;} (for a total byte count of 91). This is because snippets aren't allowed: only functions or full programs. \$\endgroup\$ Dec 3, 2016 at 15:02
  • \$\begingroup\$ @OlivierGrégoire Isn't that 93 bytes? And thanks for pointing out lambda funcions. \$\endgroup\$
    – user60199
    Dec 3, 2016 at 15:26
  • \$\begingroup\$ You're right, it's 93 bytes, I must have checked from a previous, defect version. However, all I did was wrapping so that your program would be a valid entry. Now you can golf the hell out of it! For instance, here's a golfed version of your program for only 75 bytes: x->{Long n=1111;for(;--x>0;)n=n.valueOf((n*n+"").substring(0,4));return n;}, with several techniques used (used Long to be able to use Long.valueOf with less bytes, it's not recommended in normal programming, but totally in golfing; removed m as it's unnecessary if we decrease x instead, removed unneeded braces) \$\endgroup\$ Dec 3, 2016 at 15:37

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.