ग्रिड ASCII कला कोड गोल्फ

Question

चुनौती

आवश्यकताओं को पूरा करने वाला सबसे छोटा कार्यक्रम बनाएं

आवश्यकताएँ

1. कोड को 0s का 5x5 ग्रिड उत्पन्न करना चाहिए, जैसे:

   00000
   00000
   00000
   00000
   00000
   

2. कोड को एक इनपुट (कॉलम, पंक्ति, वर्ण) को स्वीकार करना होगा। ग्रिड को तदनुसार बदलना होगा:

   शुरू:

   00000
   00000
   00000
   00000
   00000
   

   इनपुट:

   (2,5,*)
   

   आउटपुट:

   0*000
   00000
   00000
   00000
   00000
   

   (नोट: नीचे-बाएँ कोने की स्थिति 1,1 है।)

3. यदि पंक्ति / स्तंभ इनपुट 1,2,3,4 या 5 नहीं है, तो प्रोग्राम को ग्रिड के अलावा एक त्रुटि संदेश वापस करना होगा। यह आपकी पसंद का कोई भी संदेश हो सकता है (जब तक कि यह ग्रिड नहीं है), तो 0यह है एक स्वीकार्य त्रुटि-आउटपुट।

4. कार्यक्रम को सभी मुद्रण योग्य ASCII वर्ण (एक यूएस कीबोर्ड) के साथ काम करना चाहिए।

विजेता

विजेता वह व्यक्ति होगा जिसके पास सबसे छोटा कोड होगा और सभी आवश्यकताओं को पूरा करेगा। यदि एक से अधिक उत्तर काम करता है और उसकी लंबाई (सबसे छोटी) है, तो पहले उत्तर देने वाला व्यक्ति विजेता होगा।

Comments

प्रोग्राम को एक त्रुटि संदेश वापस करना होगा । क्या त्रुटि संदेश? क्या कार्यक्रम 0त्रुटि के लिए और सफलता के लिए ग्रिड पर लौट सकता है ?

— रॉड

मैट्रिक्स पर उत्पत्ति कहां है? क्या इसे शून्य या एक अनुक्रमित करने की आवश्यकता है?

— जॉर्ज

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

— आउटगॉल्फ

उन्होंने कहा कि इस कार्यक्रम को यूएस कीबोर्ड पर सभी पात्रों के साथ काम करना चाहिए क्यों न केवल ASCII? मैं एक अमेरिकी कीबोर्ड के पात्रों को भी नहीं जानता, और यह चुनौती के लिए कुछ भी नहीं जोड़ता है

— लुइस मेंडो

@LuisMendo मुझे लगता है कि यूएस कीबोर्ड ASCII है, या कम से कम एक सबसेट है।

— कॉनर ओ'ब्रायन

Answer 1

डायलॉग एपीएल , 17 13 10 बाइट्स

एक संलग्न सरणी के लिए संकेत (पंक्ति, स्तंभ) और फिर एक वर्ण के लिए। दोषपूर्ण इनपुट पर INDEX ERROR देता है।

⊖⍞@⎕⊢5 5⍴0

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

⊖ के परिणाम उल्टा फ्लिप

⍞ inputted-चरित्र

@ सामग्री को स्थिति पर प्रतिस्थापित करना

⎕ मूल्यांकन-इनपुट (संलग्न पंक्ति, स्तंभ)

⊢ का

5 5⍴ 5 × 5 सरणी

0 शून्य

Comments

है ⊢आवश्यक? मुझे लगता है कि इस मामले में यह बेमानी है।

— कॉनर ओ'ब्रायन

@ ConorO'Brien @ ConorO'Brien अगर यह नहीं है, तो पार्सर (⊂⎕)5 5एक एकल 3-तत्व सरणी - तर्क के रूप में देखता है ⍴।

— आदम

यह 13 यूनिकोड वर्ण है, 13 बाइट्स नहीं है, है ना?

— विलेक्स

@wilx बाइट्स शब्द पर क्लिक करें !

— Adám

यह उत्तर विजेता है।

— डेव जोन्स

Answer 2

रूबी, 157 149 बाइट्स

g=(1..5).map{[0]*5}
loop{puts g.map(&:join).join ?\n
x=gets.match /\((.),(.),(.)\)/
a,b=x[1].hex,x[2].hex
1/0 if a<1||a>5||b<1||b>5
g[5-b][a-1]=x[3]}

विकृत इनपुट या बाध्य स्थिति से बाहर आने पर त्रुटि

बाइट्स को बचाने में मदद करने के लिए कॉनोर'ब्रायन (8 बाइट्स) और दूर (2 बाइट्स) के लिए धन्यवाद

Comments

loop do...end-> loop{...}; मुझे लगता है कि Array.new(5,[0]*5)काम करता है, भी, या भी [*[0]*5]*5।

— कॉनर ओ'ब्रायन

@ ConorO'Brien नहींं, Array.new(5,[0]*5)संदर्भ की एक सरणी [*[0]*5]*5बनाते हैं और एक सपाट सरणी बनाते हैं

— TuxCrafting

अरे हाँ। पहले ओमित करो *। फिर वह अभी भी एक संदर्भ बनाता है।

— कॉनर ओ'ब्रायन

Array.new(5){[0]*5}(1..5).map{[0]*5}2 बाइट बचाने के लिए के साथ प्रतिस्थापित किया जा सकता है ।

— 7

Answer 3

बैच, 199 बाइट्स

@echo off
if %1 gtr 0 if %1 lss 6 if %2 gtr 0 if %2 lss 6 goto g
if
:g
for /l %%j in (5,1,-1)do call:l %* %%j
exit/b
:l
set s=000000
if %2==%2 call set s=%%s:~0,%1%%%3%%s:~%1%%
echo %s:~1,5%

यदि स्थिति सीमा से बाहर है, तो त्रुटियां।

Comments

मुझे लगता है कि आप प्रतीकों का उपयोग कर सकते हैं <, जैसे ^<। निश्चित नहीं।

— कॉनर ओ'ब्रायन

Answer 4

PHP, 111 100 97 बाइट्स

$s=str_repeat("00000\n",5);$s[($x=($a=$argv)[1])+29-6*$y=$a[2]]=$a[3];echo$x&&$y&&$x<6&$y<6?$s:E;

प्रिंट Eयदि पंक्ति / स्तंभ सीमा से बाहर हो।
साथ दौड़ोphp -r <code> <row> <column> <character>

Answer 5

पायथन, 66 बाइट्स

lambda a,b,n,l='00000\n':6>b>0<a<6and(5-b)*l+l[:a-1]+n+l[a:]+~-b*l

Comments

यह एक = 4, b = 3 के लिए विफल नहीं है?

— टाइटस

@ टिट्स अब नहीं; डी

— रॉड

समाधान Python3 के लिए भी काम करता है

— जॉर्ज

Answer 6

दिल्लोग एपीएल, 24 20 18 बाइट्स

जार्जब को धन्यवाद, 4 बाइट्स बचाए! आदम को धन्यवाद दो बाइट्स बचाए!

a←5 5⍴0⋄a[⊂⎕]←⍞⋄⊖a

इनपुट के लिए संकेत स्पष्टीकरण के लिए नीचे देखें।

---

20 बाइट्स

{a←5 5⍴0⋄a[⊂⍺]←⍵⋄⊖a}

किसी फ़ंक्शन को असाइन करें और उसे कॉल करें y x f 'c'। उदाहरण के लिए:

      f←{a←5 5⍴0⋄a[⊂⍺]←⍵⋄⊖a}

      5 2 f '*'
0 * 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

      6 6 f '*'
INDEX ERROR                   
     ←{a←5 5⍴0 ⋄ a[⊂⍺]←⍵ ⋄ ⊖a}
               ∧              

      0 0 f '*'
INDEX ERROR                   
     ←{a←5 5⍴0 ⋄ a[⊂⍺]←⍵ ⋄ ⊖a}
               ∧   

व्याख्या

{a←5 5⍴0⋄a[⊂⍺]←⍵⋄⊖a}

{...}बाएँ तर्क ⍺और सही तर्क के साथ एक कार्य है ⍵। ⋄बयानों को अलग करता है, इसलिए तीन कथन हैं:

a←5 5⍴0⋄a[⊂⍺]←⍵⋄⊖a

पहले बयान a←5 5⍴0सेट aएक करने के लिए 5द्वारा 5की ग्रिड 0रों।

दूसरा कथन सदस्य को निर्देशांक से निर्धारित करता है जिसके द्वारा निर्धारित किया ⍺गया है⍵ (है कि, चरित्र)।

अंत में, हम प्रदर्शन ⊖करते हैं aऔर वापस लौटते हैं, aउलट के पहले वाले हिस्से को उपजते हैं।

Comments

{a←5 5⍴0⋄a[⊂⌽⍺]←⍵⋄⊖a}कुछ बाइट्स बचाता है।

— ज़र्गब

@Zgarb ओह, शानदार! मुझे नहीं पता था कि अनुक्रमण उस तरह काम करता है।

— कॉनर ओ'ब्रायन

आप दो बाइट्स को एक ट्रेडफ़न बॉडी में परिवर्तित करके बचा सकते हैं:a←5 5⍴0⋄a[⊂⎕]←⍞⋄⊖a

— Adám

@ Adám कैसे काम करता है? यह TryAPL पर काम नहीं करता है।

— कॉनर ओ'ब्रायन

@ ConorO'Brien राइट। TryAPL इनपुट के लिए संकेत देना प्रतिबंधित करता है, लेकिन आप पूर्ण संस्करण को मुफ्त में प्राप्त कर सकते हैं।

— एडम

Answer 7

जावास्क्रिप्ट (ईएस 6), 73 76 बाइट्स

TypeErrorयदि स्तंभ या पंक्ति सीमा से बाहर है, तो फेंकता है ।

(c,r,C,a=[...`00000
`.repeat(5)])=>(a[29+c-r*6]=C,c<1|r<1|c>5|r>5||a).join``

डेमो

let f =

(c,r,C,a=[...`00000
`.repeat(5)])=>(a[29+c-r*6]=C,c<1|r<1|c>5|r>5||a).join``

console.log(f(2,5,'*'));

Comments

मीठा है, लेकिन यह एक त्रुटि फेंक यदि या तो है cया r1 से कम है?

— ETHproductions

@ETHproductions यह केवल परीक्षण है c == 0 || r == 0। लेकिन मुझे लगता है कि आप सही हैं: मैं इसे नकारात्मक मूल्यों को रोकने के लिए अपडेट करूंगा।

— अरनुलद

Answer 8

सी #, 199 बाइट्स

पीट आर्डेन के जवाब के आधार पर

string g(int c, int r, char a){if(c<1|c>5|r<1|r>5)return "Index Error";var b="00000";var d=new[]{b,b,b,b,b};c--;d[r-1]=new string('0',c)+a+new string('0',4-c);return string.Join("\r\n",d.Reverse());}

Ungolfed:

public static string G(int c, int r, char a)
    {
        if (c < 1 || c > 5 || r < 1 || r > 5) return "Index Error"; // Check it's not out of range
        var b = "00000";
        var d = new [] { b, b, b, b, b };                           // Generate display box, and fill with the default character
        c--;                                                        // Convert the X to a 0 based index
        d[r - 1] = new string('0',c) + a + new string('0',4-c);     // Replace the array's entry in y coordinate with a new string containing the new character
        return string.Join("\r\n", d.Reverse());                    // Reverse the array (so it's the right way up), then convert to a single string
    }

Comments

साइट पर आपका स्वागत है! मैं C # में विशेषज्ञ नहीं हूं, लेकिन ऐसा लगता है कि कुछ व्हाट्सएप हैं जिन्हें आप हटा सकते हैं।

— DJMcMayhem

(क्षमा करें, शिष्टाचार शिष्टाचार को न जानें) Shorter G (): public static string G (int c, int r, char a) {return (0 <c && c <6 && 0 <r && r <6)? String ?Cccat (Enumerable.Range) (1,29)। चयन करें (i => i% 6> 0; i / 6 == 5-r && i% 6 == c; a: '0': '\ n')): "Index Error";};

— एरिक

Answer 9

05AB1E , 27 22 बाइट्स

पंक्ति / स्तंभ> 5 होने पर कोई ग्रिड नहीं देता है।

‚6‹Pi25L²<5*¹+Q5äR»1³‡

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

पुराना वर्जन

‚6‹Pi26G¾5²<*¹+NQi\³}})5äR»

Answer 10

जेली , 28 बाइट्स

यह रास्ता बहुत लंबा लगता है ...

Ṫ0ẋ24¤;ṙÑs5UY
’ḅ5
Ṗḟ5R¤
-ÑÇ?

TryItOnline!

कैसे?

Ṫ0ẋ24¤;ṙÑs5UY - Link 1, make grid: [row, column, character] e.g. [5,2,'*']
Ṫ             - tail: character                                  '*'
     ¤        - nilad followed by link(s) as a nilad  
 0            -     zero
  ẋ           -     repeated
   24         -     24 times                                     [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
      ;       - concatenate:                                     "000000000000000000000000*"
        Ñ     - call next link (2) as a monad                    21
       ṙ      - rotate left by                                   "000*000000000000000000000"
         s5   - split into chunks of length 5                    ["000*0","00000","00000","00000","00000"]
           U  - upend (reveres each)                             ["0*000","00000","00000","00000","00000"]
            Y - join with line feeds                              0*000
              - implicit print                                    00000
                                                                  00000
’ḅ5 - Link 2, position: [row, column]                             00000
’   - decrement                                                   00000
 ḅ5 - convert from base 5

Ṗḟ5R¤ - Link 3, input error checking: [row, column, character]
Ṗ     - pop: [row, column]
 ḟ    - filter out values in
  5R¤ - range(5): [1,2,3,4,5] - any values not in this remain giving a truthy result

-ÑÇ? - Main link: [row, column, character]
   ? - ternary if:
  Ç  -    last link (3) as a monad
-    -    -1 (if truthy - the error identification)
 Ñ   - next link (1) as a monad (if falsey - the grid)

Answer 11

जावास्क्रिप्ट (ईएस 6), 89 बाइट्स

f=(X,Y,Z,x=5,y=5)=>x+y>1?(x?X+x-6|Y-y?0:Z:`
`)+f(X,Y,Z,x?x-1:5,y-!x):X<1|X>5|Y<1|Y>5?e:""

क्योंकि मुझे पुनरावृत्ति पसंद है। ReferenceErrorअमान्य निर्देशांक पर फेंकता है ।

Answer 12

गणितज्ञ, 38 बाइट्स

(x=Table[0,5,5];x[[-#2,#]]=#3;Grid@x)&

Answer 13

ब्रेन-फ्लैक 415 बाइट्स

के लिए +3 शामिल है -c

([][()()()]){{}}{}({}<(({}<(({})<>)<>>)<>)<>([((((()()()){}){}){}){}]{}<([((((()()()){}){}){}){}]{})>)(()()()()()){({}[()]<(({})){{}(<({}[()])>)}{}({}<(({})){{}(<({}[()])>)}{}>)>)}{}({}{}){<>{{}}<>{}}<>>)<>(()()()()()){({}[()]<(((((((((()()()){}){}){}){})))))((()()()()()){})>)}{}{}<>({}<()((((((()()()){}){}()){}){}()[{}])({})({})({})({}){}{}[((((()()()){}){}){}){}()]){({}[()]<<>({}<>)>)}{}<>{}>)<>{({}<>)<>}<>

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

चरित्र को पहले सम्मिलित करता है, फिर पंक्ति फिर रिक्त स्थान के बिना स्तंभ।

इसमें से अधिकांश त्रुटि से निपटने के लिए है। ब्रेन-फ्लैक के पास यह जांचने का अच्छा तरीका नहीं है कि मान एक सीमा में हैं या नहीं। त्रुटियों के लिए, यह या तो कुछ भी नहीं आउटपुट करता है, या केवल उस चरित्र को सम्मिलित करता है जिसे डाला जाना था। वास्तविक समस्या को हल करने में केवल 211 बाइट्स लगते हैं:

<>(()()()()()){({}[()]<(((((((((()()()){}){}){}){})))))((()()()()()){})>)}{}{}<>({}<()((((((()()()){}){}()){}){}()[{}])({})({})({})({}){}{}[((((()()()){}){}){}){}()]){({}[()]<<>({}<>)>)}{}<>{}>)<>{({}<>)<>}<>

Answer 14

एक्सेल VBA, 67 बाइट्स

A1 के लिए आउटपुट : vba प्रोजेक्ट के एक्टीवेसिट पर E5 , के साथ बाहर निकलता है

रन-टाइम त्रुटि '1004':

अनुप्रयोग-परिभाषित या ऑब्जेक्ट-डिफ़ाइंड त्रुटि

जब एक अवैध इनपुट प्रदान किया जाता है।

कोड:

Sub a(c,r,x)
c=IIf(r<1Or c>5,-1,c)
[A1:E5]=0
Cells(6-r,c)=x
End Sub

उपयोग:

a 4,5,"#"

आउटपुट (ऊपर उदाहरण से) :

    A   B   C   D   E
1   0   0   0   #   0
2   0   0   0   0   0
3   0   0   0   0   0
4   0   0   0   0   0
5   0   0   0   0   0

Answer 15

सी #, 208 बाइट्स

golfed:

string G(int c,int r,char a){if(c<1||c>5||r<1||r>5)return"Index Error";var b="00000";var d=new string[]{b,b,b,b,b};d[r-1]=d[r-1].Substring(0,c-1)+a+d[r-1].Substring(c);return string.Join("\r\n",d.Reverse());}

Ungolfed:

public string G(int c, int r, char a)
{
  if (c < 1 || c > 5 || r < 1 || r > 5) return "Index Error";
  var b = "00000";
  var d = new string[] { b, b, b, b, b };
  d[r - 1] = d[r - 1].Substring(0, c - 1) + a + d[r - 1].Substring(c);
  return string.Join("\r\n", d.Reverse());
}

परिक्षण:

Console.Write(G(6, 6, '*')); //Index Error

Console.Write(G(1, 4, '#'));

00000
#0000
00000
00000
00000

Console.Write(G(5, 5, '@'));

0000@
00000
00000
00000
00000

Console.Write(G(1, 1, '}'));

00000
00000
00000
00000
}0000

Comments

यदि cऔर / या rसीमा से बाहर हैं, IndexOutOfRangeExceptionतो यह फेंक देगा ताकि आप पहले बयान को हटाने में सक्षम हो सकें, हालांकि मैंने उसके लिए चश्मा ठीक से जांच नहीं किया है। आप Func<int, int, char, string>बाइट्स बचाने के लिए संकलन कर सकते हैं , मेरा मानना ​​है कि आपको कॉल के using System.Linq;कारण जोड़ने की आवश्यकता है , Reverseहालांकि मैं अपने सिर के ऊपर से याद नहीं रख सकता

— TheLethalCoder

4 बाइट्स बचाने के d[r - 1] = d[r - 1].Substring(0, c - 1) + a + d[r - 1].Substring(c);लिए बदलेंd[--r] = d[r].Substring(0, c - 1) + a + d[r].Substring(c);

— TheLethalCoder

Answer 16

WinDbg, 95 बाइट्स

j(0<(@$t0|@$t1))&(6>@$t0)&(6>@$t1)'f8<<16 L19 30;eb2000018+@$t0-@$t1*5 @$t2;da/c5 8<<16 L19';?0

लगभग आधे यह सिर्फ पुष्टि करने अनुक्रमित श्रेणी में हैं की ... इनपुट छद्म-रजिस्टरों की स्थापना द्वारा किया जाता है $t0, $t1और $t2(जहां $t2की जगह चार की ascii मूल्य रखती है)। उदाहरण के लिए, उदाहरण की (2,5,*)तरह होगा:

0:000> r$t0=2
0:000> r$t1=5
0:000> r$t2=2a

0त्रुटि पर प्रिंट ।

यह काम किस प्रकार करता है:

j (0<(@$t0|@$t1)) & (6>@$t0) & (6>@$t1)  * If $t0 and $t1 are both positive and less than 6
'
    f 8<<16 L19 30;                      * Put 19 (0n25) '0's (ascii 30) at 2000000 (8<<16)
    eb 2000018+@$t0-@$t1*5 @$t2;         * Replace the specified cell with the new char
    da /c5 8<<16 L19                     * Print 19 (0n25) chars in rows of length 5
';
    ?0                                   * ...Else print 0

नमूना आउटपुट:

0:000> r$t0=2
0:000> r$t1=5
0:000> r$t2=2a
0:000> j(0<(@$t0|@$t1))&(6>@$t0)&(6>@$t1)'f8<<16 L19 30;eb2000018+@$t0-@$t1*5 @$t2;da/c5 8<<16 L19';?0
Filled 0x19 bytes
02000000  "0*000"
02000005  "00000"
0200000a  "00000"
0200000f  "00000"
02000014  "00000"


0:000> r$t0=-2
0:000> j(0<(@$t0|@$t1))&(6>@$t0)&(6>@$t1)'f8<<16 L19 30;eb2000018+@$t0-@$t1*5 @$t2;da/c5 8<<16 L19';?0
Evaluate expression: 0 = 00000000


0:000> r$t0=4
0:000> r$t1=2
0:000> r$t2=23
0:000> j(0<(@$t0|@$t1))&(6>@$t0)&(6>@$t1)'f8<<16 L19 30;eb2000018+@$t0-@$t1*5 @$t2;da/c5 8<<16 L19';?0
Filled 0x19 bytes
02000000  "00000"
02000005  "00000"
0200000a  "00000"
0200000f  "000#0"
02000014  "00000"


0:000> r$t1=f
0:000> j(0<(@$t0|@$t1))&(6>@$t0)&(6>@$t1)'f8<<16 L19 30;eb2000018+@$t0-@$t1*5 @$t2;da/c5 8<<16 L19';?0
Evaluate expression: 0 = 00000000

Answer 17

हास्केल, 77 बाइट्स

r=[1..5]
(x#y)c|x>0,x<6,y>0,y<6=unlines[[last$'0':[c|i==x,j==6-y]|i<-r]|j<-r]

उपयोग उदाहरण:

*Main> putStr $ (2#5) '*'
0*000
00000
00000
00000
00000

तो xऔर yके माध्यम से सीमा, बाहरी और भीतरी पाश के भीतर हैं [1..5]और चार लेने cदिया दबाता है xऔर yऔर एक 0अन्यथा। अगर xया yसीमा में नहीं है, तो एक Non-exhaustive patternsअपवाद उठाया जाता है।

Answer 18

ऑक्टेव 49 बाइट्स

@(c,r,s)char(accumarray([6-r c],s+0,[5 5],[],48))

Answer 19

QBIC , 53 50 बाइट्स

संपादित करें: अब जब मुझे पता है कि मुझे शुरुआती ग्रिड नहीं दिखाना है, तो मैंने _!_!_?कमांड लाइन मापदंडों के लिए उपयोगकर्ता इनपुट को स्वैप कर दिया है ::;, जिससे 3 बाइट्स बच रहे हैं।

[5|?@00000|]::;~(b>5)+(c>5)>1|_Xd\$LOCATE 6-c,b|?B

मूल संस्करण: यह 0-ग्रिड को प्रिंट करने और 0-ग्रिड को दिखाने के लिए निर्देशांक के निर्देशांक लेने के बीच रुकता है।

[5|?@00000|]_!_!_?~(b>5)+(c>5)>1|_Xd\$LOCATE 6-c,b|?B

5 के 5 स्ट्रिंग्स के प्रिंट्स 0, 2 संख्यात्मक इनपुट और 1 स्ट्रिंग इनपुट के लिए उपयोगकर्ता से पूछता है कि क्या नंबर 5 हैं और LOCATEसही चरित्र को बदलने के लिए QBasic के फ़ंक्शन का उपयोग करता है ।

Answer 20

जावा, 99 बाइट्स

(i,j,k)->{int[]b=new int[]{60,60,60,60,60};int[][]a=new int[][]{b,b,b,b,b};a[i-1][5-j]=k;return a;}

Answer 21

> <> (मछली), 36 बाइट्स (गैर-प्रतिस्पर्धात्मक)

1-$p;
00000
00000
00000
00000
00000

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

यह [की तरह ढेर पर मापदंडों रखकर चलाया जाता है chr, y, x]। तल पर एक शून्य वास्तव chrमें अनुदेश द्वारा बदल दिया गया है p। ऐसा करने के लिए शायद बेहतर तरीके हैं, लेकिन मुझे लगा कि यह एक अनोखी और मनोरंजक स्थिति है जहां यह> <> सुविधा उपयोगी है।

व्याख्या

यह कार्यक्रम केवल 1 से घटाता है x(जैसा कि> <>, 0वास्तव में पहला स्तंभ होगा), के xसाथ स्वैप y, फिर कोडबॉक्स बिंदु x, yको इसके chrमाध्यम से बदल देता हैp । y1 से घटाए जाने की आवश्यकता नहीं है, क्योंकि कोड पहले से ही 1 से ऑफसेट है!

गैर-प्रतिस्पर्धी स्पष्टीकरण

यह गैर-प्रतिस्पर्धात्मक है क्योंकि यह वास्तव में उत्पादन नहीं करता है। मुझे बस यह बेहद मनोरंजक लगा। यदि इसे वैध आउटपुट माना जाता है, तो कृपया मुझे बताएं!

यह गैर-प्रतिस्पर्धी भी है क्योंकि y0 हो सकते हैं, लेकिन मेरा मानना ​​है कि उत्तर के साथ एकमात्र मुद्दा है। अगर यह वैध आउटपुट माना जाता है तो मैं इसे ठीक कर दूंगा, लेकिन अन्यथा, यह जवाब को कम मनोरंजक बनाता है ...

Comments

यदि इस तरह के उत्तर हतोत्साहित होते हैं, तो कृपया मुझे बताएं और मैं इसे हटा दूंगा!

— redstarcoder

Answer 22

बैश, 59 बाइट्स

golfed

printf '00000%0.s\n' {1..5}|sed "$1 s/./$3/$2"|grep -z "$3"

$ 1 , $ 2 - पंक्ति, स्तंभ, $ 3 - प्रतिस्थापन चार्ट, त्रुटि निकास कोड के माध्यम से बताई गई है

परीक्षा

>./box 2 2 "*"
00000
0*000
00000
00000
00000
>echo $?
0

>./box 6 2 '*'     
>echo $?
1

Answer 23

विम, 60 47 42 76 कीस्ट्रोक्स

इनपुट प्रारूप में है (पहली पंक्ति पर):

25*

शुरुआत में कर्सर के साथ

"ax"bxx:if<C-r>a<1||<C-r>a>5||<C-r>b<1||<C-r>b>5
^
endif
6i0<ESC>Y5pG:norm <C-r>al<C-r>bkr<C-r>-
Hqqxjq5@qdd

यदि इनपुट अमान्य है, तो फेंकता है: E492: Not an editor command: ^

आउटपुट का 42निर्माण करने वाला पक्ष केवल बाइट्स है, लेकिन एक त्रुटि बनाने के लिए, मेरे बायटेकाउंट में अत्यधिक वृद्धि हुई है।

Comments

BTW मुझे पता नहीं है कि

— क्रिति लिथोस

Answer 24

जावा 8, 194 192 बाइट्स

interface M{static void main(String[]a){String r="";int i=0,j,z=new Byte(a[0]),y=new Byte(a[1]);for(;++i<6;r+="\n")for(j=0;++j<6;r+=6-i==y&j==z?a[2]:0);System.out.print(z>0&z<7&y>0&y<7?r:0);}}

इसे सही इनपुट के साथ यहाँ आज़माएँ।
इसे गलत इनपुट के साथ यहाँ आज़माएँ।

यह पूर्ण कार्यक्रम के बजाय फ़ंक्शन के बजाय 116 114 बाइट होगा :

(a,b,c)->{String r="";for(int i=0,j;++i<6;r+="\n")for(j=0;++j<6;r+=b==6-i&a==j?c:0);return a>0&a<7&b>0&b<7?r:"0";}

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

interface M{                  // Class
  static void main(String[]a){//  Mandatory main-method
    String r="";              //   Result-String, starting empty
    int i=0,j,                //   Index-integers
        z=new Byte(a[0]),     //   First input converted to integer
        y=new Byte(a[1]);     //   Second input converted to integer
    for(;++i<6;               //   Loop (1) from 1 to 6 (inclusive)
        r+="\n")              //     After every iteration: Append a new-line to the result
      for(j=0;++j<6;          //    Inner loop (2) from 1 to 6 (inclusive)
        r+=6-i==y             //     If the second input equals `6-1`,
           &j==z?             //     and the first input equals `j`:
            a[2]              //      Append the third input to the result-String
           :                  //     Else:
            0                 //      Append a zero to the result-String
      );                      //    End of inner loop (2)
                              //   End of inner loop (1) (implicit / single-line body)
    System.out.print(         //   Print:
     z>0&z<7&y>0&y<7?         //    If the coordinates are valid (1-6):
      r                       //     Print the result `r`
     :                        //    Else:
      0);                     //     Print 0 as error instead
  }                           //  End of main-method
}                             // End of class