L'art de façonner les mots

Étant donné une matrice binaire et une chaîne de lettres, remplacez tous les 1 de la matrice de gauche à droite par les lettres de la chaîne. Une fois que les lettres ont pris la forme de la matrice, imprimez la matrice en remplaçant les 0 par des espaces. Il est probablement plus facile de donner simplement un exemple ou deux.

Cas: Cas de base ...

Entrée un:

[0,0,1,0,0]
[0,1,0,1,0]
[1,0,0,0,1]
[0,1,0,1,0]
[0,0,1,0,0]

"PPCGPPCG"

Sortie un:

  P    
 P C  
G   P
 P C 
  G  

Cas: Si la chaîne d'entrée est plus longue que le nombre de celles ...

Entrée deux:

[1,0,0]
[0,1,0]
[1,0,1]

lambda

Sortie deux:

l  
 a 
m b

Cas: Si la chaîne d'entrée est plus courte que le nombre de celles ...

Entrée trois:

[1,1,1]
[1,0,1]
[1,1,1]

PPCG

Sortie trois:

PPC
G P
PCG

Hypothèses disponibles

• Vous pouvez supposer que la chaîne d'entrée n'est jamais vide.
• Vous pouvez supposer que la matrice ne sera jamais vide.
• Vous ne pouvez pas supposer que la matrice binaire ne sera jamais entièrement composée de zéros.

Règles

• Si la chaîne est plus courte que le nombre de uns, répétez la chaîne; tous doivent être remplacés.
• Si la chaîne est plus longue que le nombre de chaînes, utilisez uniquement ce qui est nécessaire.
• Vous pouvez utiliser True / False à la place d'entiers / bits pour l'entrée.
• Les espaces de fuite SONT REQUIS, tous les zéros doivent être remplacés par des espaces.
• Une seule nouvelle ligne de fin est acceptable.
• Il s'agit du code-golf, le nombre d'octets le plus bas gagne.

MATL , 11 octets

yz:)1Gg!(c!

Les entrées sont une matrice numérique (avec ;comme séparateur de ligne) et une chaîne.

Essayez-le en ligne! Ou vérifiez les cas de test: 1 , 2 , 3 .

y       % Take the two inputs implicitly. Duplicate the first
        % STACK: [1,0,0; 0,1,0; 1,0,1], 'lambda', [1,0,0; 0,1,0; 1,0,1]
z       % Number of nonzeros
        % STACK: [1,0,0; 0,1,0; 1,0,1], 'lambda', 4
:       % Range
        % STACK: [1,0,0; 0,1,0; 1,0,1], 'lambda', [1 2 3 4]
)       % Reference indexing (select values)
        % STACK: [1,0,0; 0,1,0; 1,0,1], 'lamb'
1Gg     % Push first input as a logical matrix; will be used as index
        % STACK: [1,0,0; 0,1,0; 1,0,1], 'lamb', [1,0,0; 0,1,0; 1,0,1]
!       % Transpose. This is necessary because MATL uses column-major order
        % (down, then accross)
(       % Assignment indexing (fill with values). Since the original matrix
        % is numeric, the new values are introduced as their ASCII codes
        % STACK: [108, 0, 109; 0, 97, 0; 1, 0, 98]
c       % Convert to char
        % STACK: ['l m'; ' a '; '  b']
!       % Transpose back. Implicitly display
        % STACK: ['l  '; ' a '; 'm b']

Vim, 44 42 octets

qqy$P0xjf1"_xP{@qq@q:s/0/ /g^M:s/,/^V^M/g^M{D

Sauvegardé 2 octets grâce à @DjMcMoylex !

Ici, le ^Mest une nouvelle ligne littérale, et le^V estCTRL-V

Prend l'entrée dans ce format:

PPCG
00100,01010,10001,01010,00100

Avertissement: Si la chaîne est plus longue que ~ 40 caractères, votre ordinateur peut manquer de RAM.

Explication:

qq             @qq@q                            # Start recording a recursive macro.
  y$P0x                                         # Duplicate the string and cut out the first character
       jf1"_xP{                                 # Find the first 1, and replace it with the cut character from the string.
                                                # Now we have replaced all the 1's with their respective character, but we still have the array in the original format, and we have the string massivly duplicated at the first line, so we need to clean it up:
                    :s/0/ /g^M                  # Replace all 0's with a space
                              :s/,/^V^M/g^M     # Replace all ,'s with a newline. The ^V acts like a backslash, it escapes the newline so that the command isn't run too soon
                                           {D   # Delete the first line

Voici un gif de moi "exécutant" le "programme":

Rétine , 41 33 octets

0

+1`(.)(.*)(\D+)1
$2$1$3$1
A1`

Essayez-le en ligne!

La chaîne d'entrée est indiquée sur la première ligne de l'entrée, suivie de la matrice. Étant donné que Retina n'a aucun concept de listes (ou vraiment quoi que ce soit, sauf des chaînes), il n'y a pas de séparateurs dans la matrice binaire, sauf pour les sauts de ligne pour séparer les lignes.

Explication

0

Transforme les zéros en espaces.

+1`(.)(.*)(\D+)1
$2$1$3$1

Remplacez à plusieurs reprises le premier 1par le premier caractère de la chaîne d'entrée tout en faisant pivoter ce caractère jusqu'à la fin de la chaîne d'entrée. Cela prend en charge les cas où il y a plus de 1s que de caractères dans la chaîne d'entrée.

A1`

Ignorez la première ligne, c'est-à-dire la chaîne d'entrée.

JavaScript ES6, 67 53 50 49 octets

Enregistré 3 octets grâce à @ETHproductions Enregistré 1 de plus grâce à @Neil

(a,b,i)=>a.replace(/./g,c=>+c?b[++i]||b[i=0]:' ')

f=
(a,b,i)=>a.replace(/./g,c=>+c?b[++i]||b[i=0]:' ')

G=_=>h.innerHTML = f(`00100
01010
10001
01010
00100`,z.value)
h.innerHTML = G()

<input id=z oninput="G()" value="PPCG"></input>
<pre id=h>

Ancien code avant que je sache que les matrices de chaînes sont un format d'entrée valide:

(a,b)=>a.map(c=>c.map(d=>d?b[i++%b.length]:' ').join``,i=0).join`
`

f=
(a,b)=>a.map(c=>c.map(d=>d?b[i++%b.length]:' ').join``,i=0).join`
`

G=_=>h.innerHTML = f([[0,0,1,0,0],[0,1,0,1,0],[1,0,0,0,1],[0,1,0,1,0],[0,0,1,0,0]],z.value)
h.innerHTML = G()

<input id=z oninput="G()" value="PPCG"></input>
<pre id=h>

Perl, 40 octets

36 octets de code + -i -pdrapeaux.

@F=$^I=~/./g;s/1/$F[$i++%@F]/g;y;0; 

(notez l'espace final et le manque de nouvelle ligne finale).

Pour l'exécuter, écrivez la chaîne d'entrée après l' -iindicateur et fournissez la matrice dans l'entrée:

perl -iPPCGPPCG -pe '@F=$^I=~/./g;s/1/$F[$i++%@F]/g;y;0; ' <<< "00100
01010
10001
01010
00100"

Si votre Perl est un peu vieux, vous devrez peut-être ajouter un point-virgule final (après l'espace).

Python 2, 114 71 octets

Il s'avère que je réinventais la roue, un simple double remplacement sur une chaîne multiligne fonctionne assez bien. La chaîne a l'avantage supplémentaire de pouvoir compter les zéros directement plutôt que d'avoir à faire le très laid s*len(L)*len(L[0])pour une liste imbriquée

lambda S,s:S.replace("0"," ").replace("1","{}").format(*s*S.count('0'))

Ancienne solution:

lambda s,L:"\n".join(["".join(map(lambda n:chr(n+32),l)).replace("!","{}")for l in L]).format(*s*len(L)*len(L[0]))

D'abord, nous convertissons tout + 32 avec chr(tous les zéros deviennent des espaces), puis nous remplaçons tous les !avec {}pour permettre d'utiliser leformat fonction.

Si NULLpeut être compté comme un espace Si je décide de tricher et d'utiliser à la NULLplace de l'espace, je peux ignorer l'ajout de 32 pour économiser 12 octets. ( prints'affiche '\x00'comme un espace)

lambda s,L:"\n".join(["".join(map(chr,l)).replace('\x01','{}')for l in L]).format(*s*len(L)*len(L[0]))

APL, 18 octets

{(⍴⍺)⍴X\⍵⍴⍨+/X←,⍺}

Il s'agit d'une fonction qui prend une matrice booléenne comme argument de gauche et une chaîne comme argument de droite.

      (↑(1 0 0)(0 1 0)(1 0 1)) {(⍴⍺)⍴X\⍵⍴⍨+/X←,⍺}'lambda'
l  
 a 
m b

Explication:

APL a un intégré qui fait quelque chose comme ça, \ (développer). Cependant, il ne fonctionne que sur les vecteurs et nécessite que chaque caractère soit réellement utilisé.

• X←,⍺: aplatissez la matrice et stockez le résultat dans X.
• ⍵⍴⍨+/X: remodeler le vecteur de caractères pour qu'il ait la quantité d'éléments requise (cela prend également soin d'allonger la chaîne en répétant les caractères si nécessaire).
• X\: prendre un des personnages pour chacun 1et un espace pour chacun 0dansX .
• (⍴⍺)⍴: remodeler le résultat pour lui donner la forme de la matrice d'origine.

PHP, 110 91 97 88 82 81 80 75 octets

sauvé 6 octets grâce à @ user59178

while(""<$c=$argv[1][$i++])echo$c<1?$c?:" ":($s=$argv[2])[$k++%strlen($s)];

Courez avec -r. Attend la matrice comme chaîne multiligne dans le premier argument, chaîne dans le deuxième argument.

PowerShell v2 +, 70 octets

param($a,$b)$b|%{-join($_|%{if($_){$a[$n++];$n%=$a.length}else{' '}})}

Prend le mot d'entrée as $aet la matrice comme un tableau de tableaux as $b(voir les exemples ci-dessous). Boucle à travers $b, puis boucle à travers les éléments de chaque ligne $_|%{...}. La boucle interne est une condition if/ else, où nous émettons $a[$n++]et prenons mod-égal à la longueur de la chaîne, ou émettons un espace ' '. Ceux-ci sont -joinrassemblés dans une chaîne. Chacune des chaînes est laissée sur le pipeline, et la sortie implicite avec des sauts de ligne entre se produit viaWrite-Output à la fin du programme.

PS C:\Tools\Scripts\golfing> .\the-art-of-word-shaping.ps1 'PPCGPPCG' @(@(0,0,1,0,0),@(0,1,0,1,0),@(1,0,0,0,1),@(0,1,0,1,0),@(0,0,1,0,0))
  P  
 P C 
G   P
 P C 
  G  

PS C:\Tools\Scripts\golfing> .\the-art-of-word-shaping.ps1 'lambda' @(@(1,0,0),@(0,1,0),@(1,0,1))
l  
 a 
m b

PS C:\Tools\Scripts\golfing> .\the-art-of-word-shaping.ps1 'PPCG' @(@(1,1,1),@(1,0,1),@(1,1,1))
PPC
G P
PCG

Groovy, 63

{a,b->i=0;a.replaceAll("1",{b[i++%b.size()]}).replace("0"," ")}

Python 3, 104 (ou 83) octets

import itertools as i
def f(s,L):s=i.cycle(s);return'\n'.join(' '.join(next(s)*e for e in l)for l in L)

Il existe une option plus courte (83 octets), mais elle échouera si la chaîne est plus de 999 fois plus courte que nécessaire:

def f(s,L):s=list(s)*999;return'\n'.join(' '.join(s.pop(0)*e for e in l)for l in L)

Pyth, 12 octets

jms?R@z~hZ\ 

Essayez-le en ligne: Démonstration

Explication:

jms?R@z~hZ\ dQ   implicit d and Q at the end
                 I use the variable Z, which is initialized with 0 by default
 m           Q   map each line d of the Q (input matrix) to:
   ?R       d       map each number d of the line either to
     @z~hZ             input[Z++] (increase Z, but lookup in input string with old value)
          \            or space
  s                 join chars to a string
j                print each string on a separate line

ES6, 78 octets

  (a,b,x=0)=>(b.map(r=>r.map(i=>i?a[x++%a.length]:' ')+'\n')+'').replace(/,/g,'')

j'ai essayé

Lisp commun, 152 octets

(defun m(g w)(let((a 0))(loop for r in g do(loop for e in r do(format t"~[ ~;~c~]"e(char w a))(if(= e 1)(setf a(mod(1+ a)(length w)))))(format t"~%"))))

Usage:

* (m (list (list 1 0 1)
           (list 0 1 0)
           (list 1 0 1)) "ppcg")
p p
 c 
g p

Cette fonction parcourt chaque élément de chaque ligne de la grille. La formatchaîne de contrôle imprime un espace si l'élément est un 0 ou consomme l'argument caractère si l'élément est 1. Une nouvelle ligne est imprimée après chaque ligne de la grille. Si la chaîne est trop courte, elle se répète depuis le début; s'il est trop long, seule la partie appropriée est sortie.

Pépin , 18 octets

17 octets de code, +1 pour l' -lindicateur.

Yb{a?y@++vs}MMa^s

Prend le tableau comme premier argument de ligne de commande comme ceci: 100 010 101(doit être cité entre des shells) et la chaîne comme deuxième argument de ligne de commande.Essayez-le en ligne!

Explication

                   a and b are cmdline args, s is space, v is -1
Yb                 Yank b into global variable y
              a^s  Split a on space into list of rows
  {        }MM     Map this function to the items of the items of a (i.e. each character):
   a               Function argument
    ?              Ternary operator (truthy if 1, falsey if 0)
       ++v         If truthy, increment v...
     y@            ... and use it to index into y (cyclically)
                   I.e.: each time we hit a 1, replace it with the next character of y
          s        If falsey, space
                   The result is a list of lists of characters; -l concats sublists and
                   newline-separates the main list

Java, 237 233 octets

Edit: économisé 4 octets grâce à Mukul Kumar

Golfé:

String T(int[][]m,String b){int l=m.length,a=0;String o="";for(int i=0;i<l;i++){for(int j=0;j<l;j++){if(m[i][j]==1&&a<b.length()){o+=Character.toString(b.toCharArray()[a]);a++;if(a== b.length()-1)a=0;}else o+=" ";}o+="\n";}return o;}

Non golfé:

public String T(int[][] m, String b) {
    int l = m.length,a=0;
    String o = "";
    for(int i = 0; i < l; i++)
    {
        for(int j = 0; j < l; j++)
        {
            if(m[i][j] == 1 && a < b.length())
            {
                o += Character.toString(b.toCharArray()[a]);
                a++;

                if(a == b.length() - 1)
                    a = 0;
            }
            else
             o += " ";
        }
        o += "\n";
    }
    return o;
}

Essai:

  int[][] matrix = new int[][]
  {{ 0, 0, 1, 0, 0 }, { 0, 1, 0, 1, 0 },
  { 1, 0, 0, 0, 1 },{ 0, 1, 0, 1, 0 },
  { 0, 0, 1, 0, 0 },};
  TheArtOfWordShaping taows = new TheArtOfWordShaping();
  System.out.println(taows.T(matrix, "PPCGPPCG"));

  matrix = new int[][] {{1,0,0}, {0,1,0}, {1,0, 1}};
  taows = new TheArtOfWordShaping();
  System.out.println(taows.T(matrix, "lamda"));

  matrix = new int[][] {{1,1,1},{1,0,1},{1,1, 1}};
  taows = new TheArtOfWordShaping();
  System.out.println(taows.T(matrix, "PPCG"));

  P  
 P C 
G   P
 P C 
  P  

l  
 a 
m d

PPC
P P
CPP

Pyke, 12 octets

.FdRIKQoQl%@

Essayez-le ici!

Produit une matrice de caractères

Ou 9 octets, non compétitifs.

.FdRIKQo@

Essayez-le ici!

• Ajoutez un habillage sur les indexables où l'index demandé est plus grand que la longueur de l'indexable. .F - deep_for (entrée) I - si ^: Qo @ - Q [o ++] dR - sinon ""

Encore plus non compétitif, 8 octets

.FIQo@(P

Essayez-le ici!

• print_grid aligne désormais correctement les chaînes vides
• deep_for fait maintenant des devinettes sur des faux d'un type différent des vérités

La

.F    (  -  deep_for(input)
 I       -   if ^:
  Qo@    -    input[o++]
       P - pretty_print(^)

Java, 122 octets

String g(int[][]a,char[]b){String r="";int e=0;for(int[]c:a){for(int d:c){r+=d==0?' ':b[e++%b.length];}r+='\n';}return r;}

Mathematica, 76 octets

""<>(s=#2;f:=(s=RotateLeft[s];Last[s]);Map[If[#1,f," "]&,#,{2}]~Riffle~"\n")&

Fonction sans nom de deux arguments, dont le premier ( #) est un tableau de Trues et Falses, et le second ( s) est une liste de caractères. La fonction d'assistance

f:=(s=RotateLeft[s];Last[s])

est défini, ce qui place les mouvements du premier caractère de sà la fin, puis renvoie ce caractère qui vient d'être déplacé. Appeler fplusieurs fois renverra cycliquement les caractères de sdans l'ordre.

La fonction principale est

Map[If[#1,f," "]&,#,{2}]

qui appelle fchaque Truevaleur du tableau d'entrée et renvoie un espace sur chaque fausse entrée. (Le{2} raconteMap de travailler sur les éléments des listes de composants du tableau, plutôt que sur ces listes elles-mêmes.)

Ces 60 octets renvoient un tableau de caractères set d'espaces. L'emballage

    ""<>(...~Riffle~"\n")&

met des nouvelles lignes entre chacune des listes de ce tableau, puis concatène tout.

C ++, 61 octets

for(auto&i:m){for(int&j:i)cout<<(j?s[k++%l]:' ');cout<<'\n';}