L'arte di modellare le parole

Data una matrice binaria e una stringa di lettere, sostituisci tutti gli 1 nella matrice da sinistra, a destra con le lettere della stringa. Una volta che le lettere sono state formate nella forma della matrice, stampare la matrice, sostituendo gli 0 con spazi. Probabilmente è più semplice fare solo un esempio o due.

Custodia: custodia base ...

Input One:

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

Uscita uno:

  P    
 P C  
G   P
 P C 
  G  

Caso: se la stringa di input è più lunga del numero di quelli ...

Ingresso due:

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

lambda

Uscita due:

l  
 a 
m b

Caso: se la stringa di input è più corta del numero di quelli ...

Ingresso tre:

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

PPCG

Uscita tre:

PPC
G P
PCG

Presupposti disponibili

• Si può presumere che la stringa di input non sia mai vuota.
• Puoi presumere che la matrice non sarà mai vuota.
• Non puoi presumere che la matrice binaria non sarà mai tutti zeri.

Regole

• Se la stringa è più corta del numero di una, ripeti la stringa; tutti devono essere sostituiti.
• Se la stringa è più lunga del numero di una, usa solo ciò che è necessario.
• È possibile utilizzare True / False al posto di numeri interi / bit per l'input.
• Gli spazi finali sono obbligatori, tutti gli zeri devono essere sostituiti con spazi.
• È accettabile una singola riga finale finale.
• Questo è code-golf, vince il conteggio di byte più basso.

MATL , 11 byte

yz:)1Gg!(c!

Gli input sono una matrice numerica (con ;come separatore di riga) e una stringa.

Provalo online! Oppure verifica i casi di 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 byte

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

Salvato 2 byte grazie a @DjMcMoylex !

Qui, ^Mè una newline letterale e ^VèCTRL-V

Accetta l'input in questo formato:

PPCG
00100,01010,10001,01010,00100

Dichiarazione di non responsabilità: se la stringa è più lunga di ~ 40 caratteri, il computer potrebbe esaurire la RAM.

Spiegazione:

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

Ecco una mia gif "eseguendo" il "programma":

Retina , 41 33 byte

0

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

Provalo online!

La stringa di input viene fornita sulla prima riga dell'input, seguita dalla matrice. Poiché Retina non ha il concetto di elenchi (o in realtà qualsiasi cosa tranne le stringhe), non ci sono separatori nella matrice binaria ad eccezione degli avanzamenti di riga in righe separate.

Spiegazione

0

Trasforma gli zeri in spazi.

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

Sostituisci ripetutamente il primo 1con il primo carattere della stringa di input e allo stesso tempo ruota quel carattere alla fine della stringa di input. Questo si occupa dei casi in cui ci sono più 1s che caratteri nella stringa di input.

A1`

Elimina la prima riga, ovvero la stringa di input.

JavaScript ES6, 67 53 50 49 byte

Salvato 3 byte grazie a @ETHproductions Risparmiato ancora 1 byte grazie 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>

Il vecchio codice prima di sapere che le matrici di stringhe sono un formato di input valido:

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

36 byte di codice + -i -pflag.

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

(notare lo spazio finale e la mancanza di newline finale).

Per eseguirlo, scrivi la stringa di input dopo il -iflag e inserisci la matrice nell'input:

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

Se il tuo Perl è un po 'vecchio, potresti dover aggiungere un punto e virgola finale (dopo lo spazio).

Python 2, 114 71 byte

Ho scoperto che stavo reinventando la ruota, un semplice doppio sostituto su una corda multilinea funziona abbastanza bene. La stringa ha l'ulteriore vantaggio di poter contare gli zeri direttamente piuttosto che dover fare davvero il brutto s*len(L)*len(L[0])per un elenco nidificato

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

Vecchia soluzione:

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

Prima convertiamo tutto + 32 con chr(tutti gli zeri diventano spazi), quindi sostituiamo tutto !con {}per consentire l'uso della formatfunzione.

Se NULLposso essere contato come spazio Se decido di imbrogliare e usare al NULLposto dello spazio, posso saltare l'aggiunta di 32 per salvare 12 byte. ( printviene visualizzato '\x00'come spazio)

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

APL, 18 byte

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

Questa è una funzione che accetta una matrice booleana come argomento sinistro e una stringa come argomento destro.

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

Spiegazione:

APL ha un built-in che fa qualcosa del genere, \(espandi). Tuttavia, funziona solo su vettori e richiede che ogni personaggio sia effettivamente utilizzato.

• X←,⍺: appiattire la matrice e memorizzare il risultato in X.
• ⍵⍴⍨+/X: rimodella il vettore di caratteri in modo che abbia la quantità richiesta di elementi (ciò si occupa anche di allungare la stringa ripetendo i caratteri se necessario).
• X\: prendi uno dei personaggi per ciascuno 1e uno spazio per ciascuno 0in X.
• (⍴⍺)⍴: rimodella il risultato in modo che abbia la forma della matrice originale.

PHP, 110 91 97 88 82 81 80 75 byte

salvato 6 byte grazie a @ user59178

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

Corri con -r. Si aspetta una matrice come stringa multilinea nel primo argomento, stringa nel secondo argomento.

PowerShell v2 +, 70 byte

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

Prende la parola di input come $ae la matrice come una matrice di array come $b(vedere gli esempi di seguito). Passa attraverso $b, quindi passa attraverso gli elementi di ogni riga $_|%{...}. Il ciclo interno è una condizione if/ else, in cui output $a[$n++]o prendiamo mod uguale alla lunghezza della stringa o output di uno spazio ' '. Quelli sono -joinriportati insieme in una stringa. Ognuna delle stringhe viene lasciata sulla pipeline e l'output implicito con le nuove righe avviene tramite Write-Outputal completamento del programma.

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 (o 83) byte

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)

Esiste un'opzione più breve (83 byte), ma non riuscirà se la stringa è più di 999 volte più corta del necessario:

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 byte

jms?R@z~hZ\ 

Provalo online: dimostrazione

Spiegazione:

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 byte

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

Provai

Lisp comune, 152 byte

(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

Questa funzione scorre attraverso ogni elemento di ogni riga della griglia. La formatstringa di controllo stampa uno spazio se l'elemento è 0 o consuma l'argomento carattere se l'elemento è 1. Viene stampata una nuova riga dopo ogni riga della griglia. Se la stringa è troppo corta, si ripete dall'inizio; se è troppo lungo, viene emessa solo la parte appropriata.

Pip , 18 byte

17 byte di codice, +1 per la -lbandiera.

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

Prende l'array come primo argomento della riga di comando in questo modo: 100 010 101(deve essere citato in shell) e la stringa come secondo argomento della riga di comando. Provalo online!

Spiegazione

                   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 byte

Modifica: salvato 4 byte grazie a Mukul Kumar

golfed:

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

test:

  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 byte

.FdRIKQoQl%@

Provalo qui!

Emette una matrice di caratteri

O 9 byte, non competitivo.

.FdRIKQo@

Provalo qui!

• Aggiungi il wrapping sugli indicizzabili in cui l'indice richiesto è maggiore della lunghezza dell'indicizzabile. .F - deep_for (input) I - if ^: Qo @ - Q [o ++] dR - else ""

Ancora più non competitivo, 8 byte

.FIQo@(P

Provalo qui!

• print_grid ora allinea correttamente le stringhe vuote
• deep_for ora indovina il tipo su falsità di tipo diverso rispetto alle verità

​

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

Java, 122 byte

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 byte

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

Funzione senza nome di due argomenti, il primo dei quali ( #) è un array di Trues Falsee il secondo, ( s) è un elenco di caratteri. La funzione di aiuto

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

è definito, che mette le mosse alla fine del primo carattere se quindi restituisce quel personaggio appena mosso. Chiamare fpiù volte restituirà ciclicamente i caratteri di sin ordine.

La funzione principale è

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

che chiama ftutti i Truevalori nell'array di input e restituisce uno spazio su ogni input falso. (Il {2}dice Mapdi lavorare su elementi delle liste dei componenti dell'array, piuttosto che su quelle stesse liste.)

Quei 60 byte restituiscono una matrice di caratteri di se spazi. Il wrapper

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

inserisce nuove righe tra ciascuna delle liste di quell'array e quindi concatena tutto.

C ++, 61 byte

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