26

इनपुट के रूप में एक सकारात्मक पूर्णांक n लें , और 1 और 0 से मिलकर एक n-by-n चेकबोर्ड मैट्रिक्स आउटपुट करें ।

शीर्ष बाएं अंक हमेशा 1 होना चाहिए ।

परीक्षण के मामलों:

इनपुट और आउटपुट प्रारूप वैकल्पिक हैं। मैट्रिक्स को सूची की सूची के रूप में आउटपुट करना स्वीकार किया जाता है।

code-golf number matrix

— स्टीवी ग्रिफिन
स्रोत

क्या तार की एक सूची ठीक है?

— xnor

हां वह ठीक है।

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

1

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

52 सेकंड!

+€ḶḂ

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

— लीक नन
स्रोत

7

"52 सेकंड!" जैसे मुझे इसकी आदत नहीं है ...

— द एग्ज द आउटगॉल्फ

5

क्या आपके पास एक बीपर की तरह है, आप नई पीपीसीजी चुनौतियों के लिए 24/7 पहनते हैं?

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

@carusocomputing जिनके पास तेज़ इंटरनेट कनेक्शन है वे आमतौर पर भाग्यशाली हैं जो जीतेंगे।

— आउटगॉल्फ

9

MATL , 5 बाइट्स

:otYT

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

4उदाहरण के रूप में इनपुट पर विचार करें ।

:    % Implicit input, n. Push range [1 2 ... n]
     %   STACK: [1 2 3 4]
o    % Parity, element-wise
     %   STACK: [1 0 1 0]
t    % Duplicate
     %   STACK: [1 0 1 0], [1 0 1 0]
YT   % Toeplitz matrix with two inputs. Implicit display
     %   STACK: [1 0 1 0;
     %           0 1 0 1;
     %           1 0 1 0;
     5           0 1 0 1]

— लुइस मेंडो
स्रोत

7

जाप , 6 बाइट्स

ÆÇ+X v

इसे ऑनलाइन टेस्ट करें! ( -Qआसान दृश्य के लिए ध्वज का उपयोग करता है )

व्याख्या

 Æ   Ç   +X v
UoX{UoZ{Z+X v}}  // Ungolfed
                 // Implicit: U = input number
UoX{          }  // Create the range [0...U), and map each item X to
    UoZ{     }   //   create the range [0...U), and map each item Z to
        Z+X      //     Z + X
            v    //     is divisible by 2.
                 // Implicit: output result of last expression

टिप्पणी करने के लिए एक दिलचस्प बात यह है कि vहै नहीं एक "2 से विभाज्य" में निर्मित। इसके बजाय, यह "X द्वारा निर्मित" विभाज्य है। हालांकि, अधिकांश गोल्फिंग भाषाओं के विपरीत, जाप के कार्यों में निश्चितता नहीं है (वे किसी भी संख्या में सही-तर्क स्वीकार कर सकते हैं)। जब 0 सही-तर्क दिए जाते हैं, तो vमान लिया जाता है कि आप चाहते थे 2, और इसलिए बिल्कुल वैसा ही काम करता है जैसा कि 2कुछ नहीं के बजाय दिया गया था ।

— ETHproductions
स्रोत

7

वी , 16 , 15 बाइट्स

Ài10ÀñÙxñÎÀlD

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

Hexdump:

00000000: c069 3130 1bc0 adf1 d978 f1ce c06c 44    .i10.....x...lD

— DJMcMayhem
स्रोत

7

हास्केल , 50 41 39 38 बाइट्स

कुल 9 10 बाइट को शेव करने में मदद करने के लिए nimi और xnor को धन्यवाद

f n=r[r"10",r"01"]where r=take n.cycle

वैकल्पिक रूप से, एक बाइट के लिए और अधिक:

(!)=(.cycle).take
f n=n![n!"10",n!"01"]

या:

r=flip take.cycle
f n=r[r"10"n,r"01"n]n

संभवत: उप-रूपी, लेकिन एक साफ, सरल दृष्टिकोण।

— जूलियन वुल्फ
स्रोत

concat.repeatहै cycle: n!l=take n$cycle l। यदि आप पॉइंटफ्री जाते हैं तो यह एक और बाइट बचाता है (!)=(.cycle).take:।

— नीमी

लवली! मुझे पता था कि उसके लिए एक बेसिन था, लेकिन मेरे जीवन के नाम को याद नहीं कर सकता था

— जूलियन वुल्फ

मैं f n|r<-take n.cycle=r[r"10",r"01"]या इसी तरह का सुझाव देने जा रहा था । लेकिन हास्केल के लिए गलत प्रकार का अनुमान लगता है r? यह स्पष्ट टाइपिंग के साथ काम करता है f n|r<-take n.cycle::[a]->[a]=r[r"10",r"01"]।

— xnor

1

@ जूलियनवॉल्फ हास्केल को बहुरूपता के प्रकारों का सामना

— xnor

1

@zbw मुझे लगा कि यह मामला था लेकिन उपयोग NoMonomorphismRestrictionकरने से मदद नहीं मिली। और न ही किया था Rank2Typesया RankNTypes। क्या आप जानते हैं कि वहाँ क्या चल रहा है?

— xnor

5

APL (Dyalog) , 8 बाइट्स

~2|⍳∘.+⍳

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

व्याख्या

चलो तर्क कहते हैं n।

⍳∘.+⍳

यह एक मैट्रिक्स बनाता है

1+1 1+2 1+2 .. 1+n
2+1 2+2 2+3 .. 2+n
...
n+1 n+2 n+3 .. n+n

फिर 2|मैट्रिक्स के 2 modulo लेता है (यह सदिश करता है) जिसके बाद ~परिणाम का नहीं लेता है।

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

4

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

1-Plus~Array~{#,#}~Mod~2&

— मार्टिन एंडर
स्रोत

4

जावास्क्रिप्ट ईएस 6, 55 54 51 46 बाइट्स

@Neil को 1 बाइट धन्यवाद दिया

सहेजे गए 2 बाइट @Arnauld की बदौलत

n=>[...Array(n)].map((_,i,a)=>a.map(_=>++i&1))

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

यह सरणी के एक सरणी के रूप में आउटपुट करता है। जावास्क्रिप्ट पर्वतमाला बहुत अस्पष्ट हैं, लेकिन मैं उपयोग [...Array(n)]करता हूं जो आकार की एक सरणी उत्पन्न करता हैn

— Downgoat
स्रोत

यह अभी भी सूचकांक मापदंडों का उपयोग करने के लिए एक बाइट कम है:n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2))

— नील

@ नील हुह, मैंने मानचित्र में तीसरे पैरामीटर का उपयोग करने के लिए कभी नहीं सोचा था, धन्यवाद!

— डाउनगेट

@ अरनौल धन्यवाद! जिसने मुझे 5 और बाइट्स बचाने के लिए प्रेरित किया!

— डाउनगेट

4

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

.+
$*
1
$_¶
11
10
T`10`01`¶.+¶

इसे ऑनलाइन आज़माएं! व्याख्या: पहला चरण इनपुट को 1एस (सुविधापूर्वक!) का उपयोग करके परिवर्तित करता है जबकि दूसरा चरण मान को एक वर्ग में बदलता है। तीसरा चरण प्रत्येक पंक्ति पर वैकल्पिक बिट्स को निष्क्रिय करता है जबकि अंतिम चरण वैकल्पिक पंक्तियों पर बिट्स को निष्क्रिय करता है। संपादित करें: @MartinEnder के लिए 3 बाइट्स सहेजे गए।

— नील
स्रोत

$`1$'बस है $_।

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

@MartinEnder आह, मैं अपरिचित हूँ $_, धन्यवाद!

— नील

3

MATL , 7 बाइट्स

:t!+2\~

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

स्पष्टीकरण:

         % Implicit input (n)
:        % Range from 1-n, [1,2,3]
 t       % Duplicate, [1,2,3], [1,2,3]
  !      % Transpose, [1,2,3], [1;2;3]
   +     % Add        [2,3,4; 3,4,5; 4,5,6]
    2    % Push 2     [2,3,4; 3,4,5; 4,5,6], 2
     \   % Modulus    [0,1,0; 1,0,1; 0,1,0]
      ~  % Negate     [1,0,1; 0,1,0; 1,0,1]

_{नोट: मैंने चुनौती पोस्ट करने के बाद MATL में इसे हल करना शुरू कर दिया ।}

— स्टीवी ग्रिफिन
स्रोत

समतुल्य, और छोटा::&+o~

— लुइस मेंडो

1

अभी भी सीख रहा हूं :-) मैं कल अपडेट करूंगा। मुझे आपका अन्य दृष्टिकोण भी बहुत पसंद आया :-)

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

1

यह वही है जो मैं भी आया था। और हे, आप केवल शुद्ध MATL निर्देश सेट का उपयोग करते हैं , न कि उन pesky Y-modified निर्देश @LuisMendo का उपयोग करता है।

— सांचेस

@ सेंचुरी पेस्की, हुह ? :-P

— लुइस मेंडो

3

ब्रेकीलॉग , 15 बाइट्स

^₂⟦₁%₂ᵐ;?ḍ₎pᵐ.\

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

व्याख्या

Example Input: 4

^₂               Square:                            16
  ⟦₁             1-indexed Range:                   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
    %₂ᵐ          Map Mod 2:                         [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]
       ;?ḍ₎      Input-Chotomize:                   [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]
           pᵐ.   Map permute such that..
             .\  ..the output is its own transpose: [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]

— Fatalize
स्रोत

3

क्लोजर, 36 बाइट्स

#(take %(partition % 1(cycle[1 0])))

हाँ, नौकरी के लिए सही उपकरण।

— NikoNyrh
स्रोत

3

05AB1E , 9 7 बाइट्स

-2 बाइट्स एमिग्ना के लिए धन्यवाद

LDÈD_‚è

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

व्याख्या

LDÈD_‚sè» Argument n
LD        Push list [1 .. n], duplicate
  ÈD      Map is_uneven, duplicate
    _     Negate boolean (0 -> 1, 1 -> 0)
     ‚    List of top two elements of stack
      è   For each i in [1 .. n], get element at i in above created list
          In 05AB1E the element at index 2 in [0, 1] is 0 again

— kalsowerus
स्रोत

आप »सूची के रूप में सूची उत्पादन में कटौती कर सकते हैं ठीक है और आप भी निकाल सकते हैं s।

— इमीना

@Eigna हां, धन्यवाद!

— कलसोवरस

स्पष्टीकरण थोड़ा अप्रासंगिक है।

— १g पर आउटगॉल्फर एरिक

3

जावा (ओपनजेडके 8) , 80 77 बाइट्स

-3 बाइट्स केविन क्रूज़सेन को धन्यवाद

j->{String s="1";for(int i=1;i<j*j;s+=i++/j+i%j&1)s+=1>i%j?"\n":"";return s;}

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

अरे देखो, बहुत सारे मज़ेदार ऑपरेटरों के साथ एक अर्ध-उचित लंबाई वाला जावा उत्तर।

लैम्ब्डा जो एक इंट लेता है और एक स्ट्रिंग लौटाता है। पंक्ति संख्या और स्तंभ संख्या का उपयोग करके काम करता है / और% यह निर्धारित करने के लिए कि कौन सा मूल्य होना चाहिए, मॉड 2;

Ungolfed:

j->{
    String s="1";
    for(int i=1; i<j*j; s+= i++/j + i%j&1 )
        s+= 1>i%j ? "\n" : "";
    return s;
}

— PunPun1000
स्रोत

आप एक बाइट को बचाने के लिए जगह निकाल सकते हैं। चुनौती बताती है कि आउटपुट स्वरूप लचीला है। ओह, और आप बदल कर दो और बाइट्स बचा सकते हैं (i++/j+i%j)%2करने के लिए i++/j+i%j&1ताकि आप उन कोष्ठक जरूरत नहीं होगी। जो कुल 1 बाइट को मेरे नेस्टेड लूप सॉल्यूशन ( n->{String r="";for(int i=0,j;i++<n;r+="\n")for(j=0;j<n;r+=j+++i&1);return r;}) से कम बनाते हैं , इसलिए मुझसे +1 करते हैं। :)

— केविन क्रूज़सेन

@KevinCruijssen हाँ, मैं अभी भी अंतरिक्ष पर एक प्रतिक्रिया पर इंतजार कर रहा था। मैंने% और 1 ==% 2 की तुलना में उच्चतर वरीयता के बारे में नहीं सोचा था

— PunPun1000

2

चारकोल, 8 बाइट्स

ＵＯＮ10¶01

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: यह मोटे तौर पर निम्नलिखित क्रिया कोड में अनुवाद करता है (दुर्भाग्य से वर्तमान में डिवर्बोसिफ़ायर एक अनावश्यक विभाजक को जोड़ रहा है):

Oblong(InputNumber(), "10\n01");

— नील
स्रोत

2

अजगर , 9 बाइट्स

VQm%+hdN2

इसे इस्तेमाल करे!

एक और 9 बाइट समाधान:

mm%+hdk2Q

कोशिश करो!

— KarlKastor
स्रोत

2

जे , 9 बाइट्स

<0&=$&1 0

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

— मील की दूरी पर
स्रोत

2

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

ToeplitzMatrix@#~Mod~2&

— alephalpha
स्रोत

2

ऑक्टेव , 24 बाइट्स

@(n)~mod((a=(1:n))+a',2)

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

या समान लंबाई:

@(n)mod(toeplitz(1:n),2)

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

— alephalpha
स्रोत

2

आर , 38 37 बाइट्स

n=scan();(matrix(1:n,n,n,T)+1:n-1)%%2

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

Giuseppe के लिए -1 बाइट धन्यवाद

R के पुनर्चक्रण नियमों का लाभ लेता है, सबसे पहले मैट्रिक्स बनाते समय, और दूसरा उस मैट्रिक्स में 0: (n-1) जोड़ते समय।

— user2390246
स्रोत

आप एक बाइट को छोड़ सकते हैं tऔर इसके बजाय मैट्रिक्स का निर्माण कर सकते हैं byrow=T, जैसे कि,(matrix(1:n,n,n,T)+1:n-1)%%2

— Giuseppe

1

outer(1:n,1:n-1,"+")%%2काफी बाइट्स कम है :)

— JAD

2

Swi-Prolog, 142 बाइट्स।

t(0,1).
t(1,0).
r([],_).
r([H|T],H):-t(H,I),r(T,I).
f([],_,_).
f([H|T],N,B):-length(H,N),r(H,B),t(B,D),f(T,N,D).
c(N,C):-length(C,N),f(C,N,1).

ऑनलाइन कोशिश करें - http://swish.swi-prolog.org/p/BuabBPrw.pl

यह एक नेस्टेड सूची को आउटपुट करता है, इसलिए नियम कहते हैं:

t() टॉगल है, यह 0 -> 1 और 1 -> 0 बनाता है।
r() एक व्यक्तिगत पंक्ति के लिए सफल होता है, जो एक पंक्ति की पुनरावर्ती जांच है कि यह वैकल्पिक है और केवल शून्य है।
f()पुनरावर्ती सभी पंक्तियों की जाँच करता है, कि वे सही लंबाई हैं, कि वे मान्य पंक्तियाँ हैं r()और प्रत्येक पंक्ति एक भिन्न 0 से शुरू होती है।
c(N,C) यदि C पंक्तियों की संख्या (नेस्टेड लिस्ट) N है, और सहायक f सफल होता है, तो C आकार N का एक मान्य बिसात है।

परीक्षण के मामलों:

— TessellatingHeckler
स्रोत

2

सी, 69 67 63 बाइट्स

दो बाइट बचाने के लिए @ केविन क्रूज़सेन और चार बाइट बचाने के लिए @ceilingcat के लिए धन्यवाद!

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j;)printf("%d",j--+i&1);}

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

— Steadybox
स्रोत

आप अंतरिक्ष को हटा सकते हैं printf("%d ", क्योंकि यह आउटपुट का एक और वैध तरीका है।

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

@ ConorO'Brien हाँ, धन्यवाद।

— स्टडिओबॉक्स

आप को बदलने के द्वारा दो बाइट्स बचा सकते हैं (j+++i)%2करने के लिए j+++i&1उन कोष्ठक हटाने के लिए।

— केविन क्रूज़सेन

@ceilingcat धन्यवाद!

— स्टेडीबॉक्स

1

QBIC , 19 बाइट्स

[:|?[b|?(a+c+1)%2';

व्याख्या

[:|         FOR a = 1 to b (b is read from cmd line)
?           PRINT - linsert a linebreak in the output
[b|         FOR c = 1 to b
?(a+c+1)%2  PRINT a=c=1 modulo 2 (giving us the 1's and 0's
';            PRINT is followed b a literal semi-colon, suppressing newlines and 
              tabs. Printing numbers in QBasic adds one space automatically.

— steenbergh
स्रोत

1

ब्रेकीलॉग , 19 बाइट्स

⟦₁Rg;Rz{z{++₁%₂}ᵐ}ᵐ

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

— लीक नन
स्रोत

1

PHP , 56 बाइट्स

स्ट्रिंग के रूप में आउटपुट

for(;$i<$argn**2;)echo++$i%2^$n&1,$i%$argn?"":"
".!++$n;

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

PHP , 66 बाइट्स

2 डी सरणी के रूप में आउटपुट

for(;$i<$argn**2;$i%$argn?:++$n)$r[+$n][]=++$i%2^$n&1;print_r($r);

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

— जार्ग हुल्सरमन
स्रोत

1

सीजेएम , 17 बाइट्स

{_[__AAb*<_:!]*<}

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

एक सूची लौटाता है (TIO लिंक ने स्वरूपित आउटपुट)।

— आउटग्रॉफर को एरिक करें
स्रोत

आउट-गोल्फ

— Esolanging Fruit

@ Challenger5 हटाए गए उत्तर के साथ क्षमा करें।

— आउटगॉल्फ

1

बैश + आरएस, ४२

eval echo \$[~{1..$1}+{1..$1}\&1]|rs $1 $1

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

— डिजिटल आघात
स्रोत

1

चेडर , 38 बाइट्स

n->(|>n).map(i->(|>n).map(j->i+j+1&1))

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

— लीक नन
स्रोत

1

/// , 87 बाइट्स + इनपुट

/V/\\\///D/VV//*/k#D#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&[unary input in asterisks]

इसे ऑनलाइन आज़माएं! (इनपुट 4 के लिए)

यूनि इनपुट इन `1`एस, 95 बाइट्स + इनपुट

/V/\\\///D/VV//&1/k#&D&|D/#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&&[unary input in ones]|

इसे ऑनलाइन आज़माएं! (इनपुट 8 के लिए)

यह कैसे काम करता है?

Vऔर क्रमशः Dगोल्फ \/और //हैं।
/*/k#/और /&1/k#&//&|//इनपुट को इसके बराबर में अलग करें'k#'*len(input())
/#k//k#//&k/k&//\/k/k\//सभी ks को /r/S/ब्लॉक में ले जाएं
Ss का उपयोग बस ऐसे उदाहरणों के लिए किया जाता है जहां ks s के बाद आते हैं /ताकि वे कहीं और स्थानांतरित न हों, और Ss तब हटा दिए जाते हैं
#रों तब में बदल रहे हैं r\nरों
kS की स्ट्रिंग को एक प्रत्यावर्ती 1010...स्ट्रिंग में बदल दिया जाता है
r\nरों में बदल रहे हैं 1010...\nरों
की हर जोड़ी में 1010...\n1010\nबदल जाता है1010...\01010...;\n
या तो 0;या 1;बंद छंटनी कर रहे हैं (क्योंकि 01010...स्ट्रिंग 1 से बहुत लंबा है)

— boboquack
स्रोत

1

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

Cos[+##/2Pi]^2&~Array~{#,#}&

शुद्ध फ़ंक्शन इनपुट के रूप में एक सकारात्मक पूर्णांक ले रहा है और एक 2 डी सरणी लौटा रहा है। 1s और 0s उत्पन्न करने के लिए आवधिक फ़ंक्शन cos² (/x / 2) का उपयोग करता है।

थोड़ा और मज़े के लिए, 32-बाइट समाधान के बारे में कैसे

Sign@Zeta[1-+##]^2&~Array~{#,#}&

जो रीमैन ज़ेटा फ़ंक्शन के तुच्छ शून्य के स्थानों का उपयोग करता है।

— ग्रेग मार्टिन
स्रोत

एक चेकरबोर्ड मैट्रिक्स बनाएं

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

MATL , 5 बाइट्स

व्याख्या

जाप , 6 बाइट्स

व्याख्या

वी , 16 , 15 बाइट्स

हास्केल , 50 41 39 38 बाइट्स

APL (Dyalog) , 8 बाइट्स

व्याख्या

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

जावास्क्रिप्ट ईएस 6, 55 54 51 46 बाइट्स

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

MATL , 7 बाइट्स

ब्रेकीलॉग , 15 बाइट्स

व्याख्या

क्लोजर, 36 बाइट्स

05AB1E , 9 7 बाइट्स

व्याख्या

जावा (ओपनजेडके 8) , 80 77 बाइट्स

चारकोल, 8 बाइट्स

अजगर , 9 बाइट्स

जे , 9 बाइट्स

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

ऑक्टेव , 24 बाइट्स

आर , 38 37 बाइट्स

Swi-Prolog, 142 बाइट्स।

सी, 69 67 63 बाइट्स

QBIC , 19 बाइट्स

व्याख्या

ब्रेकीलॉग , 19 बाइट्स

PHP , 56 बाइट्स

PHP , 66 बाइट्स

सीजेएम , 17 बाइट्स

बैश + आरएस, ४२

चेडर , 38 बाइट्स

/// , 87 बाइट्स + इनपुट

यूनि इनपुट इन 1एस, 95 बाइट्स + इनपुट

यह कैसे काम करता है?

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

यूनि इनपुट इन `1`एस, 95 बाइट्स + इनपुट