बहुत ही सरल ग्रिड मार्क्स

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो तीन सकारात्मक पूर्णांक, डब्ल्यू, एच, और एन में लेता है। प्रिंट करें या एक डब्ल्यू × एच ग्रिड लौटाएं .जहां .सामान्य अंग्रेजी पढ़ने के क्रम में प्रत्येक एनएच को एक के साथ बदल दिया जाता है X।

उदाहरण के लिए, W = 7, H = 3, N = 3 को देखते हुए, ग्रिड 7 वर्ण चौड़ा और 3 ऊँचा है, और ऊपरी बाएँ से पढ़ने वाला प्रत्येक तीसरा वर्ण है X:

..X..X.
.X..X..
X..X..X

इसी प्रकार, यदि इनपुट W = 10, H = 4, N = 5 है, तो आउटपुट होगा:

....X....X
....X....X
....X....X
....X....X

टिप्पणियाँ

• "सामान्य अंग्रेजी पढ़ने का क्रम" का अर्थ है प्रत्येक पंक्ति पर दाईं ओर बाईं ओर, शीर्ष रेखा से नीचे तक।
• जब N 1 होगा तब सभी .'s X' बन जाएंगे ।
• आप और के स्थान पर किसी भी दो अलग मुद्रण योग्य ASCII वर्ण का उपयोग कर सकते हैं । .X
  • यदि आप स्थान ( ) का उपयोग करते हैं तो अनुगामी रिक्त स्थान की आवश्यकता नहीं होती है जब परिणाम नेत्रहीन समान होगा। (खाली लाइनें अभी भी आवश्यक हैं।)
  • आप ग्रिड को आकार देने वाले newlines के स्थान पर कुछ और का उपयोग नहीं कर सकते हैं।
• डब्ल्यू, एच और एन का सटीक इनपुट प्रारूप और आदेश सुपर महत्वपूर्ण नहीं है। चीजें जैसी हैं [H,W,N]या N\nW,Hठीक हैं।
• आउटपुट में एक अनुगामी न्यूलाइन ठीक है।
• बाइट्स में सबसे छोटा कोड जीतता है!

उदाहरण

W = 5, H = 3, N = 1
XXXXX
XXXXX
XXXXX

W = 5, H = 3, N = 2
.X.X.
X.X.X
.X.X.

W = 5, H = 3, N = 3
..X..
X..X.
.X..X

W = 5, H = 3, N = 4
...X.
..X..
.X...

W = 5, H = 3, N = 5
....X
....X
....X

W = 5, H = 3, N = 6
.....
X....
.X...

W = 5, H = 3, N = 7
.....
.X...
...X.

W = 5, H = 3, N = 15
.....
.....
....X

W = 5, H = 3, N = 16 (or more)
.....
.....
.....

W = 1, H = 1, N = 1
X

W = 1, H = 1, N = 2 (or more)
.

W = 8, H = 6, N = 2
.X.X.X.X
.X.X.X.X
.X.X.X.X
.X.X.X.X
.X.X.X.X
.X.X.X.X

W = 8, H = 6, N = 3
..X..X..
X..X..X.
.X..X..X
..X..X..
X..X..X.
.X..X..X

W = 8, H = 6, N = 4
...X...X
...X...X
...X...X
...X...X
...X...X
...X...X

W = 8, H = 6, N = 7
......X.
.....X..
....X...
...X....
..X.....
.X......

W = 8, H = 6, N = 16
........
.......X
........
.......X
........
.......X

W = 37, H = 1, N = 4
...X...X...X...X...X...X...X...X...X.

W = 1, H = 10, N = 8
.
.
.
.
.
.
.
X
.
.

Comments

क्या मैं यह मानने के लिए सही हूं कि प्रतिबंध " आप ग्रिड को आकार देने वाले नए अक्षरों के स्थान पर कुछ और उपयोग नहीं कर सकते हैं " में " आप ["..X..X.", ".X..X..", "X..X..X"]ग्रिड के रूप में एक सरणी नहीं लौटा सकते हैं " शामिल हैं ?

— पीटर टेलर

@PeterTaylor सही

— केल्विन के शौक

Answer 1

जे, ९ ५ बाइट्स

$":&1

रिक्त स्थान का उपयोग करता है और 1प्रपत्र में इनपुट की अपेक्षा करता हैH W f N

स्पष्टीकरण:

$":&1
   &1 bonds the fixed right argument 1 to ":
 ":   formats the right argument number (1) to take up left argument (N) number of cells
      padding with spaces, resulting  in "  1"
$     reshape to H-by-W with repeating the string if necessary 

उपयोग:

   3 7 ($":&1) 3
  1  1 
 1  1  
1  1  1

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

Comments

क्या यह भी सरणी को छोटा करता है यदि W * H, N से कम है?

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

@ मार्टिनबटनर हाँ।

— यादृच्छिक 13

यदि तर्क है ($":&1), कि 7 बाइट्स के रूप में गिनती नहीं होगी?

— रेटो कोराडी

नहीं, ()फ़ंक्शन का हिस्सा नहीं हैं; आप लिख सकते हैं f =. $":&1और फिर 3 7 f 3।

— लिन

Answer 2

पायथन 2, 60 बाइट्स

w,h,n=input()
s='%%%dd'%n%0*w*h
exec"print s[:w];s=s[w:];"*h

यह अंतरिक्ष और प्रिंट 0के स्थान पर .और X। इनपुट के रूप में टपल के रूप में लिया जाता है w,h,n।

Comments

यह एक चतुर स्ट्रिंग प्रारूप है।

— xnor

Answer 3

जे, 12 बाइट्स

$'X'_1}#&'.'

यह एक डाइएडिक फ़ंक्शन है जो सरणी H Wको इसके बाएं तर्क के Nरूप में और इसके सही तर्क के रूप में लेता है। उपयोग:

  f =: $'X'_1}#&'.'
  3 5 f 3
..X..
X..X.
.X..X

व्याख्या

$'X'_1}#&'.'
         '.'  The character '.'
       #&     repeated N times
    _1}       with the last character
 'X'          replaced by 'X'
$             reshaped into an HxW array

Comments

नौकरी के लिए सही उपकरण ?

— Addison Crump

क्या X.वास्तव में उपयोग कम है?

— lirtosiast

@ThomasKwa मेरा ऐसा मानना ​​है। मैंने इसके बजाय संख्या 0 और 1 का उपयोग करने की कोशिश की, लेकिन फिर मुझे _1कोष्ठक के साथ अगले को घेरना पड़ा , और स्तंभों के बीच रिक्त स्थान को प्रारूपित किया, और यह लंबे समय तक समाप्त हो गया।

— जर्बर्ग

Answer 4

बीबीसी बेसिक, 67 ASCII वर्ण, टोकन फ़ाइलें 43 बाइट्स

Http://www.bbcbasic.co.uk/bbcwin/download.html पर दुभाषिए को डाउनलोड करें

INPUTw,h,n:WIDTHw:PRINTLEFT$(STRING$(w*h,STRING$(n-1,".")+"X"),w*h)

बीबीसी बेसिक में फील्ड की चौड़ाई को सीमित करने के लिए एक आसान कमांड है। हम एक एक्स द्वारा पीछा की जाने वाली अवधि की प्रतियां STRING$बनाने के लिए उपयोग करते हैं। इसके बाद हम वर्णों के लिए इसे समाप्त करने के लिए बाएँ $ का उपयोग करते हैं ।w*hn-1w*h

Answer 5

मिंकोलंग 0.14 , 34 30 28 22 बाइट्स

n2-D1n$zn[z[1Rd6ZO]lO]

यहां एक मामले की जांच करें और यहां सभी परीक्षण मामलों की जांच करें। जैसे इनपुट की उम्मीद है N W H।

व्याख्या

n                 Take number from input (N)
 2-               Subtract 2
   D              Duplicate the top of stack (which is 0 because it's empty) N-2 times
    1             Push a 1 onto the stack
n                 Take number from input (W)
 $z               Store W in the register (z)
n                 Take number from input (H)
 [                Open a for loop that repeats H times
  z[              Open a for loop that repeats W times
    1R            Rotate 1 step to the right
      d           Duplicate top of stack
       6Z         Convert number to string
         O        Output as character
          ]       Close for loop
           lO     Output a newline
             ]    Close for loop

जैसा कि मिंकोलंग का कोडबॉक्स टॉरॉयडल है, यह शुरुआत में चारों ओर लपेटेगा। जैसा कि nअब हर कोई करेगा -1, यह अंततः एक त्रुटि के साथ क्रैश होता है और आगे कोई आउटपुट नहीं होता है, जिसकी अनुमति है।

Comments

इसलिए आपके लिए तुलना करना आसान है। (ध्यान दें कि यह बिल्कुल समान कोड नहीं है।)

— एल'एंडिया स्ट्रोमैन

आपसे आगे! : P :)

— एल'एंडिया स्ट्रोमैन

Answer 6

CJam (16 बाइट्स)

{1$*,:)@f%:!/N*}

आदेश में स्टैक पर इनपुट लेता है N W H, पात्रों का उपयोग करके स्ट्रिंग लौटाता है 0और 1। ऑनलाइन डेमो

विच्छेदन

{        e# Anonymous function. Stack: N W H
  1$*,   e# Stack: N W [0 1 ... W*H-1]
  :)     e# Stack: N W [1 2 ... W*H]
  @f%    e# Stack: W [1%N 2%N ... W*H%N]
  :!     e# Map Boolean not, taking 0 to 1 and anything else to 0
  /      e# Split into W-sized chunks (i.e. the lines of the grid)
  N*     e# Join the lines with newlines
}

Comments

; -; तुमने मुझे पराजित किया ;-; लेकिन अच्छी नौकरी! : D

— aoksquirrel

Answer 7

एपीएल, 13 बाइट्स

{⍪,/⍕¨⍺⍴⍵=⍳⍵}

यह H Wबाएं तर्क के रूप में लेता है औरN रूप में और सही तर्क के है।

स्पष्टीकरण:

{⍪,/⍕¨⍺⍴⍵=⍳⍵}     Dyadic function (args are ⍺ on left, ⍵ on right):
        ⍵=⍳⍵      ⍵ = (1 2 3...⍵); this is ⍵-1 0s followed by a 1
      ⍺⍴          Shape by the left argument; e.g. 5 3 gives a 5x3 array
    ⍕¨            Stringify each entry
  ,/              Join the strings in each row 
 ⍪                Make column vector of strings

इसे ऑनलाइन आज़माएं: पहले परीक्षण के मामले , अंतिम परीक्षण का मामला । ध्यान दें कि हालांकि यह बॉक्सिंग आउटपुट दिखाता है, Dyalog की मेरी कॉपी नहीं है।

Comments

क्या वे वास्तव में सिर्फ बॉक्स हैं, या एसई ऐप पात्रों को ठीक से प्रदर्शित नहीं कर रहा है?

— कार्वीजिनेट

@Carcigenicate वे बक्से नहीं हैं। पात्रों को ऑनलाइन लिंक पर ठीक प्रदर्शित करना चाहिए, क्योंकि इसमें एक अलग फ़ॉन्ट है।

— lirtosiast

आह, ठीक है। मैंने यह खो दिया। क्या आपके पास एक विशेष कीबोर्ड है या आप एक मसोकिस्ट हैं?

— कार्वीजेन्टिक

@Carcigenicate tryapl (और Dyalog छात्र संस्करण) पर आप backticks का उपयोग करके APL वर्ण टाइप कर सकते हैं। `उदाहरण के लिए` में बदल जाता है।

— lirtosiast

Answer 8

सीजाम, 20 बाइट्स

q~:Z;_@*,:){Z%!}%/N*

HW N के रूप में इनपुट लेता है।

Comments

— हूप्स

नियत: D: D: D: D

— aoksquirrel

अभी भी अन्य भाषाओं के कुछ समाधानों की तुलना में अधिक लंबा है, लेकिन मुझे यह सीजेएम के साथ 18 बाइट्स के लिए मिला है: q~_@*,@(S*'X+f=/N*इनपुट के साथ एनएच डब्ल्यू

— रेटो कोराडी

@RetoKoradi के 'Xसाथ एक और एक ले लो 0, और वह 17 होगा

— Sp3000

Answer 9

MATLAB, 61 55 54 बाइट्स

function c=g(d,n);b=ones(d);b(n:n:end)=0;c=[b'+45,''];

वाह, मैंने सोचा कि MATLAB इस एक में प्रतिस्पर्धी होगा, लेकिन मैं कितना गलत था!

फ़ंक्शन सही आयामों में से 1 की एक सरणी बनाता है, और फिर हर n तत्व को 0 पर सेट करता है (MATLAB संक्षेप में 2 डी में सूचकांकों के चारों ओर लपेटता है)। हम फिर इस संख्या में 45 ('-') जोड़ते हैं और एक चार सरणी में परिवर्तित हो जाते हैं।

प्रश्न किसी भी अलग दो ASCII वर्णों को ग्रिड के लिए उपयोग करने की अनुमति देता है, मैं कुछ बाइट्स को बचाने के लिए 'x' के स्थान पर '-' का उपयोग कर रहा हूं। इनपुट प्रारूप भी निश्चित नहीं है, इसलिए इसे आपूर्ति की जानी चाहिए[w h],n - अर्थात चौड़ाई और ऊंचाई की एक सरणी, और फिर दूसरे पैरामीटर के रूप में n।

---

यह ऑक्टेव के साथ भी काम करता है और यहां ऑनलाइन कोशिश की जा सकती है । फ़ंक्शन पहले से ही लिंक किए गए कार्यक्षेत्र में स्थापित है, इसलिए आप उदाहरण के लिए कॉल कर सकते हैं:

g([4,5],3)

कौन से आउटपुट:

..-.
.-..
-..-
..-.
.-..

Comments

एक बाइट बचाएं:c=[b'+45,''];

— स्टिव ग्रिफिन

@StewieGriffin धन्यवाद :)। किसी कारण के लिए जब मैंने कोशिश की कि मुझे नहीं लगा कि यह किसी भी बाइट को बचाया है, तो मुझे गर्भपात होना चाहिए!

— टॉम कारपेंटर

Answer 10

प्रसंस्करण, 93 बाइट्स (जावा, 104 बाइट्स)

void f(int a,int b,int c){for(int i=0;i<a*b;i++)print((i%c>c-2?"X":".")+(i%a>a-2?"\n":""));}}

मैंने जावा के बजाय प्रोसेसिंग का उपयोग किया है इसका कारण यह है कि आपको पॉइंटर को टिप करने की आवश्यकता नहीं है System.outक्योंकि एक स्थानीय चर सीधे पहुंच योग्य है। मैंने इसके साथ 11 बाइट अर्जित की। फ़ंक्शन परिणाम वापस नहीं करता है लेकिन इसे प्रिंट करता है।

Comments

आप इंक्रीमेंट (जैसे i++%a...) को आगे बढ़ाकर एक और बचत कर सकते हैं , और ऐसा लगता है कि आपने }अंत में एक स्पेयर छोड़ दिया है , जिसकी आपको आवश्यकता नहीं है।

— ज्योबिट्स

Answer 11

जाप , ३३ ३२ २ 27 25 बाइट्स

SpW-1 +Q p-~U*V/W f'.pU)·

प्रारूप में इनपुट लेता है W H N। के स्थान पर उपयोग करता है  और".X क्रमशः के और । इसे ऑनलाइन आज़माएं!

अपुष्ट और व्याख्या

SpW-1 +Q p-~U*V/W f'.pU)·qR
          // Implicit: U = width, V = height, W = interval
SpW-1 +Q  // Create a string of W - 1 spaces, plus a quotation mark.
p-~U*V/W  // Repeat this string ceil(U*V/W) times.
f'.pU)    // Split the resulting string into groups of U characters.
qR        // Join with newlines.
          // Implicit: output last expression

सुझावों का स्वागत है!

Answer 12

विटसी , २५ २३ २२ २१ १ ९ बाइट्स

@ Sp3000 को यह इंगित करने के लिए धन्यवाद कि मुझे एक डुप्लिकेट की आवश्यकता नहीं है और मुझे 2 बाइट्स बचाने हैं!

के रूप में इनपुट लेता है N W H। इसे ऑनलाइन आज़माएं!

1}\0XrV\[V\[{DN]aO]
1                         Push 1 to the stack.
 }                        Push the backmost to the front and subtract 2.
  \0X                     Duplicate the 0 temp variable times.
     r                    Reverse the stack.
      V                   Save as final global variable.
       \[         ]       Repeat top item times.
         V\[   ]          Repeat global variable times.
            {DO           Duplicate, output, then shift over an item.
                aO        Output a newline.

Answer 13

के, 21 19 18 14 बाइट्स

तर्क के रूप में लेता है (H W;N):

{".X"x#y=1+!y}

कार्रवाई में:

  f:{".X"x#y=1+!y};

  f.'((3 5;1);(3 5;2);(3 7;3);(4 10;5);(3 5;16))
(("XXXXX"
  "XXXXX"
  "XXXXX")
 (".X.X."
  "X.X.X"
  ".X.X.")
 ("..X..X."
  ".X..X.."
  "X..X..X")
 ("....X....X"
  "....X....X"
  "....X....X"
  "....X....X")
 ("....."
  "....."
  "....."))

Answer 14

पायथ - 19 18 17 बाइट्स

यह और अधिक गोल्फ की उम्मीद है। के रूप में इनपुट लेता है N\n[W, H]।

jc.[k+*dtvzN*FQhQ

टेस्ट सूट ।

Answer 15

आर, 66 बाइट्स

function(w,h,n){x=rep(".",a<-w*h);x[1:a%%n<1]="X";matrix(x,h,w,T)}

यह एक फ़ंक्शन है जो तीन पूर्णांक को स्वीकार करता है और चरित्र मानों का एक मैट्रिक्स लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

Ungolfed:

f <- function(w, h, n) {
    # Get the area of the square
    a <- w*h

    # Construct a vector of dots
    x <- rep(".", a)

    # Replace every nth entry with X
    x[1:a %% n == 0] <- "X"

    # Return a matrix constructed by row
    matrix(x, nrow = h, ncol = w, byrow = TRUE)
}

Answer 16

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

(w,h,n)=>eval('for(i=r=``;i++<w*h;i%w?0:r+=`\n`)r+=i%n?0:1')

व्याख्या

(w,h,n)=>eval('    // use eval to remove need for return keyword
  for(
    i=             // i = current grid index
      r=``;        // r = result
    i++<w*h;       // iterate for each index of the grid
    i%w?0:r+=`\n`  // if we are at the end of a line, print a newline character
                   // note: we need to escape the newline character inside the template
  )                //       string because this is already inside a string for the eval
    r+=i%n?0:1     // add a 0 for . or 1 for X to the result
                   // implicit: return r
')

परीक्षा

W = <input type="number" id="W" value="7" /><br />
H = <input type="number" id="H" value="3" /><br />
N = <input type="number" id="N" value="3" /><br />
<button onclick="result.innerHTML=(

(w,h,n)=>eval('for(i=r=``;i++<w*h;i%w?0:r+=`\n`)r+=i%n?0:1')

)(+W.value,+H.value,+N.value)">Go</button>
<pre id="result"></pre>

Answer 17

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

""<>(#<>"
"&/@ReplacePart["."~Table~{t=# #2},List/@Range[#3,t,#3]->"X"]~Partition~#)&

कई अन्य समाधानों के साथ, यह एक पंक्ति बनाता है, फिर इसे विभाजन करता है।

Answer 18

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

(w,h,n)=>(f=i=>i++<w*h?+!(i%n)+(i%w?"":`
`)+f(i):"")(0)

IIFE का उपयोग करता है fरिटर्न स्टेटमेंट को बचाने के का लूप में ।

W = 5, h = 3, n = 7 के लिए आउटपुट:

00000
01000
00010

Answer 19

सी #, 185 बाइट्स

using System;class x{void a(int w,int h,int n){int c=1;for(int i=0;i<h;i++){for(int j=1;j<=w;j++){if(c%n==0){Console.Write("x");}else{Console.Write(".");}c++;}Console.WriteLine();}}}

अधिक पठनीय पढ़ने के लिए:

using System;
class x
{
  void a(int w, int h, int n)
  {
    int c = 1;
    for (int i = 0; i < h; i++)
    {
        for (int j = 1; j <= w; j++)
        {
            if (c % n == 0)
            {
                Console.Write("x");
            }
            else
            {
                Console.Write(".");
            }
            c++;
        }
        Console.WriteLine();
     }
  }
}

उपयोग:

new x().a(7, 3, 3);

Answer 20

जूलिया, 50 बाइट्स

f(w,h,n)=reshape([i%n<1?"X":"." for i=1:w*h],w,h)'

यह एक फ़ंक्शन बनाता है fजो तीन पूर्णांक स्वीकार करता है और स्ट्रिंग्स के 2-आयामी सरणी देता है।

Ungolfed:

function f(w::Integer, h::Integer, n::Integer)
    # Construct an array of strings in reading order
    a = [i % n == 0 ? "X" : "." for i = 1:w*h]

    # Reshape this columnwise into a w×h array
    r = reshape(a, w, h)

    # Return the transpose
    return transpose(r)
end

Answer 21

रूबी, 67 56 बाइट्स

->w,h,n{(1..h).map{(1..w).map{o,$.=$.%n<1?1:0,$.+=1;o}}}

किसी सरणी को स्वीकार करने के बाद से उसे प्रिंट करना।

67 बाइट्स

->w,h,n{i=1;puts (1..h).map{(1..w).map{o,i=i%n<1?1:0,i+=1;o}.join}}

Ungolfed:

-> w, h, n {
  (1..h).map {
    (1..w).map {
      o, $. = $.%n < 1 ? 1 : 0, $.+ = 1
      o
    }
  }
}

उपयोग:

->w,h,n{(1..h).map{(1..w).map{o,$.=$.%n<1?1:0,$.+=1;o}}}[8,6,7]
=> [[0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0]]

Answer 22

MATLAB, 44 बाइट्स

नोट: टॉम कारपेंटर द्वारा उपयोग किए जाने वाले की तुलना में बहुत अलग दृष्टिकोण।

@(x,y)char(reshape(~mod(1:prod(x),y),x)'+46)

एक अनाम फ़ंक्शन को परिभाषित करता है जो इनपुट को स्वीकार करता है [W,H],N। मैंने इस समस्या का उपयोग न-मोडुलो- एन- एन का उपयोग करके किया सरणी 1: डब्ल्यू * एच के लिए और फिर समाधान को दो-आयामी सरणी में बदल दिया, जो तब एक चरित्र सरणी में बदल जाता है।

उदाहरण के लिए आउटपुट [5,3],7:

.....
./...
.../.

Answer 23

कॉमन लिस्प, SBCL, 94 बाइट्स

(lambda(a b c)(dotimes(i(* a b))(format t"~:[.~;X~]~@[~%~]"(=(mod(1+ i)c)0)(=(mod(1+ i)a)0))))

व्याख्या

~:[.~;X~] <-- takes argument - if argument is true write ., if false write X
~@[~%~] <-- takes argument - if argument is true write newline, if not treat argument as if it was not used

(=(mod(1+ i)c)0)(=(mod(1+ i)a)0) बहुत मूर्खतापूर्ण लग रहा है (क्योंकि यह बहुत अच्छा है, लेकिन मुझे नहीं पता कि इसे हल किया जा सकता है, बाइट्स की बचत

मैं का उपयोग (1+ i)करने के बजाय iक्योंकि dotimesसे शुरू होता है i=0और मैं से शुरू करना चाहते हैं 1। यह सहायक भी है क्योंकि मैं (* a b)इसके बजाय उपयोग कर सकता हूं(1+(* a b))

Answer 24

जावा, 185 183 बाइट्स

धन्यवाद थॉमस केवा, मुझे 2 बाइट्स बचाने के लिए!

interface B{static void main(String[] a){int w = Byte.parseByte(a[0]);for(int i=0;i++<w*Byte.parseByte(a[1]);)System.out.print((i%Byte.parseByte(a[2])>0?".":"X")+(i%w<1?"\n":""));}}

अनगोल्डेड (ईश):

interface A {
  static void main(String[] a) {
    int w = Byte.parseByte(a[0]);
    for(
      int i = 0;
      i++ < w*Byte.parseByte(a[1]);
    )
      System.out.print((
        i%Byte.parseByte(a[2]) > 0 ? "." : "X"
        )+(
        i%w < 1 ? "\n" : ""
      ));
  }
}

उपयोग:

$ java B 5 3 7
.....
.X...
...X.

शायद जावा एक दिन जीतेगी: पी

Comments

मुझे लगता है कि आप >0इसके बजाय उपयोग कर सकते हैं!=0 और के <1बजाय==0 ।

— lirtosiast