तारांकन वायरल

Question

एक सकारात्मक पूर्णांक एन ("वायरलिटी") को देखते हुए , आपके कार्यक्रम को एक पेड़ की ASCII- कला आरेखण बनाना चाहिए जिसमें लंबाई N की दो शाखाएँ नीचे की ओर फैली हुई हों और / या ऊपर-बाएँ कोने से दाईं ओर हों।

पहले तारांकन के बाद प्रत्येक शाखा द्वारा ली गई दिशा या तो दाईं ओर या नीचे की ओर हो सकती है, और इस विकल्प को हर अगले चरण में यादृच्छिक रूप से ¹ बनाया जाना चाहिए ।

उदाहरण के लिए, 5 के इनपुट को देखते हुए, आउटपुट जैसा दिख सकता है:

***
* ***
**
 **

दो शाखाओं को छूने की अनुमति है (आसन्न कोशिकाओं पर), लेकिन ओवरलैप नहीं (एक ही सेल पर हो), इसलिए निम्नलिखित की अनुमति नहीं होगी:

***
* *
*****
  *
  *

उदाहरण

इनपुट के लिए 1, केवल संभव आउटपुट है:

**
*

(यह सभी मान्य आउटपुट में मौजूद होगा, क्योंकि दोनों शाखाएं एक ही पथ पर होने के कारण उन्हें ओवरलैप करने का कारण बनेगी।)

3शामिल के इनपुट के लिए संभावित आउटपुट :

***
* *
**

**
***
*
*

इनपुट के लिए 7:

****
*  **
*   **
*
***
  *

इनपुट के लिए 10:

****
*  *      
*********
  *
  *****

ये है कोड गोल्फ, इसलिए सबसे छोटा वैध उत्तर (बाइट्स में) जीतता है।

^{1. यह समान रूप से यादृच्छिक होना चाहिए (यानी प्रत्येक दिशा का 50/50 मौका), या समान रूप से यादृच्छिक के करीब जैसा कि आप सामान्य हार्डवेयर पर प्राप्त कर सकते हैं।}

Comments

कृपया टिप्पणी करें कि क्या आपको मेरी लंबी पोस्ट के उपभोग में कोई समस्या हो रही है - शायद मैं कुछ छोटा कर सकता हूँ (मैं तब कोशिश करूँगा)।

— nicael

बस यही उम्मीद करना सीखो। कभी-कभी यह सभी बिल्ली के रूप में व्यस्त होता है। अन्य समय की तरह यह शांत है। मत भूलना, यह भी ईस्टर है।

— ज़ाचरी

मुझे वास्तव में यकीन नहीं है कि मेरी पोस्ट में क्या गलत है क्या जो नीचे झुका, उसे समझाने की कृपा करेंगे?

— nicael

IMO N को समय के रूप में वर्णित किया गया है: P

— ASCII-only

क्या हम रिक्त स्थान और तारांकन के बजाय 0एस और 1एस का एक मैट्रिक्स वापस कर सकते हैं ?

— dylnan

Answer 1

CJam , 58 51 बाइट्स

[TT]{_2_m*\f.+{:-},mR}ri*]ee{~\)S*\{'*t}/}%::a:.+N*

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

मूल विचार यह है कि हम शुरू करते हैं [0 0]और फिर बार-बार या तो प्रत्येक तत्व में 0 या 1 जोड़ते हैं (यह सुनिश्चित करते हुए कि वे ओवरलैप से बचने के लिए शुरुआत के अलावा कभी भी बराबर नहीं होते हैं), सभी मध्यवर्ती परिणाम एकत्र करते हैं।

[[0 0] [0 1] [0 2] [0 2] [1 3]]

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

["*"
 "**"
 "* *"
 "* * "
 " * * "]

यह आउटपुट मैट्रिक्स के विकर्ण स्लाइसों को जन्म देता है (जहां बाएं से दाएं चलना वास्तविक मैट्रिक्स में शीर्ष-दाएं से नीचे-बाएं स्थानांतरित करने के लिए मेल खाता है)।

फिर हम ::a:.+"डी-डायग्नोलाइज़" का उपयोग कर सकते हैं और परिणामी लाइनें प्राप्त कर सकते हैं:

[ "**** "
  "*  *"
  "** "
  " *"
  ""     ]

Answer 2

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

Ｆ²«Ｊ⁰¦⁰Ｆ⊕θ«¿ι*↓*≔‽²ι¿ＫＫ↗

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मूल रूप से मैंने सोचा था कि पहला कदम यादृच्छिक बनाना आसान होगा लेकिन यह पहली शाखा को पूर्वानुमानित करने के लिए गोल्फर निकला। स्पष्टीकरण:

Ｆ²«

सूचकांक चर का उपयोग करके दो बार लूप करें i। (यह वास्तव में एक अंतर्निहित सूची पर आधारित है, इसलिए यह iलूप के अंदर उत्परिवर्तित करने के लिए सुरक्षित है ।)

Ｊ⁰¦⁰

कैनवास की उत्पत्ति के लिए कूदो।

Ｆ⊕θ«

लूप N+1समय।

¿ι*↓*

A को प्रिंट करें *, लेकिन मान के आधार पर कर्सर को दाईं ओर या कर्सर के नीचे छोड़ दें i।

‽²ι

iआंतरिक लूप के अगले पुनरावृत्ति के लिए मान को यादृच्छिक करें ।

¿ＫＫ↗

यदि वर्तमान वर्ण एक है *, तो इसका मतलब है कि हम दूसरी शाखा हैं और हम सही के बजाय नीचे गए हैं, इसलिए इसे सही करने के लिए दाईं ओर ऊपर जाएं। (पहली शाखा हमेशा नीचे की ओर शुरू होती है इसलिए दूसरी शाखा हमेशा इसके ऊपर होगी, जिसका अर्थ है कि हमें केवल एक ऊर्ध्वाधर टक्कर की जांच करने की आवश्यकता है।)

Comments

यह लगभग सही है, हालांकि यह न तो Nआकार वाली शाखाओं को प्रिंट करता है , लेकिन N-1आकार :)

— nicael

@nicael क्षमा करें, ठीक किया गया।

— नील

आप शायद पहले से ही इसे कई बार देख चुके हैं, लेकिन: 23 बाइट्स

— केवल

Answer 3

जावा 10, 273 272 268 239 बाइट्स

n->{var c=new char[++n][n];for(var d:c)java.util.Arrays.fill(d,' ');for(int i=0,j=0,k=0,l=0,r=0,s=0,t=0,u=0;n-->0;){c[i+=r][j+=s]=c[k+=t][l+=u]=42;do{r=t=2;r*=Math.random();t*=Math.random();s=r^1;u=t^1;}while(i+r==k+t&j+s==l+u);}return c;}

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

29 बाइट गोल्फिंग के लिए केविन क्रूजसेन को धन्यवाद ।

Ungolfed संस्करण:

n -> { // lambda taking an int as argument
    var c = new char[++n][n]; // the output; increment the virality since the root does not count
    for(var d : c) // for every line
        java.util.Arrays.fill(d,' '); // initialize it with spaces
    for(int i = 0, j = 0, // coordinates of the first branch
            k = 0, l = 0, // coordinates of the second branch
            r = 0, s = 0, // offsets for the first branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
            t = 0, u = 0; // offsets for the second branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
        n-- > 0; ) { // decrement virality and repeat as many times
        c[i+=r][j+=s] = c[k+=t][l+=u] = 42; // move according to offsets and place an '*' for each branch, 42 is ASCII code
        do { // randomly pick offsets for both branches
            r = t = 2; // Math.random() provides results in [0,1)
            r *= Math.random(); // flip a coin for the first branch
            t *= Math.random(); // flip another coin for the second
            s = r^1; // set s to 0 if r=1, to 1 if r=0
            u = t^1; // set u to 0 if t=1, to 1 if t=0
        } while(i+r==k+t&j+s==l+u); // repeat if the branches overlap
    }
    return c; // return the output
}

Comments

239 बाइट्स (मैं केवल बातें अंदर बदल दिया है do{}। थोड़ा (ints के लिए लूप) पुनश्च पहले भाग में और रखा: अपने प्रारंभिक जवाब में 0.5करने के लिए golfed किया जा सकता था .5और साथ ही।

— केविन Cruijssen

@ केविनक्रूजसेन को लगता है कि मुझे अपने गणित पर काम करने की जरूरत है। धन्यवाद :-)

— OOBalance

Answer 4

पर्ल 5 , 208 124 122 118 बाइट्स

नई बाइट्स, इंडेंटेशन और टिप्पणियों के बिना 118 बाइट्स। स्टड से N लेता है :

@b=1..2;                            #number of branches is 2
for(1..<>){                         #add length <> (the input) to each branch
  ($x,$y)=@$_                       #get where current branch has its tip now
 ,.5>rand?$x++:$y++                 #increase either x or y
 ,$o[$y][$x]++&&redo                #try again if that place is already occupied
 ,$_=[$x,$y]                        #register new tip of current branch
   for@b                            #...and do all that for each branch 
}
say map$_||!$i++?'*':$",@$_ for@o;  #output the branches

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

Comments

अच्छा है, लेकिन यह शाखाओं को प्रिंट करता है 1 तारांकन की तुलना में कम होना चाहिए :)

— nicael

कृपया मेरे प्रश्नों में उदाहरण फिर से देखें :)

— nicael

ओह, मैं बदल दिया है 2..$Nकरने के लिए 1..shiftअब और भी कुछ बाइट्स बंद मुंडा।

— केजेटिल एस।

अच्छा उत्तर! आप कुछ बाइट्स का उपयोग कर सकते हैं <>और इनपुट के बजाय shiftतर्कों और तर्कों के साथ-साथ री-ऑर्डरइनफ के लिए भी कॉल कर सकते हैं ताकि आप परिंदों randसे बच सकें। आपको अपने असाइनमेंट को @oया तो लपेटने की आवश्यकता नहीं है । मैंने उपयोग करने की कोशिश की, @b=([],[]);जो काम करने के लिए प्रकट होता है, लेकिन मैंने बहुत अधिक प्रयोग नहीं किया है इसलिए मुझे वहां एक किनारे का मामला याद आ सकता है। आशा है कि वे थोड़ी मदद करें!

— डोम हेस्टिंग्स

पर्ल पेज में गोल्फ के लिए सुझाव दिए गए कुछ अच्छी सलाह है, यह बाहर की जाँच करने के लिए सुनिश्चित करें! गुड लक और मजा करें!

— डोम हेस्टिंग्स

Answer 5

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

from random import*
N=input()
s=eval(`[[' ']*-~N]*-~N`)
s[0][0]='*'
I=x,y=1,0
J=X,Y=0,1
exec"s[y][x]=s[Y][X]='*';i,j,k,l=choice((J+I,I+I,I+J,J+J)[x-2<X:]);x+=i;y+=j;X+=k;Y+=l;"*N
for i in s:print`i`[2::5]

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

Answer 6

पर्ल 5 -a , 97 96 93 92 बाइट्स

विकर्ण पूर्वाग्रह का कोई अधिकार नहीं है।

#!/usr/bin/perl -a
@;=[1];map{$x=$y=0;map++(.5<rand?$x:$y)*$;[$y][$x]++&&redo,1.."@F"}1,2;say+($","*")[@$_]for@

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

Answer 7

PHP, 118 बाइट्स

for($r="*",$w=$argn+2;$argn--;$r[$q+=rand(0,$r[$q+1]<"*")?:$w]=$r)$r[$p+=rand(!$i++,1)?:$w]=$r;echo wordwrap($r,$w-1);

एल्विस ऑपरेटर के लिए PHP 5.4 या बाद के संस्करण की आवश्यकता है। पुराने PHP के ?:साथ बदलें ?1:।

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Comments

मैं अलग-अलग इनपुट के साथ वहां कैसे जांच करूं?

— nicael

@nicael: आप लाइन में तर्क बदल सकते हैं$argBak=$argn=

— गैलेन इवानोव

ठीक है! यकीन नहीं है कि यह एक अच्छा तरीका है या नहीं इस तरह से "स्वीकार" करने के लिए, लेकिन समुदाय को मतदान के द्वारा निर्णय लेने दें

— nicael

@nicael TiO में, केवल मान को बदलें $argn। एक वास्तविक वातावरण में, $argnSTDIN से आता है यदि आप इसे एक पाइप के रूप में चलाते हैं -R। यह तब इनपुट की प्रत्येक पंक्ति के लिए कोड निष्पादित करेगा (लेकिन मैं बहुत निश्चित हूं कि PHP कुछ इनबॉर्नवे को परेशान नहीं करता है; इसलिए स्पष्ट रूप से लगातार रन खराब आश्चर्य से बचने की अधिक संभावना है।)

— टाइटस

Answer 8

रेड , 195 190 बाइट्स

func[n][g: func[s][i: 0 d: s while[i < n][b/(d): #"*"until[r: 1 if 1 = random 2[r: n + 1]b/(d + r) =#" "]d: d + r
i: i + 1]]b:""loop n[loop n[append b" "]append b"^/"]b/1: #"*"g n + 2 g 2 b]

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

पठनीय:

f: func[n][
    g: func[s][
        i: 0
        d: s
        while[i < n][
            b/(d): #"*"
            until[
                r: 1 if 1 = random 2[r: n + 1]
                b/(d + r) = #" "
            ]
            d: d + r
            i: i + 1
        ]
    ]
    b: ""
    loop n[loop n[append b " "]append b "^/"]
    b/1: #"*"
    g n + 2
    g 2
    b
]

Answer 9

जेली , 50 43 41 बाइट्स

2ḶẊ⁸С+\‘Ṗ
⁸ÇU;Ǥ⁻Q$¿
‘,þ`⁼€þÇS+»þ`Ị$ị⁾* 

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

यह लिखने के लिए एक बहुत मजेदार था। कुछ और अधिक इष्टतम विधि हो सकती है। इस पद्धति के भीतर भी कुछ गोल्फिंग है।

इस पोस्ट के ठीक बाद मुझे एहसास हुआ कि मैं ,þ`इसके बजाय इस्तेमाल कर सकता हूं aþ,""oþ`Ɗ।

Answer 10

आर , 148 142 बाइट्स

n=scan();`~`=sample;o=r=k=1;l=c(1,n);for(i in 1:n){r=r+l~1;t=l~1;k=k+"if"(k+t-r,t,l[l!=t]);o=c(o,r,k)};write(c(" ","*")[1:n^2%in%o+1],1,n,,"")

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

इसके अतिरिक्त, हालांकि यह आउटपुट स्पेक को पूरा नहीं करेगा, आप दो शाखाओं को अलग कर सकते हैं: इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

सूचकांक से शुरू करके 1, हम क्रमशः rजोड़कर nया 1क्रमशः शाखा के लिए दाएं या बाएं कदम का चयन करते हैं। फिर हम शाखा के लिए एक और दाएं या बाएं कदम का चयन करते हैं k, और अगर यह पता चलता है कि कहां rजा रहा है, तो हम दूसरी दिशा का चयन करते हैं। तब हम उन मूल्यों को निर्धारित करते हुए उपयोग करते हैं rऔर kसूचकांकों के रूप में उपयोग करते हैं । Iterating बार, हम फिर परिणाम प्रिंट करते हैं।m"*"n-1

Answer 11

जेली , 39 38 बाइट्स

ḣ2+\€Ẏ
2Rd¤ṗẊÇ⁻Q$$¿Ç0,0ṭ‘Ṭ€×þ/$€Sị⁾* Y

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

यद्यपि असंबद्ध रूप से असंबंधित है, dएक बाइट (मेरे पिछले दृष्टिकोण से अधिक) को बचाने के लिए यहां उपयोगी है।

Answer 12

पायथन 2 , 191 187 176 बाइट्स

from random import*
n=input()
p,q=c=1,1j;s={p,q,0}
exec'z=choice(c);q,p=p+[z,1+1j-z][p+z in s],q;s|={q};'*2*~-n
R=range(n+1)
for y in R:print''.join(' *'[y+x*1jin s]for x in R)

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

फार्म की जटिल संख्या के लिए पायथन को मूल समर्थन है a+bj; यह कुछ 2-D समस्याओं को थोड़ा अधिक सुगम बनाता है ...