Nghệ thuật tạo hình từ

Đưa ra một ma trận nhị phân và một chuỗi các chữ cái, thay thế tất cả 1 trong ma trận từ trái sang phải bằng các chữ cái của chuỗi. Khi các chữ cái đã được tạo thành hình dạng của ma trận, hãy in ma trận, thay thế 0 bằng dấu cách. Có lẽ dễ dàng hơn để đưa ra một hoặc hai ví dụ.

Trường hợp: Trường hợp cơ sở ...

Đầu vào thứ nhất:

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

Đầu ra thứ nhất:

  P    
 P C  
G   P
 P C 
  G  

Trường hợp: Nếu chuỗi đầu vào dài hơn số lượng ...

Đầu vào hai:

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

lambda

Đầu ra hai:

l  
 a 
m b

Trường hợp: Nếu chuỗi đầu vào ngắn hơn số lượng ...

Đầu vào ba:

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

PPCG

Đầu ra ba:

PPC
G P
PCG

Giả định có sẵn

• Bạn có thể giả sử chuỗi đầu vào không bao giờ trống.
• Bạn có thể cho rằng ma trận sẽ không bao giờ trống.
• Bạn có thể không cho rằng ma trận nhị phân sẽ không bao giờ là số không.

Quy tắc

• Nếu chuỗi ngắn hơn số lượng, lặp lại chuỗi; tất cả những cái phải được thay thế.
• Nếu chuỗi dài hơn số lượng, chỉ sử dụng những gì cần thiết.
• Bạn có thể sử dụng Đúng / Sai thay cho số nguyên / bit cho đầu vào.
• Không gian lưu trữ ĐƯỢC YÊU CẦU, tất cả các số không phải được thay thế bằng khoảng trắng.
• Một dòng mới duy nhất được chấp nhận.
• Đây là mã golf, số byte thấp nhất sẽ thắng.

MATL , 11 byte

yz:)1Gg!(c!

Đầu vào là một ma trận số (với ;dấu phân cách hàng) và một chuỗi.

Hãy thử trực tuyến! Hoặc xác minh các trường hợp kiểm tra: 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

Đã lưu 2 byte nhờ @DjMcMoylex !

Ở đây, ^Mmột dòng chữ mới, và ^VlàCTRL-V

Lấy đầu vào ở định dạng này:

PPCG
00100,01010,10001,01010,00100

Tuyên bố miễn trừ trách nhiệm: Nếu chuỗi dài hơn ~ 40 ký tự, máy tính của bạn có thể hết ram.

Giải trình:

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

Đây là một gif của tôi "chạy" "chương trình":

Võng mạc , 41 33 byte

0

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

Hãy thử trực tuyến!

Chuỗi đầu vào được đưa ra trên hàng đầu tiên của đầu vào, theo sau là ma trận. Vì Retina không có khái niệm về danh sách (hoặc thực sự là bất cứ thứ gì ngoại trừ chuỗi), không có dấu tách trong ma trận nhị phân ngoại trừ các đường dẫn để phân tách các hàng.

Giải trình

0

Biến số không thành không gian.

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

Liên tục thay thế 1ký tự đầu tiên bằng ký tự đầu tiên của chuỗi đầu vào đồng thời xoay ký tự đó đến cuối chuỗi đầu vào. Điều này quan tâm đến các trường hợp có nhiều 1s hơn các ký tự trong chuỗi đầu vào.

A1`

Hủy dòng đầu tiên, tức là chuỗi đầu vào.

JavaScript ES6, 67 53 50 49 byte

Đã lưu 3 byte nhờ @ETHproductions Đã lưu thêm 1 byte nhờ @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>

Mã cũ trước khi tôi biết rằng ma trận chuỗi là một định dạng đầu vào hợp lệ:

(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 mã + -i -pcờ.

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

(lưu ý không gian cuối cùng và thiếu dòng mới cuối cùng).

Để chạy nó, hãy viết chuỗi đầu vào sau -icờ và cung cấp ma trận trong đầu vào:

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

Nếu Perl của bạn hơi cũ, bạn có thể cần thêm dấu chấm phẩy cuối cùng (sau dấu cách).

Python 2, 114 71 byte

Hóa ra tôi đã phát minh lại bánh xe, một thay thế đơn giản trên chuỗi đa dây hoạt động khá tốt. Chuỗi có lợi ích bổ sung là có thể đếm số 0 trực tiếp thay vì phải thực sự xấu xí s*len(L)*len(L[0])cho danh sách lồng nhau

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

Giải pháp cũ:

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

Đầu tiên chúng ta chuyển đổi mọi thứ + 32 bằng chr(tất cả các số 0 trở thành khoảng trắng), sau đó chúng ta thay thế tất cả !bằng {}để cho phép sử dụng formathàm.

Nếu NULLcó thể được tính là khoảng trắng Nếu tôi quyết định gian lận và sử dụng NULLthay vì khoảng trắng, tôi có thể bỏ qua việc thêm 32 để lưu 12 byte. ( printhiển thị '\x00'dưới dạng khoảng trắng)

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

Đây là một hàm lấy một ma trận boolean làm đối số bên trái của nó và một chuỗi làm đối số bên phải của nó.

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

Giải trình:

APL có tích hợp sẵn làm một cái gì đó như thế này, \(mở rộng). Tuy nhiên, nó chỉ hoạt động trên các vectơ và nó yêu cầu mỗi ký tự phải được sử dụng thực sự.

• X←,⍺: làm phẳng ma trận và lưu kết quả trong X.
• ⍵⍴⍨+/X: định hình lại vectơ ký tự sao cho nó có số lượng phần tử cần thiết (điều này cũng đảm nhiệm việc kéo dài chuỗi bằng cách lặp lại các ký tự nếu cần thiết).
• X\: Lấy một trong những ký tự cho mỗi 1và một không gian cho mỗi 0trong X.
• (⍴⍺)⍴: định hình lại kết quả để nó có hình dạng của ma trận gốc.

PHP, 110 91 97 88 82 81 80 75 byte

đã lưu 6 byte nhờ @ user59178

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

Chạy với -r. Yêu cầu ma trận là chuỗi đa dòng trong đối số thứ nhất, chuỗi trong đối số thứ hai.

PowerShell v2 +, 70 byte

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

Lấy từ đầu vào là $avà ma trận dưới dạng một mảng như $b(xem ví dụ bên dưới). Vòng lặp qua $b, sau đó vòng qua các phần tử của mỗi hàng $_|%{...}. Vòng lặp bên trong là một điều kiện if/ elsetrong đó chúng ta hoặc xuất ra $a[$n++]và lấy mod bằng với độ dài của chuỗi hoặc xuất ra một khoảng trắng ' '. Những cái đó được -joined lại với nhau thành một chuỗi. Mỗi chuỗi được để lại trên đường ống và đầu ra ngầm định với các dòng mới giữa xảy ra thông qua Write-Outputkhi hoàn thành chương trình.

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 (hoặc 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)

Có tùy chọn ngắn hơn (83 Byte), nhưng sẽ thất bại nếu chuỗi ngắn hơn 999 lần so với mức cần thiết:

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

Bình thường, 12 byte

jms?R@z~hZ\ 

Dùng thử trực tuyến: Trình diễn

Giải trình:

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

Tôi đã thử

Lisp thông thường, 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"~%"))))

Sử dụng:

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

Hàm này lặp qua từng phần tử của mỗi hàng của lưới. Chuỗi formatđiều khiển sẽ in một khoảng trắng nếu phần tử là 0 hoặc sử dụng đối số ký tự nếu phần tử là 1. Một dòng mới được in sau mỗi hàng của lưới. Nếu chuỗi quá ngắn, nó lặp lại từ đầu; nếu quá dài, chỉ có phần thích hợp được xuất ra.

Pip , 18 byte

17 byte mã, +1 cho -lcờ.

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

Lấy mảng làm đối số dòng lệnh đầu tiên như thế này: 100 010 101(cần được trích dẫn trong shell) và chuỗi là đối số dòng lệnh thứ hai. Hãy thử trực tuyến!

Giải trình

                   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

Chỉnh sửa: đã lưu 4 byte nhờ Mukul Kumar

Chơi gôn

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

Ung dung:

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

Kiểm tra:

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

Hãy thử nó ở đây!

Xuất ra một ma trận các ký tự

Hoặc 9 byte, không cạnh tranh.

.FdRIKQo@

Hãy thử nó ở đây!

• Thêm gói trên các chỉ mục trong đó chỉ mục được yêu cầu lớn hơn chiều dài của chỉ mục. . - deep_for (đầu vào) I - if ^: Qo @ - Q [o ++] dR - other ""

Thậm chí nhiều hơn, 8 byte

.FIQo@(P

Hãy thử nó ở đây!

• print_grid Bây giờ sắp xếp các chuỗi trống đúng cách
• deep_for bây giờ không đoán kiểu trên các loại giả khác với các sự thật

Là một tài tài, hay nói, qua, qua một khác, qua giữ, qua, qua một tài khác, qua giữ, qua, qua, qua một tài khác, qua giữ, qua, qua, mới, qua, mới đăng, mới, mới đăng, mới đăng, mới đăng, mới đăng, mới cam mới, mới đăng, mới đăng, mới đăng cam đăng

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

Toán học, 76 byte

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

Hàm không tên của hai đối số, đầu tiên trong đó ( #) là một mảng gồm Trues và Falses và thứ hai trong đó ( s) là danh sách các ký tự. Hàm trợ giúp

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

được định nghĩa, trong đó đặt các di chuyển ký tự đầu tiên sđến cuối và sau đó trả về ký tự vừa di chuyển đó. Gọi fnhiều lần sẽ trả lại theo chu kỳ các ký tự stheo thứ tự.

Chức năng cốt lõi là

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

sẽ gọi fmọi Truegiá trị trong mảng đầu vào và trả về một khoảng trắng trên mỗi đầu vào sai. (Việc {2}bảo Maplàm việc trên các phần tử của danh sách thành phần của mảng, thay vì chính các danh sách đó.)

60 byte đó trả về một mảng các ký tự svà khoảng trắng. Bao bọc

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

đặt các dòng mới giữa mỗi danh sách của mảng đó và sau đó ghép mọi thứ.

C ++, 61 byte

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