人们不断告诉我，数字的平方就是数字乘以本身。这显然是错误的。对数字求平方的正确方法是将其堆叠成一个正方形，方法是将其堆叠在其顶部等于其位数的次数，然后从所得平方中读取所有数字，水平和垂直（仅从左到右）和垂直（从上到下），然后将它们加在一起。因此，对于数字123，首先创建正方形：

123
123
123

然后，从正方形中取出所有行和列，并将它们加在一起：

123+123+123+111+222+333

这给我们一个结果1035。

对于负数，您通常进行堆叠（请记住，您仅计算位数，因此长度中不包括负号），然后正常读取水平数（带负号），然后忽略负号垂直数字。因此，对于数字，-144我们得到平方：

-144
-144
-144

这给了我们-144-144-144+111+444+444，等于567

对于只有一位的数字，平方始终等于加倍的数字（水平读取一次，垂直读取一次）。所以4给我们

4

这给我们4+4，等于8。

对于带有小数部分的数字，请正常堆叠（请记住，在堆叠数字的次数中仅对数字进行计数，因此不计算小数点），并且在读取垂直数字时忽略小数点符号。例如，数字244.2给我们

244.2
244.2
244.2
244.2

这给我们244.2+244.2+244.2+244.2+2222+4444+4444+2222，等于14308.8。

小数或复数不能平方。

你的任务：

我已经厌倦了以手工方式对数字求平方，所以我决定自动化该过程。给我写一个程序或函数，它以浮点数或字符串（无论您愿意使用什么）作为输入，并以我的方式返回对它进行平方的结果。

例子：

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

得分：

我的手都无法写出所有这些正方形，并且我的计算机不支持复制/粘贴，因此，我键入的代码量最少（出于某种原因以字节为单位？）的条目将获胜！

05AB1E，7个字节

þSDg×+O

在线尝试！

说明

þ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

果冻， 13  12 字节

fØDẋ€L$ŒV+VS

一个接受字符列表（格式正确的十进制数字，前导零是-1 <n <1的要求）的单子链接，并返回一个数字。

在线尝试！

14字节接受并返回号码（输入限制在+/- 10 ^-5通过ŒṘ）： ŒṘ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

Haskell，59 56字节

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

输入被视为字符串。

在线尝试！

怎么运行的

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

o\d
l
¬xpV +V*Ng

在线测试！

说明

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核心），150个 141 133字节的

@TheLethalCoder节省了9个字节@@ LeLethalCoder
节省了8个字节

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

在线尝试！

将字符串作为输入，并将“平方”数字输出为浮点数。

此代码遵循以下算法：

1. 从输入创建一个新的字符串，但不带小数点和符号，因此我们可以从此处获取长度和列数。

2. 计算输入乘以我们在点1创建的字符串的长度。

3. 对于“正方形”中的每一列，创建一个具有列号和行长的新字符串，并将其添加到我们的结果中。

例：

输入： -135.5

1. 如果替换小数点和符号1355，将得到长度为的字符串4。
2. 输入时间4 ：-135.5 * 4 = -542。
3. 现在，我们为每列创建新的字符串，解析它们，并将它们添加到我们的结果：
   1111，3333，5555，5555。

如果将这些数字加起来15012，将得到，这正是程序将输出的结果。

Brachylog，23个字节

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+

在线尝试！

Brachylog不适用于浮子...

说明：

{∋ịṫ}ᶠ⟨≡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
                        with
        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)

外壳，15个字节

§+ȯṁrfΛ±TṁrSR#±

接受一个字符串并返回一个数字。 在线尝试！

说明

内置的解析函数r会在无效输入上给出解析错误，而不是返回默认值，这有点烦人，这意味着我必须显式过滤掉由非数字组成的列。如果在格式错误的输入上返回0，我可以删除fΛ±并保存3个字节。

§+ȯṁ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字节

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

测试套件。

Python 3，78个字节

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

测试套件。

第二种方法是受@officialaimm解决方案启发而移植到Python 3。

Python 2中，81 74个字节

-7个字节，感谢@Mr。Xcoder：'/'<i

• 接受整数或浮点数，返回浮点数。

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

在线尝试！

说明：

说的123.45是输入。[i for i in`x`if"/"<x]给出一个字符串化整数列表['1','2','3','4','5']（也是z）。现在，我们进行迭代，[x]+z即在此处[123.45,'1','2','3','4','5']将每个元素乘以，然后将每个元素转换为Float（以便字符串也相应地转换），从而产生。最后，我们计算并获得。len(z)5[617.25,11111.0,22222.0,33333.0,44444.0,55555.0]sum(...)167282.25

JavaScript，75 62字节

a=>(b=a.match(/\d/g)).map(b=>a+=+b.repeat(c),a*=c=b.length)&&a

在线尝试

感谢Arnauld -2个
字节感谢Shaggy -5个字节（我虽然该函数必须接收一个数字，但是现在我看到很多其他答案也接收了字符串）

Perl 5中，37 33 + 1（-p）= 38 34个字节

$_*=@n=/\d/g;for$\(@n){$_+=$\x@n}

在线尝试！

使用了Dom代码中的一些技巧来剃除4个字节

解释：

@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

果冻，17个字节

ŒṘfØDẋ€L©$ŒV;ẋ®$S

在线尝试！

Pyth，18个字节

s+RvQsM*RF_lB@jkUT

在这里尝试。

Pyth，21 20字节

K@jkUTQ+smv*lKdK*lKv

测试套件。

使用与@EriktheOutgolfer的答案完全不同的方法，该方法帮助我从22到21进行了1字节的聊天。

说明

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ-过滤数字并将其分配给变量K。
         m-地图。用变量d遍历数字
           v-评估（转换为浮点型）。
            * lKd-将每个字符串数字乘以K的长度。
        s-总和
       +-总和
                 * lKvQ-将数字乘以数字的长度字符串

八度，100 82字节

非常感谢@TomCarpenter教我分配具有返回值并为我节省了18字节！

@(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n)))

在线尝试！

取消高尔夫/解释

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
end

这种工作方式是，我们基本上需要将数字本身n相乘，然后再添加列的总和。求和s' * logspace(0,n-1,n)可以得出列的总和，例如，如果v=-123.4该矩阵为：

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

所以我们只需要sum完成就可以了。

迅速4，139个 134字节

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,+))}

测试套件。

说明

• func f(s:String)- f用显式的String参数定义一个函数s。

• let k=s.filter{"/"<$0}-过滤数字：我注意到，双方-并.具有较小的ASCII值比所有的数字和/之间.，-和0。因此，"/"就像我在Python答案中所做的那样，我只是检查是否小于当前字符。

• print(...) -打印结果。

• Float(s)!*Float(k.count)-将String和位数转换为Float并将它们相乘（Swift不允许Float和Int乘法:(））。因此，它将相乘的次数相加x，其中x包含的位数是。

• k.map{Int(String(repeating:$0,count:k.count))!- 用当前值k.map{}映射。取每个数字，创建一个由相同数字组成的字符串，并将其转换为浮点数。k$0String(repeating:$0,count:k.count)xFloat(...)!

• .reduce(0,+) -获取上面列表的总和。

• 最后+总结两个结果。

让我们举个例子吧！

说我们的字符串是"0.45"。首先，我们过滤数字，所以剩下0, 4, 5。我们转换"0.45"为Float并乘以位数：0.45 * 3 = 1.35。然后我们把每一个数字，并把它变成一个字符串重复该数字，直到充满广场（多少位有）的宽度0, 4, 5 -> 000, 444, 555。我们总结一下000 + 444 + 555 = 999。然后，我们将结果加在一起：1.35 + 999 = 1000.35。

C＃，139137字节

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

由于@Ian H，节省了2个字节。

在线尝试！

完整/格式化版本：

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

            Console.WriteLine(f(123));
            Console.WriteLine(f(-144));
            Console.WriteLine(f(4));
            Console.WriteLine(f(244.2));

            Console.ReadLine();
        }
    }
}

Mathematica，107个字节

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

PHP，78 88 +1字节

for($e=preg_match_all("#\d#",$n=$argn);~$c=$n[$i++];)$s+=str_repeat($c,$e);echo$s+$n*$e;

与一起作为管道运行-nR。

在PHP 7.1中可能会产生警告。Repace $c,$e与$c>0?$c:0,$e要修复。

Python 3，68 70 73 77字节

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

在线尝试！

循环遍历每个数字字符，并重复全部数字字符的数量，将其变为整数，然后将其添加到中n。这种方式n获得了加法d时间，总和的水平部分以及数字重复（垂直部分）。最初使用，str.isdigit但>"/"由于此线程中的其他功能，节省了大量字节。n以字符串形式保存两个字节，但输出更混乱。

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

在线尝试！