Sztuka kształtowania słowa

Biorąc pod uwagę macierz binarną i ciąg liter, zamień wszystkie 1 w macierzy od lewej do prawej na litery tego ciągu. Po uformowaniu liter w kształt matrycy wydrukuj matrycę, zastępując zerami spacje. Prawdopodobnie łatwiej jest podać przykład lub dwa.

Case: Case base ...

Wejście pierwsze:

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

Wyjście pierwsze:

  P    
 P C  
G   P
 P C 
  G  

Przypadek: jeśli ciąg wejściowy jest dłuższy niż liczba jedynek ...

Wejście drugie:

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

lambda

Wyjście drugie:

l  
 a 
m b

Przypadek: jeśli ciąg wejściowy jest krótszy niż liczba jedynek ...

Wejście trzecie:

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

PPCG

Wyjście trzecie:

PPC
G P
PCG

Dostępne założenia

• Możesz założyć, że ciąg wejściowy nigdy nie jest pusty.
• Możesz założyć, że matryca nigdy nie będzie pusta.
• Nie można zakładać, że macierz binarna nigdy nie będzie miała samych zer.

Zasady

• Jeśli ciąg znaków jest krótszy niż liczba jedynek, powtórz ciąg; wszystkie muszą zostać wymienione.
• Jeśli ciąg jest dłuższy niż liczba jedynek, użyj tylko tego, co jest potrzebne.
• Możesz użyć True / False zamiast liczb całkowitych / bitów dla danych wejściowych.
• Końcowe spacje SĄ WYMAGANE, wszystkie zera muszą być zastąpione spacjami.
• Pojedynczy znak nowej linii jest dopuszczalny.
• To jest golf golfowy, wygrywa najmniej bajtów.

MATL , 11 bajtów

yz:)1Gg!(c!

Dane wejściowe to macierz numeryczna (z ;separatorem wierszy) i ciąg znaków.

Wypróbuj online! Lub sprawdź przypadki testowe: 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 bajty

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

Zaoszczędź 2 bajty dzięki @DjMcMoylex !

Tutaj ^Mjest dosłownie nowa linia, i ^VjestCTRL-V

Pobiera dane wejściowe w tym formacie:

PPCG
00100,01010,10001,01010,00100

Oświadczenie: Jeśli ciąg znaków jest dłuższy niż ~ 40 znaków, na komputerze może zabraknąć pamięci RAM.

Wyjaśnienie:

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

Oto gif mojego „uruchamiania” „programu”:

Siatkówka , 41 33 bajtów

0

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

Wypróbuj online!

Łańcuch wejściowy jest podany w pierwszym rzędzie danych wejściowych, a następnie macierz. Ponieważ Retina nie ma pojęcia list (a tak naprawdę niczego poza ciągami znaków), w macierzy binarnej nie ma żadnych separatorów, z wyjątkiem kanałów do oddzielnych wierszy.

Wyjaśnienie

0

Zamienia zera w spacje.

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

Wielokrotnie zamień pierwszy 1na pierwszy znak ciągu wejściowego, jednocześnie obracając ten znak na koniec ciągu wejściowego. Dotyczy to przypadków, gdy 1w ciągu wejściowym znajduje się więcej s niż znaków.

A1`

Odrzuć pierwszy wiersz, tzn. Ciąg wejściowy.

JavaScript ES6, 67 53 50 49 bajtów

Zaoszczędź 3 bajty dzięki @ETHproductions Zaoszczędź jeszcze 1 dzięki @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>

Stary kod, zanim wiedziałem, że macierze łańcuchowe są poprawnym formatem wejściowym:

(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 bajtów

36 bajtów kodu + -i -pflagi.

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

(zwróć uwagę na ostatnią przestrzeń i brak końcowej nowej linii).

Aby go uruchomić, napisz ciąg wejściowy za -iflagą i podaj macierz na wejściu:

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

Jeśli twój Perl jest nieco stary, może być konieczne dodanie końcowego średnika (po spacji).

Python 2, 114 71 bajtów

Okazuje się, że odświeżyłem koło, prosta podwójna wymiana na sznurku wielowierszowym działa całkiem dobrze. Dodatkową zaletą łańcucha jest możliwość bezpośredniego zliczania zer zamiast konieczności wykonywania naprawdę brzydkiej s*len(L)*len(L[0])listy zagnieżdżonej

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

Stare rozwiązanie:

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

Najpierw musimy konwertować wszystko + 32 z chr(same zera stać przestrzenie), a następnie zastąpić wszystkie wymienione !w {}celu umożliwienia korzystania z formatfunkcji.

Jeśli NULLmożna to zaliczyć jako spację Jeśli zdecyduję się oszukać i użyć NULLzamiast spacji, mogę pominąć dodanie 32, aby zaoszczędzić 12 bajtów. ( printwyświetla się '\x00'jako spacja)

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

APL, 18 bajtów

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

Jest to funkcja, która przyjmuje macierz boolowską jako lewy argument, a łańcuch jako prawy argument.

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

Wyjaśnienie:

APL ma wbudowaną funkcję, która robi coś takiego \(rozwiń). Działa jednak tylko na wektorach i wymaga faktycznego użycia każdej postaci.

• X←,⍺: spłaszcz macierz i zapisz wynik w X.
• ⍵⍴⍨+/X: przekształć wektor znaków, tak aby zawierał wymaganą liczbę elementów (zajmuje się także wydłużaniem łańcucha przez powtarzanie znaków, jeśli to konieczne).
• X\: weź po jednym znaku dla każdego 1i spację dla każdego 0w X.
• (⍴⍺)⍴: przekształć wynik, aby miał kształt oryginalnej matrycy.

PHP, 110 91 97 88 82 81 80 75 bajtów

zapisano 6 bajtów dzięki @ user59178

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

Uruchom z -r. Oczekuje, że macierz jako ciąg wielowierszowy w pierwszym argumencie, ciąg w drugim argumencie.

PowerShell v2 +, 70 bajtów

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

Pobiera słowo wejściowe jako, $aa macierz jako tablicę tablic jako $b(patrz przykłady poniżej). Pętle $b, a następnie pętle przez elementy każdego rzędu $_|%{...}. Pętla wewnętrzna jest warunkiem if/ else, w którym albo wypisujemy $a[$n++]i przyjmujemy mod-równy długości łańcucha, albo wypisujemy spację' ' . Są one -joinedytowane razem z powrotem w ciąg. Każdy ciąg jest pozostawiony w potoku, a dorozumiane dane wyjściowe z nowymi liniami pomiędzy są Write-Outputrealizowane po zakończeniu programu.

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 (lub 83) bajtów

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)

Istnieje krótsza opcja (83 bajty), ale nie powiedzie się, jeśli ciąg znaków będzie ponad 999 razy krótszy niż potrzeba:

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 bajtów

jms?R@z~hZ\ 

Wypróbuj online: demonstracja

Wyjaśnienie:

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 bajtów

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

próbowałem

Common Lisp, 152 bajty

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

Stosowanie:

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

Ta funkcja przechodzi przez każdy element każdego rzędu siatki. formatCiąg kontrola albo drukuje miejsca, jeśli element jest 0 lub zużywa argument znaków jeśli element jest 1. Nowa linia zostanie wydrukowany po każdym wierszu siatki. Jeśli ciąg jest zbyt krótki, powtarza się od początku; jeśli jest za długi, wysyłana jest tylko odpowiednia część.

Pip , 18 bajtów

17 bajtów kodu, +1 dla -lflagi.

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

Pobiera tablicę jako pierwszy argument wiersza polecenia: 100 010 101(musi być cytowany w powłokach), a ciąg znaków jako drugi argument wiersza poleceń.Wypróbuj online!

Wyjaśnienie

                   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 bajtów

Edycja: zapisano 4 bajty dzięki Mukulowi Kumarowi

Gra w golfa:

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

Nie golfowany:

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

Testowanie:

  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 bajtów

.FdRIKQoQl%@

Wypróbuj tutaj!

Wyprowadza macierz znaków

Lub 9 bajtów, niekonkurencyjne.

.FdRIKQo@

Wypróbuj tutaj!

• Dodaj zawijanie na indeksach, w przypadku których indeks jest większy niż długość indeksu. .F - deep_for (input) I - if ^: Qo @ - Q [o ++] dR - else ""

Jeszcze bardziej niekonkurencyjny, 8 bajtów

.FIQo@(P

Wypróbuj tutaj!

• print_grid teraz poprawnie wyrównuje puste ciągi
• deep_for teraz zgaduje na podstawie fałszów innego typu niż prawdy

W pobliżu

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

Java, 122 bajty

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 bajtów

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

Nienazwana funkcja dwóch argumentów, z których pierwszy (# ) jest tablicą Trues iFalse s, a drugi ( s) jest listą znaków. Funkcja pomocnika

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

jest zdefiniowany, co stawia ruchy pierwszego znaku s do końca, a następnie zwraca ten właśnie przeniesiony znak. fKilkukrotne wywołanie cyklicznie zwróci znakis w kolejności.

Podstawową funkcją jest

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

który wzywa f każdegoTrue wartość w tablicy wejściowej i zwraca spację na każdym fałszywym wejściu. ( {2}Mówi, Mapaby pracować na elementach list komponentów tablicy, a nie na samych listach).

Te 60 bajtów zwraca tablicę znaków-z-s i spacji. Opakowanie

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

umieszcza znaki nowej linii między listami każdej tablicy, a następnie łączy wszystko.

C ++, 61 bajtów

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