एक द्विपद के वर्ग का चित्रण करें

Question

दिए गए (किसी भी तरह से) दो अलग-अलग प्राकृतिक संख्याओं (किसी भी उचित आकार के), आउटपुट (किसी भी तरह से) उनकी राशि का वर्ग नीचे दिए गए उदाहरणों के रूप में:

4 और 3 को देखते हुए, आउटपुट:

12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

1 और 3 को देखते हुए, आउटपुट:

3 9 9 9
3 9 9 9
3 9 9 9
1 3 3 3

व्हाट्सएप कारण में भिन्न हो सकता है लेकिन कॉलम को बाएं-संरेखित, दाएं-संरेखित या (छद्म-) केंद्रित होना चाहिए।

एक अनुगामी न्यूलाइन ठीक है, लेकिन मानक कमियां नहीं हैं।

यह कोड-गोल्फ है इसलिए # LanguageName, 123अपने उत्तर में एक शीर्षलेख शामिल करें, जहां संख्या वर्ण है (उन भाषाओं के लिए बाइट्स जो पाठ-आधारित नहीं हैं)। बड़े यूनिकोड वर्णों के लिए कोड पैकिंग की अनुमति नहीं है।

---

बोनस: -3 यदि आपका कोड 0 में से एक होने पर सिर्फ एक वर्ग का आउटपुट देता है; उदाहरण के लिए दिया गया 0 और 3, आउटपुट:

9 9 9
9 9 9
9 9 9

Comments

इनपुट संख्याओं का अधिकतम मूल्य क्या है? धन्यवाद।

— उज्ज्वल

@donbright कोई कृत्रिम सीमा नहीं। केवल वह सीमा है जो आपके कंप्यूटर और भाषा को संभाल सकती है जब यह प्रतिनिधित्व, अभिकलन (आपके चुने हुए एल्गोरिथ्म के साथ) और परिणाम की बात आती है। संभावित रूप से, एक प्रिंटर से लैस एक आधुनिक कंप्यूटर जो डेटा लाइन को लाइन से स्वीकार करता है, उसकी लगभग कोई सीमा नहीं होगी ... :-)

— Adám

क्या वर्ग अभिविन्यास दिया गया है, या हम इसे 90 डिग्री घुमा सकते हैं?

— जॉन ड्वोरक

हालांकि 0 मान के लिए बोनस क्यों? यदि केवल एक वर्ग नहीं तो अपेक्षित आउटपुट क्या होगा?

— मार्च हो

@MarchHo यही कारण है कि बोनस इतना छोटा है। फिर भी, कुछ भाषाएं खाली सरणियों को संभालने में सक्षम नहीं हो सकती हैं।

— अड्म

Answer 1

जे, 9 बाइट्स - 3 = 6

#~@|.*/#~

@ एनबीजेड के एपीएल जवाब से प्रेरित होकर , @randomra द्वारा नीचे गिरा दिया गया। यह एक क्रिया को परिभाषित करता है जो संख्याओं की एक सरणी में ले जाती है। इसका उपयोग इस प्रकार है:

   (#~@|.*/#~) 4 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

मैं 3-बाइट बोनस का भी दावा करता हूं, क्योंकि 0 का इनपुट शून्य के उप-मेट्रिक्स का उत्पादन करता है:

   (#~@|.*/#~) 4 0
16 16 16 16
16 16 16 16
16 16 16 16
16 16 16 16
   (#~@|.*/#~) 0 3
9 9 9
9 9 9
9 9 9

व्याख्या

इस चुनौती में J की निश्चित बढ़त है। नाश्ते के लिए सरणी हेरफेर समस्याओं को खाने के अलावा, यह डिफ़ॉल्ट रूप से 2 डी मेट्रिक्स को सही प्रारूप में प्रिंट करता है।

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table

Comments

इससे मुझे घर पर होने का एहसास होता है।

— 12

यह समाधान table flipperASCII इमोटिकॉन (□ °） ° obs Pet

— TNT

Answer 2

ऑक्टेव, 45 बाइट्स - 3 = 42

s=@(m,n)[a=ones(n,1)*n;b=ones(m,1)*m].*[b;a]'

व्याख्या

इससे दो वैक्टर बनते हैं (मान लेते हैं m = 4और n = 3):

ones(n, 1)आकार के लोगों की एक सरणी का निर्माण करता है n x 1, इसलिए nहम प्राप्त करने वालों को गुणा करते हैं :

ones(n, 1) * n => [3 3 3]' (where ' is transpose... n x 1 is a column vector)

a = [3 3 3  4 4 4 4]'   %// a is a column vector
b = [4 4 4 4  3 3 3]    %// b is a row vector

फिर वैक्टर को तत्व-वार फैशन में गुणा किया जाता है, स्वचालित प्रसारण विस्तार के साथ ताकि 7-तत्व वैक्टर 7x7-तत्व मैट्रिक्स का उत्पादन करें:

    [3] .* [4 4 4 4 3 3 3]
    [3]
    [3]
    [4]
    [4]
    [4]
    [4]

उदाहरण के लिए, की पहली पंक्ति के गुणन aसे bदेता है:

    [3] .* [4 4 4 4 3 3 3] = [12 12 12 12  9  9  9]

और इसी तरह बाकी की पंक्तियों के लिए a।

आउटपुट:

>> s(4,3)
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

>> s(3,0)
ans =

   9   9   9
   9   9   9
   9   9   9

आप इसे यहां आइडोन पर आजमा सकते हैं

Comments

आप निकाल सकते हैं s=। हमारे पास यह कन्वेंशन है कि अनाम फ़ंक्शंस / लैम्ब्डा को एक चर में संग्रहीत करने की आवश्यकता नहीं है।

— 22

@flawr, लेकिन तब उत्तर 42 नहीं होगा ...

— बीकर

ठीक है।

— एडम

Answer 3

दिल्लोग एपीएल , 10-3 = 7

इस उत्तर से प्रेरित होकर * जहां तर्कों को दोहराया जाता है और फिर गुणा तालिका में उपयोग किया जाता है:

⊖∘.×⍨(/⍨⎕)

⎕एक प्रॉम्प्ट ( ⎕:) जारी करता है और तब दर्ज की गई किसी भी अभिव्यक्ति का मूल्यांकन करता है। (सुरक्षा कारणों से, यह नहीं काम पर करता है TryAPL लेकिन उस पर काम करता है NGN / एपीएल ।)
/⍨अपने तर्क ही बार (Replicates /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨एक गुणन तालिका बनाता है।
⊖उल्टा हो जाता है।

यह किसी भी लंबाई के इनपुट पर काम करने के लिए होता है (इनपुट 6 रिक्त स्थान है, आउटपुट बाएं मार्जिन पर है):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ Empty list (the square of nothing)
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0      ⍝ 0​² = 0
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0 1      ⍝ (0+1)​² = 1²
1
      ⊖∘.×⍨(/⍨⎕)
⎕:
      2 3      ⍝ (2+3)​² = 2² + 3²
6 6 9 9 9
6 6 9 9 9
6 6 9 9 9
4 4 6 6 6
4 4 6 6 6
      ⊖∘.×⍨(/⍨⎕)
⎕:
      1 2 3      ⍝ (1+2+3)​² = 1² + 2(1×2) + 2(1×3) + 2² + 2(2×3) + 3²
3 6 6 9 9 9
3 6 6 9 9 9
3 6 6 9 9 9
2 4 4 6 6 6
2 4 4 6 6 6
1 2 2 3 3 3
      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍳4    ⍝ Integers 1 through 4
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
2 4 4  6  6  6  8  8  8  8
2 4 4  6  6  6  8  8  8  8
1 2 2  3  3  3  4  4  4  4

---

* मूल रूप से, मेरे मन में एक अलग समाधान था: प्रत्येक आयत को दो तर्कों के प्रत्येक संयोजन के लिए गुणा तालिका बनाकर अलग से बनाया गया है। फिर चार वर्गों को लंबवत और क्षैतिज रूप से एक साथ जोड़ दिया जाता है। यह इस तरह दिख रहा है:

,/⍪⌿⊖∘.(,⍴×)⍨⎕

⎕शीघ्र, जैसा कि ऊपर।
,⍴×<आर्गनों को मिलाएं ( ,और ⍴उनके उत्पाद से भरे आयत को आकार देने के लिए) का उपयोग करें ×।
∘.(... )⍨एक तालिका बनाएं जहां प्रत्येक सेल जो कुछ भी निर्दिष्ट किया गया है (... )
⊖लंबवत रूप से पलटें।
⍪⌿कोशिकाओं को लंबवत रूप से मिलाएं।
,/क्षैतिज रूप से कोशिकाओं को मिलाएं।

Comments

अच्छा! समान स्कोर के साथ जम्मू में समान विचार:(|.*/])@#~

— ज़र्ब

@Zgarb अपने उत्तर को अपडेट करें और मेरा जैसा फुटनोट डालें। जे इसके हकदार हैं!

— आदम

Answer 4

आर, 31 - 3 = 28

rev(b<-rep(a<-scan(),a))%*%t(b)

स्पष्टीकरण:

           a<-scan()            # take numeric input and store as vector a
    b<-rep(         ,a)         # repeat each numeric input by itself and store as vector b
rev(                   )        # the reverse of vector b
                        %*%     # matrix multiplication
                           t(b) # the transposed of vector b

यह भी दो से अधिक संख्या के लिए काम करता है। उदाहरण के लिए, (5,3,2) के लिए आउटपुट इस तरह दिखता है:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]   10   10   10   10   10    6    6    6    4     4
 [2,]   10   10   10   10   10    6    6    6    4     4
 [3,]   15   15   15   15   15    9    9    9    6     6
 [4,]   15   15   15   15   15    9    9    9    6     6
 [5,]   15   15   15   15   15    9    9    9    6     6
 [6,]   25   25   25   25   25   15   15   15   10    10
 [7,]   25   25   25   25   25   15   15   15   10    10
 [8,]   25   25   25   25   25   15   15   15   10    10
 [9,]   25   25   25   25   25   15   15   15   10    10
[10,]   25   25   25   25   25   15   15   15   10    10

Comments

आपको संभवतः इसका उत्तर देने के लिए catया writeइसे एक वैध उत्तर होने के लिए लपेटना होगा ।

— डेविड अर्मेनबर्ग

@DavidArenburg मैं क्यों नहीं देख रहा हूँ? यह कहता है "आउटपुट (किसी भी तरह से)"। यह मुझे केवल एक ही आउटपुट के लिए ले गया, ताकि मुझे आवश्यकताओं के भीतर रखा जाए।

— फ़्रीक्वेड्ड

हाँ शायद आप सही हैं। नहीं यकीन है कि वे क्या मतलब है।

— डेविड अरेनबर्ग

@DavidArenburg हाँ, यह ठीक है। यह एक डेटा / टेक्स्ट चैलेंज है, न कि इनपुट / आउटपुट चैलेंज।

— अदम

Answer 5

हास्केल, 153 125 बाइट्स - 3 = 122

(#)=replicate
d=length.show
y%x=unlines$(>>= \n->(1+d(x*x+y*y)-d n)#' '++show n)<$>x#(y#(x*y)++x#(x*x))++y#(y#(y*y)++x#(x*y))

कोड का आधा आउटपुट स्वरूपण के लिए है। यह मनमाने बड़े पूर्णांकों के लिए काम करता है। उदाहरण आउटपुट:

> putStrLn $ 4 % 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

> putStrLn $ 6 % 0
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36

कभी-कभी संख्याओं के बीच एक अतिरिक्त खाली स्थान के है, क्योंकि मैं कर रहा हूँ की गणना अंतरिक्ष के आधार पर जरूरत x*x+y*yके बजाय max (x*x) (y*y), जैसे

> putStrLn $ 2 % 3
  6  6  9  9  9
  6  6  9  9  9
  6  6  9  9  9
  4  4  6  6  6
  4  4  6  6  6

लेकिन यह सबसे अधिक व्हाट्सएप पर है।

Answer 6

गणितज्ञ 56-3 = 53

अद्यतन : मैंने एक दूसरी विधि जोड़ी, ठीक उसी कोड आकार की, जो एक नामित फ़ंक्शन का उपयोग करता है। यह एक रोजगार की Arrayबजाय एक Tableही तर्क का पालन करता है। (निचे देखो।)

विधि 1

यह उत्पादों की एक तालिका बनाता है, जिनमें से कारक पंक्ति, स्तंभ मानों पर निर्भर करते हैं। संख्याओं की जोड़ी को पूर्णांकों की सूची में दर्ज किया जाता है। अनाम कार्य जैसे कि निम्न, सबसे उपयोगी होते हैं यदि उन्हें किसी प्रोग्राम में केवल एक बार उपयोग किया जाए। अन्यथा यह नामांकित फ़ंक्शन का उपयोग करने के लिए अधिक समझ में आता है।

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&

प्रत्येक कारक एक if-then कथन है:

• If[r>#2,#,#2] का अर्थ है, "यदि पंक्ति संख्या दूसरे इनपुट से अधिक है, तो पहले इनपुट को कारक के रूप में उपयोग करें, अन्यथा दूसरे इनपुट का उपयोग करें।
• If[c>#,#2,#] का अर्थ है, "यदि कॉलम संख्या पहले इनपुट से अधिक है, तो कारक के रूप में दूसरे इनपुट का उपयोग करें, अन्यथा पहले इनपुट का उपयोग करें।

---

उदाहरण 1

 Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{5,3}

---

उदाहरण 2

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{0,3}

---

विधि 2 (साथ ही 56-3 = 53)

यह विधि 1 के समान काम करता है। लेकिन इसे कम कोड की आवश्यकता होती है। और एक तालिका में कोशिकाओं के विपरीत, कोशिकाएं पते योग्य हैं। यह विधि उपयोग करने के लिए बेहतर है यदि फ़ंक्शन एक से अधिक बार उपयोग किया जाएगा।

a_~f~b_:=Grid@Array[If[#>a,a,b]If[#2>a,b,a]&,{a+b,a+b}]

ऊपर के उदाहरण निम्नलिखित द्वारा निर्मित होते हैं:

पूर्व 1:

f[4,3]

पूर्व 2:

f[0,3]

Comments

यह सरल है। उस विधि से मैं अपने स्वयं के समाधान को 4 वर्णों से कम कर सकता हूं।

— अदम

धन्यवाद। मुझे बस एहसास हुआ कि एक ही दृष्टिकोण नामांकित फ़ंक्शन के साथ काम करता है। ऊपर विधि 2 देखें।

— डेविड

Answer 7

ऑक्टेव, 34 - 3 = 31

@(a)rot90(b=repelems(a,[1,2;a]))*b

उदाहरण:

octave:1> f = @(a)rot90(b=repelems(a,[1,2;a]))*b;
octave:2> f([4,3])
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

octave:3> f([0,3])
ans =

   9   9   9
   9   9   9
   9   9   9

Comments

वाह, मेरा कोई विचार नहीं repelemsथा। बहुत बढ़िया!

— बीकर

Answer 8

सीजाम, 27 बाइट्स - 3 = 24

q:L~_]ze~_ff{*sL,2*Se[}W%N*

CJam शैली सरणी के रूप में इनपुट लेता है। यह आवश्यक से थोड़ी अधिक रिक्ति का उपयोग करता है, लेकिन मुझे लगता है कि यह "कारण के भीतर" है, और यह हमेशा ठीक से संरेखित है।

इसका परीक्षण यहां करें।

व्याख्या

q:L    e# Read the input and store it in L.
~_     e# Evaluate the input, pushing [A B] onto the stack and duplicate it.
]z     e# Wrap both in an array and transpose it to get [[A A] [B B]].
e~     e# Run-length decode, getting A copies of A and B copies of B.
_ff{   e# Double map over each pair of entries in this new array...
  *s   e#   Multiply the two values.
  L,2* e#   Push twice the length of the input string.
  Se[  e#   Pad the result to this width with spaces (from the left).
}
W%     e# Reverse the resulting matrix to get the correct orientation.
N*     e# Join the rows with linefeed characters.

Comments

अच्छा है, लेकिन क्या कारण है कि बहुत अधिक सफेद-स्थान, और इसे कम करने के लिए क्या आवश्यक होगा?

— 21

@NBZ सबसे कम रास्ता मैंने पाया है कि सेल चौड़ाई पर एक विश्वसनीय ऊपरी सीमा की गणना इनपुट स्ट्रिंग की लंबाई का दोगुना उपयोग करने के लिए है (क्योंकि बड़ी संख्या वर्ग की संख्या के रूप में कई अंकों से दोगुना से अधिक नहीं होगा। अपने आप)। निश्चित रूप से मैं परिणामी संख्याओं के आधार पर आवश्यक वास्तविक राशि की गणना कर सकता हूं, लेकिन यह काफी लंबा होगा।

— मार्टिन एंडर

Answer 9

सी फ़ंक्शन (ग्लिबक का उपयोग करके), 122 बाइट्स - 3 = 119

2 छोरों के साथ अधिकतर सीधा कार्यान्वयन। मुझे उम्मीद है कि कुछ गोल्फिंग अवसर हैं जिन्हें मैंने यहां याद किया है:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

फ़ंक्शन के पहले दो मापदंडों में इनपुट पारित किए जाते हैं, अन्य दो डमी हैं। कॉलम सही-संरेखित हैं।

नोट glibc puts()हमेशा लगता है कि बाइट्स की संख्या वापस आ रही है जिसमें निहित ट्रेलिंग न्यूलाइन भी शामिल है, जो कि हमें यहाँ चाहिए। कोई गारंटी नहीं कि यह किसी अन्य परिवाद के साथ काम करेगा।

एक पूर्ण कार्यक्रम में:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

int main (int argc, char **argv) {
    if (argc == 3) {
        f(atoi(argv[1]),atoi(argv[2]));
    }
}

संकलन gcc sqrbin.c -o sqrbin(या make sqrbin)। चेतावनियों को सुरक्षित रूप से अनदेखा किया जा सकता है।

उदाहरण आउटपुट:

$ ./sqrbin 4 3
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
$ ./sqrbin 4 0
 16 16 16 16
 16 16 16 16
 16 16 16 16
 16 16 16 16
$ 

Comments

मेरे अनुभव के आधार पर, puts()मशीन का निर्भर मूल्य वापसी है। यह 10 उदाहरण के लिए खदान पर है। इसके अलावा, यहां एक टिप है: यदि आप सशर्त रूप से बाहरी लूप में काउंटर बढ़ाते हैं, तो आप आमतौर पर दो छोरों को एक में संपीड़ित कर सकते हैं। मेरा समाधान दर्शाता है कि यह कैसे किया जा सकता है।

— xsot

@xsot हां, puts()रिटर्न कोड केवल सफलता के लिए + ve होने की गारंटी है। हालांकि ग्लिबक के साथ मेरा परीक्षण यह दर्शाता है कि वापसी मूल्य लिखित बाइट्स की संख्या है। लूप समेकन के लिए - हाँ, मुझे उस तकनीक के बारे में पता है और कोशिश की है कि यहाँ, अभी तक इस मामले में कोई कमी नहीं है।

— डिजिटल ट्रॉमा

Answer 10

रूबी, (133 - 3) = 130 बाइट्स

s=1
a=ARGV.map{|e|s*=(e=e.to_i);[e]*e}.flatten
s=s.to_s.size
a.reverse.each{|i|a.each{|j|print (i*j).to_s.rjust(s).ljust(s+3)};puts}

4,3 के लिए

12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12

1,3 के लिए

3   9   9   9   
3   9   9   9   
3   9   9   9   
1   3   3   3

0,3 के लिए

9   9   9   
9   9   9   
9   9   9

Comments

PPCG में आपका स्वागत है! मुझे नहीं लगता कि आपकी गद्दी बड़ी संख्या के लिए पर्याप्त है। 1एक बड़ी संख्या की तरह होने पर विचार करें 9999। इस तरह से sबाहर आ जाएगा 4, तो आप की चौड़ाई के लिए padding रहे हैं, s+3 = 7लेकिन 9999^28 अंकों की जरूरत है। आप 2*sइसके बजाय उपयोग करना चाह सकते हैं ।

— मार्टिन एंडर

भले ही, यहां कुछ गोल्फ युक्तियाँ हैं: मैं नहीं देखता कि आपको करने से rjustपहले इसकी आवश्यकता क्यों है ljust। आप छोटा कर सकते हैं printकरने के लिए $><<(और यह बाद अंतरिक्ष से छुटकारा पाने के)। ARGVएक उपनाम है $*। आप flattenइस तरह से कुछ के साथ अपने सरणी के निर्माण से बचने में सक्षम हो सकता है : codegolf.stackexchange.com/a/19493/8478 । इसके अलावा, फ़ंक्शन-केवल उत्तर निश्चित रूप से यहां (यहां तक ​​कि अनाम कार्यों) के आसपास भी अनुमति दी जाती है, ताकि फ़ंक्शन इनपुट के रूप में पूर्णांक ले सके , और आपको कोई भी काम नहीं करना होगा .to_i।

— मार्टिन एंडर

@ मार्टिनबटनर, सुझावों के लिए धन्यवाद।

— हर्ष गुप्ता

Answer 11

पायथन 2, 176 बाइट्स - 3 = 173

def g(m,n):
 y,x,z,l,f='y','x','z','l','%'+str(len(str(max(m*m,n*n))))+'s'
 d={y:m*n,x:n*n,z:m*m,l:'\n'}
 for i in map(lambda x:d[x],(y*m+x*n+l)*n+(z*m+y*n+l)*m): print f % i,

यह एक चरित्र ग्रिड बनाने के लिए पायथन स्ट्रिंग फ़ंक्शन का उपयोग करता है, फिर पूर्णांक और प्रिंट स्वरूपित आउटपुट के साथ वर्णों को बदलता है।

Comments

दिलचस्प विधि।

— 11

Answer 12

मतलाब, 58 - 3 = 55

एक अनाम फ़ंक्शन का उपयोग करना:

@(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)

उदाहरण:

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(4,3)
ans =
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(0,3)
ans =
     9     9     9
     9     9     9
     9     9     9

(पुराना हल) ५ ९ - ३ = ५६

एक अनाम फ़ंक्शन का उपयोग करना:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]

Answer 13

सी, (125 - 3) बाइट्स

i,j,a;main(b,s){for(sscanf(gets(s),"%d %d",&a,&b);j<a+b;)printf(++i>a+b?i=!++j,"\n":"%*d",strlen(s)*2,(i<a?a:b)*(j<b?b:a));}

इनपुट को एक ही लाइन पर दो अंतरिक्ष-पृथक पूर्णांक के रूप में लिया जाता है। प्रत्येक सेल इनपुट स्ट्रिंग के दो बार लंबाई के लिए रिक्त स्थान के साथ गद्देदार है।

Comments

IM करने के लिए gcc (4.8.4) के साथ संकलन करने में परेशानी हो रही है ...

— उज्ज्वल

मैंने इसका परीक्षण golf.shinh.org/check.rb पर किया जो डेबियन पैकेज gcc-4.6.1-2 का उपयोग करता है। आपको कौन सी संकलन त्रुटियां मिल रही हैं?

— xsot

क्षमा करें, मैंने फिर से एक पंक्ति के रूप में कोशिश की और यह काम किया, ... लेकिन जब मैं भागता हूं तो मुझे एक segfault मिलता है। मैंने स्ट्रिंग 2 3 में प्रवेश किया और रिटर्न मारा और यह कहता है सेगमेंटेशन फॉल्ट (कोर डंप)

— डॉन उज्ज्वल

क्षमा करें, लेकिन मुझे नहीं पता कि यह आपके लिए काम क्यों नहीं करेगा। कम से कम आप अभी भी उस साइट पर कोड को आज़मा सकते हैं जिसे मैंने पहले जोड़ा था :)

— xsot

Answer 14

पायथ, 39 - 3 = 36

Pyth में बिल्ट-इन मैट्रिक्स फॉर्मेटिंग नहीं है, जो आकार को बहुत बढ़ाता है, क्योंकि आउटपुट नंबर्स को मैन्युअल रूप से पैड करना होता है। यहाँ मैं क्या लेकर आया हूँ।

JAQL*b]jdm.[`d\ l`eS^R2Jsm*d]*bdJj+yHyG

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

Answer 15

ब्लॉक , 51 बाइट्स 52 62 82 87 (गैर-प्रतिस्पर्धात्मक)

::`+`1|U;{`*`1}|A;`+`1,0+`1={`1^2}|;0+`,`1+`={`^2}|

Ungolfed:

::
  ` + `1                    | Expand;
  {` * `1}                  | SetAll;
  ` + `1, 0 + `1 = {`1 ^ 2} | Set;
  0 + `, `1 + `  = {` ^ 2}  | Set

कोशिश करो