ศิลปะแห่งการสร้างคำ

รับเมทริกซ์ไบนารีและสตริงตัวอักษรแทนที่ 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,0,0]
[0,1,0]
[1,0,1]

lambda

เอาท์พุทสอง:

l  
 a 
m b

กรณี: ถ้าสตริงอินพุตสั้นกว่าจำนวนสตริง ...

อินพุตสาม:

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

PPCG

เอาท์พุทสาม:

PPC
G P
PCG

สมมติฐานที่มีอยู่

• คุณอาจคิดว่าสายป้อนไม่เคยว่างเปล่า
• คุณอาจคิดว่าเมทริกซ์จะไม่ว่างเปล่า
• คุณอาจไม่คิดว่าเมทริกซ์ไบนารีจะไม่เป็นศูนย์ทั้งหมด

กฎระเบียบ

• หากสตริงสั้นกว่าจำนวนสตริงให้ทำซ้ำสตริง; ทุกคนจะต้องถูกแทนที่
• หากสตริงยาวกว่าจำนวนสตริงให้ใช้สิ่งที่จำเป็นเท่านั้น
• คุณสามารถใช้ True / False แทนจำนวนเต็ม / บิตสำหรับการป้อนข้อมูล
• ต้องการช่องว่างต่อท้ายต้องเปลี่ยนศูนย์ทั้งหมดด้วยช่องว่าง
• ขึ้นบรรทัดใหม่ต่อท้ายเป็นที่ยอมรับ
• นี่คือ code-golf, จำนวนไบต์ต่ำสุดที่ชนะ

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

เป็นกลุ่ม44 44ไบต์

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

บันทึก 2 ไบต์ต้องขอบคุณ@DjMcMoylex !

นี่^Mคือบรรทัดใหม่ตามตัวอักษรและ^VคือCTRL-V

รับอินพุตในรูปแบบนี้:

PPCG
00100,01010,10001,01010,00100

คำเตือน:หากสตริงมีความยาวเกินกว่า 40 ตัวอักษรคอมพิวเตอร์ของคุณอาจหมด RAM

คำอธิบาย:

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 ไม่มีแนวคิดของรายการ (หรืออะไรก็ได้ยกเว้นสตริง) จึงไม่มีตัวคั่นในไบนารีเมทริกซ์ยกเว้นสำหรับ linefeeds ไปยังแถวที่แยกต่างหาก

คำอธิบาย

0

เปลี่ยนศูนย์เป็นช่องว่าง

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

แทนที่1อักขระตัวแรกด้วยอักขระตัวแรกของสตริงอินพุตซ้ำ ๆในขณะที่หมุนอักขระนั้นไปยังจุดสิ้นสุดของสตริงอินพุต สิ่งนี้จะใช้ในกรณีที่มี1อักขระมากกว่าตัวอักขระในสตริงอินพุต

A1`

ยกเลิกบรรทัดแรกเช่นสตริงอินพุต

JavaScript ES6, 67 53 50 49 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @ETHproductions บันทึกอีก 1 รายการขอบคุณ @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>

โค้ดเก่าก่อนที่ฉันจะรู้ว่าเมทริกซ์สตริงเป็นรูปแบบอินพุตที่ถูกต้อง:

(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 ไบต์

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 ของคุณค่อนข้างเก่าคุณอาจต้องเพิ่มเซมิโคลอนสุดท้าย (หลังจากเว้นวรรค)

Python 2, 114 71 ไบต์

ปรากฎว่าฉันคิดค้นล้อขึ้นมาใหม่การเปลี่ยนดับเบิ้ลอย่างง่าย ๆ บนสตริงหลายเส้นทำได้ค่อนข้างดี สตริงมีประโยชน์เพิ่มเติมของความสามารถในการนับเลขศูนย์โดยตรงแทนที่จะต้องทำสิ่งที่น่าเกลียดจริงๆs*len(L)*len(L[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(ศูนย์ทั้งหมดกลายเป็นช่องว่าง) จากนั้นเราแทนที่ทั้งหมด!ด้วย{}เพื่ออนุญาตให้ใช้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และพื้นที่สำหรับแต่ละใน0X
• (⍴⍺)⍴: ปรับแต่งผลลัพธ์ใหม่เพื่อให้มีรูปร่างของเมทริกซ์ดั้งเดิม

PHP, 110 91 97 88 82 81 80 75 ไบต์

บันทึก 6 ไบต์ด้วย @ user59178

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แล้ว loops $_|%{...}ผ่านองค์ประกอบของแต่ละแถว Inner loop เป็นif/ elseเงื่อนไขที่เราส่งออกอย่างใดอย่างหนึ่ง$a[$n++]และใช้ mod- เท่ากับความยาวของสตริงหรือช่องว่าง' 'ออก เหล่านั้นถูก-joinรวมเข้าด้วยกันเป็นสตริง แต่ละสตริงถูกปล่อยไว้บนไพพ์ไลน์และเอาต์พุตโดยนัยกับบรรทัดใหม่ระหว่างสิ่งที่เกิดขึ้นผ่านWrite-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

Groovy, 63

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

Python 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. การขึ้นบรรทัดใหม่ได้รับการตีพิมพ์หลังจากที่แถวของตารางทุก หากสตริงสั้นเกินไปสตริงนั้นจะซ้ำตั้งแต่ต้น หากยาวเกินไปเฉพาะส่วนที่เหมาะสมเท่านั้นที่จะได้รับผลลัพธ์

Pip , 18 ไบต์

โค้ดขนาด 17 ไบต์, +1 สำหรับการ-lตั้งค่าสถานะ

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

Java, 237 233 ไบต์

แก้ไข: บันทึกแล้ว 4 ไบต์ขอบคุณ Mukul Kumar

แข็งแรงเล่นกอล์ฟ:

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

การทดสอบ:

  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 ไบต์

.FdRIKQoQl%@

ลองที่นี่!

เอาต์พุตเมทริกซ์ของอักขระ

หรือ 9 ไบต์ไม่มีการแข่งขัน

.FdRIKQo@

ลองที่นี่!

• เพิ่มการตัดคำบนดัชนีที่ดัชนีร้องขอมีขนาดใหญ่กว่าความยาวของการจัดทำดัชนี .F - deep_for (อินพุต) I - ถ้า ^: Qo @ - Q [o ++] dR - else ""

noncompetitive มากขึ้น 8 ไบต์

.FIQo@(P

ลองที่นี่!

• print_grid ตอนนี้จัดตำแหน่งสตริงที่ว่างเปล่าอย่างถูกต้อง
• deep_for ตอนนี้ทำการคาดเดาชนิดของความจริงที่แตกต่างกับความจริง

​

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

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

Mathematica, 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';}