वर्ड शेपिंग की कला

Question

वर्ड शेपिंग की कला

बाइनरी मैट्रिक्स, और अक्षरों की एक स्ट्रिंग को देखते हुए, स्ट्रिंग के अक्षरों के साथ सभी 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 का उपयोग कर सकते हैं।
• ट्रेलिंग रिक्त स्थान आवश्यक हैं, सभी शून्य को रिक्त स्थान के साथ प्रतिस्थापित किया जाना चाहिए ।
• एक एकल अनुगामी न्यूलाइन स्वीकार्य है।
• यह कोड-गोल्फ है, सबसे कम बाइट काउंट जीतता है।

Comments

क्या मैट्रिक्स को एक सरणी के रूप में इनपुट करना है या क्या मैं एक बहु-स्ट्रिंग का उपयोग कर सकता हूं?

— टाइटस

@ यह ठीक है, मार्टिन एंडर पहले से ही ठीक है।

— मैजिक ऑक्टोपस Urn

आधार मामले को दाएं नहीं छोड़ा गया है। क्या आपका मतलब ऊपर से नीचे है, फिर दाएं से बाएं?

— edc65

यदि मैट्रिक्स है, उदाहरण के लिए, शून्य का एक 2x2 ग्रिड, तो क्या हमें एक ही स्थान या 2x2 ग्रिड से रिक्त स्थान का उत्पादन करना चाहिए?

— कृत्रिम

@ pieman2201 ने बेहतर होने के लिए टेस्ट केस # 4 को मंजूरी दे दी।

— मैजिक ऑक्टोपस Urn

Answer 1

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

Comments

MATL मूल रूप से परिभाषित करता है कि मैंने हमेशा कैसे संग्रह देखा है ...

— मैजिक ऑक्टोपस Urn

Matlab की तरह @carusocomputing, मुख्य डेटा प्रकार "आयताकार" सरणियाँ हैं: मैट्रिक्स या उनके एन-आयामी एनालॉग्स। उनमें संख्या, वर्ण या बूलियन मूल्य हो सकते हैं। सेल एरेज़ भी हैं, जिसमें मनमानी चीजें शामिल हो सकती हैं, जैसे कि पायथन की सूची

— लुइस मेंडो

2 सप्ताह के खुले रहने के बाद चयनित सर्वश्रेष्ठ उत्तर।

— मैजिक ऑक्टोपस Urn

Answer 2

विम, ४४ ४२ बाइट्स

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 है:

Comments

हाहाहा, डिस्क्लेमर से प्यार करो।

— मैजिक ऑक्टोपस Urn

आप एक जोड़े को उतारने के {स्थान पर उपयोग कर सकते हैं gg।

— DJMcMayhem

ठीक है, जिफ वास्तव में साफ है, लेकिन क्या आपको लगता है कि आप इसे केवल लिंक के माध्यम से शामिल कर सकते हैं? हर बार जब मैं अतीत को स्क्रॉल करने की कोशिश करता हूं तो यह मेरे क्रोम को पीछे छोड़ देता है :(

— wnnmaw

Answer 3

रेटिना , 41 33 बाइट्स

0

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

इसे ऑनलाइन आज़माएं!

इनपुट स्ट्रिंग इनपुट की पहली पंक्ति पर दी गई है, उसके बाद मैट्रिक्स। चूंकि रेटिना के पास सूचियों की कोई अवधारणा नहीं है (या वास्तव में तार के अलावा कुछ भी नहीं है), बाइनरी मैट्रिक्स में कोई पंक्तियाँ नहीं हैं सिवाय अलग-अलग पंक्तियों के लाइनफीड के।

व्याख्या

0

शून्य को रिक्त स्थान में बदल देता है।

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

बार-बार 1इनपुट स्ट्रिंग के पहले चरित्र के साथ पहले को बदलें, जबकि इनपुट स्ट्रिंग के अंत में उस चरित्र को घुमाते हुए। यह उन मामलों को ध्यान में रखता है जहाँ 1इनपुट स्ट्रिंग में वर्णों की तुलना में अधिक s हैं ।

A1`

पहली पंक्ति, यानी इनपुट स्ट्रिंग को छोड़ दें।

Comments

(.)(.*)- तेही ...

— मैजिक ऑक्टोपस Urn

Answer 4

जावास्क्रिप्ट ईएस 6, 67 53 50 49 बाइट्स

सहेजे गए 3 बाइट्स @ETHproductions की बदौलत @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>

Comments

मैं सुझाव देता हूं c=>' '[c]||b[i++%b.length], लेकिन दुख की बात है कि यह अब बाइट है ...

— ETHproductions

हालाँकि, 3 बाइट्स बचाने का एक और तरीका है:(a,b,i)=>a.replace(/\d/g,c=>+c?b[++i]||b[i=0]:' ')

— ETHproductions

मुझे लगता है कि यह स्ट्रिंग के दूसरे चरित्र पर शुरू होगा। एक स्निपेट अपडेट अच्छा होगा।

— टाइटस

@ टिट्स पहले, iहै undefined, इसलिए ++iरिटर्न NaN। के बाद से bकोई है NaNसंपत्ति, b[++i]रिटर्न undefined, और ||ऑपरेटर अपनी दाईं ओर तर्क चलाता है, स्थापित करने iके लिए 0और में पहली चार लौटने b।

— ETHproductions

आप परीक्षण क्यों कर रहे हैं \d? निश्चित रूप से .पर्याप्त है, क्योंकि आपको केवल 0एस और 1एस के साथ सौदा करना है ( .नई लाइनों से मेल नहीं खाता)।

— नील

Answer 5

पर्ल, 40 बाइट्स

कोड + -i -pझंडे के 36 बाइट्स ।

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

यदि आपका पर्ल थोड़ा पुराना है, तो आपको अंतिम अर्धविराम (अंतरिक्ष के बाद) जोड़ना पड़ सकता है।

Answer 6

पायथन 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 बजाय धोखा देने और उपयोग करने का निर्णय लेता हूं, तो मैं 12 बाइट्स को बचाने के लिए 32 के अतिरिक्त को छोड़ सकता हूं। ( एक स्थान के रूप में printप्रदर्शित होता '\x00'है)

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

Comments

क्या NULLs का उपयोग करना कम नहीं होगा, और अंत में उन्हें जगह से बदलना होगा?

— nedla2004

@ nedla2004, आप कैसे सुझाव देते हैं कि मैं ऐसा करूं? .replace('\x00',' ')अंत में बस जोड़ने से 20 बाइट्स जुड़ जाते हैं

— wnnmaw

लेकिन फिर मुझे लगता है कि आप इससे छुटकारा पा सकते हैं: नक्शा (लंबो n: chr (n + 32), l)

— nedla2004

दूसरा समाधान पूरे समय NULLs के साथ काम करता है, जो मुझे 12 बाइट्स बचाता है, अंत में रिक्त स्थान पर स्वैप करने से मुझे इससे अधिक खर्च होगा

— wnnmaw

मुझे लगा कि आप वास्तव में जितना कर सकते हैं उससे अधिक को हटा सकते हैं।

— nedla2004

Answer 7

एपीएल, 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।
• (⍴⍺)⍴: परिणाम को फिर से आकार दें ताकि उसमें मूल मैट्रिक्स का आकार हो।

Answer 8

PHP, 110 91 97 88 82 81 80 75 बाइट्स

@ उपयोगकर्ता59178 के लिए 6 बाइट्स धन्यवाद बचाया

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

के साथ भागो -r। पहले तर्क में मैट्रिक्स को मल्टीलाइन स्ट्रिंग के रूप में, दूसरे तर्क में स्ट्रिंग की उम्मीद है।

Comments

एक 80 बाइट अपने 82 के आधार पर संस्करण बाइट्स संस्करण: foreach(str_split($argv[1])as$c)echo$c<1?$c?:" ":($s=$argv[2])[$k++%strlen($s)];मैं दो ternaries के आदेश बदली है और इस तरह का उपयोग करके दूसरे से कोष्ठक गिरा <1बजाय>0

— user59178

के for(;""!=$c=$argv[1][$i++];)बजाय का उपयोग करके आप 4 बाइट्स बचा सकते हैंforeach(...)

— user59178

Answer 9

PowerShell v2 +, 70 बाइट्स

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

इनपुट शब्द के रूप में $aऔर मैट्रिक्स को सरणी के रूप में $b(नीचे उदाहरण देखें) के रूप में लेता है । के माध्यम से छोरों $b, फिर प्रत्येक पंक्ति के तत्वों के माध्यम से छोरों $_|%{...}। इनर पाश एक है if/ elseहालत, जहां हम या तो उत्पादन $a[$n++]और आधुनिक-बराबर स्ट्रिंग की लंबाई, या उत्पादन एक अंतरिक्ष करने के लिए ले ' '। वे -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

Answer 10

ग्रूवी, 63

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

Answer 11

पायथन 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)

Comments

दूसरा समाधान मेरे लिए काम नहीं करता है, क्योंकि आप nextएक सूची पर कॉल नहीं कर सकते । यदि आप ऐसा करते s=iter(list(s)*999)हैं (89 बाइट्स)

— L3viathan

@ L3viathan क्षमा करें, मेरा मतलब यह था s.pop(0)। ऐसा लगता है कि मैंने गलत संस्करण की नकल की, जो तय किया।

— अलिसा

s[i++%s.length()]एक अच्छी कार्यप्रणाली है, हालांकि मुझे अजगर का पता नहीं है।

— मैजिक ऑक्टोपस Urn

यह अच्छा होगा, लेकिन i++पायथन में ऐसा कुछ नहीं है

— एलिसा

Answer 12

पायथ, 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

Answer 13

ईएस 6, 78 बाइट्स

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

मैंने कोशिश की

Comments

PPCG में आपका स्वागत है!

— 14

Answer 14

आम लिस्प, 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. एक नई पंक्ति ग्रिड के हर पंक्ति के बाद प्रिंट हो जाती है। यदि स्ट्रिंग बहुत कम है, तो यह शुरुआत से दोहराता है; यदि यह बहुत लंबा है, तो केवल उचित भाग ही आउटपुट मिलता है।

Answer 15

रंज , 18 बाइट्स

-lध्वज के लिए कोड के 17 बाइट्स, +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

Answer 16

जावा, 237 233 बाइट्स

संपादित करें: मुकुल कुमार के लिए 4 बाइट्स सहेजे गए

golfed:

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

Comments

आप सभी अंतर को एक पंक्ति में घोषित कर सकते हैं .....

— मुकुल कुमार

Answer 17

पाइके, 12 बाइट्स

.FdRIKQoQl%@

यहाँ कोशिश करो!

वर्णों का एक मैट्रिक्स आउटपुट

या 9 बाइट्स, नॉन-कंपेटिटिव।

.FdRIKQo@

यहाँ कोशिश करो!

• अनुक्रमणिका पर रैपिंग को जोड़ें जहां सूचकांक के लिए पूछा गया कि अनुक्रमणिका की लंबाई से बड़ा है। // - deep_for (इनपुट) I - if ^: Qo @ - Q [o ++] dR - और ""

और भी गैर-अक्षम्य, 8 बाइट्स

.FIQo@(P

यहाँ कोशिश करो!

• print_grid अब खाली तारों को ठीक से संरेखित करें
• deep_for अब सत्यता के लिए एक अलग प्रकार के झूठ पर प्रकार-अनुमान करता है

​

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

Answer 18

जावा, 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;}

Answer 19

मैथमेटिका, 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")&

उस एरे की सूचियों में से प्रत्येक के बीच नई सुर्खियाँ डालता है और फिर सब कुछ समेट देता है।

Answer 20

सी ++, 61 बाइट्स

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