Mots dans les mots dans les mots dans les mots. . .

17

Dans cette police pixélisée de lettres majuscules de l'alphabet, tous les caractères font 5 unités de large et 5 de haut.

 ███  ████   ███  ████  █████ █████  ████ █   █ █████     █ █   █ █     █   █
█   █ █   █ █   █ █   █ █     █     █     █   █   █       █ █  █  █     ██ ██
█████ ████  █     █   █ ████  ████  █  ██ █████   █       █ ███   █     █ █ █
█   █ █   █ █   █ █   █ █     █     █   █ █   █   █   █   █ █  █  █     █   █
█   █ ████   ███  ████  █████ █      ████ █   █ █████  ███  █   █ █████ █   █

█   █  ███  ████   ███  ████   ████ █████ █   █ █   █ █   █ █   █ █   █ █████
██  █ █   █ █   █ █   █ █   █ █       █   █   █ █   █ █   █  █ █   █ █     █ 
█ █ █ █   █ ████  █   █ ████   ███    █   █   █  █ █  █ █ █   █     █     █  
█  ██ █   █ █     █  ██ █  █      █   █   █   █  █ █  █ █ █  █ █    █    █   
█   █  ███  █      ████ █   █ ████    █    ███    █    █ █  █   █   █   █████

Il y a aussi 1 unité d'espace entre les lettres et entre les lignes, comme on peut le voir. Ainsi, chaque lettre peut occuper jusqu'à 6 × 6 unités d'espace.

Supposons qu'au lieu d'utiliser le caractère de bloc complet ( ) pour former directement les formes des lettres, nous voulions utiliser d' autres lettres dans la même police . Cela implique de multiplier par 6 les dimensions du texte afin que les lettres constituées de blocs entiers puissent être utilisées comme remplacements de bloc complet dans le texte plus grand.

Si cela n'a pas de sens, nous espérons que cet exemple le fera. Voici un A fait de B utilisant la police pixelisée:

      ████  ████  ████       
      █   █ █   █ █   █      
      ████  ████  ████       
      █   █ █   █ █   █      
      ████  ████  ████       
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 
                             
████  ████  ████  ████  ████ 
█   █ █   █ █   █ █   █ █   █
████  ████  ████  ████  ████ 
█   █ █   █ █   █ █   █ █   █
████  ████  ████  ████  ████ 
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 

Les B sont constitués de blocs pleins et les A sont constitués de B. Notez que les B ont toujours une unité entre eux horizontalement et verticalement.

Nous pouvons étendre cette idée en utilisant des mots au lieu de simples lettres. Voici "L'EAU" en "FEU":

█████                   █████             ████  █████ █████             █████ ████  █████ █████ █████       ████  █████ █████ █████ ████        █████ █████ █████ ████       
█                         █               █   █ █     █                   █   █   █ █     █       █         █   █ █     █       █   █   █       █     █       █   █   █      
████                      █               ████  ████  ████                █   ████  ████  ████    █         ████  ████  ████    █   ████        ████  ████    █   ████       
█                         █               █  █  █     █                   █   █  █  █     █       █         █  █  █     █       █   █  █        █     █       █   █  █       
█                       █████             █   █ █████ █                 █████ █   █ █████ █     █████       █   █ █████ █     █████ █   █       █████ █     █████ █   █      
                                                                                                                                                                             
█████                   █████       ████                    █████                   █████                   █████                               ████                    █████
█                         █         █   █                   █                       █                         █                                 █   █                   █    
████                      █         ████                    ████                    ████                      █                                 ████                    ████ 
█                         █         █  █                    █                       █                         █                                 █  █                    █    
█                       █████       █   █                   █████                   █                       █████                               █   █                   █████
                                                                                                                                                                             
█████       █████       ████        █████ █████ █████ ████  █████                   █████                   █████ ████  █████ █████             █████ ████  █████ █████      
█             █         █   █       █     █       █   █   █ █                       █                         █   █   █ █     █                   █   █   █ █     █          
████          █         ████        ████  ████    █   ████  ████                    ████                      █   ████  ████  ████                █   ████  ████  ████       
█             █         █  █        █     █       █   █  █  █                       █                         █   █  █  █     █                   █   █  █  █     █          
█           █████       █   █       █████ █     █████ █   █ █████                   █                       █████ █   █ █████ █                 █████ █   █ █████ █          
                                                                                                                                                                             
█████       █████       ████        █████                   █████                   █████                   ████                                █████             █████      
█             █         █   █       █                       █                         █                     █   █                               █                 █          
████          █         ████        ████                    ████                      █                     ████                                ████              ████       
█             █         █  █        █                       █                         █                     █  █                                █                 █          
█           █████       █   █       █████                   █                       █████                   █   █                               █████             █          
                                                                                                                                                                             
      █████       █████             ████                    █████                   █████                   █████ ████  █████ █████ █████       ████                    █████
      █             █               █   █                   █                       █                         █   █   █ █     █       █         █   █                   █    
      ████          █               ████                    ████                    ████                      █   ████  ████  ████    █         ████                    ████ 
      █             █               █  █                    █                       █                         █   █  █  █     █       █         █  █                    █    
      █           █████             █   █                   █████                   █                       █████ █   █ █████ █     █████       █   █                   █████

Remarquez comment "FIRE" apparaît à plusieurs reprises sur chaque ligne, et toujours dans l'ordre, quel que soit l'espace entre les lettres. Trois des cas les plus à droite de "FEU" ont été coupés tôt en raison de la forme des lettres de "EAU".

Cette idée peut être encore développée, en utilisant ces mots faits de mots pour faire des mots faits de mots faits de mots , ou même des mots faits de mots faits de mots faits de mots . Il n'y a pas de limite théoriquement.

Un autre exemple mettrait ce message au-dessus de la limite de 30 000 caractères, mais vous pouvez voir ce que l'on entend par «mots faits de mots faits de mots» en exécutant cet astucieux extrait de pile. Laissez simplement les paramètres à leurs valeurs par défaut et appuyez sur "Go!". Vous devriez voir le mot "DOG" fait du mot "CAT" fait du mot "MOUSE".

Taper toute liste de mots séparés par des espaces ne contenant que des majuscules dans la zone de texte produira le premier mot fait du deuxième mot fait du troisième, fait du quatrième, fait de ... etc.

AVERTISSEMENT: la saisie de plus de 4 ou même de 3 mots produira BEAUCOUP de texte et prendra du temps. Cela peut planter votre navigateur / ordinateur / voiture.

Défi

Le but de ce défi est de refléter ce que fait l'extrait de pile avec le moins de caractères.

Vous devez écrire un programme qui accepte une chaîne de mots séparés par des espaces ne contenant que des lettres majuscules, et génère le premier mot "composé de" le deuxième "composé de" le troisième et ainsi de suite, en utilisant la police pixellisée indiquée ci-dessus.

La case à cocher "ASCII ordinaire" et les fonctionnalités de taille de police de l'extrait n'ont pas besoin d'être prises en charge dans votre programme. Refléter la transformation de listes de mots en mots constitués de mots est le point principal et la seule exigence.

Détails

  • L'entrée doit provenir de stdin, de la ligne de commande, ou vous pouvez simplement écrire une fonction qui prend une chaîne.

  • Vous pouvez supposer que l'entrée est toujours valide, c'est-à-dire une chaîne de mots en lettres majuscules, séparés par exactement un espace, sans espaces de début ou de fin.

  • La sortie doit aller vers stdout (ou une alternative similaire) ou vers un fichier avec le nom de votre choix.

  • La sortie doit consister entièrement en caractères vides espace , personnages espace plein , et les nouvelles lignes.

    • Les caractères vides / plein espace doivent être respectivement espace et bloc plein ( , ), ou point et X ( ., X) respectivement.
  • La sortie ne doit contenir aucune colonne de début contenant uniquement des caractères d'espace vide , bien que toute combinaison de caractères d'espace vide de fin sur toutes les lignes soit autorisée.

    • Donc c'est permis:

      X...X.XXXXX..
      X...X.X
      X.X.X.XXXX....
      X.X.X.X..
      .X.X..XXXXX..
      
    • Mais ce n'est pas:

      .X...X.XXXXX..
      .X...X.X
      .X.X.X.XXXX....
      .X.X.X.X..
      ..X.X..XXXXX..
      
  • Il ne doit pas y avoir de lignes de début ou de fin contenant uniquement des caractères d'espace vide . Une seule nouvelle ligne de fin est éventuellement autorisée.

Voici une version plus conviviale de la police:

.XXX.
X...X
XXXXX
X...X
X...X

XXXX.
X...X
XXXX.
X...X
XXXX.

.XXX.
X...X
X....
X...X
.XXX.

XXXX.
X...X
X...X
X...X
XXXX.

XXXXX
X....
XXXX.
X....
XXXXX

XXXXX
X....
XXXX.
X....
X....

.XXXX
X....
X..XX
X...X
.XXXX

X...X
X...X
XXXXX
X...X
X...X

XXXXX
..X..
..X..
..X..
XXXXX

....X
....X
....X
X...X
.XXX.

X...X
X..X.
XXX..
X..X.
X...X

X....
X....
X....
X....
XXXXX

X...X
XX.XX
X.X.X
X...X
X...X

X...X
XX..X
X.X.X
X..XX
X...X

.XXX.
X...X
X...X
X...X
.XXX.

XXXX.
X...X
XXXX.
X....
X....

.XXX.
X...X
X...X
X..XX
.XXXX

XXXX.
X...X
XXXX.
X..X.
X...X

.XXXX
X....
.XXX.
....X
XXXX.

XXXXX
..X..
..X..
..X..
..X..

X...X
X...X
X...X
X...X
.XXX.

X...X
X...X
.X.X.
.X.X.
..X..

X...X
X...X
X.X.X
X.X.X
.X.X.

X...X
.X.X.
..X..
.X.X.
X...X

X...X
.X.X.
..X..
..X..
..X..

XXXXX
...X.
..X..
.X...
XXXXX

Notation

Il s'agit de donc la soumission la plus courte en octets l' emporte. Toute instance d'un bloc complet ( ) peut être comptée comme 1 octet au lieu de 3, donc les soumissions qui utilisent Xn'ont aucun avantage.

Loisirs de Calvin
la source
5
Vous pouvez exécuter le code JavaScript suivant (l'ex en tapant. javascript:Dans la barre d'URL et de le coller) pour faire de l'art ASCII ici beaucoup, beaucoup plus facile à lire: $('#question pre').css('line-height',1). Résultat: i.stack.imgur.com/XmB8C.png
Doorknob
1
Ou pour inclure les réponses$('#question pre, .answer pre').css('line-height',1)
Martin Ender
Je sais qu'il est un peu trop tard pour faire cette blague, mais je n'ai pas pu résister: i.imgur.com/vAZi1Zt.png .
algorithmshark
Comment ai-je raté ce défi?!
Magic Octopus Urn

Réponses:

8

CJam, 171 165 162 161 161 octets

qS/_0=,0a*a\{{W:I;{'[{RI):I=}?i65-"c¿»ÐòO*4Õ]%ÐÎ<à IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/=}%z1af*}%R,1a*a*}fR2a*"█ 
"f=

Je traite comme 1 octet. Reste que tous les caractères sont bien dans la plage ASCII, donc les traiter comme 1 octet aussi.

Vous pouvez utiliser cette boîte à pâte pour le code exact

Exemple de sortie pour entrée:

FIRST HELLO WORLD

entrez la description de l'image ici

Comment ça fonctionne

Tout d'abord

"c¿»ÐòO*4Õ]%ÐÎ<à IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/

est simplement le motif de chacun des 27 caractères ( A-Zet espace) qui est composé de 0(aux Xpositions) et 1(aux .positions). Après décodage, cela donne un tableau de 27 éléments de tableaux 2D de 5 lignes et 5 colonnes représentant Xet .pour chacun des 27 caractères. Appelons ce tableau comme L.

Maintenant, le code restant:

qS/                      "Read the input and split it on space to get array Q";
   _0=                   "Get a copy of the first element of the above array";
      ,0a*               "Create an array filled with 0 with length of the first element";
          a\             "Wrap that array in another array and swap to get Q on top";
{  ...  }fR              "This is a for each loop on the array Q with R having the";
                         "current element value in each loop";
 {...}%                  "In the first iteration, the 0 array we created will be the";
                         "only thing on stack, in subsequent iterations, the result";
                         "of previous iteration will be on stack";
  W:I;                   "Initialize variable I with -1";
      {...}%             "Run this block on each element of the current array";
{'[{RI):I=}?i65-L=}%     "This is the above code block. In each iteration, we figure";
                         "out what character needs to be be put at the current index";
                         "Then we get the pattern of 0 and 1 for that character";
 '[{      }?             "Stack contains either 0 or 1. If it is 1, we want to leave";
                         "that index blank, so we put pattern of '[ which is 5X5 spaces";
    RI_:I=               "When we do not want a blank character, we get the next"
                         "character from R to fill the non empty space";
            i65-         "Convert A-Z  to 0-27 notation";
                L=       "Get the corresponding pattern from the pattern array L";
z1af*                    "After the above iterations, for each line of the previous";
                         "iteration's output, we get a vertical 2D array for next";
                         "iteration. We transpose it and join each character in";
                         "this line using a space";
      R,1a*a*            "After getting all lines from current iteration, we join them";
                         "with one full line of space characters";

 2a*                     "After all iterations, we have the 0 1 based 2D array for the";
                         "final output ASCII with each row representing a line. We join";
                         "these lines with 2, to get a 0 1 2 based array";
     "█                  "A brick, a space and a newline. Mapping 1 to 1 with 0 1 2";
"                        "based array";
 f=                      "For each of the 0 1 2 based array element, convert them to";
                         "one of the brick, space and new line character";

Essayez-le en ligne ici

Optimiseur
la source
9

Python 3, 437 octets

from numpy import*
s=input().split()
d=fromstring('NONO__^Q_PQAQQNONO^_QQQQQ_QQQQAAAQDPIA[SQQQQADQQQJJH_OAQOOY_DPGAUUQOQONDQJUDDDQQQQAAQQDQIAQYQAYIPDQJUJDBQONO_A^Q_NQ_QQNA^QODNDJQD_',byte)[:,None]>>arange(5)&1
b=0
x=1
y=len(s[0])
n=[[1]*y]
for w in s:
 g=n;b+=x;x*=6;n=zeros((x,x*y),int);i=-6
 for q in g:
  o=j=0;i+=6
  for p in q:n[i:i+5,j:j+5]|=d[ord(w[o%len(w)])-65::26]*p;o+=p;j+=6
for r in n[:-b]:print(''.join(' █'[x] for x in r))

Les formes des caractères sont encodées en ASCII. Chaque octet ASCII correspond à une ligne d'un caractère, avec des bits représentant des blocs unitaires. Ce n'est pas un schéma très efficace, mais il est facile de décompresser dans des masques de bits NumPy pour chaque caractère.

Nous commençons avec un tableau 2D de 1. Il a une colonne pour chaque caractère du premier mot et une seule ligne. Ensuite, pour chaque mot, nous créons un nouveau tableau de 0, six fois plus élevé et six fois plus large que le tableau précédent. Lorsque le tableau précédent avait un 1, la section 6x6 correspondante du nouveau tableau est remplie avec le masque de bits du caractère approprié.

Voici un exemple (avec une police extrêmement petite):

entrez la description de l'image ici

grc
la source
5

CJam, 181 174 170 octets

Tous ces caractères non ASCII sont toujours dans la plage ASCII étendue, ils peuvent donc tous être codés dans un seul octet. (Sauf pour le , mais celui-ci est traité spécialement selon les spécifications du défi.) Par conséquent, je compte chaque caractère comme un octet.

"Á  :½A%õ­Íú£à˪ë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;lS/_0=,'█*a\{f{W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%W<zSf*}Sa*}/N*

Stack Exchange a probablement modifié certains des caractères non imprimables, vous devrez donc peut-être copier le code à partir de cette boîte à pâte .

Testez-le ici.

Prend l'entrée via STDIN comme une liste de mots séparés par des espaces. Le premier mot est la plus grande échelle. Par exemple:

HOLISM REDUCTIONISM

les rendements

████                    █████             ████  █   █  ███              █████                               █████  ███  █   █ █████  ████             █   █ ████  █████ ████        █   █                    ███ 
█   █                   █                 █   █ █   █ █   █               █                                   █   █   █ ██  █   █   █                 ██ ██ █   █ █     █   █       █   █                   █   █
████                    ████              █   █ █   █ █                   █                                   █   █   █ █ █ █   █    ███              █ █ █ ████  ████  █   █       █   █                   █    
█  █                    █                 █   █ █   █ █   █               █                                   █   █   █ █  ██   █       █             █   █ █  █  █     █   █       █   █                   █   █
█   █                   █████             ████   ███   ███                █                                 █████  ███  █   █ █████ ████              █   █ █   █ █████ ████         ███                     ███ 

████                    █████       ████                    █   █        ███                                            █████                   █████                                ███  █   █       █████  ████
█   █                   █           █   █                   █   █       █   █                                             █                       █                                 █   █ ██  █         █   █    
████                    ████        █   █                   █   █       █                                                 █                       █                                 █   █ █ █ █         █    ███ 
█  █                    █           █   █                   █   █       █   █                                             █                       █                                 █   █ █  ██         █       █
█   █                   █████       ████                     ███         ███                                              █                     █████                                ███  █   █       █████ ████ 

████  █████ ████  █   █  ███        █████                   █████        ███                                            █   █                         █████  ████ █   █             ████        █████       ████ 
█   █ █     █   █ █   █ █   █         █                       █         █   █                                           ██  █                           █   █     ██ ██             █   █       █           █   █
████  ████  █   █ █   █ █             █                       █         █   █                                           █ █ █                           █    ███  █ █ █             ████        ████        █   █
█  █  █     █   █ █   █ █   █         █                       █         █   █                                           █  ██                           █       █ █   █             █  █        █           █   █
█   █ █████ ████   ███   ███          █                     █████        ███                                            █   █                         █████ ████  █   █             █   █       █████       ████ 

████                    █████       ████                    █   █        ███                                            █████                                           █████        ███                    █   █
█   █                   █           █   █                   █   █       █   █                                             █                                               █         █   █                   ██  █
████                    ████        █   █                   █   █       █                                                 █                                               █         █   █                   █ █ █
█  █                    █           █   █                   █   █       █   █                                             █                                               █         █   █                   █  ██
█   █                   █████       ████                     ███         ███                                              █                                             █████        ███                    █   █

████                    █████             ████  █   █  ███              █████ █████  ███  █   █ █████        ████ █   █ ████  █████ ████        █   █  ███  █████ █████              ███                    █   █
█   █                   █                 █   █ █   █ █   █               █     █   █   █ ██  █   █         █     ██ ██ █   █ █     █   █       █   █ █   █   █     █               █   █                   ██  █
████                    ████              █   █ █   █ █                   █     █   █   █ █ █ █   █          ███  █ █ █ ████  ████  █   █       █   █ █       █     █               █   █                   █ █ █
█  █                    █                 █   █ █   █ █   █               █     █   █   █ █  ██   █             █ █   █ █  █  █     █   █       █   █ █   █   █     █               █   █                   █  ██
█   █                   █████             ████   ███   ███                █   █████  ███  █   █ █████       ████  █   █ █   █ █████ ████         ███   ███    █   █████              ███                    █   █

Explication

Tout d'abord, nous stockons une table de recherche pour les formes de lettres dans L:

"Á  :½A%õ­Íú£à˪ë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;

La première chaîne juste un nombre compressé. Nous traitons les points de code comme des chiffres de base 257, puis nous convertissons le nombre résultant en binaire. YYbest 2 est en base 2, donc ça donne [1 0]. Nous utilisons la substitution d'élément avec " █"pour transformer les chiffres en espaces et bloquer les caractères. Enfin, nous avons divisé la chaîne en lignes de 5 caractères, puis en blocs de 5 lignes. Le résultat est stocké Let jeté de la pile.

Maintenant, l'idée générale est de commencer avec une seule ligne de la longueur du mot à plus grande échelle. Et puis pour chaque mot, nous parcourons la grille existante et développons tous les blocs jusqu'au caractère correspondant à la plus petite échelle suivante (tout en insérant des lignes et des colonnes vides pour la séparation). Voici la préparation des entrées:

lS/_0=,'█*a\
lS/          "Read input, split on spaces.";
   _0=       "Duplicate and get first word.";
      ,'█*   "Get length repeat █ that many times.";
          a  "Wrap in array, to make the grid two-dimensional.";
           \ "Swap with word list.";

Examinons d'abord la structure extérieure du programme restant. Le bloc suivant {...}/est exécuté pour chaque mot et développe chacun des caractères du bloc.

{f{...}Sa*}/N*
{         }/   "Process each word in the input.";
 f{...}        "Map this block onto each line of the grid, passing in the current word as well.";
       Sa*     "Since each original line will be turned into 5 lines, the grid is still grouped
                into blocks of 5 lines. We join them together with empty lines as required.";
            N* "Join all lines together with newlines.";

Enfin, regardons comment une seule ligne est développée:

W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%
W:T;                                "Store -1 in T.";
    \                               "Swap word with line.";
     {                           }% "Map this block onto each character.";
      ' =                           "Check if the character is a space.";
         {      }{            }?    "If it is, run the first block, otherwise the second.";
          S5*                       "Create a string of five spaces.";
             a5*                    "Create an array of five such strings.";
                  T):T              "Push T, increment, store in T.";
                      1$=           "Copy the word and access the T'th character, cyclically.";
                         'A-        "Subtract A from the letter.";
                            L=      "Use the result to get the character shape from L.";
                                \   "Swap resulting block with word.";

"At this point each character is replaced with a 5x5 array of new characters.
 So we actually have a 3D array right now. Since we used a map operation, the
 current word will also be at the end of the array, which we need to get rid off.";

W<zSf*
W<     "Discard last array element - the current word.";
  z    "Zip or transpose the top two levels of the array.";
   Sf* "Join each line together with spaces.";

Le résultat est imprimé automatiquement à la fin du programme.

Martin Ender
la source