Các thách thức

Cho hai chuỗi, mỗi chuỗi có độ dài lên tới 30, bao gồm các ký tự ASCII có thể in (mã $[32, 126]$ ), đặt chúng lên thang cân bằng trong vài byte mã nhất! Điều này bao gồm các bước sau:

1. Tính và so sánh trọng số của chuỗi
2. Chọn thang đo nghệ thuật ASCII nghiêng phù hợp
3. Đặt hai chuỗi lên thang đo

Các chuỗi có thể được truyền dưới dạng một mảng, hai đối số hoặc bất kỳ phương thức hợp lý nào khác.

Các trọng lượng của một chuỗi được định nghĩa là tổng các trọng lượng của các nhân vật của chuỗi, trong đó:

• Dấu cách có trọng số 0 ( )
• Chữ thường có trọng số là 2 ( abcdefghijklmnopqrstuvwxyz)
• Chữ in hoa có trọng số 4 (ABCDEFGHIJKLMNOPQRSTUVWXYZ )
• Tất cả các biểu tượng khác có trọng số 3 ( !"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~)

Các vảy trông như thế này:

          . _
          | _- * / \
          | - * / \
       _- * | / \
    _- * | / \
   / \ | * ------ *
  / \ |
 / \ |
/ \ |
* ------ * |
    ______ | ______

    _.
   / \ * -_ |
  / \ * - |
 / \ | * -_ 
/ \ | * -_
* ------ * | / \
          | / \
          | / \
          | / \
          | * ------ *
    ______ | ______

          .
          |
    ______ | ______
   / \ | / \
  / \ | / \
 / \ | / \
/ \ | / \
* ------ * | * ------ *
          |
          |
    ______ | ______

Nếu chuỗi đầu tiên nặng hơn, hãy sử dụng bản vẽ đầu tiên làm cơ sở cho đầu ra của bạn; nếu chuỗi thứ hai nặng hơn, sử dụng bản vẽ thứ hai; nếu các chuỗi có trọng lượng bằng nhau, sử dụng thứ ba. Khoảng trắng Trailing được cho phép.

Tôi sẽ sử dụng một phân đoạn của bản vẽ thứ ba làm cơ sở cho tất cả các ví dụ sau.

Chuỗi đầu tiên nên được đặt vào chảo bên trái và chuỗi thứ hai vào chảo bên phải.

Đặt một chuỗi trên pan bằng cách đặt các ký tự không phải không gian của nó trong vùng 6x5 ngay phía trên dấu gạch ngang, như được đánh dấu bằng #s ở đây (bạn có thể kết thúc phần ghi đè của thang cân bằng - điều đó tốt):

 ###### _
 ######
 ######
 ######
/ ###### \
* ------ *

Tất cả các nhân vật này nên được "giải quyết" tức là. hoặc ở trên một -ký tự hoặc một ký tự khác từ chuỗi:

  ĐÚNG SAU
    ____ ____ ____
 f / \ / \ / \
  l \ / \ / \
 / \ / hov \ / s \
/ oating \ / eri ng \ / ettled \
* ------ * * ------ * * ------ *

Ngoài ra, toàn bộ ngăn xếp phải càng phẳng càng tốt, có nghĩa là trong sáu cột rộng 1, chiều cao của cao nhất và chiều cao của ngắn nhất không được chênh lệch quá 1:

    SAI ĐÚNG ĐÚNG ĐÚNG
[cao nhất: 5] [cao nhất: 4] [cao nhất: 5] [cao nhất: 2]
[ngắn nhất: 0] [ngắn nhất: 2] [ngắn nhất: 4] [ngắn nhất: 2]
      5__5_ ____ 5_5__ ____
     45445 & / \ 445454 / \
     45445 $% & $ @ 445454 / \
    / 45445 &% @% $ & 445454% & $ @% &
   / 45445 \ / & $ @ $ &% \ / 445454 \ / $ @ $% $$ \
   * ------ * * ------ * * ------ * * ------ *

Thứ tự / sắp xếp chính xác của các nhân vật không quan trọng. Sau đây là tất cả các sắp xếp hợp lệ cho chuỗi "Cân nhắc từ của bạn!":

    ____ ____ ____ ____
   / \ / \ / \ / \
 DS! \ / nợ oe \ u! Wd \
 của chúng tôi Wihuos yoiwgr eghioo
/ Cân nặng \ / egyrr! \ / Wrhd! S \ / rrsuwy \
* ------ * * ------ * * ------ * * ------ *

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

INPUT: "CODE GOLF", "thử thách mã hóa"
TRỌNG LƯỢNG: 32, 32
VÍ DỤ ĐẦU RA:
          . 
          |
    ______ | ______
   / \ | / \
  / \ | nge
 / OO \ | challe
/ CFGLED \ | / mã hóa \
* ------ * | * ------ *
          |
          |
    ______ | ______ 

VÀO: "", "$"
TRỌNG LƯỢNG: 0, 3
VÍ DỤ ĐẦU RA:
    _.
   / \ * -_ |
  / \ * - |
 / \ | * -_ 
/ \ | * -_
* ------ * | / \
          | / \
          | / \
          | / $ \
          | * ------ *
    ______ | ______

INPUT: "BẠN BIẾT NHỮNG GÌ NÓI!", "Có_always_a_relevant_xkcd"
TRỌNG LƯỢNG: 75, 65
VÍ DỤ ĐẦU RA:
          . tr_a_s
          | _hekx_y
          | - * elcdta
       _- * | revanw
    _- * | / e's_al \
  T / \ | * ------ *
 AUYOHY |
 A!
/ OTSMEW \ |
* ------ * |
    ______ | ______

Than , 110 byte

ＵＭθ⪫⪪ι ω≔⁰ηＦθ≦⁻ΣＥι⁻⁺³№ακ№βκηＰ-×⁷_↑χ.¶¶≔³ζ¿η«≔∨›⁰η⁵ζＭ±⁶±²_Ｆ⁴⁺¶*-§_|_ι¿›⁰η‖»Ｐ-⁺|×⁶_Ｊ±⁴±ζＦθ«←⁶↑*↗⁴↓↘⁴←↖*←⪪ι⁶Ｊ⁹⁻ζ⁶

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào là một mảng của hai chuỗi. Giải trình:

ＵＭθ⪫⪪ι ω

Loại bỏ khoảng trắng từ cả hai chuỗi.

≔⁰η

Giả sử cân bằng trọng lượng.

Ｆθ

Vòng qua cả hai chuỗi.

≦⁻ΣＥι⁻⁺³№ακ№βκη

Trừ đi sự khác biệt chạy từ trọng lượng của chuỗi.

Ｐ-×⁷_↑χ.¶¶

In cơ sở của thang đo cân bằng.

≔³ζ

Giả sử rằng cả hai chảo là 3 trên mặt đất.

¿η«

Nếu trọng lượng không cân bằng ...

≔∨›⁰η⁵ζ

... tính chiều cao của chảo trái ...

Ｍ±⁶±²_Ｆ⁴⁺¶*-§_|_ι

... Vẽ số dư nghiêng xuống bên phải ...

¿›⁰η‖»

... và phản ánh nếu chảo trái nặng hơn.

Ｐ-⁺|×⁶_

Nếu không thì vẽ một sự cân bằng cấp độ.

Ｊ±⁴±ζ

Nhảy đến chảo quy mô đầu tiên.

Ｆθ«

Lặp lại các đầu vào.

←⁶↑*↗⁴↓↘⁴←↖*

Vẽ tỷ lệ chảo.

←⪪ι⁶

Cắt đầu vào thành các chuỗi con có chiều dài 6 và in chúng lộn ngược để chúng lấp đầy chảo lên trên.

Ｊ⁹⁻ζ⁶

Nhảy đến chảo quy mô thứ hai.

Trăn 2 , 1101 1071 855 837 byte

-216 byte với nén chuỗi

-18 byte bằng cách giảm một số lần lặp lại

from zlib import decompress as Z
from base64 import b64decode as D
r=range(6)
j="".join
w=lambda a:0if not a else(2+2*(a[0]<'[')if a[0].isalpha()else 3)+w(a[1:])
t=Z(D('eJxT0FKIV1BQ0AWT8SAIJsAcXTCppQAGumBSSx8MYsBAC0kCAiCySAIKEJW4ZHGpxA8AejMemQ=='))
p=lambda k,l,m:j(map(j,[(t[2*l+m::6][:30-len(k)]+k)[i::6]for i in r]))
def A(a,b):
 e=cmp(w(j(a.split())),w(j(b.split())))+1;return Z(D('eJxVUUGuhTAI3HOKWTdBW/U2SHoQ4O6ftvrMb0hLZJgZAYABFZB5KxD4zrZtNJOJMaHWIIoa0D6Ao+jrWRiHEI7kMcQg9VLBCo9O3dCbdanepOvZQztF9rRH2xUlwISehIZ96HltLFqu1IMF2p1QH/S+1Ge7CT5blIVOxqUWFudjqHPSwhitjPbzf7uZ1HaIaG2hShFTfU7Eca6J7MBr1K+3/YbRVLd2VlE5oilp7EG/gV7+DPQuSAsZPm7PZE9HBY2G+ctS/QzR+whSGlPAGz4mkkl5Sf18SMvkyL9iF6aLd2WLUm/KDVzvJu93k2tLZXlwetgLmFH4MzcKCaJnqX1Fz3iOf4//Pi7EwP4BHmyJpg=='))[e::3].format(*map(lambda c:[p(j(([a,b]*3)[c].split()),e,c)[i::5]for i in r],r))

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

Chạy như A(string_one, string_two .

w tính toán trọng số của chuỗi đệ quy.

t là văn bản được nén và xen kẽ của tất cả sáu thang đo có thể xảy ra để nén rất độc đáo.

p lấy chuỗi (với khoảng trắng được loại bỏ), trọng lượng của chuỗi và bên cạnh của sự cân bằng của chuỗi đó và tạo ra một khối ký tự 5x6.

Alấy các chuỗi và xây dựng các khối của chúng với p. Chuỗi khổng lồ ở phía dưới là ba chuỗi định dạng xen kẽ và nén.

JavaScript (ES6),  340  337 byte

Lấy đầu vào là một mảng gồm 2 mảng ký tự. Vẽ ký tự đầu ra theo ký tự.

S=>(s=Math.sign(~(g=i=>(S[i]=S[i].filter(c=>c>' '?i+=/[a-z]/gi.test(c)?c>{}?2:4:3:0),i))(0)+g(1))+1,g=x=>y>10?'':(X=(r=x>9)?20-x:x,Y=(r?2-s:s)*2+y,S[+r][X>0&&X<7&&47-Y*6+X]||`. /\\|-_*
`[~X?x-10?y>9?X>3?6:1:[x+y*3-17,2*y-4,x+~y*3][s]/2|X<4?Y<5|Y>8?Y-9|X>7?1:X%7?5:7:~X+Y?X+Y-8?1:2^r:3^r:[7-x%3,6,5+x%3][s]:y&&4:8])+g(x<21?x+1:!++y))(y=0)

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

Làm sao?

Chúng tôi xác định hàm trợ giúp đầu tiên loại bỏ khoảng trắng khỏi chuỗi đầu vào $S[i]$ và trả lại trọng lượng của nó:

g = i => (                   // i = string index
  S[i] = S[i].filter(c =>    // for each character c in S[i]:
    c > ' ' ?                //   if c is not a space:
      i +=                   //     update i:
        /[a-z]/gi.test(c) ?  //       if c is a letter:
          c > {} ?           //         if c is in lower case:
            2                //           add 2 to i
          :                  //         else:
            4                //           add 4 to i
        :                    //       else (not a letter):
          3                  //         add 3 to i
    :                        //   else (a space):
      0                      //     remove c from S[i]
  ), i                       // end of filter(); return i
)                            //

NB: Bởi vì chúng tôi sử dụng lại $i$ để tính trọng lượng, nó giảm đi một $S[1]$.

Chúng tôi tính toán $s$, bằng $0$ nếu $S[0]$ nặng hơn $2$ nếu $S[1]$ nặng hơn, hoặc $1$ nếu cả hai chuỗi có cùng trọng lượng:

s = Math.sign(~g(0) + g(1)) + 1

Bây giờ chúng ta gọi hàm trợ giúp thứ hai để vẽ đầu ra:

g = x =>                     // given x:
  y > 10 ?                   //   if we've reached the last row:
    ''                       //     stop recursion
  :                          //   else:
    ( X = (r = x > 9) ?      //     r = true if we're on the right side
        20 - x               //       X = 20 - x on the right side
      :                      //     or:
        x,                   //       X = x on the left side
      Y = (r ? 2 - s : s)    //     Y is the position of the scale tray
          * 2 + y,           //     according to s and the current side
      S[+r][                 //     we try to extract a character from S[0] or S[1]:
        X > 0 && X < 7 &&    //       provided that we're located above the tray
        47 - Y * 6 + X       //       and using an index based on (X, Y)
      ] ||                   //     if this character doesn't exist,
      `. /\\|-_*\n`[INDEX]   //     we need to draw the balance instead
    ) +                      //     (see the next part)
    g(x < 21 ? x + 1 : !++y) //     append the result of a recursive call

Trường hợp INDEXđược tính như sau:

~X ?                         // if this is not the last character of the current row:
  x - 10 ?                   //   if this is not the central column:
    y > 9 ?                  //     if this is the last row:
      X > 3 ? 6 : 1          //       draw the base ('_' or a space)
    :                        //     else:
      [ x + y * 3 - 17,      //       attempt to draw the beam:
        2 * y - 4,           //         using an equation depending on s
        x + ~y * 3           //         whose result must be -1, 0 or 1
      ][s] / 2 | X < 4 ?     //       if it's invalid or X is less than 4:
        Y < 5 | Y > 8 ?      //         if we're not over the chains:
          Y - 9 | X > 7 ?    //           if we're not over the pan:
            1                //             draw a space
          :                  //           else:
            X % 7 ? 5 : 7    //             draw the pan ('-' or '*')
        :                    //         else:
          ~X + Y ?           //           if this is not an interior chain:
            X + Y - 8 ?      //             if this is not an exterior chain:
              1              //               draw a space
            :                //             else:
              2 ^ r          //               draw the exterior chain ('/' or '\')
          :                  //           else:
            3 ^ r            //             draw the interior chain ('/' or '\')
      :                      //       else:
        [ 7 - x % 3,         //         draw the beam, using either '_' -> '-' -> '*'
          6,                 //         or just '_'
          5 + x % 3          //         or '*' -> '-' -> '_'
        ][s]                 //         depending on s
  :                          //   else:
    y && 4                   //     draw the central pillar ('|' or '.')
:                            // else:
  8                          //   append a line feed

Java 10, 1043 993 988 983 byte

(a,b)->{var r=new char[11][21];for(var A:r)java.util.Arrays.fill(A,' ');a=a.replace(" ","");b=b.replace(" ","");int A=s(a),B=s(b),j,c,i=3;for(;++i<17;r[3][i]=A==B?'_':32)r[10][i]=95;for(i=11;i-->1;)r[i][10]=i>0?'|':46;if(A==B){r[8][0]=r[8][7]=r[8][13]=r[8][20]=42;for(i=0;++i<20;)if(i<8|i>13)r[8][i]=45;for(i=8;i-->4;r[i][7-i]=r[i][20-i]=47)r[i][i]=r[i][i+13]=92;A=B=8;}else{r[5][i=A<B?0:13]=r[5][i+7]=r[9][13-i]=r[9][20-i]=42;for(i=5;i-->1;r[i][A>B?18-i*3:2+i*3]=42)r[i][A>B?17-i*3:3+i*3]=45;for(i=0;++i<20;)r[i>13?A>B?5:9:A>B?9:5][i>13|i<7?i:1]=45;for(i=9;i-->1;r[i][i>4?A>B?8-i:21-i:A>B?17-i:4-i]=47)r[i][i>4?A>B?i-1:i+12:A>B?i+16:i+3]=92;A=(A>B?r[i=0][16]=r[1][13]=r[3][7]=r[4][4]=95:(r[0][i=4]=r[1][7]=r[3][13]=r[4][16]=95));A=9-i;B=5+i;}c(r,a,A,7);c(r,b,B,20);return r;};int s(String s){int r=0;for(int i:s.getBytes())r+=i>64&i<91?4:i>96&i<123?2:3;return r;}void c(char[][]r,String s,int p,int q){for(int c=0,i=p,j;i-->p-5;)for(j=q;j-->q-6&c<s.length();)r[i][j]=s.charAt(c++);}

-5 byte nhờ @ceilingcat .

Đầu vào là hai Chuỗi, kết quả sẽ tạo ra ma trận ký tự.

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

Giải trình:

// Method with two String parameters and character-matrix return-type:
(a,b)->{
  // Result matrix, with 11 rows and 21 columns:
  var r=new char[11][21];
  // Initially fill the entire matrix with spaces:
  for(var A:r)java.util.Arrays.fill(A,' ');
  // Remove all spaces from the input-Strings:          
  a=a.replace(" ","");b=b.replace(" ","");
  // Call a separated method to calculate the scores of both input-Strings:
  int A=s(a),B=s(b),

  // Fill the cells for the base with '_',
  // and also fill the cells for the balance-bar with '_' when the scores are equal:
  j,c,i=3;for(;++i<17;r[3][i]=A==B?'_':32)r[10][i]=95;
  // Fill the cells for the stand with '|':
  for(i=11;i-->1;)r[i][10]=i>0?'|'
  // And the top of it with '.':
  :46;

  // If the scores are equal:
  if(A==B){
    // Fill the four appropriate cells for the sides of the scales with '*':
    r[8][0]=r[8][7]=r[8][13]=r[8][20]=42;
    // Fill the appropriate cells for the scales themselves with '-':
    for(i=0;++i<20;)if(i<8|i>13)r[8][i]=45;
    // Fill the appropriate cells of the robes with '/' and '\':
    for(i=8;i-->4;r[i][7-i]=r[i][20-i]=47)r[i][i]=r[i][i+13]=92;
    // Set A and B both to 8 to use later on:
    A=B=8;}
  // If the scores aren't equal:
  else{
    // Fill the four appropriate cells for the sides of the scales with '*':
    r[5][i=A<B?0:13]=r[5][i+7]=r[9][13-i]=r[9][20-i]=42;
    // Fill the appropriate four cells of the balance-bar with '-':
    for(i=5;i-->1;r[i][A>B?18-i*3:2+i*3]=42)r[i][A>B?17-i*3:3+i*3]=45;
    // Fill the appropriate cells of the scales with '-':
    for(i=0;++i<20;)r[i>13?A>B?5:9:A>B?9:5][i>13|i<7?i:1]=45;
    // Fill the appropriate cells of the robes with '/' and '\':
    for(i=9;i-->1;r[i][i>4?A>B?8-i:21-i:A>B?17-i:4-i]=47)r[i][i>4?A>B?i-1:i+12:A>B?i+16:i+3]=92;
    // Fill the four appropriate cells of the balance-bar with '_',
    // and set A and B to 9 and 5 depending on which score is higher:
    A=(A>B?r[i=0][16]=r[1][13]=r[3][7]=r[4][4]=95:(r[0][i=4]=r[1][7]=r[3][13]=r[4][16]=95));A=9-i;B=5+i;}
  // Call a separated method to fill the cells above the scales with the input-characters:
  c(r,a,A,7);c(r,b,B,20);
  // And finally return the resulting character-matrix:
  return r;};

// Separated method to calculate the score of the given String:
int s(String s){
  // Initially start the score-sum at 0:
  int r=0;
  // Loop over the characters of the given String:
  for(int i:s.getBytes())
    // Increase the sum by:
    r+=
      // 4 for uppercase letters:
      i>64&i<91?4
      // 2 for lowercase letters:
      :i>96&i<123?2
      // 3 for any other character:
      :3;
  // And return the resulting sum:
  return r;}

// Separated method to draw the strings on top of the scales:
void c(char[][]r,String s,int p,int q){
  // Keep a counter so we know when we're done drawing the given String:
  for(int c=0,
  // Loop over the appropriate rows bottom to top:
  i=p,j;i-->p-5;)
    // Inner loop over the appropriate cells of this row left to right,
    for(j=q;j-->q-6
    // as long as we're not done yet with the input-String:
        &c<s.length();)
      // And fill that appropriate cell with the next character in line of the given String:
      r[i][j]=s.charAt(c++);}