Bây giờ chúng ta đã biết làm thế nào để vuông và tam giác một số chính xác, chúng ta sẽ tìm hiểu làm thế nào để hình bình hành một. Để hình bình hành một số, trước tiên chúng ta sắp xếp nó thành hình bình hành bằng cách xếp nó lên trên một số lần bằng số chữ số của nó và thêm khoảng trắng để biến nó thành hình bình hành. Vì vậy, 123sẽ hình thành:

   123
  123
 123

Bây giờ chúng ta lấy mỗi số ngang và dọc và thêm chúng, 123+123+123+1+12+123+23+3bằng 531, là hình bình hành của 123.

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm, khi được cung cấp một số làm đầu vào, trả về hình bình hành của số đó.

Đầu vào:

Một số nguyên không âm hoặc một số nguyên không âm được biểu thị bằng một chuỗi.

Đầu ra:

Hình bình hành của số nguyên.

Các trường hợp thử nghiệm:

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

Ghi điểm:

Đây là môn đánh gôn , điểm số thấp nhất tính bằng byte!

MATL , 12 byte

tnEXyPY+c!Us

Đầu vào là một chuỗi. Hãy thử trực tuyến!

Giải trình

Hãy xem xét đầu vào '123'là một ví dụ.

Mã này nhân đôi đầu vào ( t) và xây dựng ma trận nhận dạng ( Xy) có kích thước gấp đôi chiều dài đầu vào ( 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

sau đó lật ngược nó lại ( 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

Chuỗi đầu vào, được hiểu là mã ASCII của các chữ số, tương đương với vectơ hàng số

49 50 51

Tích chập hai chiều kích thước đầy đủ ( Y+) của vectơ và ma trận trên cho

 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

Giải thích các số đó trở lại dưới dạng mã ASCII ( c) đưa ra ma trận char sau, với char 0 được biểu thị dưới dạng khoảng trắng:

     123
    123 
   123  
  123   
 123    
123

Transpose ( !) biến đổi điều này thành

     1
    12
   123
  123 
 123  
123   
23    
3     

Giải thích mỗi hàng dưới dạng một số ( U) cho vectơ cột số

  1
 12
123
123
123
123
 23
  3

và tổng hợp nó ( s) cho kết quả cuối cùng , 531.

Võng mạc , 22 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải thích: Giai đoạn đầu tiên phân chia số đầu vào ở mỗi chữ số và bao gồm tất cả các tiền tố độc quyền và hậu tố bao gồm, đưa ra các số dọc, cộng với số đầu vào ban đầu được lặp lại cho mỗi chữ số, đưa ra các số nằm ngang. Các giai đoạn còn lại sau đó chỉ đơn giản là tổng các số kết quả.

05AB1E ,  12 11  8 byte

_{Tôi chắc chắn biết điều này có thể được đánh gôn hơn nữa - lời khuyên chào mừng!}

-1 byte nhờ vào Erik the Outgolfer (tránh kết thúc tốt đẹp nhưng sử dụng phép nối)
và sau đó ...
-3 byte nữa nhờ Adnan (tránh nhân với độ dài-1 bằng cách thêm vào và trừ đi đầu vào ở cuối)

.s¹η++Oα

Hãy thử trực tuyến!

Làm sao?

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

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

Hãy thử trực tuyến!

Husk , 13 12 byte

ṁit§+SRL§+ḣṫ

Hãy thử trực tuyến!

Giải trình

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

𝐱S𝐗𝔻𝔻𝐬𝕤

Coi chừng. Chứa rắn:S𝐬𝕤

Hãy thử trực tuyến!

Python 3 , 85 70 byte

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

Đối với đầu vào 12345:

Tổng hợp các lát đầu vào 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345, bằng cách sử dụng lập chỉ mục chuỗi thành chỉ mục (r) = 1,2,3,4 trước khi truyền sang số nguyên và thêm vào 12345 * 2

Trân trọng cảm ơn:

-14 Byte @Jonathan Allen

-1 Byte @ovs

Hãy thử trực tuyến!

Japt , 15 11 byte

-4 byte nhờ @Shaggy.

¬£iYç
cUz)x

Lấy đầu vào dưới dạng chuỗi.

Hãy thử trực tuyến!

Giải trình

£

Tách mảng đầu vào thành chữ số ( ¬) và ánh xạ bởi ( £) hàm sau, trong đó Y là chỉ mục.
["1", "2", "3"]

iYç

Giá trị đầu vào (ẩn) với Ykhoảng trắng ( ç) được chèn ( i) ở đầu. Điều này được gán cho U.
["123", " 123", " 123"]

cUz1)x

Ghép nối với chính nó xoay 90 ° đúng ( 1thời gian). Sau đó tổng ( x).
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531.

Japt , 31 18 byte

-13 byte nhờ @ETHproductions

Cách tiếp cận này không hoạt động tốt khi sử dụng Japt. Giải pháp của Justin tốt hơn nhiều.

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

Giải trình:

[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

Hãy thử trực tuyến!

Ruby , 61 55 + 1 = 56 byte

Sử dụng -ncờ. Đầu vào từ STDIN.

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

Hãy thử trực tuyến!

JavaScript, 77 74 byte

Đã lưu 3 byte nhờ vào Ink Ink

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

Bình thường , 20 19 byte

Cách tiếp cận tiền tố hiện tại của tôi (hy vọng sẽ chơi gôn hơn nữa).

+*tlQsQssM+_M.__Q._

Test Suite hoặc thử một cách tiếp cận khác với cùng số byte .

Giải trình

+*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.

Để hiểu khái niệm tốt hơn, chúng ta sẽ lấy một ví dụ, nói "123".

• Đầu tiên chúng ta nhận được các tiền tố của đầu vào. Đó là những ['1', '12', '123'].

• Sau đó, chúng tôi nhận được các tiền tố của đầu vào đảo ngược, nghĩa là: ['3', '32', '321']và đảo ngược từng tiền tố , do đó chúng tôi nhận được ['3', '23', '123'].

• Chúng tôi nối hai danh sách và chuyển đổi từng phần tử thành một số nguyên, do đó chúng tôi có được [3, 23, 123, 1, 12, 123].

• Bằng cách tổng hợp danh sách, kết quả là 285.

• Sản phẩm Plà độ dài của đầu vào - 1 (tức là 2) nhân với biểu diễn số nguyên của nó ( 2 * 123 = 246).

• Cuối cùng, chúng tôi tổng hợp hai kết quả : 285 + 246, do đó chúng tôi có được 531, đó là kết quả chính xác.

Bình thường , 20 byte

+*hlQsQsm+s>Qds<QdtU

Phòng thử nghiệm.

Giải trình

Giải thích để đến sau khi chơi golf. Bây giờ tôi đã không thành công để chơi golf này (tôi có ý tưởng).

+*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 byte

Giải pháp:

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

Ví dụ:

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

Giải trình:

{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

Thạch , 18 byte

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

Hãy thử trực tuyến!

Swift 3 , 213 byte

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

Không thể được kiểm tra trực tuyến, vì nó chậm và hết thời gian. Bạn có thể dùng thử trong Swift Playgrounds nếu bạn muốn thử nghiệm nó.

Chạy mẫu

Đầu vào:

f (n: "123")
f (n: "101")
f (n: "1234567")

Đầu ra:

531
417
10288049

Thạch , 12 byte

LḶṚ⁶ẋ;€µ;ZVS

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi. Tạo "hình bình hành" dưới dạng ma trận các ký tự, sau đó đánh giá từng hàng và cột để lấy các số tổng.

Giải trình

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 byte ( -lmcờ biên dịch 78 + )

Chào! Đây là lần gửi đầu tiên của tôi, tôi hy vọng tôi đã không phá vỡ bất kỳ quy tắc nào.

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

Hãy thử trực tuyến!

Ungolfed, không có cảnh bá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;
}

Java 8, 147 137 126 116 114 byte

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

-13 byte (137 → 126 và 116 → 114) nhờ @ OlivierGrégoire .

Giải trình:

Hãy thử nó ở đây.

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 byte

-6 byte bằng cách không sử dụng c ()

-59 byte nhờ @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}

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi.

Tôi hoàn toàn chắc chắn có những cải tiến cần thực hiện, chủ yếu là tận dụng bất kỳ thế mạnh nào của R ... nhưng trong một thách thức về cơ bản là thao tác chuỗi, tôi đang cố gắng xem làm thế nào.

Chỉnh sửa: Tốt hơn nhiều bây giờ khi tôi không lặp lại một ý tưởng tồi!

Perl 5 , 53 + 1 (-n) = 54 byte

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

Hãy thử trực tuyến!

Toán học, 77 byte

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