People keep telling me that the square of a number is the number multiplied by itself. This is obviously false. The correct way to square a number is to make it into a square, by stacking it on top of itself a number of times equal to the number of digits it has, and then reading all the numbers from the resultant square, both horizontally (from left to right only) and vertically (from up to down only), and then adding them together. So, for the number 123, you first create the square:


Then you take all of the rows and columns from the square, and add them together:


Which gives us a result of 1035.

For negative numbers, you stack normally (remember that you only count the number of digits, so the negative sign is not included in the length), and then read the horizontal numbers normally (with negative signs), and then ignore the negative signs for the vertical numbers. So, for the number -144 we get the square:


Which gives us -144-144-144+111+444+444, which equals 567

For numbers with only one digit, the square is always equal to the number doubled (read once horizontally and once vertically). So 4 gives us


Which gives us 4+4, which equals 8.

For numbers with decimal parts, stack normally (remember that only digits are counted in the number of times you stack the number, and therefore the decimal point is not counted), and ignore the decimal symbols when reading the vertical numbers. For example, the number 244.2 gives us


Which gives us 244.2+244.2+244.2+244.2+2222+4444+4444+2222, which equals 14308.8.

Fractional or complex numbers cannot be squared.

Your Task:

I'm tired of squaring numbers my way by hand, so I've decided to automate the process. Write me a program or function that takes a float or string, whichever you prefer, as input and returns the result of squaring it my way.


123    -> 1035
388    -> 3273
9999   -> 79992
0      -> 0
8      -> 16
-6     -> 0
-25    -> 27
-144   -> 567
123.45 -> 167282.25
244.2  -> 14308.8
2      -> 4
-0.45  -> 997.65
0.45   -> 1000.35


My hands are getting cramped from writing out all those squares, and my computer doesn't support copy/paste, so the entry with the least amount of code for me to type (measured in bytes for some reason?) wins!

  • 1
    \$\begingroup\$ "123.45" and "244.2" aren't valid floats in and of itself because the computer stores number in binary. This isn't normally a problem until the problem relies on the decimal representation. \$\endgroup\$ – Leaky Nun Jul 29 '17 at 13:22
  • \$\begingroup\$ @LeakyNun, I don't really know what you mean by that. The problem isn't unsolvable (at least in python), I'm pretty sure I could do it fairly easily, although in a large number of bytes. It would require some string manipulation, however. \$\endgroup\$ – Gryphon Jul 29 '17 at 13:27
  • \$\begingroup\$ @Gryphon So we must take input as a string? \$\endgroup\$ – Leaky Nun Jul 29 '17 at 13:28
  • 3
    \$\begingroup\$ @Gryphon This is where it fails. 244.2 is not a float number. It cannot be converted to the string "244.2". \$\endgroup\$ – Leaky Nun Jul 29 '17 at 13:29
  • 3
    \$\begingroup\$ @Gryphon But behaviours like this makes it very inconvenient. \$\endgroup\$ – Leaky Nun Jul 29 '17 at 13:38

20 Answers 20


05AB1E, 7 bytes


Try it online!


þSDg×+O Implicit input
þ       Keep digits
 S      Get chars
  D     Duplicate
   g    Length
    ×   Repeat string(s)
     +  Add (implicit input added to all elements)
      O Sum
  • 3
    \$\begingroup\$ Ooo explanation when you can please \$\endgroup\$ – Jonathan Allan Jul 29 '17 at 14:23
  • 1
    \$\begingroup\$ Also I would note that the single leading zero is a requirement on the input for -1 < input < 1 (i.e. 0.45 and .45 are different inputs but the same number, only the former is acceptable) \$\endgroup\$ – Jonathan Allan Jul 29 '17 at 14:28
  • \$\begingroup\$ @JonathanAllan The latter isn't handled anyways. \$\endgroup\$ – Erik the Outgolfer Jul 29 '17 at 14:30
  • \$\begingroup\$ @JonathanAllan Done. \$\endgroup\$ – Erik the Outgolfer Jul 29 '17 at 14:32

Jelly,  13  12 bytes


A monadic link accepting a list of characters (a well-formed decimal number, the single leading zero being a requirement for -1 < n < 1) and returning a number.

Try it online!

14 bytes to accept and return numbers (input limited at +/-10-5 by ŒṘ): ŒṘfØDẋ€L$ŒV+⁸S.


fØDẋ€L$ŒV+VS - Link: list of characters         e.g. "-0.45"
 ØD          - yield digit characters                "0123456789"
f            - filter keep                           "045"
      $      - last two links as a monad:
     L       -   length (number of digit characters) 3
   ẋ€        -   repeat list for €ach digit          ["000","444","555"]
       ŒV    - evaluate as Python code (vectorises)  [0,444,555]
          V  - evaluate (the input) as Jelly code    -0.45
         +   - addition (vectorises)                 [-0.45,443.55,554.55]
           S - sum                                   997.65
  • \$\begingroup\$ Umm, you can replace +€ with + in 15-byte version for -1. \$\endgroup\$ – Erik the Outgolfer Jul 29 '17 at 14:14
  • \$\begingroup\$ Already did, thanks though! \$\endgroup\$ – Jonathan Allan Jul 29 '17 at 14:14
  • \$\begingroup\$ Umm not in the 15-byte version. EDIT: 3 seconds too early I suppose... \$\endgroup\$ – Erik the Outgolfer Jul 29 '17 at 14:14
  • \$\begingroup\$ Yup just noticed you said 15 byte version - thanks again! \$\endgroup\$ – Jonathan Allan Jul 29 '17 at 14:15

Haskell, 59 56 bytes

f s|l<-filter(>'.')s=0.0+sum(read<$>(s<$l)++[c<$l|c<-l])

The input is taken as a string.

Try it online!

How it works

l<-filter(>'.')s      -- let l be the string of all the numbers of the input string
f s   = 0.0 + sum     -- the result is the sum of (add 0.0 to fix the type to float)
   read<$>            -- turn every string of the following list into a number
   s<$l               -- length of l times the input string followed by
   [c<$l|c<-l]        -- length of l times c for each c in l   

Japt v2, 16 bytes

¬xpV +V*Ng

Test it online!


o\d    First line: Set U to the result.
o      Keep only the chars in the input that are
 \d      digits. (literally /\d/g)

l    Second line: Set V to the result.
l    U.length

¬xpV +V*Ng    Last line: implicitly output the result.
¬             Split U into chars.
 x            Sum after
  pV            repeating each V times.
     +V*Ng    Add V * first input (the sum of the horizontals) to the result.

C# (.NET Core), 150 141 133 bytes

Saved 9 bytes thanks to @TheLethalCoder
Saved another 8 bytes thanks to @TheLethalCoder

a=>{var c=(a+"").Replace(".","").Replace("-","");int i=0,l=c.Length;var r=a*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;}

Try it online!

Takes a string as an input and outputs the 'squared' number as a float.

This code follows the following algorithm:

  1. Create a new string from the input, but without the decimal points and symbols, so we can get our length and the numbers for the columns from there.

  2. Calculate the input times the length of the string we created at point 1.

  3. For each column in our 'square', create a new string with the column number and the row length and add it to our result.


Input: -135.5

  1. If we replace decimal points and symbols we get the string 1355, which has a length of 4.
  2. The input times 4: -135.5 * 4 = -542.
  3. Now we create new strings for each column, parse them and add them to our result:
    1111, 3333, 5555, 5555.

If we sum these numbers up we get 15012, which is exactly what our program will output.

  • 1
    \$\begingroup\$ Welcome on the site, and nice first answer (the explanations in particular are appreciated!) ! \$\endgroup\$ – Dada Jul 31 '17 at 8:19
  • \$\begingroup\$ @Dada Thank you! Even tough I am rather unpleased by the bytes I gained from stuff like string.Replace(), but I guess thats the only way it works! \$\endgroup\$ – Ian H. Jul 31 '17 at 8:24
  • \$\begingroup\$ Might be able to save some bytes by setting i and l to floats. \$\endgroup\$ – TheLethalCoder Jul 31 '17 at 13:53
  • \$\begingroup\$ @TheLethalCoder Thought of that aswell, sadly indexing does not work with floats, and .Length cannot implicitly be converted to float. \$\endgroup\$ – Ian H. Jul 31 '17 at 13:55
  • 1
    \$\begingroup\$ a=>{var c=a.Replace(".","").Replace("-","");int i=0,l=c.Length;var r=float.Parse(a)*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;} 141 bytes. Might be able to save by taking input as a float and casting to a string with n+"" but I haven't checked. \$\endgroup\$ – TheLethalCoder Jul 31 '17 at 14:00

Brachylog, 23 bytes


Try it online!

Brachylog doesn't go well with floats...


{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+ Takes string (quoted) input, with '-' for the negative sign
     ᶠ                  Return all outputs (digit filter)
{   }                    Predicate (is digit?)
 ∋                        An element of ? (input)
  ị                       Convert to number (fails if '-' or '.')
   ṫ                      Convert back to string (needed later on)
      ⟨   ⟩             Fork
       ≡                 Identity
         l               Length
        z                Zip
             ᵐ          Map
            ₎            Subscript (optional argument)
           j              Juxtapose (repeat) (this is where we need strings)
              ;         Pair with literal
               [ ]       List
                ?         ?
                  z     Zip
                   c    Concatenate (concatenate elements)
                     ᵐ  Map
                    ị    Convert to number
                      + Add (sum elements)

Husk, 15 bytes


Takes a string and returns a number. Try it online!


It's a bit annoying that the built-in parsing function r gives parse errors on invalid inputs instead of returning a default value, which means that I have to explicitly filter out the columns that consist of non-digits. If it returned 0 on malformed inputs, I could drop fΛ± and save 3 bytes.

§+ȯṁrfΛ±TṁrSR#±  Implicit input, e.g. "-23"
             #±  Count of digits: 2
           SR    Repeat that many times: ["-23","-23"]
         ṁr      Read each row (parse as number) and take sum of results: -46
  ȯṁrfΛ±T        This part is also applied to the result of SR.
        T        Transpose: ["--","22","33"]
     fΛ±         Keep the rows that contain only digits: ["22","33"]
   ṁr            Parse each row as number and take sum: 55
§+               Add the two sums: 9

Python 3, 95 94 87 85 84 bytes

def f(i):l=[x for x in i if"/"<x];k=len(l);print(k*float(i)+sum(int(x*k)for x in l))

Test Suite.

Python 3, 78 bytes

lambda x:sum(float(i*len(z))for z in[[i for i in str(x)if"/"<i]]for i in[x]+z)

Test Suite.

The second approach is a port to Python 3 inspired by @officialaimm's solution.


Python 2, 81 74 bytes

-7 bytes thanks to @Mr. Xcoder: '/'<i

  • Takes in integer or float, returns float.
lambda x:sum(float(i*len(z))for z in[[i for i in`x`if"/"<i]]for i in[x]+z)

Try it online!


Say 123.45 is given as input. [i for i in`x`if"/"<x] gives a list of stringified integers ['1','2','3','4','5'] (which is also z). Now we iterate through [x]+z i.e. [123.45,'1','2','3','4','5'], multiplying each element by len(z), here 5 and converting each to a Float (so that strings also convert accordingly), yielding [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Finally we calculate the sum(...) and obtain 167282.25.

  • \$\begingroup\$ 78 bytes. Replace i.isdigit() with "/"<i<":" \$\endgroup\$ – Mr. Xcoder Jul 29 '17 at 18:34
  • 1
    \$\begingroup\$ 74 bytes. You can replace i.isdigit() with "/"<i, in fact, because both . and - have lower ASCII codes than digits, adn / is in between them \$\endgroup\$ – Mr. Xcoder Jul 29 '17 at 18:39
  • \$\begingroup\$ You're welcome. I've ported it to Python 3 as an alternative to my answer \$\endgroup\$ – Mr. Xcoder Jul 29 '17 at 18:46

JavaScript, 75 62 bytes


Try it online

-2 bytes thanks to Arnauld
-5 bytes thanks to Shaggy (I though the function must receive a number, but now I see that lot of other answers receive string too)


Perl 5, 37 33 + 1 (-p) = 38 34 bytes


Try it online!

Used some tricks from Dom's code to shave 4 bytes


@n=/\d/g;    # extract digits from input
$_*=@n;      # multiply input by number of digits
for$\(@n){   # for each digit:
  $_+=       # add to the input
  $\x@n}     # this digit, repeated as many times as there were digits
             # taking advantage of Perl's ability to switch between strings
             # and numbers at any point
  • \$\begingroup\$ Came up with a very similar approach, but managed to get a couple of bytes off using $\ and exiting the loop: try it online! \$\endgroup\$ – Dom Hastings Jul 31 '17 at 14:40
  • \$\begingroup\$ Used some inspiration from you to shave mine down. What's the "}{" construct at the end of yours? I'm not familiar with that one. \$\endgroup\$ – Xcali Aug 5 '17 at 2:28
  • \$\begingroup\$ It's one I learnt from this site, basically -n and -p literally wrap a while(){...} around the code so }{ breaks out of that. This unsets $_ but if you use $\ as your variable it'll still get printed since $\ is appended to every print. Means you can stores number or something in that and disregard $_. Not sure that was a great explanation, but check out the Tips for golfing g in Perl thread, I'm sure that'll explain it better! Glad to have helped your score though! \$\endgroup\$ – Dom Hastings Aug 5 '17 at 7:43

Jelly, 17 bytes


Try it online!


Pyth, 18 bytes


Try it here.


Pyth, 21 20 bytes


Test suite.

Uses a completely different approach from @EriktheOutgolfer's answer, which helped me golf 1 byte in chat, from 22 to 21.



K@jkUTQ                   - Filters the digits and assigns them to a variable K.
         m                - Map. Iterated through the digits with a variable d
           v              - Evaluate (convert to float).
            *lKd          - Multiplies each String digit by the length of K.
        s                 - Sum
       +                  - Sum
                 *lKvQ    - Multipies the number  by the length of the digits String

Octave, 100 82 bytes

Thanks a lot @TomCarpenter for teaching me that assignments have a return value and saving me 18 bytes!


Try it online!


function f=g(v)
  s=strrep(num2str(abs(v)),'.','')-'0';  % number to vector of digits (ignore . and -)
  n=nnz(s);                              % length of that vector
  f=n*v+sum(sum(s'*logspace(0,n-1,n)))   % add the number n times and sum the columns of the square

The way this works is that we basically need to add the number itself n times and then add the sum of the columns. Summing s' * logspace(0,n-1,n) achieves the sum of columns, for example if v=-123.4 that matrix will be:

[ 1     10    100   1000;
  2     20    200   2000;
  3     30    300   3000;
  4     40    400   4000 ]

So we just need to sum it up and we're done.

  • 1
    \$\begingroup\$ You can save 18 bytes by smushing it all into an anonymous function @(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n))). Try it online! \$\endgroup\$ – Tom Carpenter Jul 30 '17 at 21:37

Swift 4, 139 134 bytes

func f(s:String){let k=s.filter{"/"<$0};print(Float(s)!*Float(k.count)+k.map{Float(String(repeating:$0,count:k.count))!}.reduce(0,+))}

Test Suite.


  • func f(s:String) - Defines a function f with an explicit String parameter s.

  • let k=s.filter{"/"<$0} - Filters the digits: I noticed that both - and . have smaller ASCII-values than all the digits, and / is between ., - and 0. Hence, I just checked if "/" is smaller than the current character, as I did in my Python answer.

  • print(...) - Prints the result.

  • Float(s)!*Float(k.count) - Converts both the String and the number of digits to Float and multiplies them (Swift does not allow Float and Int multiplication :()). So it adds the number x times, where x is the number of digits it contains.

  • k.map{Int(String(repeating:$0,count:k.count))! - k.map{} maps over k with the current value $0. String(repeating:$0,count:k.count) takes each digit, creates a String of x identical digits and Float(...)! converts it to a Floating-point number.

  • .reduce(0,+) - Gets the sum of the list above.

  • And finally + sums the two results.

Let's take an example!

Say our String is "0.45". First off, we filter the digits, so we are left with 0, 4, 5. We convert "0.45" to Float and multiply by the number of digits: 0.45 * 3 = 1.35. Then we take each digit and turn it into a String repeating that digit until it fills the width of the square (how many digits there are): 0, 4, 5 -> 000, 444, 555. We sum this, 000 + 444 + 555 = 999. Then we just add the results together: 1.35 + 999 = 1000.35.


C#, 139 137 bytes

using System.Linq;n=>{var d=(n+"").Where(char.IsDigit);return d.Sum(i=>int.Parse(new string(i,d.Count())))+new int[d.Count()].Sum(_=>n);}

Saved 2 bytes thanks to @Ian H.

Try it online!

Full/Formatted version:

namespace System.Linq
    class P
        static void Main()
            Func<double, double> f = n =>
                var d = (n + "").Where(char.IsDigit);
                return d.Sum(i => int.Parse(new string(i, d.Count()))) + new int[d.Count()].Sum(_ => n);


  • \$\begingroup\$ You can save 2 bytes at the beginning by using var d=(n+ ... instead of var d = (n .... \$\endgroup\$ – Ian H. Jul 31 '17 at 14:17
  • \$\begingroup\$ @IanH. Forgot to remove all the spaces -_- That's what I get for answering whilst doing a support call. \$\endgroup\$ – TheLethalCoder Jul 31 '17 at 14:19

Mathematica, 107 bytes

(t=Length[s=#&@@RealDigits[#]//.{a___, 0}:>{a}];If[IntegerPart@#==0,t++];t#+Tr[FromDigits@Table[#,t]&/@s])&

PHP, 78 88 +1 bytes


Run as pipe with -nR.

May yield warnings in PHP 7.1. Repace $c,$e with $c>0?$c:0,$e to fix.


Python 3, 68 70 73 77 bytes

lambda n:sum(float(n)+int(_*sum(x>"/"for x in n))for _ in n if"/"<_)

Try it online!

Loops over every digit character and repeats it by the number of digit characters overall, makes that into an integer, and adds that to n. This way n gets added d times, the horizontal part of the sum, along with the digit repetition, which is the vertical part. Originally used str.isdigit but >"/", thanks to others in this thread, saved a lot of bytes. Saves two bytes by taking n as a string, but the output is messier.

lambda n:sum(n+int(_*sum(x>"/"for x in str(n)))for _ in str(n)if"/"<_)

Try it online!


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.