आसान बाइनरी त्रिकोण

18

इनपुट को धनात्मक पूर्णांक के रूप में देखते हुए n>=1, nनिम्न त्रिभुज की पहली पंक्तियों को आउटपुट करें :

                  1
                1 0 1
              0 0 1 0 0
            1 1 1 0 1 1 1
          0 0 0 0 1 0 0 0 0
        1 1 1 1 1 0 1 1 1 1 1
      0 0 0 0 0 0 1 0 0 0 0 0 0
    1 1 1 1 1 1 1 0 1 1 1 1 1 1 1
  0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1

केंद्र स्तंभ को छोड़कर सभी शून्य और सभी लोगों के बीच पंक्तियों को वैकल्पिक किया गया है।

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

  • इनपुट :3

  • आउटपुट : 

        1
  1 0 1
0 0 1 0 0

  • इनपुट :10

  • उत्पादन :

                      1
                1 0 1
              0 0 1 0 0
            1 1 1 0 1 1 1
          0 0 0 0 1 0 0 0 0
        1 1 1 1 1 0 1 1 1 1 1
      0 0 0 0 0 0 1 0 0 0 0 0 0
    1 1 1 1 1 1 1 0 1 1 1 1 1 1 1
  0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1

आपके कोड को किसी भी काम करना होगा n<100 । यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीतता है!

ट्रेलिंग स्पेस / न्यूलाइन्स और प्रमुख न्यूलाइन्स की अनुमति है!

code-golf  sequence  binary 
— XNOR
स्रोत
क्या अतिरिक्त सफेद स्थान स्वीकार्य है और यदि ऐसा है, तो कौन सी (अग्रणी लाइनें / अग्रणी / अनुगामी / प्रशिक्षण लाइनें)?
— जोनाथन एलन
1
क्या हम संख्याओं की सूचियों की सूची दे सकते हैं?
— आउटगोल्फर
8
सूचियों की सूची @EriktheOutgolfer ठीक है!
1
चूंकि सूचियों की एक सूची ठीक है, इसलिए मैं मान रहा हूं कि केंद्रित संरेखण की आवश्यकता नहीं है, क्या यह है?
— लुइस मेंडो
1
यह आपकी चुनौती है, लेकिन मेरी राय में यदि आप सूचियों की सूची को अनुमति देने के लिए पर्याप्त लचीले हैं, तो यह प्रारूपण के साथ सख्त होने का कोई मतलब नहीं है
— लुइस मेंडो

जवाबों:

7

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

Ṭ=Ḃµ€ŒB

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

-1 बाइट थैंक्स टू एरिक द आउटगोलर

व्याख्या

Ṭ=Ḃµ€ŒB  Main link
    €    For each element in (implicit range of) the input:
Ṭ        List 1s and 0s with 1s in the indices in the left argument (generates `[0, 0, ..., 1]`)
 =Ḃ      Is this equal to `(z % 2)` where `z` is the range number? (Every other row is flipped)
     ŒB  Reflect each row
— HyperNeutrino
स्रोत
आप बदल सकते हैं ¶Çके साथ µके लिए -1।
— एरिक आउटगोल्फर
@EriktheOutgolfer ओह धन्यवाद!
— हाइपरएनुट्रिनो
4

अजगर 2 , 50 बाइट्स

lambda n:[i*`i%2`+`~i%2`+i*`i%2`for i in range(n)]

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

यह पंक्तियों को स्ट्रिंग्स की सूची के रूप में लौटाता है।

अजगर 2 , 67 65 63 बाइट्स (स्वरूपित)

n=input()
for i in range(n):k=i*`i%2`;print(n-i)*" "+k+`~i%2`+k

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

यह प्रत्येक पंक्ति पर एक अनुगामी स्थान के साथ आउटपुट करता है।

— मिस्टर एक्सकोडर
स्रोत
3

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

⁼€=ḂŒḄµ€

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

-2 हाइपरनेट्रिनो को धन्यवाद ।

— आउटगोल्फ को एरिक करें
स्रोत
ओह गंभीरता से .... दूसरा निनाद विभाजित करें: पी
— जोनाथन एलन
@JonathanAllan यह वास्तव में एक नियम में बदलाव था ... btw मुझे लगता है कि यह भी गोल्फ खेलने योग्य है ...
— बाहर निकलना
हाँ, मैं एक 15 बाइट ग्रिड था तो 10 बाइट सूची ...
— जोनाथन एलन
1
@JonathanAllan हाइपर अच्छा हो रहा है ...
— एरिक आउट द आउटफेलर
¬^Ḃबन सकता है =Ḃक्योंकि NOT (XOR (A B))सिर्फ IFF (A B) संपादित जाहिरा तौर पर मैं और अधिक golfed से मैंने सोचा कि मैं o_O lol था
— HyperNeutrino
3

अजगर 2 , 50 बाइट्स

lambda n:[[i%2]*i+[~i%2]+i*[i%2]for i in range(n)]

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

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

lambda n:[(([i%2]*i+[~i%2])*2)[:-1]for i in range(n)]

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

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

lambda n:[[[i%2,~i%2][j==i]for j in range(2*i+1)]for i in range(n)]

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

— totallyhuman
स्रोत
2
Haha, अब हम बंधे हुए हैं :)
— श्री Xcoder
65 बाइट्स (लंबे समय तक)
— श्री एक्सकोडर
3

जाप , 12 9 बाइट्स

õÈÇ¥Y^uÃê

इसे ऑनलाइन टेस्ट करें!

काफी थोड़ा जेली की तुलना में दुख की बात है, लेकिन Japt ऐसा कुछ नहीं है Ṭतो मैं मैं क्या है के साथ क्या करना चाहिए ...

व्याख्या

 õÈ   Ç   ¥ Y^ uà ê
UõXY{XoZ{Z==Y^Yu} ê}      Ungolfed
                          Implicit: U = input number
Uõ                        Create the range [1..U].    [1, 2, 3, 4]
  XY{              }      Map each item X and 0-index Y in this to
     Xo                     Create the range [0..X).  [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]
       Z{      }            Map each item Z in this to
         Z==Y                 Z is equal to Y         [[1], [0, 1], [0, 0, 1], [0, 0, 0, 1]]
             ^Yu              XORed with Y % 2.       [[1], [1, 0], [0, 0, 1], [1, 1, 1, 0]]
                  ê         Bounce.                   [[1],
                                                       [1, 0, 1],
                                                       [0, 0, 1, 0, 0],
                                                       [1, 1, 1, 0, 1, 1, 1]]
                          Implicit: output result of last expression
— ETHproductions
स्रोत
बिल्डरों के लिए हुर्रे: पी: पी: पी
— हाइपरएनुट्रीनो
हां, किसी ने चेन पायथन-जेली-पायथन-जेली को तोड़ दिया!
— श्री Xcoder
@ Mr.Xcoder जहां जेली वास्तव में पायथन में लागू की गई है। : p
— १17
3

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

Table[CellularAutomaton[51,{{1},0},#,{All,All}][[i]][[#-i+2;;-#+i-2]],{i,#}]&

@ कोई पेड़ नहीं इसे 48 बाइट्स के लिए नीचे गिरा देता है!

मैथेमेटिका, 48 बाइट्स

#&@@@NestList[CellularAutomaton@51,{{1},0},#-1]&
— J42161217
स्रोत
हुह मैं इसे एक सेलुलर ऑटोमेटा मानने के बारे में नहीं सोचता था। अच्छा!
— HyperNeutrino
2
एक ही चीज लेकिन गोल्फर: #&@@@NestList[CellularAutomaton@51,{{1},0},#-1]&48 बाइट्स
— एक पेड़ नहीं
3

Pyth , 14 बाइट्स

2 बाइट बचाने के लिए @Jakube का धन्यवाद!

ms_+Bm%d2d%hd2

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

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

@ बाइट के लिए @ बाइट के लिए बहुत-बहुत धन्यवाद

m++K*d]%d2%td2K

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

पायथ , 16 बाइट्स

m++K*d`%d2`%td2K

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

— मिस्टर एक्सकोडर
स्रोत
]पहले कोड में दूसरा निकालें ।
— जकुब १४'१ at को १२:०४
@Jakube हाँ, धन्यवाद। तत्वों को सूचियों में जोड़ने के लिए ऑटो-सूचीकरण के बारे में भूल गए।
— श्री एक्सकोडर
और यहाँ एक 14 बाइट्स समाधान है:ms_+Bm%d2d%hd2
— जकुबे
@Jakube हाँ, मैं अभी द्विभाजन के बारे में सोच रहा था, लेकिन मैं ऐसा नहीं कर सका क्योंकि मैं मोबाइल पर हूं। फिर से बहुत बहुत धन्यवाद!
— श्री Xcoder
3

आर , 73 बाइट्स

Giuseppe के लिए धन्यवाद! अच्छा पकड़ा।

n=scan();for(i in 1:n)cat(c(rep(" ",n-i),x<-rep(1-i%%2,i-1)),i%%2,x,"\n")

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

आर , 78 बाइट्स

n=scan();for(i in 1:n)cat(x<-c(rep(" ",n-i),rep(1-i%%2,i-1)),i%%2,rev(x),"\n")

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

आर , 82 बाइट्स

n=scan();for(i in 1:n){j=i%%2;x=c(rep(" ",n-i),rep(1-j,i-1));cat(x,j,rev(x),"\n")}

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

आर , 110 बाइट्स - स्टडआउट के लिए आउटपुट

m=matrix(x<-rep_len(0:1,n<-scan()),n,n-1);m[upper.tri(m,T)]=" ";for(i in 1:n)cat(rev(m[i,]),1-x[i],m[i,],"\n")

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

आर , 130 बाइट्स - एक फ़ाइल में आउटपुट

m=matrix(x<-rep_len(0:1,n<-scan()),n,n-1);m[upper.tri(m,T)]=" ";for(i in 1:n)cat(rev(m[i,]),1-x[i],m[i,],"\n",file="a",append=i>1)

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

एक फ़ाइल के लिए बाहर लिखना क्योंकि मुझे नहीं पता कि इसे कंसोल में कैसे फिट किया जाए अगर n==99(परिणाम यहां देखें )।

— djhurio
स्रोत
2
मुझे नहीं लगता कि आपको बड़े एन के लिए कंसोल रैपिंग के बारे में चिंता करने की आवश्यकता है। व्यक्तिगत रूप से मैं फ़ाइल करूँगा, फ़ाइल = "a" क्योंकि STDOUT का आउटपुट सही है।
— मिकीट
1
— Giuseppe
1

पास्कल , 181 154 बाइट्स

27 बाइट्स ने @ThePirateBay को धन्यवाद दिया

procedure f(n:integer);var i,j:integer;begin for i:=1to n do begin write(' ':(n-i+1)*2);for j:=1to i*2-1do write((ord(j<>i)+i)mod 2,' ');writeln()end end;

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

Unglofed

procedure f (n: integer);
    var i, j: integer;
    begin
        for i := 1 to n do
        begin
            write(' ': (n-i+1) * 2);
            for j := 1 to i*2-1 do
                write((ord(j<>i) + i) mod 2, ' ')
            writeln()
        end
    end;
— Uriel
स्रोत
1
— टीएच
1

रेटिना , 25 बाइट्स

.+
$*0
0
1$`¶
T`d`10`¶.*¶

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पहला चरण इनपुट को उस लंबाई के शून्य में बदल देता है। दूसरा चरण तब उस स्ट्रिंग के सभी उपसर्गों (स्ट्रिंग को शामिल नहीं करता है) को लेता है और उनके लिए 1 उपसर्ग करता है। तीसरा चरण तब बिट्स को वैकल्पिक लाइनों पर टॉगल करता है।

— नील
स्रोत
1

05AB1E , 24 21 18 बाइट्स

FNÉN×NÈJûIN>-úˆ}¯»

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

संपादित करें: ठीक है, यह मेरा पहला 05AB1E गोल्फ है इसलिए मुझे आश्चर्य नहीं है कि चीजें गोल्फ हो सकती हैं। इतिहास संपादित करें:

  • 18 (ऊपर देखें)
    • तो वहाँ है एक दूसरे को काटना दर्पण (दोनों .∞औरû ) है, जो चीजें एक बहुत आसान बनाता है
    • जैसा कि करना ÈऔरÉ बनाना, 2%और 2%_बहुत कम करना
  • 21: FN2%DN×Dr_sJIN>-úˆ}¯»
    • हटाए गए निहित सामान: IF-> F, )J->J
    • baaकरने के लिए aabकिया जा सकता है .À(घूर्णन) लेकिन यह भी द्वारा r(पीछे) (कम)
  • 24: IFN2%DN×D.À_s)JIN>-úˆ}¯»
— LarsW
स्रोत
0

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

ＥＮ⪫ＩＥ⁺¹ι﹪⁺ι¬λ² ‖Ｏ←

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＥＮ              For each of the input number of rows
  ⪫             Join with spaces
   Ｉ            Convert to string
    Ｅ⁺¹ι        For each column
        ﹪⁺ι¬λ²  Calculate the digit
‖Ｏ←             Reflect to the left
— नील
स्रोत
0

जावास्क्रिप्ट, 140 132 बाइट्स (उचित प्रारूपण के साथ)

n=>{A=Array;a='';b=0;for(x of A(n)){for(c of A(n-b))a+=' ';for(c of A(b))a+=b%2;a+=(b+1)%2;for(c of A(b))a+=b%2;a+='\n';b++}return a}

यह ऑनलाइन की कोशिश करो

— डेविड बेली
स्रोत
यदि आप नहीं जानते हैं, तो आप A=Array8 बाइट को बचाने के लिए उपयोग कर सकते हैं ।
अच्छी बात है, मुझे उस समय ऐसा नहीं लगा
— डेविड बेली
आप 1 से कम से कम 3 और बाइट्स बचा सकते हैं: 1) इसके बजाय A=Array;आप Aपहली सरणी कॉल (यानी। for(x of(A=Array)(n))) पर इनिट वैरिएबल कर सकते हैं , जो 1 बाइट बचाता है, 2) बदलें'\n' शाब्दिक नई लाइन के साथ (ग्रेव एक्सेंट का उपयोग करें), 3) आप नहीं। कोष्ठक की आवश्यकता है (b+1)%2क्योंकि यह इसके बराबर है b+1&1।
0

जावास्क्रिप्ट (ईएस 6) , 74 73 71 68 64 बाइट्स

-7 बाइट @Neil द्वारा

f=n=>n--?[...f(n), [...Array(n-~n)].map((v,i)=>(n+(i==n))%2)]:[]

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

सरल पुनरावर्ती कार्य जो लाइनों को एक-एक करके उत्पन्न करता है। संख्या की सरणी के रूप में आउटपुट।

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

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

f=(n,w=2*n+1,N=n,s=" ".repeat((N-n)*2))=>(--n?f(n,w,N)+s+[...Array(n-~n)].map((v,i)=>(n+(i==n))%2).join(" "):s+1)+"\n"

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

— Birjolaxew
स्रोत
(n%2+(i==n))%2को सरल बनाया जा सकता है (n+(i==n))%2।
— नील
या 1&n^i==nकाम कर सकता है, लेकिन मैंने इसका परीक्षण नहीं किया है।
— नील
इसके अलावा प्रयास करें n--?...:[]। (और आपको ;कोड गोल्फ में आवश्यकता नहीं है ।)
— नील
2*n+1हो सकता है n-~n, लेकिन मैं निश्चित रूप से याद नहीं कर सकता।
— नील
@ नील धन्यवाद! मुझे जो काम मिल सकता है, वह जोड़ा
— बिरजोलक्सेव
0

जे, 32 बाइट्स

3 :'-.^:(2|y)(=|.)i.>:+:y'&.>@i.

इसे ऑनलाइन आज़माएं!यह एक अनाम फ़ंक्शन है जो मानों की बॉक्सिंग सूची देता है।

मैं कल्पना करना पसंद करता हूं कि स्पष्ट फ़ंक्शन परिभाषा कैप और इस तरह के हटाने के आधार पर बाइट्स को बचाती है, लेकिन यह शायद एक टैसी उत्तर की तुलना में कुछ बाइट्स जोड़ता है।

व्याख्या

3 :'-.^:(2|y)(=|.)i.>:+:y'&.>@i.
                              i. For i = 0 ... input - 1
3 :'-.^:(2|y)(=|.)i.>:+:y'        Explicit function: compute nth row
                    >:+:y          2n+1
                  i.               Range [0,2n+1)
             (=|.)                 Equate range to reversed range
                                    (yield 0 0 0 ... 1 ... 0 0 0)
                                   If
                                    n = 1 (mod 2)
                                   Then
                                    Negate each value
                          &.>     Box
— गोभी
स्रोत
0

जे , 17 बाइट्स

(2&|~:0=i:)&.>@i.

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

बॉक्सिंग सरणियों की एक सूची आउटपुट करता है।

व्याख्या

(2&|~:0=i:)&.>@i.  Input: n
               i.  Range from 0 to n, exclusive end
           & >     Unbox each and perform on each x
        i:           Range from -x to x, inclusive
      0=             Equal to 0
    ~:               Not equal
 2&|                 x mod 2
           &.>       Perform inverse of unbox (box)
— मील की दूरी पर
स्रोत
0

जावा 8, 121 111 109 101 बाइट्स

n->{String r[]=new String[n],t;for(int i=0,j;i<n;r[i++]=t+i%2+t)for(j=0,t="";j++<i;t+=i%2);return r;}

मेरा वर्तमान बाइट-स्कोर (101) बाइनरी त्रिकोण की एक पंक्ति भी है। :)

स्पष्टीकरण:

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

n->{                         // Method with integer parameter and String-array return-type
  String r[]=new String[n],  //  Result String-array
         t;                  //  Temp String
  for(int i=0,j;             //  Some index-integers
      i<n;                   //  Loop (1) from 0 to `n` (exclusive)
      r[i++]=                //    After every iteration, set the next row to:
        t+                   //     `t` +
        i%2                  //     Center digit (`i` has already been raised by 1 now)
        +t)                  //     + `t` again
    for(j=0,t="";            //   Reset index `j` and the temp-String `t`
        j++<i;               //   Inner loop (2) from 0 to `i` (exclusive)
      t+=i%2                 //    Append `t` with an outer digit
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
  return r;                  //  Return resulting String-array
}                            // End of method
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.