एक कैंटर सेट प्रिंट करें

Question

चुनौती

एक एन-लेवल कैंटर सेट बनाएँ ।

कैंटर टर्नरी सेट को बार-बार लाइन सेगमेंट के खुले मध्य तिहाई को हटाकर बनाया जाता है।

कार्यक्रम एक पैरामीटर N(एक पूर्णांक संख्या) प्राप्त करता है और फिर प्रिंट (कंसोल या इसी तरह से) में एन स्तरों का एक कैंटर सेट होता है। प्रिंट में केवल अवांछनीय ( _) और सफ़ेद रिक्त स्थान वर्ण हो सकते हैं। पैरामीटर सकारात्मक या नकारात्मक हो सकता है और संकेत कैंटर सेट निर्माण अभिविन्यास को इंगित करता है: यदि N > 0कैंटर सेट का निर्माण नीचे की ओर किया जाता है और यदि N < 0कैंटर सेट का निर्माण ऊपर की ओर किया जाता है। यदि N = 0तब प्रोग्राम एक लाइन ( _) को प्रिंट करता है ।

उदाहरण के लिए:

एन = 2

_________
___   ___
_ _   _ _

एन = -2

_ _   _ _
___   ___
_________

एन = 3

___________________________
_________         _________
___   ___         ___   ___
_ _   _ _         _ _   _ _

एन = -3

_ _   _ _         _ _   _ _
___   ___         ___   ___
_________         _________
___________________________

मानदंड जीतना

जैसा कि यह एक कोड गोल्फ चुनौती है, सबसे छोटा कोड जीतता है।

संपादित: बदसूरत सुझाव से 0 इनपुट को संशोधित करें।

Comments

N = 0 होने पर कुछ भी क्यों नहीं छापते? यह 0 को एक विशेष मामला बनाता है, और पुनरावृत्ति का उपयोग करना कठिन बनाता है। सामान्य हैंडलिंग एकल प्रिंट करना होगा _(लेकिन -0 मिलते समय इसे नीचे प्रिंट करें)।

— बदसूरत

सही। मैंने पहले ही ऐनक को संशोधित कर दिया है।

— Averroes

Answer 1

गोल्फस्क्रिप्ट, 49 42 40 चार्ट

~.abs.3\?'_'*\{.3%..,' '*\++}*](0>2*(%n*

42-> 40 के लिए हमार के लिए धन्यवाद ।

अधिक संख्या-सिद्धांत-दृष्टिकोण पर मेरा सर्वश्रेष्ठ प्रयास दुखद रूप से बहुत लंबा है:

~.abs:^3\?,{3^)?+3base(;1+1?.'_'*^@-)' '*+}%zip\0>2*(%n*

या

~.abs 3\?:^,{6^*+3base.1+1?.('_'*@,@-' '*+}%zip\0>2*(%n*

और मुझे संदेह है कि लंबाई baseऔर zipइसे पकड़ना असंभव बना देगा।

Comments

~.abs.@/\.3\?'_'*\{.3%..,' '*\++}*](%n*39 वर्ण है, लेकिन इनपुट पर क्रैश होता है 0। :-(

— इल्मरी करोनें

@IlmariKaronen, हाँ, शून्य द्वारा विभाजन सी कार्यान्वयन के लिए एक दर्द था जो मैंने भी लिखा था, क्योंकि इसका मतलब था कि आप n/abs(n)प्राप्त करने के लिए नहीं कर सकते signum(n)।

— पीटर टेलर

Answer 2

अजगर, ११६ ११३ १०४ १०४ १०s चर

n=input()
d=n>0 or-1
for i in range(n*d+1)[::d]:
 s='_'*3**i
 while i<n*d:s+=len(s)*' '+s;i+=1
 print s

पुराने एल्गोरिथ्म 113 वर्णों में सबसे ऊपर है

r=input()
u='_'
l=[u]
for _ in abs(r)*u:o=len(l[0]);l=[s+o*' '+s for s in l]+[u*o*3]
print'\n'.join(l[::r>0 or-1])

Answer 3

रूबी (97)

स्टीवन रूंबल्स्की के अजगर संस्करण पर आधारित:

n,r=$*[0].to_i,[?_]
n.abs.times{z=r[0].size;r=r.map{|s|s+' '*z+s}+[?_*z*3]}
puts n<0?r:r.reverse

पिछले प्रयास, दोनों समान लंबाई (112)

भागों से लाइनें बनाएँ:

c=->x,n{n<1??_*x :(z=c[s=x/3,n-1])+' '*s+z}
r=(0..m=(n=$*[0].to_i).abs).map{|i|c[3**m,i]}
puts n<0?r.reverse: r

एक पंक्ति से शुरू करें, उसमें छेद करें:

r=[?_*3**a=(n=$*[0].to_i).abs]
a.times{|c|r<<r[-1].gsub((x=?_*o=3**(a-c-1))*3,x+' '*o+x)}
puts n<0?r.reverse: r

Answer 4

पर्ल, 93 वर्ण

@x=($t=$x=_ x 3**($a=abs($n=<>)),map$x.=$"x($x=~s/(.)../$1/g).$x,1..$a);say for$n<0?sort@x:@x

मुझे लगा कि मैं यह देखने की कोशिश करूंगा कि पीटर टेलर का गोल्फस्क्रिप्ट समाधान पर्ल के लिए कितना अच्छा है । उल्लेखनीय विशेषताओं में तीन वर्णों को बचाने के sortबजाय का उपयोग करना शामिल है reverse, इस तथ्य का उपयोग करना कि पहले एक अंतरिक्ष सॉर्ट करता है _।

Answer 5

कॉमन लिस्प, 217 210 वर्ण

(defun m(x)(flet((c(n v)(if(= n 0)`((,v))(cons(substitute v nil(make-list(expt 3 n)))(mapcar #'append(c(1- n)v)(c(1- n)" ")(c(1- n)v))))))(format t "~{~{~a~}~%~}"(let((r(c(abs x)'_)))(if(< x 1)(reverse r)r)))))

विस्तारित:

(defun m(x)
  (flet((c(n v)
    (if(= n 0)
       `((,v))
       (cons(substitute v nil(make-list(expt 3 n)))
            (mapcar #'append
                    (c(1- n)v)
                    (c(1- n)" ")
                    (c(1- n)v))))))
   (format t "~{~{~a~}~%~}"(let((r(c(abs x)'_)))(if(< x 1)(reverse r)r)))))

मुझे लगता है कि अगर लिस्प कोड किसी अन्य भाषा (C, 219) के लिए किसी भी शुरुआती गिनती को हरा देता है, तो मैं ठीक कर रहा हूं :)

Answer 6

सी ( 163 161 वर्ण)

i,l,N;f(n,m,s){if(n){s=--n<l?m:s;f(n,m,s);f(n,s,s);f(n,m,s);}else
putchar(m);}main(n,v)int**v;{for(i=N=abs(n=atoi(1[v]));i+1;i--)l=n<N?N-i:i,f(N,95,32),f(0,10);}

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

Answer 7

सी, 219 193 179 143 136 131 अक्षर

पीटर टेलर के विचारों में से एक का अनुसरण किया, साथ ही मेरे स्वयं के सुधार ने 6 और बचाए।
@PeterTaylor से कुछ युक्तियों को एकीकृत किया, साथ ही उनके मुख्य कार्य की प्रतिलिपि बनाई, थोड़े बदलाव के साथ, जो एक चरित्र को बचाता है (क्या इसे कॉपी करना है? चूँकि हममें से कोई भी यह नहीं जीतेगा, मुझे लगता है कि यह बहुत बुरा नहीं है)।
मैंने एक महत्वपूर्ण सुधार के बारे में सोचा कि मेरी पुनरावृत्ति कैसे काम करती है, और पीटर टेलर के उत्तर को देखने के बाद, मैंने इसे फिर से हासिल करने के लिए लागू किया। जब उसका जवाब फिर से पढ़ा, तो मैंने देखा कि मैंने लगभग वही किया जो उसने किया था। तो ऐसा लगता है कि उन्होंने जो संकरण सुझाया है। एक ही लंबाई रखते हुए,
लूप को भी सरल बनाया main।
और इसके बजाय न्यूलाइन प्रिंट करने के लिए पीटर की चाल चलीputs("") - एक चरित्र बचाता है।

intपरिवर्तनशील घोषणा से हटाया गया - एक चेतावनी, लेकिन 4 वर्ण बचाता है।
नई एल्गोरिथ्म अग्रिम में 3 ^ x की गणना नहीं करता है, लेकिन 3 ^ x वर्णों को मुद्रित करने के लिए एक लूप का उपयोग करता है।
परिभाषित करके एक और बचा सकता है int*v, लेकिन तब 64 बिट काम नहीं करेगा।
वर्ण गणना व्हॉट्सएप को बाहर करती है (जिसे हटाया जा सकता है)।

o,i,n;
p(c) {
    n-- ?
        p(c),p(o>n?c:32),p(c)
    :
        putchar(c);
    n++;
}
main(c,v)int**v; {
    for(n=abs(c=atoi(v[1]));i<=n;i++)o=c+n?n-i:i,p(95),puts("");
}

पुराना एल्गोरिथ्म, 219 वर्ण:

p(l,o,i,m,c,j) {
    for(;i<(m=l);i++)
        for(j=0,c=95;m/o||!putchar(c);j++)
            i/m%3-1||(c=32),m/=3;
    puts("");
}
main(c,v,n,i,l,o)int**v;{
    (n=atoi(v[1]))<0?n=-n:(c=0);
    for(i=n,l=1;i;i--)l*=3;
    o=c?1:l;
    for (;i<=n;i++)p(l,o,0),c?o*=3:(o/=3);
}

Comments

@PeterTaylor, मैं iपैरामीटर को हटा नहीं सकता , क्योंकि वैश्विक का उपयोग करने से हस्तक्षेप होगा main। l--के साथ हस्तक्षेप करेगा o>=l, और मुझे इसे बदलना होगा >(इसलिए मैं इसे क्यों लिखूं जैसे कि यह एक बुरी बात है?) मैं भी आपको कॉपी कर सकता हूं main, जो सरल और मेरे मुकाबले छोटा है।

— बदसूरत

@PeterTaylor, आप इसके बारे में सही थे i- मैंने इस तथ्य को याद किया कि मैं वास्तव में अब इसका उपयोग नहीं करता (मुझे लगा कि आपका मतलब है कि मैं पास नहीं हूं)।

— ugoren

वैसे, मुझे कोई आपत्ति नहीं है कि आप मेरा मुख्य कार्य कर रहे हैं। अंगूठे का मेरा नियम यह है कि किसी और के चरित्र को बदलने के लिए किसी अन्य के समाधान की नकल करना अत्यधिक आक्रामक है, किसी और के समाधान की प्रतिलिपि बनाना, इसके आधे हिस्से को फिर से लिखना पूरी तरह से उचित है, और बीच में कहीं एक ग्रे क्षेत्र है। हमें मेटा पर कुछ सामुदायिक मानकों पर सहमत होने का प्रयास करना चाहिए।

— पीटर टेलर

@PeterTaylor, मुझे लगता है कि हम एक प्रकार के गतिरोध पर पहुंच गए। मेरा pअब काफी इष्टतम लगता है, और आपका mainबेहतर था (मुझे यकीन नहीं है कि यह इष्टतम है, लेकिन इसे और बेहतर नहीं बना सकता)। इसलिए एक नई सरल कार्यक्रम संरचना को छोड़कर, जाने का एकमात्र तरीका हम में से दूसरे के कोड की नकल करना था।

— बदसूरत

BTW आप अपने पात्रों की गिनती कैसे कर रहे हैं? क्योंकि मैं आपका नवीनतम संस्करण 138 चार्ट बनाता हूं, न कि 136.

— पीटर टेलर

Answer 8

जे, ४४ ३ ९ 38 37 बाइट्स

' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|

प्रारंभ में 1 (प्रतिनिधित्व _) के साथ शुरू होने वाले अगले सेट के निर्माण के लिए पुनरावृत्ति का उपयोग करता है ।

प्रयोग

   f =: ' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|
   f 0
_
   f 1
___
_ _
   f _1
_ _
___
   f 2
_________
___   ___
_ _   _ _
   f _2
_ _   _ _
___   ___
_________
   f 3
___________________________
_________         _________
___   ___         ___   ___
_ _   _ _         _ _   _ _
   f _3
_ _   _ _         _ _   _ _
___   ___         ___   ___
_________         _________
___________________________

व्याख्या

' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|  Input: integer n
                                    |  Absolute value of n
                (,:1)                  The array [1]
                     1&(          )~   Repeat abs(n) times starting with x = [1]
                                 ]       Identity function, gets x
                            0&*          Multiply x by 0
                               ,.        Join the rows together
                         ]               Identity function, gets x
                          ,.             Join the rows together
                     1  ,                Prepend a row of 1's and return
      0&>                              Test if n is negative, 1 if true else 0
         _&(   )                       If n is negative
             |.                          Reverse the previous result
            ]                            Return that
                                       Else pass the previous result unmodified
' _'                                   The string ' _'
    {~                                 Select from the string using the result
                                       as indices and return

Comments

अच्छा! मैंने व्यक्तिगत रूप से कोशिश नहीं की है, लेकिन मुझे एजेंडा का उपयोग करना बहुत पसंद है @.- इसे जोड़कर, $:यहां कुछ उपयोग हो सकता है? जैसे कुछ (zero case)`(positive case)`(negative case)@.*, या शायद भी ":@_:`(positive case)`(|."1@$:)@.*।

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

मैंने एक पुनरावर्ती समाधान का प्रयास नहीं किया है, लेकिन मैं इसे आज़मा सकता हूं।

— मील

Answer 9

आर , 141 139 137 बाइट्स

m=abs(n<-scan());write("if"(n<m,rev,c)(c(" ","_")[Reduce(`%x%`,rep(list(matrix(c(1,1,1,1,0,1),3)),m),t(1))[,1+2^m-2^(m:0)]+1]),1,3^m,,"")

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

'('पहचान समारोह के रूप में Giuseppe के उपयोग के लिए -15 बाइट्स भी धन्यवाद ; writeके बजायcatप्रिंट आउटपुट के ; का चतुर उपयोग %x%।

-2 बाइट्स किर्ल एल की बदौलत पहचान समारोह के cबजाय उपयोग करके '('।

Comments

यहां एक क्रोनकर उत्पाद काम कर सकता है? %x%? वैकल्पिक पंक्तियों को लेने के साथ कुछ मुद्दे हो सकते हैं ...

— Giuseppe

@Giuseppe मैंने कोशिश की, छोटे "एच" के उत्तर से अपने "एच" बनाएं "... मैं इसे एक और कोशिश दूंगा।

— JayCe

आह, तो यह आप ही थे जिन्होंने इसे उकेरा। यही कारण है कि मैंने kronभी सोचा था ! मुझे लगता है कि अगर हम सही दृष्टिकोण पा सकते हैं तो 125 बाइट्स की तरह नीचे जाने में सक्षम होना चाहिए।

— ग्यूसेप

आप `(`पहचान फ़ंक्शन के रूप में उपयोग कर सकते हैं ताकि आप writeसीधे catऔर forलूप के बजाय उपयोग कर सकें । 141 बाइट्स

— ग्यूसेप

@Giuseppe मुझे नहीं पता था (कि इस तरह इस्तेमाल किया जा सकता है, या कि if दो कार्यों से चयन करने के लिए इस्तेमाल किया जा सकता है। और मैं लिखना शुरू करूँगा ... बहुत सारे "\ n" बचाता है।

— JayCe

Answer 10

पायथन, 177 164 वर्ण

N=input()
n=abs(N)
c=lambda x:0if x<1 else x%3==1or c(x/3)
r=["".join([["_"," "][c(x/3**i)]for x in range(3**n)])for i in range(n+1)]
print"\n".join(r[::N>0 or-1])

Comments

आप अजगर 2 का उपयोग कर रहे जब से तुम के परिणामों को कास्ट करने की जरूरत नहीं है inputके रूप में int। आपकी अंतिम दो पंक्तियों को छोटा किया जा सकता हैprint"\n".join(r[::N>0 or-1])

— स्टीवन रूम्बल्स्की

@ पहले मैंने बदलाव किए। धन्यवाद।

— खाना

Answer 11

पर्ल, 113 वर्ण

$i=abs($I=<>);@w=$_='_'x3**$i;while($i--){$x=3**$i;s/(__){$x}/'_'x$x.' 'x$x/eg;push@w,$_}say for$I>0?reverse@w:@w

विस्तारित:

$i=abs($I=<>);
@w=$_='_'x3**$i;
while($i--){
    $x=3**$i;
    s/(__){$x}/'_'x$x.' 'x$x/eg;
    push@w,$_
}
say for$I>0?reverse@w:@w

Answer 12

जावास्क्रिप्ट 121 बाइट्स

आंतरिक पुनरावर्ती कार्य, फिर जरूरत पड़ने पर पिछड़े आउटपुट का ध्यान रखना

n=>(f=(n,t=n&&f(n-1),r=t[0])=>n?[r+r+r,...t.map(x=>x+t[n]+x)]:['_',' '],f=f(n<0?-n:n),f.pop(),n<0?f.reverse():f).join`\n`

कम गोल्फ वाला

n=>{
  var f = n => { // recursive function
    var t = n && f(n-1), r = t[0]
    return n 
      ? [r+r+r, ...t.map(x => x+t[n]+x)]
      : ['_',' ']
  };
  f = f(n < 0 ? -n : n);
  f.pop(); // last row is all blanks
  if (n<0) f.reverse();
  return f.join`\n`
}

परीक्षा

var F=
n=>(f=(n,t=n&&f(n-1),r=t[0])=>n?[r+r+r,...t.map(x=>x+t[n]+x)]:['_',' '],f=f(n<0?-n:n),f.pop(),n<0?f.reverse():f).join`\n`

function go()
{
  var n=+I.value
  O.textContent = F(n)
}

go()

<input id=I type=number value=3 oninput='go()'>
<pre id=O></pre>

Answer 13

बैच, 265 262 242 236 235 बाइट्स

@echo off
set/pn=
set c=%n%,-1,0
if %n% lss 0 set c=0,1,%n:-=%
for /l %%i in (%c%)do call:l %%i
exit/b
:l
set s=_
for /l %%j in (1,1,%n:-=%)do call:m %1 %%j
echo %s%
:m
set t=%s%
if %1 lss +%2 set t=%s:_= %
set s=%s%%t%%s%

संपादित करें: @ l4m2 के लिए धन्यवाद 12 19 बाइट्स सहेजे गए। अनावश्यक %a%चर को हटाकर 8 बाइट्स बचाए।

Comments

यह 247 बाइट्स के लिए।

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

@ ConorO'Brien आपको लगता है कि यह 261 होगा यदि मैंने सभी CRs और साथ ही LF (जो मुझे यकीन है कि आपको करने की आवश्यकता नहीं है, लेकिन मैं उस तरह आलसी हूं) को गिना।

— नील

तो क्या आप अपने कोड से CR को नहीं हटा रहे हैं? भले ही यह आवश्यक नहीं है। लेकिन फ़ाइलों और किसी भी तरह से छीन लिया? : पी

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

@ ConorO'Brien बैच फाइल लिखने के लिए नोटपैड का उपयोग करने की बात स्वीकार करता हूं।

— नील

क्या आप ऐसा कुछ कर सकते हैं set c=%n%,-1,0 [LF] if %n% lss 0 set c=0,1,%a% [LF] for /l %%i in (%c%)do call:l %%i?

— l4m2

Answer 14

जावास्क्रिप्ट (Node.js) , 148 बाइट्स

n=>f=(L=n<0&&n,R=n>0&&n)=>[...Array(r=3**(n>0?n:-n))].map(_=>((j++).toString(3)+1).indexOf(1)>(L>0?L:-L)?'_':' ',j=r+r).join``+`
${L++<R?f(L,R):''}`

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

Answer 15

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

lambda n:'\n'.join(eval("[i+' '*len(i)+i for i in"*abs(n)+"'_'"+"]+['___'*len(i)]"*abs(n))[::n<1or-1])

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

Answer 16

प्रोलोग (एसडब्ल्यूआई) , 265 232 213 बाइट्स

S-E-R:-between(S,E,R).
[]/R/R.
[H|T]/B/R:-T/[H,32,H|B]/R.
N+R:-(N>0->O is N-1,O+S,S/[]/R;R=`_`).
N*[H|T]:-1-N-_,writef("%n",[H]);N*T.
_*[]:-nl.
-N:-(0-N-J,K is N-J;N-0-I,J is -I,K is I-N),L is 3^K,J+R,L*R,1=0;1=1.

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

Answer 17

पॉवरशेल , 111 बाइट्स

filter f{if($s=[math]::Sign($_)){($x=$_-$s|f|%{$_+' '*($l=$_|% Le*)+$_})|?{$s-1};'_'*3*$l;$x|?{$s+1}}else{'_'}}

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

कम गोल्फ वाला:

filter f{
    if($sign=[math]::Sign($_)){
        $x=$_-$sign|f|%{
            $_+' '*($length=$_|% Length)+$_
        }
        $x|?{$sign-1}  # output $x if $_ is negative
        '_'*3*$length
        $x|?{$sign+1}  # output $x if $_ is positive
    }
    else{
        '_'
    }
}