Pesez vos mots!

10

Le défi

Étant donné deux chaînes, chacune d'une longueur allant jusqu'à 30, consistant en des caractères ASCII imprimables (codes [32,126] ), mettez-les sur une échelle de balance dans le moins d'octets de code! Cela comprend les étapes suivantes:

  1. Calculer et comparer les poids des chaînes
  2. Choisissez l'échelle ASCII d'art correctement inclinée
  3. Placez les deux cordes sur la balance

Les chaînes peuvent être passées sous la forme d'un tableau, de deux arguments ou de toute autre méthode raisonnable.


Le poids d'une chaîne est défini comme la somme des poids des caractères de cette chaîne, où:

  • Les espaces ont un poids de 0 ( )
  • Les lettres minuscules ont un poids de 2 ( abcdefghijklmnopqrstuvwxyz)
  • Les lettres majuscules ont un poids de 4 ( ABCDEFGHIJKLMNOPQRSTUVWXYZ)
  • Tous les autres symboles ont un poids de 3 ( !"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~)

Les écailles ressemblent à ceci:

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

Si la première chaîne est plus lourde, utilisez le premier dessin comme base de votre sortie; si la deuxième chaîne est plus lourde, utilisez le deuxième dessin; si les cordes ont le même poids, utilisez la troisième. Les espaces de fin sont autorisés.


J'utiliserai un segment du troisième dessin comme base pour tous les exemples suivants.

La première chaîne doit être placée sur le plateau gauche et la deuxième chaîne sur le plateau droit.

Placez une chaîne sur un panoramique en plaçant ses caractères non-espace dans la zone 6x5 immédiatement au-dessus des tirets, comme indiqué par #s ici (vous pouvez finir par écraser une partie de l'échelle de la balance - c'est très bien):

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

Tous ces caractères doivent être «réglés», c'est-à-dire soit au-dessus d'un -caractère ou d'un autre caractère de la chaîne:

  FAUX MAUVAIS CORRECT
    ____ ____ ____
 F /\ /\ /\
  l \ / \ / \
 / \ / hov \ / s \
/ oating \ / eri ng \ / ettled \
* ------ * * ------ * * ------ *

De plus, la pile entière doit être aussi plate que possible, ce qui signifie que parmi les six colonnes de 1 largeur, la hauteur de la plus haute et la hauteur de la plus courte ne doivent pas différer de plus de 1:

    FAUX MAUVAIS CORRECT CORRECT
[le plus haut: 5] [le plus grand: 4] [le plus grand: 5] [le plus grand: 2]
[le plus court: 0] [le plus court: 2] [le plus court: 4] [le plus court: 2]
      5__5_ ____ 5_5__ ____
     45445 & / \ 445454 / \
     45445 $% & $ @ 445454 / \
    / 45445 &% @% $ & 445454% & $ @% &
   / 45445 \ / & $ @ $ &% \ / 445454 \ / $ @ $% $$ \
   * ------ * * ------ * * ------ * * ------ *

L'ordre / la disposition exacte des personnages n'a pas d'importance. Voici tous les arrangements valides pour la chaîne "Pesez vos mots!":

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

Cas de test

ENTRÉE: "CODE GOLF", "défis de codage"
POIDS: 32, 32
EXEMPLE DE SORTIE:
          . 
          |
    ______ | ______
   / \ | / \
  / \ | nge \ s
 / OO \ | challe
/ CFGLED \ | /codage\
* ------ * | * ------ *
          |
          |
    ______ | ______ 
ENTRÉE: "", "$"
POIDS: 0, 3
EXEMPLE DE SORTIE:
    _.
   / \ * -_ |
  / \ * - |
 / \ | * -_ 
/ \ | * -_
* ------ * | / \
          | / \
          | / \
          | / $ \
          | * ------ *
    ______ | ______
ENTRÉE: "VOUS SAVEZ CE QU'ILS DISENT!", "Il y a_ toujours_a_relevant_xkcd"
POIDS: 75, 65
EXEMPLE DE SORTIE:
          . tr_a_s
          | _hekx_y
          | - * elcdta
       _- * | revanw
    _- * | / e's_al \
  T / \ | * ------ *
 AUYOHY |
 A! HWYK |
/ OTSMEW \ |
* ------ * |
    ______ | ______
sept négatif
la source
1
L'espace de fin est-il acceptable?
Hiatsu
@Hiatsu Yep, ça va.
négatif sept
2
J'aime ce défi, vraiment. Cependant il y a 2 points qui m'empêchent de lui donner mon +1. Premièrement: si les espaces ne "pèsent" rien et ne sont pas inclus dans l'illustration, pourquoi les inclure? Il est juste inutile de les filtrer en premier. Deuxièmement: cela me semble être un défi "2 en 1" / caméléon - Défi 1: Déterminer quelle chaîne est "plus lourde", Défi 2: Générer de l'art ASCII.
Shaggy
@Shaggy Je pense que c'est une évaluation juste. La publication de cela m'a appris à garder les choses simples.
négatif sept

Réponses:

7

Charbon de bois , 110 octets

UMθ⪫⪪ι ω≔⁰ηFθ≦⁻ΣEι⁻⁺³№ακ№βκηP-×⁷_↑χ.¶¶≔³ζ¿η«≔∨›⁰η⁵ζM±⁶±²_F⁴⁺¶*-§_|_ι¿›⁰η‖»P-⁺|×⁶_J±⁴±ζFθ«←⁶↑*↗⁴↓↘⁴←↖*←⪪ι⁶J⁹⁻ζ⁶

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée comme un tableau de deux chaînes. Explication:

UMθ⪫⪪ι ω

Supprimez les espaces des deux chaînes.

≔⁰η

Supposons que l'équilibre des poids.

Fθ

Boucle sur les deux cordes.

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

Soustrayez la différence courante du poids de la chaîne.

P-×⁷_↑χ.¶¶

Imprimez la base de la balance.

≔³ζ

Supposons que les deux casseroles soient à 3 du sol.

¿η«

Si les poids ne s'équilibraient pas ...

≔∨›⁰η⁵ζ

... calculer la hauteur du bac gauche ...

M±⁶±²_F⁴⁺¶*-§_|_ι

... dessinez l'équilibre penché vers la droite ...

¿›⁰η‖»

... et réfléchissez si le plateau gauche était plus lourd.

P-⁺|×⁶_

Sinon, dessinez un équilibre de niveau.

J±⁴±ζ

Passez au premier panoramique d'échelle.

Fθ«

Boucle sur les entrées.

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

Dessinez l'échelle de l'échelle.

←⪪ι⁶

Coupez l'entrée en sous-chaînes de longueur 6 et imprimez-les à l'envers afin qu'elles remplissent le bac vers le haut.

J⁹⁻ζ⁶

Passez au deuxième panoramique de l'échelle.

Neil
la source
6

Python 2 , 1101 1071 855 837 octets

-216 octets avec compression de chaînes

-18 octets en réduisant la répétition

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

Essayez-le en ligne!

Exécuter en tant que A(string_one, string_two.

w calcule le poids de la chaîne de manière récursive.

t est le texte compressé et entrelacé des six échelles possibles, qui se comprime très bien.

p prend la chaîne (sans les espaces supprimés), le poids de la chaîne et le côté de la balance sur laquelle se trouve la chaîne, et crée un bloc de caractères 5x6.

Aprend les cordes et construit leurs blocs avec p. La chaîne géante en bas est composée de trois chaînes de format entrelacées et compressées.

Hiatsu
la source
3

JavaScript (ES6),  340  337 octets

Prend l'entrée comme un tableau de 2 tableaux de caractères. Dessine le caractère de sortie par caractère.

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)

Essayez-le en ligne!

Comment?

S[je]

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

jeS[1] .

s0S[0]2S[1]1

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

Nous invoquons maintenant la deuxième fonction d'aide pour dessiner la sortie:

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

INDEXest calculé comme suit:

~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
Arnauld
la source
1

Java 10, 1043 993 988 983 octets

(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 octets grâce à @ceilingcat .

Les entrées sont deux chaînes, ce qui donnera comme résultat une matrice de caractères.

Essayez-le en ligne.

Explication:

// 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++);}
Kevin Cruijssen
la source