단어 형성의 예술

이진 행렬과 문자 문자열이 주어지면 행렬의 모든 1을 왼쪽에서 오른쪽으로 문자열의 문자로 바꿉니다. 문자가 행렬 모양으로 만들어지면 0을 공백으로 바꾸어 행렬을 인쇄하십시오. 예를 하나 또는 두 개만주는 것이 더 쉽습니다.

사례 : 기본 사례 ...

입력 하나 :

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

출력 하나 :

  P    
 P C  
G   P
 P C 
  G  

사례 : 입력 문자열이 1보다 큰 경우 ...

입력 2 :

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

lambda

출력 2 :

l  
 a 
m b

사례 : 입력 문자열이 1보다 적은 경우 ...

입력 3 :

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

PPCG

출력 3 :

PPC
G P
PCG

사용 가능한 가정

• 입력 문자열이 비어 있지 않다고 가정 할 수 있습니다.
• 행렬이 절대로 비어 있지 않다고 가정 할 수 있습니다.
• 이진 행렬이 모두 0이 아니라고 가정 할 수는 없습니다.

규칙

• 문자열이 1보다 적 으면 문자열을 반복하십시오. 모든 것을 교체해야합니다.
• 문자열이 1보다 많으면 필요한 것만 사용하십시오.
• 입력에 정수 / 비트 대신 True / False를 사용할 수 있습니다.
• 후행 공백이 필요합니다. 모든 0은 공백 으로 바꿔야 합니다.
• 단일 후행 줄 바꿈이 허용됩니다.
• 이것은 코드 골프, 가장 낮은 바이트 수입니다.

MATL , 11 바이트

yz:)1Gg!(c!

입력은 숫자 행렬 ( ;행 구분 기호 포함) 및 문자열입니다.

온라인으로 사용해보십시오! 또는 테스트 사례를 확인하십시오 ( 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 바이트

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

@DjMcMoylex 덕분에 2 바이트가 절약되었습니다 !

여기서는 ^M문자 그대로의 개행 ^V이며CTRL-V

이 형식으로 입력을받습니다.

PPCG
00100,01010,10001,01010,00100

면책 조항 : 문자열이 ~ 40 자보다 길면 컴퓨터에 램이 부족할 수 있습니다.

설명:

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

다음은 "프로그램" "실행 중"의 GIF입니다.

망막 , 41 33 바이트

0

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

온라인으로 사용해보십시오!

입력 문자열은 입력의 첫 번째 행에 제공되며 행렬이 이어집니다. Retina에는 목록 개념 (또는 실제로 문자열을 제외한 것)이 없으므로 행 피드를 구분하기위한 줄 바꿈을 제외하고 이진 행렬에는 분리자가 없습니다.

설명

0

0을 공백으로 바꿉니다.

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

첫 번째 반복해서 교체 1첫 번째 문자를 입력 문자열의 첫 번째 문자로 해당 문자를 입력 문자열의 끝으로 회전하십시오. 1입력 문자열에 s보다 많은 문자가있는 경우주의를 기울 입니다.

A1`

첫 줄, 즉 입력 문자열을 버리십시오.

자바 스크립트 ES6, 67 53 50 49 바이트

@ETHproductions 덕분에 3 바이트 절약 @Neil 덕분에 1 개 더 절약

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

문자열 매트릭스가 유효한 입력 형식이라는 것을 알기 전의 이전 코드 :

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

펄, 40 바이트

36 바이트의 코드 + -i -p플래그.

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

(마지막 공간과 마지막 줄 바꿈 부족).

실행하려면 -i플래그 뒤에 입력 문자열을 작성하고 입력 에 행렬을 제공하십시오.

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

Perl이 약간 오래된 경우 공백 뒤에 마지막 세미콜론을 추가해야 할 수도 있습니다.

파이썬 2, 114 71 바이트

바퀴를 다시 발명 한 것으로 나타났습니다. 여러 줄 문자열의 간단한 이중 교체가 잘 작동합니다. 문자열은 s*len(L)*len(L[0])중첩 된 목록에 대해 실제로 추한 것을 수행하지 않고 직접 0을 계산할 수 있다는 추가 이점이 있습니다.

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

오래된 해결책 :

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

먼저 모든 + 32를 chr(0은 모두 공백이 됨)으로 변환 한 다음 !with {}를 모두 사용하여format 함수 합니다.

NULL공간으로 계산할 수있는 경우 공간NULL 대신 부정하고 사용하기로 결정한 경우 32 바이트를 건너 뛰고 12 바이트를 절약 할 수 있습니다. ( 공백으로 print표시 '\x00')

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

APL, 18 바이트

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

부울 행렬을 왼쪽 인수로, 문자열을 오른쪽 인수로 취하는 함수입니다.

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

설명:

APL에는 이와 같은 기능을하는 내장 기능이 있습니다 \(확장). 그러나 벡터에서만 작동하며 실제로 각 문자를 사용해야합니다.

• X←,⍺: 행렬을 평평하게하고 결과를 X에 저장합니다.
• ⍵⍴⍨+/X: 필요한 양의 요소를 갖도록 문자형 벡터의 모양을 변경합니다 (필요한 경우 문자를 반복하여 문자열 길이를 늘립니다).
• X\각각의 문자 중 하나 걸릴 1각각의 공간 0에서을 X.
• (⍴⍺)⍴: 원래 행렬의 모양을 갖도록 결과의 형태를 변경합니다.

PHP, 110 91 97 88 82 81 80 75 바이트

@ user59178 덕분에 6 바이트 절약

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

로 실행하십시오 -r. 첫 번째 인수에서는 행렬을, 두 번째 인수에서는 문자열로 여러 줄 문자열로 예상합니다.

PowerShell v2 +, 70 바이트

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

입력 단어를 $a행렬로 배열의 배열 로 취합니다 $b(아래 예 참조). 루프를 $b반복 한 다음 각 행의 요소를 반복합니다 $_|%{...}. 내부 루프는 문자열의 길이와 같거나 mod-equal 또는 공백을 출력 하는 if/ else조건 입니다. 그것들은 다시 끈으로 묶어집니다. 각 문자열은 파이프 라인에 남아 있으며, 프로그램 완료시 개행 문자가 포함 된 암시 적 출력이 발생합니다 .$a[$n++]' '-joinWrite-Output

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

그루비, 63

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

파이썬 3, 104 (또는 83) 바이트

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)

더 짧은 옵션 (83 바이트)이 있지만 문자열이 필요한 것보다 999 배 이상 짧으면 실패합니다.

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 바이트

jms?R@z~hZ\ 

온라인으로 사용해보십시오 : 데모

설명:

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 바이트

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

나는 시도했다

공통 리스프, 152 바이트

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

용법:

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

이 함수는 그리드의 각 행의 각 요소를 반복합니다. format요소가 0 또는 요소가 1. 뉴 라인은 그리드의 모든 행 후 인쇄됩니다 경우 문자 인수를 소모하는 경우 제어 문자열은 공간을 인쇄 중 하나. 줄이 너무 짧으면 처음부터 반복됩니다. 너무 길면 적절한 부분 만 출력됩니다.

핍 , 18 바이트

17 바이트 코드, -l플래그는 +1

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

배열을 다음과 같은 첫 번째 명령 줄 인수로 사용하고 100 010 101(셸에서 인용해야 함) 문자열을 두 번째 명령 줄 인수로 사용합니다.온라인으로 사용해보십시오!

설명

                   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

자바, 237233 바이트

편집 : Mukul Kumar 덕분에 4 바이트 절약

골프 :

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

언 골프 드 :

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

테스트 :

  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

파이크, 12 바이트

.FdRIKQoQl%@

여기 사용해보십시오!

문자 행렬을 출력합니다

또는 9 바이트 (비경쟁).

.FdRIKQo@

여기 사용해보십시오!

• 요청한 색인이 색인 작성 가능 길이보다 큰 색인 작성 가능 파일에 랩핑을 추가하십시오. .F-deep_for (input) I-if ^ : Qo @-Q [o ++] dR-else ""

훨씬 비경쟁적인 8 바이트

.FIQo@(P

여기 사용해보십시오!

• print_grid 빈 문자열을 올바르게 정렬합니다.
• deep_for 이제 진실과 다른 유형의 거짓에 대한 유형 추측

​

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

자바, 122 바이트

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

매스 매 티카, 76 바이트

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

두 인수의 이름이없는 함수 중 첫 번째 ( #)는 Trues 및 Falses 의 배열 이며 두 번째 인수 ( s)는 문자 목록입니다. 도우미 기능

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

가 정의되어 첫 번째 문자를 s끝까지 이동시킨 다음 방금 이동 한 문자를 반환합니다. f여러 번 호출 하면 주기적으로 문자를 반환합니다s 순서대로 .

핵심 기능은

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

입력 배열의 f모든 True값 을 호출 하고 모든 잘못된 입력에 공백을 반환합니다. (이 목록 자체가 아니라 배열의 구성 요소 목록 요소에 대해 작업하도록 {2}지시 Map합니다.)

60 바이트는 s공백과 문자의 배열을 반환 합니다. 래퍼

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

각 배열의 목록 사이에 줄 바꿈을 넣고 모든 것을 연결합니다.

C ++, 61 바이트

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