A arte de moldar palavras

Dada uma matriz binária e uma sequência de letras, substitua todos os 1s da matriz da esquerda para a direita pelas letras da sequência. Depois que as letras forem formadas na forma da matriz, imprima a matriz, substituindo os zeros por espaços. Provavelmente é mais fácil apenas dar um exemplo ou dois.

Caso: Caso base ...

Entrada Um:

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

Saída um:

  P    
 P C  
G   P
 P C 
  G  

Caso: Se a sequência de entrada for maior que o número de unidades ...

Entrada dois:

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

lambda

Saída dois:

l  
 a 
m b

Caso: Se a sequência de entrada for menor que o número de unidades ...

Entrada três:

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

PPCG

Saída três:

PPC
G P
PCG

Premissas Disponíveis

• Você pode assumir que a sequência de entrada nunca está vazia.
• Você pode assumir que a matriz nunca estará vazia.
• Você não pode assumir que a matriz binária nunca será todos os zeros.

Regras

• Se a sequência for menor que o número de unidades, repita a sequência; todos devem ser substituídos.
• Se a sequência for maior que o número de unidades, use apenas o necessário.
• Você pode usar Verdadeiro / Falso no lugar de números inteiros / bits para a entrada.
• Os espaços à direita SÃO NECESSÁRIOS, todos os zeros devem ser substituídos por espaços.
• Uma única nova linha à direita é aceitável.
• Isso é código-golfe, menor número de bytes ganhos.

MATL , 11 bytes

yz:)1Gg!(c!

As entradas são uma matriz numérica (com o ;separador de linhas) e uma sequência.

Experimente online! Ou verifique os casos de teste: 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

Guardado 2 bytes graças a @DjMcMoylex !

Aqui, o ^Mé uma nova linha literal e o^V éCTRL-V

Aceita a entrada neste formato:

PPCG
00100,01010,10001,01010,00100

Aviso Legal: Se a string tiver mais de ~ 40 caracteres, o computador poderá ficar sem memória RAM.

Explicação:

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

Aqui está um gif meu "executando" o "programa":

Retina , 41 33 bytes

0

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

Experimente online!

A string de entrada é fornecida na primeira linha da entrada, seguida pela matriz. Como o Retina não tem conceito de listas (ou realmente qualquer coisa, exceto cadeias), não há separadores na matriz binária, exceto os feeds de linha para separar as linhas.

Explicação

0

Transforma zeros em espaços.

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

Substitua repetidamente o primeiro 1pelo primeiro caractere da sequência de entrada enquanto gira esse caractere até o final da sequência de entrada. Isso cuida dos casos em que há mais 1s do que caracteres na sequência de entrada.

A1`

Descarte a primeira linha, ou seja, a sequência de entrada.

JavaScript ES6, 67 53 50 49 bytes

Guardado 3 bytes graças a @ETHproductions Guardado mais 1 graças 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 antigo antes que eu soubesse que as matrizes de string são um 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 -psinalizadores.

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

(observe o espaço final e a falta de nova linha final).

Para executá-lo, escreva a sequência de entrada após o -isinalizador e forneça a matriz na entrada:

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

Se o seu Perl for um pouco antigo, talvez seja necessário adicionar um ponto e vírgula final (após o espaço).

Python 2, 114 71 bytes

Acontece que eu estava reinventando a roda, uma simples substituição dupla em uma corda de várias linhas funciona muito bem. A string tem o benefício adicional de poder contar zeros diretamente, em vez de precisar fazer o realmente feio s*len(L)*len(L[0])para uma lista aninhada

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

Solução antiga:

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

Primeiro convertemos tudo + 32 com chr(todos os zeros se tornam espaços), depois substituímos todos !por {}para permitir o uso deformat função.

Se NULLpuder ser contado como um espaço Se eu decidir trapacear e usar em NULLvez do espaço, posso pular a adição de 32 para salvar 12 bytes. ( printexibido '\x00'como um espaço)

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←,⍺}

Essa é uma função que usa uma matriz booleana como argumento à esquerda e uma string como argumento à direita.

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

Explicação:

O APL possui um built-in que faz algo assim, \(expanda). No entanto, ele funciona apenas em vetores e exige que cada caractere seja realmente usado.

• X←,⍺: achatar a matriz e armazenar o resultado em X.
• ⍵⍴⍨+/X: reformule o vetor de caracteres para que ele tenha a quantidade necessária de elementos (isso também ajuda a prolongar a sequência repetindo caracteres, se necessário).
• X\: Tomar um dos caracteres para cada 1e um espaço para cada 0no X.
• (⍴⍺)⍴: reformule o resultado para que ele tenha o formato da matriz original.

PHP, 110 91 97 88 82 81 80 75 bytes

economizou 6 bytes graças a @ user59178

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

Corra com -r. Espera matriz como sequência multilinha no primeiro argumento, sequência no segundo argumento.

PowerShell v2 +, 70 bytes

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

Leva a palavra de entrada como $ae a matriz como uma matriz de matrizes como $b(veja exemplos abaixo). Faz um $bloop através dos elementos de cada linha $_|%{...}. O loop interno é uma condição if/ else, onde produzimos $a[$n++]e modificamos igual ao comprimento da string ou produzimos um espaço ' '. Esses são -joinreunidos novamente em uma sequência. Cada uma das seqüências é deixada no pipeline e a saída implícita com novas linhas entre acontece através Write-Outputda conclusão do 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 (ou 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)

Há uma opção mais curta (83 bytes), mas falhará se a sequência for mais de 999 vezes menor que o necessário:

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

Pitão, 12 bytes

jms?R@z~hZ\ 

Experimente online: Demonstração

Explicação:

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

eu tentei

Lisp comum, 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

Essa função percorre cada elemento de cada linha da grade. A formatcadeia de controle imprime um espaço se o elemento for 0 ou consome o argumento de caractere se o elemento for 1. Uma nova linha é impressa após cada linha da grade. Se a string for muito curta, ela se repete desde o início; se for muito longo, apenas a parte apropriada será exibida.

Pip , 18 bytes

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

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

Aceita a matriz como o primeiro argumento da linha de comando, assim: 100 010 101 (precisa ser citado em shells) e a string como o segundo argumento da linha de comando.Experimente online!

Explicação

                   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: salvou 4 bytes graças a Mukul Kumar

Golfe:

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

Ungolfed:

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

Teste:

  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%@

Experimente aqui!

Produz uma matriz de caracteres

Ou 9 bytes, não competitivo.

.FdRIKQo@

Experimente aqui!

• Adicione disposição em indexáveis ​​onde o índice solicitado é maior que o comprimento do indexável. .F - deep_for (input) I - se ^: Qo @ - Q [o ++] dR - else ""

Ainda mais não competitivo, 8 bytes

.FIQo@(P

Experimente aqui!

• print_grid agora alinha cordas vazias corretamente
• deep_for agora adivinhar tipos de falsidades de um tipo diferente das verdades

O que outras pessoas estão dizendo

.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")&

Sem nome função de dois argumentos, a primeira das quais ( #) é uma matriz de Trues e Falses, e o segundo dos quais ( s) é uma lista de caracteres. A função auxiliar

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

é definido, o que coloca os movimentos do primeiro caractere sno final e, em seguida, retorna esse caractere recém-movido. Ligar fvárias vezes retornará ciclicamente os caracteres des em ordem.

A função principal é

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

que chama fcada Truevalor na matriz de entrada e retorna um espaço em cada entrada falsa. (O {2}dizMap para trabalhar em elementos das listas de componentes da matriz, em vez das próprias listas.)

Esses 60 bytes retornam uma matriz de caracteres de se espaços. O invólucro

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

coloca novas linhas entre as listas dessa matriz e concatena tudo.

C ++, 61 bytes

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