既然我们知道如何正确地对一个数进行平方和三角化，我们将学习如何对一个数进行平行四边形绘制。要对数字进行平行四边形绘制，我们首先将其堆叠在其自身顶部的次数等于其具有的位数，然后添加空格使其成为平行四边形，从而将其布置为平行四边形。因此123将形成：

   123
  123
 123

现在我们获取每个水平和垂直数字，并将它们相加123+123+123+1+12+123+23+3，等于531，即的平行四边形123。

你的任务：

编写一个程序或函数，当给定数字作为输入时，返回该数字的平行四边形。

输入：

非负整数，或由字符串表示的非负整数。

输出：

整数的平行四边形。

测试用例：

1234567 -> 10288049
123     -> 531
101     -> 417
12      -> 39

得分：

这是代码高尔夫，以字节为单位的最低分数获胜！

MATL，12字节

tnEXyPY+c!Us

输入是一个字符串。在线尝试！

说明

以输入'123'为例。

该代码复制了输入（t），并构建了一个Xy大小为输入长度（nE）两倍的单位矩阵（）：

1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1

然后将其上下颠倒（P）：

0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 1 0 0
0 0 1 0 0 0
0 1 0 0 0 0
1 0 0 0 0 0

输入字符串，被解释为数字的ASCII码，等效于数字行向量

49 50 51

Y+上述向量和矩阵的全尺寸二维卷积（）

 0  0  0  0  0 49 50 51
 0  0  0  0 49 50 51  0
 0  0  0 49 50 51  0  0
 0  0 49 50 51  0  0  0
 0 49 50 51  0  0  0  0
49 50 51  0  0  0  0  0

将这些数字解释为ASCII码（c），得到以下char矩阵，其中char 0表示为空格：

     123
    123 
   123  
  123   
 123    
123

转置（!）将其转换为

     1
    12
   123
  123 
 123  
123   
23    
3     

将每一行解释为数字（U）给出数字列向量

  1
 12
123
123
123
123
 23
  3

并将其相加（s）得出最终结果531。

视网膜，22字节

.
$`;$&$';$_;
\d+
$*
1

在线尝试！链接包括测试用例。说明：第一阶段将输入数字拆分为每个数字，并包括所有排他前缀和包含后缀，给出垂直数字，再加上为每个数字重复的原始输入数字，给出水平数字。然后，其余阶段只需将所得的数字相加即可。

05AB1E， 12 11  8 字节

_{我敢肯定知道这能可进一步golfed -技巧欢迎！}

-1个字节要感谢Outgolfer的Erik（避免自动换行，但要使用串联）
，然后...
-3个字节要感谢Adnan（通过对矢量进行加法运算并在最后减去输入，避免与length-1相乘）

.s¹η++Oα

在线尝试！

怎么样？

.s¹η++Oα - implicit input, say i      e.g.  123
.s       - suffixes                         [3,23,123]
  ¹      - push i                           123
   η     - prefixes                         [1,12,123]
    +    - addition of top two              [4,35,246]
     +   - addition (vectorises)            [127,158,369]
      O  - sum                              654
       α - absolute difference abs(123-654) 531
         - implicit print

Haskell，90 78 76 71 64 63 59 57字节

g x=sum[x+div x(10^a)+mod x(10^a)|(a,_)<-zip[1..]$show x]

在线尝试！

外壳，13 12字节

ṁit§+SRL§+ḣṫ

在线尝试！

说明

              -- implicit input, say "123"
   §+         -- concatenate the results of the following two functions
     SR       --  ¹repeat the input n times, where n is the result of the next function
       L      --   length                                                  ["123","123"]
        §+   --  ²concatenate the results of the following two functions
          ḣ  --     prefixes                                              ["","1","12","123"]
           ṫ --     suffixes                                              ["123","23","3",""]
              -- inner concatenation                                      ["","1","13","123","123","23","3",""]
              -- outer concatenation                                      ["123","123","","1","13","123","123","23","3",""]
  t           -- all but the first element                                ["123","","1","13","123","123","23","3",""]
ṁ             -- map then sum
 i            --   convert to integer (where "" converts to 0)

Neim，7个字节

𝐱S𝐗𝔻𝔻𝐬𝕤

谨防。包含蛇：S𝐬𝕤

在线尝试！

Python 3中，85 70个字节

f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)+i(n)or i(n)*2

对于输入12345：

通过在转换为整数之前使用字符串索引来索引（r）= 1,2,3,4，对输入1 + 2345 + 12345、12 + 345 + 12345、123 + 45 + 12345、1234 + 5 + 12345的切片求和，并加到12345 * 2

特别感谢：

-14字节@乔纳森·艾伦

-1字节@ovs

在线尝试！

Japt，15 11字节

-4个字节，感谢@Shaggy。

¬£iYç
cUz)x

将输入作为字符串。

在线尝试！

说明

£

将输入数组拆分为数字（¬），然后通过（£）映射以下函数，其中Y为索引。
["1", "2", "3"]

iYç

输入值（隐含），在开始处以Y（ç）插入空格（）i。这已分配给U。
["123", " 123", " 123"]

cUz1)x

将其自身与右旋转90度（1时间）串联起来。然后求和（x）。
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531。

Japt，31个 18字节

-13个字节，感谢@ETHproductions

使用Japt时，这种方法效果不佳。贾斯汀的解决方案要好得多。

[U*Ål U¬£tYÃUå+]xx

说明：

[U*Ål U¬£tYÃUå+]xx
[              ]    // Create a new array
 U*Ål               // Push: Input * Input.slice(1).length()
                    // Push:
      U¬            //   Input, split into chars
        £tY         //   Map; At each char: .substr(Index)
            Uå+     // Push: Cumulative reduce Input; with addition
                xx  // Sum all the items, twice

在线尝试！

红宝石，61 55 + 1 = 56字节

使用-n标志。来自STDIN的输入。

p (1..~/$/).sum{|i|[$_[i,~/$/],$_[0,i],$_].sum &:to_i}

在线尝试！

JavaScript，77 74字节

借助Value Ink，节省了3个字节

f=a=>[...a+a].map((_,b)=>a-=-z.substr((b-=n)>0?b:0,b+n),a*=n=(z=a).length)|a

console.log(f('123'));
console.log(f('101'));
console.log(f('12'));
console.log(f('1234567'));
console.log(f('102033'));

Pyth，20 19字节

我当前的前缀方法（希望能进一步发展）。

+*tlQsQssM+_M.__Q._

测试套件或尝试使用具有相同字节数的替代方法。

说明

+*tlQsQssM+_M.__Q._  - Full program that reads a String from STDIN, with implicit input.

  tlQ                - Length of the input - 1.
     sQ              - The input converted to an integer.
 *                   - Product of the above two elements. We will call this P.
                 ._  - Prefixes of the input.
          +          - Concatenated with:
           _M.__Q    - The prefixes of the reversed input, reversed.
        sM           - Convert each to an integer.
       s             - Sum.
+                    - Addition of the product P and the sum above.

为了更好地理解该概念，我们将举个例子说"123"。

• 我们首先得到输入的前缀。那些是['1', '12', '123']。

• 然后，我们获得反向输入的前缀，即：['3', '32', '321']和反向每个前缀，因此得到['3', '23', '123']。

• 我们将两个列表连接起来，然后将每个元素转换为整数，从而获得[3, 23, 123, 1, 12, 123]。

• 通过汇总列表，结果为285。

• 乘积P是输入的长度-1（即2）乘以它的整数表示形式（2 * 123 = 246）。

• 最后，我们将两个结果相加：285 + 246，因此得到531，这是正确的结果。

Pyth，20个字节

+*hlQsQsm+s>Qds<QdtU

测试套件。

说明

进一步打高尔夫球后再作解释。我暂时还没有成功打高尔夫球（不过我有想法）。

+*hlQsQsm+s>Qds<QdtUQ  - Full program. Reads from STDIN. Q means input, and is implicit at the end.

  hlQ                  - Length of the input + 1.
     sQ                - The input converted to an integer.
 *                     - Multiply the above. We'll call the result P.
        m         tUQ  - Map over [1...length of the input)
          s>Qd         - input[currentItem:] casted to an integer.
              s<Qd     - input[:currentItem] casted to an integer.
         +             - Sum the above.
       s               - Sum the list.
+                      - Add the sum of the list and P.

q / kdb +，34个字节

解：

{sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}

例子：

q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"1234567"
10288049
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"123"    
531
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"101"    
417
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"12"     
39

说明：

{sum"J"$((c#c),c-til 2*c:count x)#\:x} / ungolfed
{                                    } / lambda function
                                    x  / implicit input
                                 #\:   / apply take (#) to each-left element with the right element
        (                       )      / the left element
                       c:count x       / count length and save in variable c
                     2*                / multiply by 2 (e.g. 6)
                 til                   / range, so 0 1 2 3 4 5
               c-                      / vector subtraction, so 3 2 1 0 -1 -2
         (   )                         / do this together
          c#c                          / 3 take 3, so 3 3 3
              ,                        / join, so 3 3 3 3 2 1 0 - 1 -2          
    "J"$                               / cast this "123", "123", "123" .. "23" to longs
 sum                                   / sum them up and return result

果冻，18字节

DµṚ;\U;;\ṖVS+Ḍ×¥L$

在线尝试！

雨燕 3，213字节

func f(n:String){print((n.characters.count-1)*Int(n)!+(0..<n.characters.count).map{r in Int(n[n.index(n.startIndex,offsetBy:r)..<n.endIndex])!+Int(n[n.startIndex..<n.index(n.endIndex,offsetBy:-r)])!}.reduce(0,+))}

无法在线测试，因为它速度慢且超时。如果您想测试它，可以在Swift Playgrounds中尝试。

样品运行

输入：

f（n：“ 123”）
f（n：“ 101”）
f（n：“ 1234567”）

输出：

531
417
10288049

果冻，12字节

LḶṚ⁶ẋ;€µ;ZVS

在线尝试！

将输入作为字符串。创建“平行四边形”作为字符矩阵，然后评估每一行和每一列以求和。

说明

LḶṚ⁶ẋ;€µ;ZVS  Input: string S
L             Length
 Ḷ            Lowered range - [0, 1, ..., len(S)-1]
  Ṛ           Reverse
   ⁶          The char ' ' (space)
    ẋ         Create that many characters of each in the range
     ;€       Prepend each to S
       µ      Begin a new monadic chain
        ;     Concatenate with
         Z    Transpose
          V   Eval each string
           S  Sum

C（gcc），95 8481个字节（78 + -lm编译器标志）

嗨！这是我的第一次提交，希望我没有违反任何规则。

g,o,l;f(char*s){l=atoi(s);while(s[o++])g+=l/pow(10,o)+atoi(s+o);return g+l*o;}

在线尝试！

取消高尔夫，没有警告：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int g,o,l;

int f(char *s){
  l = atoi(s);

  while(s[o++]) {
    g+=l/pow(10,o)+atoi(s+o);
  }

  return g+l*o;
}

int main(void){
  printf("%d\n",f("1234567"));
  return 0;
}

爪哇8，147个 137 126 116 114字节

n->{Integer l=(n+"").length(),r=n*l,i=0;for(;++i<l*2;)r+=l.valueOf((n+"").substring(i>l?i-l:0,i<l?i:l));return r;}

@OlivierGrégoire使得 -13个字节（137→126和116→114）。

说明：

在这里尝试。

n->{                          // Method with integer as parameter and return-type
  Integer l=(n+"").length(),  //  Length of the input integer
      r=n*l,                  //  Result-integer (starting at `n*l`)
      i=0;                    //  Index-integer (starting at 0)
  for(;++i<l*2;               //  Loop from 0 through two times `l` (exclusive)
    r+=                       //   Add to the result-integer sum:
       l.valueOf((n+"").substring(
                              //    Substring of input, converted to integer:
        i>l?                  //     If `i` is larger than `l`:
         i-l                  //      Substring starting at `i-l`
        :                     //     Else:
         0,                   //      Substring starting at 0
        i<l?                  //     If `i` is smaller than `l`:
         i                    //      Substring ending at `i` (exclusive)
        :                     //     Else:
         l)                   //      Substring ending at `l` (exclusive)
  );                          //  End of loop
  return r;                   //  Return resulting sum
}                             // End of method

[R ，168个 162 103字节

不使用c（）-6个字节

-59字节感谢@Giuseppe

function(n){k=nchar(n)
a=k*strtoi(n)
for(i in 1:k)for(j in i:k)a=a+(i==1|j==k)*strtoi(substr(n,i,j))
a}

在线尝试！

将输入作为字符串。

我绝对肯定有待改进，主要是在利用R的任何优势方面……但是在本质上是字符串操作的挑战中，我正在努力寻找方法。

编辑：现在好多了，因为我没有迭代一个坏主意！

Perl 5，53 +1（-n）= 54字节

$r=$_*(@n=/./g);for$i(@n){$r+=$_+($t=(chop).$t)}say$r

在线尝试！

Mathematica，77个字节

(s=IntegerDigits@#;t=Length@s;Tr[FromDigits/@Table[s~Take~i,{i,-t,t}]]+t#-#)&