Die Kunst der Wortgestaltung

Ersetzen Sie bei einer gegebenen binären Matrix und einer Folge von Buchstaben alle Einsen in der Matrix von links nach rechts durch die Buchstaben der Folge. Sobald die Buchstaben in die Form der Matrix gebracht wurden, drucken Sie die Matrix aus und ersetzen Sie die Nullen durch Leerzeichen. Es ist wahrscheinlich einfacher, nur ein oder zwei Beispiele zu nennen.

Fall: Basisfall ...

Eingang Eins:

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

Ausgang Eins:

  P    
 P C  
G   P
 P C 
  G  

Fall: Wenn die Eingabezeichenfolge länger als die Anzahl der Einsen ist ...

Eingang zwei:

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

lambda

Ausgang zwei:

l  
 a 
m b

Fall: Wenn die Eingabezeichenfolge kürzer als die Anzahl der Einsen ist ...

Eingang drei:

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

PPCG

Ausgang drei:

PPC
G P
PCG

Verfügbare Annahmen

• Sie können davon ausgehen, dass die Eingabezeichenfolge niemals leer ist.
• Sie können davon ausgehen, dass die Matrix niemals leer sein wird.
• Sie dürfen nicht davon ausgehen, dass die binäre Matrix niemals ausschließlich aus Nullen besteht.

Regeln

• Wenn die Zeichenfolge kürzer als die Anzahl der Einsen ist, wiederholen Sie die Zeichenfolge. Alle müssen ersetzt werden.
• Wenn die Zeichenfolge länger als die Anzahl der Zeichenfolgen ist, verwenden Sie nur das, was benötigt wird.
• Sie können True / False anstelle von Ganzzahlen / Bits für die Eingabe verwenden.
• Nachgestellte Leerzeichen SIND ERFORDERLICH, alle Nullen müssen durch Leerzeichen ersetzt werden.
• Eine einzelne nachgestellte Zeile ist zulässig.
• Dies ist Code-Golf, die niedrigste Byte-Anzahl gewinnt.

MATL , 11 Bytes

yz:)1Gg!(c!

Eingaben sind eine numerische Matrix (mit ;als Zeilentrennzeichen) und eine Zeichenkette.

Probieren Sie es online! Oder überprüfen Sie die Testfälle: 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

2 Bytes gespart dank @DjMcMoylex !

Hier ist das ^Mein wörtlicher Zeilenumbruch, und das ^VistCTRL-V

Übernimmt die Eingabe in diesem Format:

PPCG
00100,01010,10001,01010,00100

Haftungsausschluss: Wenn die Zeichenfolge länger als ~ 40 Zeichen ist, hat Ihr Computer möglicherweise keinen RAM mehr.

Erläuterung:

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

Hier ist ein GIF von mir, wie ich das "Programm" "laufe":

Retina , 41 33 Bytes

0

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

Probieren Sie es online!

Die Eingabezeichenfolge wird in der ersten Zeile der Eingabe angegeben, gefolgt von der Matrix. Da Retina kein Konzept für Listen (oder wirklich alles außer Zeichenfolgen) hat, gibt es in der Binärmatrix keine Trennzeichen, außer für Zeilenvorschübe zum Trennen von Zeilen.

Erläuterung

0

Wandelt Nullen in Leerzeichen um.

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

Ersetzen Sie das erste 1Zeichen wiederholt durch das erste Zeichen der Eingabezeichenfolge, während Sie dieses Zeichen gleichzeitig bis zum Ende der Eingabezeichenfolge drehen. Dies ist in Fällen 1hilfreich, in denen die Eingabezeichenfolge mehr als s Zeichen enthält.

A1`

Verwerfen Sie die erste Zeile, dh die Eingabezeichenfolge.

JavaScript ES6, 67 53 50 49 Bytes

3 Bytes dank @ETHproductions gespart 1 weitere dank @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>

Alter Code, bevor ich wusste, dass String-Matrizen ein gültiges Eingabeformat sind:

(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 Byte Code + -i -pFlags.

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

(Beachten Sie das letzte Leerzeichen und das Fehlen des letzten Zeilenumbruchs).

Um es auszuführen, schreiben Sie die Eingabezeichenfolge nach dem -iFlag und geben Sie die Matrix in die Eingabe ein:

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

Wenn Ihr Perl ein bisschen alt ist, müssen Sie möglicherweise ein abschließendes Semikolon (nach dem Leerzeichen) hinzufügen.

Python 2, 114 71 Bytes

Es stellte sich heraus, dass ich das Rad neu erfunden habe. Ein einfacher doppelter Ersatz für eine mehrzeilige Saite funktioniert ganz gut. Die Zeichenfolge hat den zusätzlichen Vorteil, dass sie Nullen direkt zählen kann, anstatt das wirklich Hässliche s*len(L)*len(L[0])für eine verschachtelte Liste tun zu müssen

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

Alte Lösung:

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

Zuerst konvertieren wir alles + 32 mit chr(alle Nullen werden zu Leerzeichen), dann ersetzen wir alles !mit {}, um die Verwendung der formatFunktion zu ermöglichen .

Wenn NULLals Leerzeichen gezählt werden kann Wenn ich beschließe, zu betrügen und NULLanstelle von Leerzeichen zu verwenden, kann ich die Addition von 32 überspringen, um 12 Bytes zu sparen. ( printwird '\x00'als Leerzeichen angezeigt )

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

Dies ist eine Funktion, die eine boolesche Matrix als linkes Argument und eine Zeichenfolge als rechtes Argument verwendet.

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

Erläuterung:

APL hat ein eingebautes Programm, das so etwas macht \(expand). Es funktioniert jedoch nur mit Vektoren und erfordert, dass jedes Zeichen tatsächlich verwendet wird.

• X←,⍺: Reduziere die Matrix und speichere das Ergebnis in X.
• ⍵⍴⍨+/X: Verändern Sie die Form des Zeichenvektors so, dass er die erforderliche Anzahl von Elementen enthält (dies sorgt auch dafür, dass die Zeichenfolge verlängert wird, indem Zeichen bei Bedarf wiederholt werden).
• X\: Nimm eines der Zeichen für jedes 1und ein Leerzeichen für jedes 0in X.
• (⍴⍺)⍴: Das Ergebnis so umformen, dass es die Form der ursprünglichen Matrix hat.

PHP, 110 91 97 88 82 81 80 75 Bytes

6 Bytes gespart dank @ user59178

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

Laufen Sie mit -r. Erwartet Matrix als mehrzeilige Zeichenfolge im ersten Argument, Zeichenfolge im zweiten Argument.

PowerShell v2 +, 70 Byte

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

Nimmt das Eingabewort als $aund die Matrix als Array von Arrays als $b(siehe Beispiele unten). Durchläuft $bdie Elemente jeder Zeile und durchläuft sie dann $_|%{...}. Die innere Schleife ist eine if/ else-Bedingung, bei der wir entweder $a[$n++]mod ausgeben und gleich der Länge des Strings nehmen oder ein Leerzeichen ausgeben ' '. Diese werden -joinwieder zu einer Schnur zusammengefügt. Jede der Zeichenfolgen verbleibt in der Pipeline, und die implizite Ausgabe mit Zeilenumbrüchen zwischen erfolgt über Write-Outputbei Programmabschluss.

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 Jahre alt

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

Python 3, 104 (oder 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)

Es gibt eine kürzere Option (83 Bytes), die jedoch fehlschlägt, wenn die Zeichenfolge mehr als 999-mal kürzer als erforderlich ist:

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\ 

Probieren Sie es online aus: Demonstration

Erläuterung:

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

Ich habe es versucht

Common Lisp, 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"~%"))))

Verwendung:

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

Diese Funktion durchläuft jedes Element jeder Zeile des Rasters. Die formatSteuerzeichenfolge gibt entweder ein Leerzeichen aus, wenn das Element eine 0 ist, oder verbraucht das Zeichenargument, wenn das Element 1 ist. Nach jeder Zeile des Rasters wird eine neue Zeile gedruckt. Wenn die Zeichenfolge zu kurz ist, wird sie von Anfang an wiederholt. Wenn es zu lang ist, wird nur der entsprechende Teil ausgegeben.

Pip , 18 Bytes

17 Byte Code, +1 für -lFlag.

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

Nimmt das Array als erstes Befehlszeilenargument 100 010 101(muss in Anführungszeichen gesetzt werden) und die Zeichenfolge als zweites Befehlszeilenargument. Probieren Sie es online!

Erläuterung

                   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

Edit: 4 Bytes dank Mukul Kumar gespeichert

Golf gespielt:

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

Testen:

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

Probieren Sie es hier aus!

Gibt eine Zeichenmatrix aus

Oder 9 Bytes, nicht konkurrenzfähig.

.FdRIKQo@

Probieren Sie es hier aus!

• Fügen Sie Zeilenumbrüche für Indexables hinzu, bei denen der angeforderte Index größer als die Länge des Indexables ist. .F - deep_for (Eingabe) I - if ^: Qo @ - Q [o ++] dR - else ""

Noch nicht konkurrenzfähiger, 8 Bytes

.FIQo@(P

Probieren Sie es hier aus!

• print_grid Richtet jetzt leere Zeichenfolgen richtig aus
• deep_for Jetzt wird über Fälschungen anderer Art als die Wahrheiten getippt

Für den Fall, dass Sie nicht mehr weiterkommen möchten

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

Unbenannte Funktion von zwei Argumenten, von denen das erste ( #) ein Array von Trues und Falses ist und das zweite ( s) eine Liste von Zeichen ist. Die Helferfunktion

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

wird definiert, wodurch die Züge das erste Zeichen von san das Ende setzen und dann das gerade verschobene Zeichen zurückgeben. Durch fmehrmaliges Aufrufen werden die Zeichen der sReihe nach zyklisch zurückgegeben .

Die Kernfunktion ist

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

Das ruft fjeden TrueWert im Eingabearray auf und gibt bei jeder falschen Eingabe ein Leerzeichen zurück. (Der {2}Befehl weist Sie Mapan, Elemente der Komponentenlisten des Arrays zu bearbeiten, anstatt diese Listen selbst.)

Diese 60 Bytes geben ein Array von Zeichen sund Leerzeichen zurück. Der Wrapper

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

Fügt Zeilenumbrüche zwischen die Listen des jeweiligen Arrays ein und verkettet dann alles.

C ++, 61 Bytes

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