Viết chương trình lấy một chuỗi không trống gồm các chữ số từ 0 đến 9 và in cách chúng sẽ được hiển thị trên màn hình bảy đoạn bằng cách sử dụng dấu gạch chéo ( /, \).

Đây là những hình dạng chữ số chính xác:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Khi một chữ số xuất hiện sau một chữ số khác, chúng được xâu theo đường chéo lên và sang phải, với một không gian chéo ở giữa. Vì vậy, ví dụ, 203sẽ trở thành thế này:

    /\
     /\
  /\  /
  \ \
/\ \/
 / 
 \/

Lưu ý rằng 1nhân vật chiếm cùng một dung lượng như những người khác. Hai dòng của 1bên phải của màn hình, không phải bên trái.

Vì vậy, 159114sẽ trở thành này:

           \
          \/\
         \
          \
       \
        \
    /\
    \/\
  /   /
  \/\
 \  /
  \

Có thể có bất kỳ số lượng và sự kết hợp nào giữa các dòng mới hoặc dấu cách hàng đầu trong dấu đầu ra miễn là các chữ số ở đúng vị trí đối với nhau.

Vì vậy 159114, điều này cũng sẽ hợp lệ:

          \        
         \/\     
        \
         \
      \    
       \          
   /\     
   \/\
 /   /
 \/\         
\  /
 \    

Lấy đầu vào từ stdin hoặc dòng lệnh hoặc viết một hàm có trong một chuỗi. In kết quả ra thiết bị xuất chuẩn hoặc bạn có thể trả về dưới dạng chuỗi nếu bạn viết hàm.

Bất kỳ chuỗi không trống của các chữ số từ 0 đến 9 nên làm việc, bao gồm chuỗi chữ số duy nhất (ví dụ 8) và chuỗi với số không hàng đầu (ví dụ ở 007, các số không làm cần phải được in).

Mã ngắn nhất tính bằng byte thắng.

CJam, 77 71 70 69 63 62 byte

r_,5*_Sa*a*\{~"÷Ðëúܾ¿ðÿþ"=i2bS"\/"4*W<+.*3/..e>2fm>2m>}/Wf%N*

Tất cả các ký tự đều có thể in được, vì vậy sao chép và dán sẽ hoạt động tốt.

Hãy thử trực tuyến trong trình thông dịch CJam .

Ý tưởng

Chúng tôi bắt đầu bằng cách kiểm tra số chữ số n trong đầu vào và đẩy một hình vuông không gian đủ lớn để bao phủ đầu ra. Trong quá trình thực hiện, hình vuông này sẽ được mã hóa thành một mảng hai chiều của chuỗi một ký tự.

Một hình vuông có chiều dài 2n + 1 sẽ vừa phải (nghĩa là không có khoảng trắng xung quanh) để thực hiện đơn giản, nhưng chúng tôi sẽ sử dụng một chiều dài 5n để lưu một vài byte. Rất may, khoảng trắng xung quanh được cho phép.

Nếu chúng ta đảo ngược các dòng của bảy dấu gạch chéo của 8 , chúng ta có được những điều sau đây:

 \/
\/\
/\

Biểu diễn của tất cả các chữ số có thể được mã hóa dưới dạng số nguyên 8 bit, trong đó bit ^thứ i là 0 nếu ký tự ^thứ i sẽ được thay thế bằng khoảng trắng. Đối với các chữ số từ 0 đến 9 , các số nguyên kết quả là

247 208 235 250 220 190 191 240 255 254

tương ứng với các ký tự ISO-8559-1 sau đây:

÷Ðëúܾ¿ðÿþ

Đối với mỗi chữ số trong đầu vào, sau khi chọn số nguyên 8 bit tương ứng, chúng tôi lặp lại ký tự ^thứ i của biểu diễn 8 chính xác một lần _i , trong đó a _i là bit ^thứ i của số nguyên. Điều này đẩy một chuỗi các chuỗi có một hoặc không ký tự. Bằng cách chia mảng này thành các đoạn có độ dài 3, chúng ta có được một mảng trong đó mỗi phần tử tương ứng với một dòng của biểu diễn.

Bây giờ, chúng tôi tính toán tối đa vectơ của các chuỗi đại diện cho hình vuông và các chuỗi đại diện cho chữ số. Các chuỗi /và \lớn hơn chuỗi  , vì vậy chúng sẽ thay thế các khoảng trắng trong hình vuông. Tuy nhiên, chuỗi rỗng nhỏ hơn chuỗi  , do đó, chuỗi rỗng trong biểu diễn chữ số sẽ giữ nguyên khoảng trắng trong hình vuông.

Bây giờ chúng ta xoay các hàng và cột theo hai đơn vị để đặt biểu diễn chữ số sau vào phần thích hợp của hình vuông và lặp lại quy trình cho các chữ số còn lại trong đầu vào.

Cuối cùng, chúng tôi đảo ngược từng hàng và chèn một dòng cấp giữa các hàng riêng lẻ.

Mã

r_,      e# Read a token from STDIN and push the length of a copy.
5*_      e# Multiply the length by 5 and push a copy.
Sa*      e# Repeat the array [" "] that many times.
a*       e# Repeat the array [[" " ... " "]] that many times.
\{       e# For each character C in the input:
  ~      e#   Push eval(C), i.e., the digit the character represents.

  "÷Ðëúܾ¿ðÿþ"

         e#   Push the encodings of all 10 seven slash representations.

  =      e#   Select the proper one.
  i2b    e#   Push the resulting characters code point in base 2, i.e., its bits.
  S      e#   Push " ".
  "\/"4* e#   Push "\/\/\/\/".
  +W<    e#   Concatenate and eliminate the last character.
  .*     e#   Vectorized repetition.

         e#   For the digit 5, e.g., we have [1 0 1 1 1 1 1 0] and  " \/\/\/\" on
         e#   the stack, so .* yields [" " "" "/" "\" "/" "\" "/" ""].

  3/     e#   Divide the representation into chunks of length 3, i.e., its lines.
  ..e>   e#   Compute the twofold vectorized maximum, as explained above.
  2fm>   e#   Rotate each line to characters to the right.
  2m>    e#   Rotate the lines two units down.
}/
Wf%      e# Reverse each line.
N*       e# Place linefeeds between them.

Các phép quay cuối cùng sẽ làm rối loạn đầu ra nếu chiều dài cạnh của hình vuông nhỏ hơn 2n + 3 . Vì 5n ≥ 2n + 3 cho tất cả các số nguyên dương n , hình vuông đủ lớn để ngăn chặn điều này.

Python 3, 189 183 174 byte

s="a%sa"%input()
while s[1:]:b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")];S=len(s)*"  ";print(S+a+b,c+d+"\n"+S+e+f+g);*s,_=s

Việc nén có vẻ ổn đối với tôi, nhưng tôi gặp khó khăn khi nghĩ ra một cách hay để bỏ bảy biến ...

Rất may, thông số kỹ thuật khá thoải mái về các quy tắc khoảng trắng, bởi vì có rất nhiều khoảng trắng hàng đầu.

Mở rộng:

s="a%sa"%input()
while s[1:]:
  b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "
                 for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")]
  S=len(s)*"  "
  print(S+a+b,c+d+"\n"+S+e+f+g)
  *s,_=s

Giải trình

Các vị trí phân khúc được đại diện bởi các biến là:

    ab               /\
    efg               /\
  ab cd            /\  /
  efg              \ \
ab cd            /\ \/
efg               /
 cd               \/

Mỗi phân đoạn được mã hóa bằng một ký tự Unicode 2 byte duy nhất. Ví dụ: ϻmã hóa gphân đoạn như vậy:

bin(ord("ϻ")) = bin(1019) = "0b1111111011"
                               ^^^^^^^^^^
                               9876543210

Thật vậy, 2là chữ số duy nhất không sử dụng phân đoạn dưới cùng bên phải của màn hình bảy phân đoạn.

C, 1098 345 323 319 byte

Đầu tiên Thứ hai Thứ ba lần thực hiện. Cuối cùng quyết định bỏ bộ đệm màn hình để lưu một vài byte. Chương trình này lấy tham số là các chữ số và in các chữ số ở định dạng 7 đoạn.

Người tham gia lần đầu. Chỉ để cho vui. Hãy nhẹ nhàng.

a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977},i,j,k,n,m;char*c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
main(w,char**v){f(i,n=strlen(v[1]))f(k,(m=n-i-1)?2:3){f(j,m*2)P(32);f(w,3)Q(m,k,w);if(!k&&i)f(w,2)Q(m+1,2,w+1);P(10);}}

Mở rộng, cảnh báo miễn phí:

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

int a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977};
char *c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
int main(int w, char **v)
{
    int i,j,k,n,m;
    f(i,n=strlen(v[1])) {
        m=n-i-1;
        f(k,m?2:3) {
            f(j,m*2) P(32);
            f(w,3) Q(m,k,w);
            if (!k&&i) f(w,2) Q(m+1,2,w+1);
            P(10);
        }
    }
}

JavaScript, 192 178 167 162 byte

f=x=>{n=b="\n";for(k in x)for(i=0;i<8;)b+=("î\xA0Öô¸|~àþü".charCodeAt(x[k])>>i++&1?i%2?"/":"\\":" ")+(i%3?"":n+"  ".repeat(k));return b.split(n).reverse().join(n)}

Cách sử dụng: f("1337");sẽ trở lại

      /\
        \
    /\   
     /\
  /\  /
   /\
 \  /
  \

Nó sử dụng các tính năng của ES6 và có thể có một số hành vi phụ thuộc thực hiện do thiếu dấu chấm phẩy và dấu ngoặc đơn, nhưng nó hoạt động trong Firefox.

Mở rộng:

f=x=>
{
    n = b = "\n";

    for (k in x)
        for (i=0; i<8;)
            b += ("î\xA0Öô¸|~àþü".charCodeAt(x[k]) >> i++ & 1? i%2? "/" : "\\" : " ") + (i%3? "" : n+"  ".repeat(k));

    return b.split(n).reverse().join(n)
}

Giải trình:

llà một mảng chứa 10 ký tự byte đơn tương ứng với hình dạng của mỗi chữ số. Ví dụ, chữ số 0 được biểu thị bằng ký tự î:

/\        11
\ \  -->  101  --> 11 101 110 = î
 \/       011

Các ký tự đầu vào được sử dụng làm khóa cho mảng giữ hình dạng của chúng đại diện cho các đối tác, được đọc từng bit một.

Perl - 103 byte

#!perl -n
print$i+$%2?U^(u,$i--%2?v9:z)[$i<4+$%2&vec$_,4*$-3-$i,1]:$/.!($i=$--)
while$+=2*y/0-9/wPkz\\>?p~/

Ở trên có 6 ký tự không thể in được (nguồn có thể được tải xuống tại Ideone ) và tương đương với các mục sau:

#!perl -n
print$i+$^F%2?U^(u,$i--%2?v9:z)[$i<4+$^F%2&vec$_,4*$^F-3-$i,1]:$/.!($i=$^F--)
while$^F+=2*y/0-9/wPkz\\>?p\177~/

Mỗi ký tự ^Fcó thể được thay thế bằng ký tự 6 (ACK) và được \177thay thế bằng ký tự 127 (DEL).

Các shebang được tính là 1, dòng mới thứ hai là không liên tục. Đầu vào được lấy từ stdin.

Sử dụng mẫu

$ echo 0123 | perl seven-slash.pl

      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

$ echo 456789 | perl seven-slash.pl

          /\
          \/\
        /\  /
        \/\
      /\ \/
        \
    /
    \/\
  /  \/
  \/\
 \  /
\/\

Giải trình

Đầu ra được tạo ra một byte mỗi lần. Mỗi ký tự được phiên âm và sau đó được hiểu là một mảng bit sử dụng vec. Các bit được lưu trữ theo cách sau:

   /\           56 
   \/\          234
 /\ \/   ->   56 01
 \/\          234 
  \/           01

Đầu ra xen kẽ giữa 3 và 5 dấu gạch chéo, để các bit 56tràn vào 01chữ số tiếp theo. Bit 7không được sử dụng.

C #, 360 355 331 byte

Xin chào, lần đầu tiên thử chơi golf. Hy vọng điều này không quá tệ đối với một C # -entry.

string p(string n){var l=new string[n.Length*2+1];var i=l.Length-1;for(;i>0;){var x=@"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0]-48)*7,7);for(var j=i-3;j>=0;){l[j--]+="  ";}l[i--]+=" "+x[5]+x[6];l[i--]+=""+x[2]+x[3]+x[4];l[i]+=""+x[0]+x[1];n=n.Remove(0, 1);}return string.Join("\n",l);}

Cách sử dụng: p("159114");sẽ trở lại

          \
         \/\
        \
         \
      \
       \
   /\
   \/\
 /   /
 \/\
\  /
 \

Mở rộng:

string p(string n)
    {
        var l = new string[n.Length * 2 + 1];
        var i = l.Length - 1;
        for (; i > 0; )
        {
            var x = @"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0] - 48) * 7, 7);

            for (var j = i - 3; j >= 0; )
            {
                l[j--] += "  ";
            }
            l[i--] += " " + x[5] + x[6];
            l[i--] += "" + x[2] + x[3] + x[4];
            l[i] += "" + x[0] + x[1];

            n = n.Remove(0, 1);
        }

        return string.Join("\n", l);
    }

trăn 2, 317 298 278 273,15

def f(s):
    r=range;n=len(s)*2;l=[[' ']*-~n for x in r(-~n)]
    for x in r(0,n,2):
        for i,[d,y,c]in enumerate(zip('0112012','1021012',r'\\\\///')):l[n-2-x+int(y)][x+int(d)]=[' ',c][('%7s'%(bin(ord('}(7/jO_,\x7fo'[map(int,s)[x/2]])))[2:])[i]=='1']
    for x in l:print''.join(x)

Tôi coi 4 không gian là các tab trong khi đếm.
Không nén và có thể đọc được:

def f(s):
    r=['1111101','0101000','0110111','0101111','1101010','1001111','1011111','0101100','1111111','1101111']
    ''.join(map(lambda x:chr(eval('0b'+x)),r))
    n=len(s)*2
    l=[[' ']*(n+1) for x in xrange(n+1)]
    shifts=[(0,1,'\\'),(1,0,'\\'),(1,2,'\\'),(2,1,'\\'),(0,0,'/'),(1,1,'/'),(2,2,'/')]
    for x in xrange(0,n,2):
        y=n-2-x
        for i,[dx,dy,c] in enumerate(shifts):
            l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' '
    return '\n'.join(''.join(x) for x in l)

KDB (Q), 172 136 byte

{d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;
 -1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}

Giải trình

1) Tạo dbản đồ với tất cả các hình dạng chữ số.

2) Pad ma trận với các số không thêm và thêm chúng lại với nhau. tức là "01"

0           0 0 0 2 0   
0           0 0 0 0 2
1 2 0 0 0 + 0 0 0 0 0
2 0 2 0 0   0
0 2 1 0 0   0

3) Sử dụng chỉ mục để ánh xạ " /\"và in với -1.

Kiểm tra

q){d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;-1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}"0123456789"
                  /\
                  \/\
                /\  /
                \/\
              /\ \/
                \
            /
            \/\
          /  \/
          \/\
         \  /
        \/\
      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

Tôi chắc chắn điều này có thể ngắn hơn !!

Cảm ơn @hjk

Pip, 122 + 1 = 123 byte

Sử dụng -ncờ. Đưa đầu vào thông qua đối số dòng lệnh.

l:$.(J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Ma)z:2*#ap:sXz+2RLz+2Fi,5Fj,z{c:[4-ii]//2+j(pc@0c@1):(lij)}RVp

Các ký tự trong chuỗi UTF-8 có các điểm mã sau : 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Hơi vô dụng:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^t@a.2<>2}Ma)
z:2*#a+2
p:sXzRLz
Fi,5
 Fj,2*#a {
  x:i//2+j
  y:(4-i)//2+j
  p@y@x:l@i@j
 }
P RVp

Chiến lược cơ bản là tìm các ký tự cấu thành của mỗi số và sau đó xiên chúng một cách thích hợp. Ví dụ: for 8, chúng tôi muốn điều này (khoảng trắng được biểu thị bằng dấu chấm):

/.
\\
/.
\\
/.

cái sẽ biến thành thế này:

 .  
/\. 
\/\.
 \/ 

Đặc điểm hay của chiến lược này là nhiều số bị lệch trước có thể được ghép cạnh nhau.

Bây giờ, chúng ta có thể mã hóa /.\\/.\\/.trong cơ sở 3 như 1200120012. Sau đó, chúng ta có thể chuyển đổi nó thành thập phân và coi nó như một điểm mã UTF-8.

Biểu thức J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Manhận được dữ liệu bị sai lệch theo quy trình sau:

                            Ma   Map this lambda function to each character in input:
        (A_TB3M"...")            Create list of the code points of each character in UTF-8
                                   string, converted to base 3
                     @_          Index into that list using the input character
                       .2        Concatenate 2 to the end of the base-3 value (all of the
                                   pre-skewed number grids end in 2, i.e. space)
       ^                         Split the number into a list of its digits
 "\/ "@                          Index into this string with those digits, giving a list
                                   of slashes & spaces
J                                Join the list together into a string
                         <>2     Group string two characters at a time

Khi chúng tôi đã ghép các chuỗi này cạnh nhau bằng cách sử dụng $., sau đó chúng tôi tạo ra một lưới các không gian (2 * n +2 vuông), lặp qua lưới bị lệch trước và thay thế các không gian tương ứng trong lưới sau bị lệch bằng nhân vật phù hợp. Để xem điều đó xảy ra, người ta có thể sửa đổi mã để in từng giai đoạn và tạm dừng cho đầu vào của người dùng:

Lưới thực sự được xây dựng lộn ngược, bởi vì điều đó dường như làm cho toán học dễ dàng hơn.

Tôi chắc chắn có thuật toán tốt hơn để sử dụng. Nhưng tôi muốn đưa ra ý tưởng của riêng mình thay vì sao chép ý kiến ​​của người khác.

Thêm về Pip

Brainfuck - 719 byte

Chỉ dành cho bối cảnh lịch sử, tín dụng cho Daniel B Cristofani. Tôi không chắc chắn chính xác khi nào nó được tạo ra, nhưng nó có sẵn từ Lưu trữ Internet sớm nhất là vào ngày 9 tháng 5 năm 2003.

Đầu ra cho 9khác với trong mô tả vấn đề.

>>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]

Perl, 270 byte

Tôi thực sự không nên lãng phí thời gian của mình vào việc này.

$e="\\";$g=" ";$_=reverse<>;$l=length;push@a,(119,18,107,91,30,93,125,19,127,95)[$1]while/(.)/g;for($i=0;$i<=$l;$i++){$j=2*($l-$i);$b=$a[$i];$c=$i&&$a[$i-1];print" "x$j,$b&1?"/":$g,$b&2?$e:$g,$g,$c&32?$e:$g,$c&64?"/":$g,"
"," "x$j,$b&4?$e:$g,$b&8?"/":$g,$b&16?$e:$g,"
"}

JavaScript ( ES6 ), 191 206

Chạy đoạn trích trong Firefox để kiểm tra.

F=m=>(
  a='    \\/  /\\/\\ /  /\\  \\\\ \\'.match(/.../g),
  o=f='',r=' ',
  [for(d of m)(
    n=1e3+'¯B\x91ÿ$ê\x86A\x87ë'.charCodeAt(d)+'', // here there are 3 valid characters tha the evil stackoverflow editor just erase off, so I had to put them as hex escape
    o='\n'+f+' '+a[n[2]]+'\n'+r+a[n[1]]+o,
    r=f+a[n[3]],
    f+='  ')],
  r+o
)


//TEST

go=_=>O.innerHTML =(v=I.value)+'\n'+F(v)

go()

<input id=I value='0123456789'><button onclick='go()'>-></button>
<pre id=O></pre>

Java 8, 341 byte

n->{int i=n.length*2,j=i+1,k=0,t;String l[]=new String[j],x;for(;j-->0;l[j]="");for(;i>0;l[i--]+=" "+x.substring(5,7),l[i--]+=x.substring(2,5),l[i]+=x.substring(0,2))for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\').substring(t=(n[k++]-48)*7,t+7),j=i-2;j-->0;)l[j]+="  ";return"".join("\n",l);}

Cổng câu trả lời C # .NET của @Shion , vì vậy hãy đảm bảo nâng cấp anh ấy!

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

Giải trình:

n->{                       // Method with character-array parameter and String return-type
  int i=n.length*2,        //  Two times the length of the input array
      j=i+1,               //  Index integer, starting at `i+1`
      k=0,t;               //  Temp integers
  String l[]=new String[j],//  String-array for the rows, default filled with `null`
         x;                //  Temp-String
  for(;j-->0;l[j]="");     //  Replace all `null` with empty Strings
  for(;i>0                 //  Loop `i` downwards in the range [`n.length*2`, 0)
      ;                    //   After every iteration:
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         " "               //     A space
         +x.substring(5,7),//     And the 6th and 7th characters of temp-String `x`
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         x.substring(2,5), //     The 3rd, 4th and 5th characters of temp-String `x`
       l[i]+=              //    Append the row at index `i` with:
         x.substring(0,2)) //     The 1st and 2nd characters of the temp-String `x`
    for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\')
                           //   String containing all digit-parts
          .substring(t=(n[k++]-48)*7,t+7),
                           //   and take the substring of 7 characters at index
                           //   `n[k]` as integer multiplied by 7
        j=i-2;j-->0;)      //   Inner loop `j` in the range (`i`-2, 0]
      l[j]+="  ";          //    And append the rows at index `j` with two spaces
  return"".join("\n",l);}  //  Return the rows delimited with new-lines