El reto

Dadas dos cadenas, cada una de hasta 30, que consiste en caracteres ASCII imprimibles (códigos $[32, 126]$ ), ¡colóquelos en una balanza en la menor cantidad de bytes de código! Esto consta de los siguientes pasos:

1. Calcular y comparar los pesos de las cuerdas.
2. Elija la escala de arte ASCII inclinada adecuadamente
3. Coloque las dos cuerdas en la escala.

Las cadenas se pueden pasar como una matriz, dos argumentos o cualquier otro método razonable.

El peso de una cadena se define como la suma de los pesos de los caracteres de esa cadena, donde:

• Los espacios tienen un peso de 0 ( )
• Las letras minúsculas tienen un peso de 2 ( abcdefghijklmnopqrstuvwxyz)
• Las letras mayúsculas tienen un peso de 4 ( ABCDEFGHIJKLMNOPQRSTUVWXYZ)
• Todos los demás símbolos tienen un peso de 3 ( !"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~)

Las escalas se ven así:

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

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

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

Si la primera cadena es más pesada, use el primer dibujo como base de su salida; si la segunda cuerda es más pesada, use el segundo dibujo; Si las cuerdas tienen el mismo peso, use la tercera. Se permite el espacio en blanco al final.

Usaré un segmento del tercer dibujo como base para todos los siguientes ejemplos.

La primera cuerda debe colocarse en la bandeja izquierda y la segunda cuerda en la bandeja derecha.

Coloque una cadena en una bandeja colocando sus caracteres no espaciales dentro del área de 6x5 inmediatamente arriba de los guiones, como se marca con #s aquí (puede terminar sobrescribiendo parte de la escala de equilibrio, eso está bien):

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

Todos estos caracteres deben "resolverse", es decir. ya sea encima de un -carácter u otro carácter de la cadena:

  Incorrecto Incorrecto Correcto
    ____ ____ ____
 f / \ / \ / \
  l \ / \ / \
 / \ / hov \ / s \
/ oating \ / eri ng \ / ettled \
* ------ * * ------ * * ------ *

Además, toda la pila debe ser lo más plana posible, lo que significa que de las seis columnas de 1 ancho, la altura de la más alta y la más baja no deben diferir en más de 1:

    INCORRECTO INCORRECTO CORRECTO CORRECTO
[más alto: 5] [más alto: 4] [más alto: 5] [más alto: 2]
[más corto: 0] [más corto: 2] [más corto: 4] [más corto: 2]
      5__5_ ____ 5_5__ ____
     45445 y / \ 445454 / \
     45445 $% & $ @ 445454 / \
    / 45445 &% @% $ & 445454% & $ @% &
   / 45445 \ / & $ @ $ &% \ / 445454 \ / $ @ $% $$ \
   * ------ * * ------ * * ------ * * ------ *

El orden exacto / disposición de los personajes no importa. Los siguientes son todos los arreglos válidos para la cadena "¡Sopesa tus palabras!":

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

Casos de prueba

ENTRADA: "CODE GOLF", "desafíos de codificación"
PESOS: 32, 32
EJEMPLO DE SALIDA:
          . 
          El |
    ______ | ______
   / \ | / \
  / \ | nge \ s
 / OO \ | desafíos
/ CFGLED \ | /codificación\
* ------ * | * ------ *
          El |
          El |
    ______ | ______ 

ENTRADA: "", "$"
PESOS: 0, 3
EJEMPLO DE SALIDA:
    _.
   / \ * -_ |
  / \ * - |
 / \ | * -_ 
/ \ | * -_
* ------ * | / \
          El | / \
          El | / \
          El | PS
          El | * ------ *
    ______ | ______

ENTRADA: "¡SABES LO QUE DICEN!", "There_always_a_relevant_xkcd"
PESOS: 75, 65
EJEMPLO DE SALIDA:
          . tr_a_s
          El | _hekx_y
          | - * elcdta
       _- * | renovar
    _- * | / e's_al \
  T / \ | * ------ *
 AUYOHY |
 A! HWYK |
/ OTSMEW \ |
* ------ * |
    ______ | ______

Carbón , 110 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada como una matriz de dos cadenas. Explicación:

ＵＭθ⪫⪪ι ω

Elimina los espacios de ambas cadenas.

≔⁰η

Asumir el equilibrio de los pesos.

Ｆθ

Pase sobre ambas cuerdas.

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

Resta la diferencia de carrera del peso de la cuerda.

Ｐ-×⁷_↑χ.¶¶

Imprime la base de la balanza.

≔³ζ

Suponga que ambas bandejas están 3 del suelo.

¿η«

Si los pesos no se equilibraban ...

≔∨›⁰η⁵ζ

... calcule la altura de la bandeja izquierda ...

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

... dibuje la balanza inclinada hacia la derecha ...

¿›⁰η‖»

... y reflexionar si la sartén izquierda era más pesada.

Ｐ-⁺|×⁶_

De lo contrario, dibuje un equilibrio de nivel.

Ｊ±⁴±ζ

Salta a la primera bandeja de escala.

Ｆθ«

Pase sobre las entradas.

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

Dibuja la bandeja de escala.

←⪪ι⁶

Corte la entrada en subcadenas de longitud 6 e imprímalas al revés para que llenen la bandeja hacia arriba.

Ｊ⁹⁻ζ⁶

Salta a la segunda bandeja de escala.

Python 2 , 1101 1071 855 837 bytes

-216 bytes con compresión de cadena

-18 bytes al reducir algunas repeticiones

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

Pruébalo en línea!

Corre como A(string_one, string_two.

w calcula el peso de la cadena de forma recursiva.

t es el texto comprimido y entrelazado de las seis escalas posibles, que se comprime muy bien.

p toma la cadena (con espacios eliminados), el peso de la cadena y el lado del equilibrio en el que está la cadena, y crea un bloque de caracteres de 5x6.

Atoma las cuerdas y construye sus bloques con p. La cadena gigante en la parte inferior tiene tres cadenas de formato entrelazadas y comprimidas.

JavaScript (ES6),  340  337 bytes

Toma la entrada como una matriz de 2 matrices de caracteres. Dibuja el carácter de salida por carácter.

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)

Pruébalo en línea!

¿Cómo?

$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

Ahora invocamos la segunda función auxiliar para dibujar la salida:

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

Donde INDEXse calcula de la siguiente manera:

~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 gracias a @ceilingcat .

Las entradas son dos cadenas, lo que dará como resultado una matriz de caracteres como resultado.

Pruébalo en línea.

Explicación:

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