El arte de formar palabras

Dada una matriz binaria y una cadena de letras, reemplace todos los 1 en la matriz de izquierda a derecha con las letras de la cadena. Una vez que las letras se han formado en la forma de la matriz, imprima la matriz, reemplazando los 0 con espacios. Probablemente sea más fácil solo dar un ejemplo o dos.

Caso: Caso base ...

Entrada uno:

[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"

Salida uno:

  P    
 P C  
G   P
 P C 
  G  

Caso: si la cadena de entrada es más larga que la cantidad de unidades ...

Entrada dos:

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

lambda

Salida dos:

l  
 a 
m b

Caso: si la cadena de entrada es más corta que la cantidad de unidades ...

Entrada tres:

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

PPCG

Salida tres:

PPC
G P
PCG

Suposiciones disponibles

• Puede suponer que la cadena de entrada nunca está vacía.
• Puede suponer que la matriz nunca estará vacía.
• No puede suponer que la matriz binaria nunca será todos ceros.

Reglas

• Si la cadena es más corta que la cantidad de unidades, repita la cadena; Todos deben ser reemplazados.
• Si la cadena es más larga que la cantidad de unidades, solo use lo que se necesita.
• Puede usar Verdadero / Falso en lugar de enteros / bits para la entrada.
• SE REQUIEREN espacios finales, todos los ceros deben ser reemplazados por espacios.
• Una nueva línea final es aceptable.
• Este es el código de golf, gana el conteo de bytes más bajo.

MATL , 11 bytes

yz:)1Gg!(c!

Las entradas son una matriz numérica (con un ;separador de filas) y una cadena.

Pruébalo en línea! O verificar los casos de prueba: 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 bytes

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

¡ Ahorré 2 bytes gracias a @DjMcMoylex !

Aquí, el ^Mes una nueva línea literal, y el ^VesCTRL-V

Toma la entrada en este formato:

PPCG
00100,01010,10001,01010,00100

Descargo de responsabilidad: si la cadena es más larga que ~ 40 caracteres, su computadora podría quedarse sin RAM.

Explicación:

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

Aquí hay un gif de mí "ejecutando" el "programa":

Retina , 41 33 bytes

0

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

Pruébalo en línea!

La cadena de entrada se da en la primera fila de la entrada, seguida de la matriz. Dado que Retina no tiene el concepto de listas (o realmente cualquier cosa excepto cadenas), no hay separadores en la matriz binaria, excepto los avances de línea para separar las filas.

Explicación

0

Convierte ceros en espacios.

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

Reemplace repetidamente el primero 1con el primer carácter de la cadena de entrada mientras gira ese carácter al final de la cadena de entrada. Esto se encarga de casos en los que hay más 1s que caracteres en la cadena de entrada.

A1`

Deseche la primera línea, es decir, la cadena de entrada.

JavaScript ES6, 67 53 50 49 bytes

Guardado 3 bytes gracias a @ETHproductions Guardado 1 más gracias a @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>

Código anterior antes de saber que las matrices de cadenas son un formato de entrada válido:

(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 bytes

36 bytes de código + -i -pbanderas.

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

(tenga en cuenta el espacio final y la falta de nueva línea final).

Para ejecutarlo, escriba la cadena de entrada después del -iindicador y proporcione la matriz en la entrada:

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

Si su Perl es un poco viejo, es posible que deba agregar un punto y coma final (después del espacio).

Python 2, 114 71 bytes

Resulta que estaba reinventando la rueda, un simple reemplazo doble en una cadena multilínea funciona bastante bien. La cadena tiene el beneficio adicional de poder contar ceros directamente en lugar de tener que hacer lo realmente feo s*len(L)*len(L[0])para una lista anidada

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

Vieja solución:

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

Primero convertimos todo + 32 con chr(todos los ceros se convierten en espacios), luego reemplazamos todo !con {}para permitir el uso de la formatfunción.

Si NULLse puede contar como un espacio Si decido hacer trampa y usar en NULLlugar de espacio, puedo omitir la adición de 32 para ahorrar 12 bytes. (se printmuestra '\x00'como un espacio)

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

APL, 18 bytes

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

Esta es una función que toma una matriz booleana como argumento izquierdo y una cadena como argumento derecho.

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

Explicación:

APL tiene una función integrada que hace algo como esto \(expandir). Sin embargo, solo funciona en vectores, y requiere que cada carácter se use realmente.

• X←,⍺: aplana la matriz y almacena el resultado en X.
• ⍵⍴⍨+/X: cambia la forma del vector de caracteres para que tenga la cantidad requerida de elementos (esto también se encarga de alargar la cadena repitiendo caracteres si es necesario).
• X\: Tomar uno de los caracteres para cada uno 1y un espacio para cada uno 0de X.
• (⍴⍺)⍴: da nueva forma al resultado para que tenga la forma de la matriz original.

PHP, 110 91 97 88 82 81 80 75 bytes

guardado 6 bytes gracias a @ user59178

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

Corre con -r. Espera matriz como cadena multilínea en primer argumento, cadena en segundo argumento.

PowerShell v2 +, 70 bytes

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

Toma la palabra de entrada como $ay la matriz como una matriz de matrices como $b(ver ejemplos a continuación). Recorre $b, luego recorre los elementos de cada fila $_|%{...}. El bucle interno es una condición if/ else, donde sacamos $a[$n++]y tomamos mod-igual a la longitud de la cadena, o sacamos un espacio ' '. Esos se -joinvuelven a juntar en una cadena. Cada una de las cadenas se deja en la tubería, y la salida implícita con nuevas líneas entre ocurre Write-Outputal finalizar el programa.

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 (u 83) bytes

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)

Hay una opción más corta (83 Bytes), pero fallará si la cadena es más de 999 veces más corta de lo necesario:

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 bytes

jms?R@z~hZ\ 

Pruébelo en línea: demostración

Explicación:

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 bytes

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

Lo intenté

Lisp común, 152 bytes

(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"~%"))))

Uso:

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

Esta función recorre cada elemento de cada fila de la cuadrícula. La formatcadena de control imprime un espacio si el elemento es un 0 o consume el argumento del carácter si el elemento es 1. Se imprime una nueva línea después de cada fila de la cuadrícula. Si la cadena es demasiado corta, se repite desde el principio; si es demasiado largo, solo se genera la parte adecuada.

Pip , 18 bytes

17 bytes de código, +1 para -lbandera.

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

Toma la matriz como el primer argumento de la línea de comando como este: 100 010 101(necesita ser citado en shells) y la cadena como el segundo argumento de la línea de comando.Pruébalo en línea!

Explicación

                   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 bytes

Editar: guardado 4 Bytes gracias a Mukul Kumar

Golfizado:

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;}

Sin 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;
}

Pruebas:

  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 bytes

.FdRIKQoQl%@

Pruébalo aquí!

Emite una matriz de caracteres

O 9 bytes, no competitivos.

.FdRIKQo@

Pruébalo aquí!

• Agregue envoltura en indexables donde el índice solicitado es mayor que la longitud de la indexable. .F - deep_for (input) I - if ^: Qo @ - Q [o ++] dR - else ""

Aún más no competitivo, 8 bytes

.FIQo@(P

Pruébalo aquí!

• print_grid ahora alinea las cadenas vacías correctamente
• deep_for ahora adivina sobre falsas de un tipo diferente a las verdades

​

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

Java, 122 bytes

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 bytes

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

Función sin nombre de dos argumentos, el primero de los cuales ( #) es una matriz de Trues y Falses, y el segundo de los cuales ( s) es una lista de caracteres. La función auxiliar

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

está definido, lo que coloca los movimientos del primer personaje shasta el final y luego devuelve el personaje recién movido. Llamar fvarias veces devolverá cíclicamente los caracteres de sen orden.

La función central es

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

que invoca fcada Truevalor en la matriz de entrada y devuelve un espacio en cada entrada falsa. (El {2}le dice Mapque trabaje en elementos de las listas de componentes de la matriz, en lugar de esas listas mismas).

Esos 60 bytes devuelven una matriz de caracteres de sy espacios. La envoltura

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

coloca nuevas líneas entre cada una de las listas de esa matriz y luego concatena todo.

C ++, 61 bytes

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