Die Herausforderung

Geben Sie zwei Zeichenfolgen mit einer Länge von jeweils bis zu 30, die aus druckbaren ASCII-Zeichen (Codes ) bestehen, in den wenigsten Code-Bytes auf eine Waage! Dies besteht aus folgenden Schritten:$[32, 126]$

1. Berechnen und vergleichen Sie die Gewichte der Zeichenfolgen
2. Wählen Sie die entsprechend geneigte ASCII-Kunstskala
3. Legen Sie die beiden Saiten auf die Waage

Die Zeichenfolgen können als Array, zwei Argumente oder eine andere sinnvolle Methode übergeben werden.

Das Gewicht einer Zeichenfolge ist definiert als die Summe der Gewichte der Zeichen dieser Zeichenfolge, wobei:

• Leerzeichen haben ein Gewicht von 0 ( )
• Kleinbuchstaben haben ein Gewicht von 2 ( abcdefghijklmnopqrstuvwxyz)
• Großbuchstaben haben ein Gewicht von 4 ( ABCDEFGHIJKLMNOPQRSTUVWXYZ)
• Alle anderen Symbole haben ein Gewicht von 3 ( !"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~)

Die Waage sieht folgendermaßen aus:

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

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

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

Wenn die erste Zeichenfolge schwerer ist, verwenden Sie die erste Zeichnung als Basis für Ihre Ausgabe. Wenn die zweite Zeichenfolge schwerer ist, verwenden Sie die zweite Zeichnung. Wenn die Saiten das gleiche Gewicht haben, verwenden Sie die dritte. Nachgestellte Leerzeichen sind zulässig.

Ich werde ein Segment der dritten Zeichnung als Basis für alle folgenden Beispiele verwenden.

Die erste Saite sollte auf die linke Pfanne und die zweite Saite auf die rechte Pfanne gelegt werden.

Platzieren Sie eine Zeichenfolge in einer Pfanne, indem Sie die Nicht-Leerzeichen innerhalb des 6x5-Bereichs unmittelbar über den Bindestrichen platzieren, wie hier mit #s gekennzeichnet (möglicherweise überschreiben Sie einen Teil der Waage - das ist in Ordnung):

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

Alle diese Zeichen sollten "erledigt" sein, dh. entweder über einem -Zeichen oder einem anderen Zeichen aus der Zeichenfolge:

  FALSCH FALSCH RICHTIG
    ____ ____ ____
 f / \ / \ / \
  l \ / \ / \
 / \ / hov \ / s \
/ oating \ / eri ng \ / ettled \
* ------ * * ------ * * ------ *

Außerdem sollte der gesamte Stapel so flach wie möglich sein, dh von den sechs 1-breiten Säulen dürfen sich die Höhe der höchsten und die Höhe der kürzesten nicht um mehr als 1 unterscheiden:

    FALSCH FALSCH RICHTIG RICHTIG
[am höchsten: 5] [am höchsten: 4] [am höchsten: 5] [am höchsten: 2]
[kürzeste: 0] [kürzeste: 2] [kürzeste: 4] [kürzeste: 2]
      5__5_ ____ 5_5__ ____
     45445 & / \ 445454 / \
     45445 $% & $ @ 445454 / \
    / 45445 &% @% $ & 445454% & $ @% &
   / 45445 \ / & $ @ $ &% \ / 445454 \ / $ @ $% $$ \
   * ------ * * ------ * * ------ * * ------ *

Die genaue Reihenfolge / Anordnung der Zeichen spielt keine Rolle. Das Folgende sind alle gültigen Anordnungen für die Zeichenfolge "Wiegen Sie Ihre Wörter!":

    ____ ____ ____ ____
   / \ / \ / \ / \
 ds! \ / owd oe \ u! Wd \
 ourwor Wihuos yoiwgr eghioo
/ Weighy \ / egyrr! \ / Wrhd! S \ / rrsuwy \
* ------ * * ------ * * ------ * * ------ *

Testfälle

EINGABE: "CODE GOLF", "Codierungsherausforderungen"
GEWICHTE: 32, 32
BEISPIELAUSGABE:
          . 
          |
    ______ | ______
   / \ | / \.
  / \ | nge \ s
 / OO \ | Herausforderung
/ CFGLED \ | / Kodierung \
* ------ * | * ------ *
          |
          |
    ______ | ______ 

EINGABE: "", "$"
GEWICHTE: 0, 3
BEISPIELAUSGABE:
    _.
   / \ * -_ |
  / \ * - |
 / \ | * -_ 
/ \ | * -_
* ------ * | / \.
          | / \.
          | / \.
          | / $ \
          | * ------ *
    ______ | ______

EINGABE: "SIE WISSEN, WAS SIE SAGEN!", "Es gibt immer einen relevanten xxccd"
GEWICHTE: 75, 65
BEISPIELAUSGABE:
          . tr_a_s
          | _hekx_y
          | - * elcdta
       _- * | revanw
    _- * | / e's_al \
  T / \ | * ------ *
 AUYOHY |
 A! HWYK |
/ OTSMEW \ |
* ------ * |
    ______ | ______

Holzkohle , 110 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Nimmt die Eingabe als Array von zwei Zeichenfolgen auf. Erläuterung:

ＵＭθ⪫⪪ι ω

Entfernen Sie die Leerzeichen von beiden Zeichenfolgen.

≔⁰η

Nehmen Sie die Gewichtsbalance an.

Ｆθ

Schleife über beide Saiten.

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

Subtrahieren Sie die Laufdifferenz vom Gewicht der Saite.

Ｐ-×⁷_↑χ.¶¶

Drucken Sie die Basis der Waage.

≔³ζ

Angenommen, beide Pfannen befinden sich 3 über dem Boden.

¿η«

Wenn die Gewichte nicht balancierten ...

≔∨›⁰η⁵ζ

... die Höhe der linken Pfanne berechnen ...

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

... ziehen Sie die Waage nach rechts unten ...

¿›⁰η‖»

... und überlegen, ob die linke Pfanne schwerer war.

Ｐ-⁺|×⁶_

Ansonsten ziehen Sie eine Waage.

Ｊ±⁴±ζ

Springe zur ersten Waagschale.

Ｆθ«

Schleife über die Eingänge.

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

Zeichnen Sie die Waagschale.

←⪪ι⁶

Schneiden Sie die Eingabe in Teilzeichenfolgen der Länge 6 und drucken Sie sie verkehrt herum, so dass sie die Pfanne nach oben füllen.

Ｊ⁹⁻ζ⁶

Springe zur zweiten Waagschale.

Python 2 , 1101 1071 855 837 Bytes

-216 Bytes mit String-Komprimierung

-18 Bytes durch Reduzieren einiger Wiederholungen

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

Probieren Sie es online aus!

Ausführen als A(string_one, string_two.

w berechnet das Gewicht der Zeichenfolge rekursiv.

t ist der komprimierte und verschachtelte Text aller sechs möglichen Skalen, der sehr gut komprimiert wird.

p Nimmt die Zeichenfolge (mit entfernten Leerzeichen), das Gewicht der Zeichenfolge und die Seite des Gleichgewichts, auf der sich die Zeichenfolge befindet, und erstellt einen 5x6-Zeichenblock.

Animmt die Saiten und baut ihre Blöcke mit p. Die riesige Zeichenfolge unten besteht aus drei Format-Zeichenfolgen, die interlaced und komprimiert sind.

JavaScript (ES6),  340  337 Byte

Nimmt die Eingabe als Array von 2 Zeichenarrays auf. Zeichnet die Ausgabe zeichenweise.

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)

Probieren Sie es online aus!

Wie?

$S[i]$

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

$i$$S[1]$

$s$$0$$S[0]$$2$$S[1]$$1$

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

Wir rufen jetzt die zweite Hilfsfunktion auf, um die Ausgabe zu zeichnen:

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

Wo INDEXwird wie folgt berechnet:

~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 Bytes

(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 Bytes dank @ceilingcat .

Eingabe sind zwei Strings, die als Ergebnis eine Zeichenmatrix ergeben.

Probieren Sie es online aus.

Erläuterung:

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