एक ASCII डबल हेलिक्स ड्रा करें

Question

एक प्रोग्राम लिखें जो पूर्णांक या कमांड लाइन के माध्यम से पूर्णांक एन में लेता है।

यदि N 0 है, तो एकल पत्र Oको stdout में मुद्रित किया जाना चाहिए।

---

यदि N पॉजिटिव है , तो यह क्षैतिज ASCII आर्ट डबल हेलिक्स , जो N सेगमेंट चौड़ा है, मुद्रित होना चाहिए।

यदि N 1 है, तो आउटपुट है:

 /\
O  O
 \/

यदि N 2 है, तो आउटपुट है:

 /\ /\
O  /  O
 \/ \/

यदि N 3 है, तो आउटपुट है:

 /\ /\ /\
O  /  /  O
 \/ \/ \/

यदि N 4 है, तो आउटपुट है:

 /\ /\ /\ /\
O  /  /  /  O
 \/ \/ \/ \/

पैटर्न बड़े एन के लिए ठीक उसी तरह से जारी है। ध्यान दें कि फॉरवर्ड स्लैश ( /) को सिवाय सभी स्थानों पर उपयोग किया जाना चाहिए, सिवाय Oछोरों को छोड़कर ।

---

यदि N ऋणात्मक है , तो यह ऊर्ध्वाधर ASCII आर्ट डबल हेलिक्स, लंबा -N सेगमेंट, मुद्रित होना चाहिए।

यदि N -1 है, तो आउटपुट है:

 O
/ \
\ /
 O

यदि N -2 है, तो आउटपुट है:

 O
/ \
\ /
 \
/ \
\ /
 O

यदि N -3 है, तो आउटपुट है:

 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O

यदि N -4 है, तो आउटपुट है:

 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O

पैटर्न छोटे एन के लिए ठीक उसी तरह से जारी है। ध्यान दें कि बैकवर्ड स्लैश ( \) को सभी स्थानों पर उपयोग किया जाना चाहिए, सिवाय Oसिरों के हेलिक्स को पार करना चाहिए ।

विवरण

• एक कार्यक्रम के बजाय, आप एक फ़ंक्शन लिख सकते हैं जो एन को पूर्णांक के रूप में लेता है और परिणाम को सामान्य रूप से प्रिंट करता है या इसे स्ट्रिंग के रूप में लौटाता है।
• किसी भी N के लिए आउटपुट में वैकल्पिक रूप से एक अनुगामी न्यूलाइन हो सकती है।
• किसी भी N के लिए आउटपुट की कोई भी लाइन वैकल्पिक रूप से 4 या उससे कम अनुगामी स्थान हो सकती है।
• कोई भी अग्रणी स्थान कभी नहीं होना चाहिए जो निर्दिष्ट पैटर्न का हिस्सा नहीं हैं।
• बाइट्स में सबसे छोटा कोड जीतता है।

Comments

शानदार सवाल!

— जोशपब्रॉन

यह मुझे लगता है कि n = 0 के लिए, यह प्रिंट करने के लिए सुविधाजनक हो सकता है <spc>O<spc> या \nO\n। क्या अप्राकृतिक अग्रणी व्हाट्सएप की अनुमति है?

— लेवल रिवर सेंट

print "."हेलिक्स देखने के लिए ज़ूम इन करें। * नोडनॉड *

— डेविड रिचेर्बी

@steveverrill यह मददगार हो सकता है, लेकिन अब बहुत सारे जवाब हैं, मैं नियम नहीं बदलना चाहता। मैंने स्पष्ट किया है कि अग्रणी स्थान पैटर्न का हिस्सा नहीं हैं।

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

Answer 1

CJam, 56 55 53 52 50 बाइट्स

S'O:Ori:X0>"\/"=" / \\\ / "+Xz*1>O]s3/X"z"<~N*X\O?

उस आकार को देखो! मुख्य अपराधी N = 0विशेष मामला है और ऊर्ध्वाधर हेलिक्स के \बजाय /।

यहाँ दिया गया है कि यह कैसे काम करता है:

S'O:O                                  e# Put a space on stack. Now put char O on stack
                                       e# and assign it to variable O. This is not really
                                       e# helping in golfing as using 'O everywhere is
                                       e# same number of bytes
     ri:X                              e# Read input as in integer and store it in X
         0>"\/"=                       e# If X is greater than 0, choose /, otherwise \
                " / \\\ / "            e# Put this string on stack
                           +           e# Append to chosen \ or /
                            Xz*        e# Repeat it abs(X) times
1>                                     e# Remove the first character from repeated string
  O]                                   e# Put char O on stack, wrap everything in an array
                                       e# and convert it to string.
    3/                                 e# Split the string into parts of length 3
      X"z"<~                           e# If X is positive, transpose the array to get a
                                       e# horizontal helix, otherwise it would be vertical
            N*                         e# Join the parts with newline
              X\O?                     e# If X was 0, then pick char O instead of this
                                       e# final joined string.

कोड को तीन भागों में विभाजित किया गया है:

• भाग या X0>"\/"=" / \\\ / "+तो देता है "/ / \\\ / "या "\ / \\\ / "जो महत्वपूर्ण है क्योंकि हेलिक्स बस वैकल्पिक से बना है "/ \"और या "\ /"तो में शामिल हो गया है । उदाहरण के लिए, यदि आप इनपुट पर विचार करते हैं , तो आपका अंतिम दोहराया स्ट्रिंग होगा (भागने के बिना)। यह स्पष्ट रूप से शुरुआत में अतिरिक्त है और अंत में एक अतिरिक्त स्थान है।" / "" \ "2"/ / \\ / / / \\ / "/
• दूसरा हिस्सा उपरोक्त स्ट्रिंग को अतिरिक्त चीजों के साथ सही करने और विभाजित करने के लिए है। एक इनपुट के लिए 2, बिना नए अंक के वांछित अंतिम स्ट्रिंग होगी " O / \\\ / / / \\\ / O", लेकिन उपरोक्त बिंदु के बाद, हमारे पास केवल है "/ / \\\ / / / \\\ / "। इसलिए हम पहले चरित्र को हटाते हैं, एक स्थान और 'Oशुरुआत में और दूसरे 'Oको अंत में जोड़ते हैं । फिर हम अंत में इसे 3 भागों में विभाजित करते हैं
• अंत में, हम यह तय करते हैं कि एक ऊर्ध्वाधर हेलिक्स के लिए इस विभाजन स्ट्रिंग को स्थानांतरित करना है या नहीं; नए सिरे से भागों में शामिल हों; और इस और एक चरित्र के बीच चयन करें 'O(इनपुट 0 केस के लिए)

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

Answer 2

जावास्क्रिप्ट (ईएस 6), 126 132 133

A=n=>(F=(f,j='')=>f+(j+f).repeat(n-1),n>0?F(' /\\')+`
o${F('  ','/')}o
`+F(' \\/'):(n=-n)?` o${F(`
/ \\
\\ /
`,' \\')} o`:'o') 

// Test
for(i=0;i<10;i++)
  P.innerHTML = P.innerHTML + A(i)+'\n\n\n',
  N.innerHTML = N.innerHTML + A(-i)+'\n\n\n'

pre { 
  font-size: 10px;
  line-height: 9px;
}

<table>
<tr><th>Positive</th><th>Negative</th></tr>
<tr><td valign=top><pre id=P></pre></td><td><pre id=N></pre></td></tr>
</table>

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

अधिक पठनीय

A=n=>(
  F=(f,j='')=>f+(j+f).repeat(n-1),
  n > 0 ? F(' /\\') + '\no' + F('  ','/') + 'o\n'+F(' \\/')
  : (n=-n) ? ' o' + F('\n/ \\\n\\ /\n',' \\')'+' o':'o'
)  

Comments

और मैंने सोचा कि मैं जेएस के साथ अच्छा हूं ... क्या n=>(कर रहा है? मैंने उस ऑपरेटर को पहले कभी नहीं देखा और न ही इस्तेमाल किया।

— YU NO WORK

@YUNOWORK यह एक फंक्शन बनाने के लिए ES6 फीचर है, यह अभी भी केवल फायरफॉक्स पर उपलब्ध है। Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— edc65

यह कुछ अच्छा सामान है, जल्द ही ES6 में भी देखना चाहिए। स्पष्टीकरण देने के लिए धन्यवाद!

— YU NO WORK

Answer 3

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

M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)?jb?gQ\/>Q0msdCg_Q\\Q\O

प्रदर्शन।

स्पष्टीकरण:

पहला खंड, M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)एक फ़ंक्शन को परिभाषित करता है g, जो दो इनपुट लेता है। पहला इनपुट, Gउपयोग करने के लिए पुनरावृत्ति की संख्या है। यह इनपुट का पूर्ण मूल्य है। दूसरा इनपुट, Hसर्पिल के केंद्र में रखने के लिए वर्ण है।

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

पहले तत्व द्वारा परिभाषित किया गया है Jj"/\\"*hGd। रिक्त स्थान *hGdकी स्ट्रिंग है G+1। j"/\\"*hGdउस स्ट्रिंग "/\"को डेलीमीटर के साथ जोड़ता है। Jशुरुआत में भविष्य में उपयोग के लिए परिणामी मूल्य बचाता है।

दूसरा तत्व है jP*G+*2dH*2\O। हम साथ शुरू करते हैं +*2dH। इनपुट चरित्र के बाद यह दो स्थान है। फिर, हम उस स्ट्रिंग Gसमय को दोहराते हैं *G। फिर, हम इसके अंतिम वर्ण को निकालते हैं P। अंत में, हम इस स्ट्रिंग को दो Oवर्णों के साथ घेरते हैं j ... *2\O।

तीसरा तत्व के साथ उत्पन्न होता है _J। यह केवल पहली पंक्ति का उल्टा है।

उत्तरार्द्ध खंड, ?jb?gQ\/>Q0msdCg_Q\\Q\Oसकारात्मक, नकारात्मक और शून्य तीन अलग-अलग सकारात्मकताओं के बीच चयन करता है। पहले अगर-तब की स्थिति Q, इनपुट। दूसरी स्थिति >Q0यह है कि इनपुट सकारात्मक है या नहीं।

यदि Qशून्य है, \Oवर्ण O, मुद्रित है।

यदि Qनॉनज़रो है, तो हम नई सुर्खियों में दूसरी टर्नरी के परिणाम में शामिल होते हैं और इसे प्रिंट करते हैं jb। अगर Qसकारात्मक है, सूची में शामिल हो गए और मुद्रित है gQ\/, g(Q,"/")।

यदि Qनकारात्मक है, तो सूची में शामिल और मुद्रित किया जाता है msdCg_Q\\। हम शुरुआत करते हैं g_Q\\, जो है g(-Q,"\")। फिर हम पंक्तियों और स्तंभों के साथ स्थानांतरित करते हैं C। msdवर्णों के परिणामी स्वरों को तार में बदल देता है, नई कहानियों में शामिल होने और मुद्रित होने के लिए तैयार होता है।

Answer 4

अजगर 2, 118

n=input()
a=[' O '[n==0:]]+['/ \\','\\ /','  /\\ '[n<0::2]]*abs(n)
a[-1]=a[0]
for x in[a,zip(*a)][n>0]:print''.join(x)

स्ट्रिंग्स की सूची से वर्टिकल डबल हेलिक्स बनाता है और क्षैतिज को प्राप्त करने के लिए इसे स्थानांतरित करता है। मुझे यकीन है कि इसमें सुधार किया जा सकता है।

Comments

अच्छा काम। एक बात: यह नंबर 0. के बजाय एक कैपिटल लेटर "O" होना चाहिए

— एलेक्स ए

@AlexA। धन्यवाद - मैं पूरी तरह से चूक गया।

— grc

Answer 5

जावा, 500 488 बाइट्स

मेरी पहली कोशिश, और दुर्भाग्य से वर्तमान नेता की तुलना में यह 10 * लंबा है :( किसी को कोई सुझाव है (किसी अन्य भाषा का उपयोग करने के अलावा)?

import java.util.*;class t{public static void main(String[] args){Scanner sc=new Scanner(System.in);int n=Integer.parseInt(sc.nextLine());if(n>0){for(int i=0;i<n;i++)System.out.print(" /\\");o("");System.out.print('o');for(int i=0;i<n-1;i++)System.out.print("  /");o("  o");for(int i=0;i<n;i++)System.out.print(" \\/");}else if(n<0){o(" o ");for(int i=0;i<-n-1;i++){o("/ \\");o("\\ /");o(" \\ ");}o("/ \\");o("\\ /");o(" o ");}else o("o");}static void o(String s){System.out.println(s);}}

Comments

PPCG में आपका स्वागत है! यह महत्वपूर्ण नहीं है कि आप जावा के साथ सीजेएम जैसी गोल्फिंग भाषा के कारक 10 हैं। ;) आनंद एक ही भाषा, या समान क्रिया-कलापों की भाषाओं में, और आपकी भाषा की नई विधाओं को सीखने की कोशिश करता है। मैं जावा में गोल्फिंग से परिचित नहीं हूं, लेकिन आप कुछ बाइट्स को कम वर्ग के नाम और लगातार 1-अक्षर वाले चर नामों से बचा सकते हैं। इसके अलावा, क्या आप हर बार import System.*लिखने के लिए सिर्फ या कुछ नहीं बचा Systemसकते हैं?

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

वास्तव में वह कर सकता है, import static java.lang.System.*;या वह एक चर के रूप में मानक आउटपुट स्ट्रीम को बचा सकता है (हालांकि, मुझे नहीं पता कि क्या वह इस मामले में बचत करेगा या बाधा देगा, जांच नहीं की गई है)।

— Bloo

जावा के लिए +1। आप scचर से छुटकारा पा सकते हैं क्योंकि यह केवल एक बार कहा जाता है। 14 बाइट्स से बचे।

— Topher

मुझे पता है कि यह लगभग तीन साल हो गया है, लेकिन काफी कुछ चीजें गोल्फ हो सकती हैं: class M{public static void main(String[]a){int n=new Integer(new java.util.Scanner(System.in).next()),i=n;if(n>0){for(;i-->0;)o(" /\\");o("\no");for(i=n;i-->1;)o(" /");o(" o\n");for(i=0;i++<n;)o(" \\/");}else if(n<0){o(" o \n");for(i=0;i++<~n;)o("/ \\\n\\ /\n \\ \n");o("/ \\\n\\ /\n o \n");}else o("o\n");}static<T>void o(T s){System.out.print(s);}}( 352 बाइट्स ) इसे ऑनलाइन आज़माएं।

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

इसके अलावा, इस चुनौती के लिए एक फ़ंक्शन की अनुमति है, इसलिए जावा 8+ लैम्ब्डा का उपयोग करते समय यह 251 बाइट्स हो सकता है : n->{int i=n;if(n>0){for(;i-->0;)o(" /\\");o("\no");for(i=n;i-->1;)o(" /");o(" o\n");for(i=0;i++<n;)o(" \\/");}else if(n<0){o(" o \n");for(i=0;i++<~n;)o("/ \\\n\\ /\n \\ \n");o("/ \\\n\\ /\n o \n");}else o("o\n");};<T>void o(T s){System.out.print(s);} इसे ऑनलाइन आज़माएं।

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

Answer 6

हास्केल, 156 बाइट्स

h 0="O"
h n|n>0=' ':c n "/\\ "++"\nO"++c(n-1)"  /"++"  O\n "++c n "\\/ "
   |0<1=" O\n/ \\\n"++c(-n-1)"\\ /\n \\\n/ \\\n"++"\\ /\n O"
c x=concat.replicate x

फिर आप इसे इस प्रकार लिख सकते हैं:

*Main> putStrLn $ h 1
 /\ 
O  O
 \/ 
*Main> putStrLn $ h 0
O
*Main> putStrLn $ h (-1)
 O
/ \
\ /
 O
*Main> putStrLn $ h 3
 /\ /\ /\ 
O  /  /  O
 \/ \/ \/ 
*Main> putStrLn $ h (-3)
 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O
*Main>

Comments

आप लिख सकते हैं 1<2या इसके बजाय कुछ ऐसा लिख सकते हैं True, और एक बाइट बचा सकते हैं।

— मारीनस

@marinus: अद्यतन, बहुत धन्यवाद।

— विलेम वैन ओन्सेम

Answer 7

सी #, 242 241 238 230 222 219 बाइट्स

मार्टिन की टिप्पणी से प्रेरित , यहाँ कुछ इस तरह से मेरा पहला प्रयास है:

string h(int n){int x=0;string p="",r=n==0?"O":p;if(n>0){for(;x++<n;){r+=" /\\";p+=" \\/";}r+="\nO  ";for(;x-->2;)r+="/  ";r+="O\n"+p;}else if(n<0){r+=@" O
/ \
";for(--x;x-->n;)r+=@"\ /
 \
/ \
";r+=@"\ /
 O";}return r;}

अधिक आसानी से:

string h(int n)
{
    int x = 0;
    string p = "",
            r = n==0 ? "O" : p;
    if (n > 0) {
        for (; x++ < n;) {
            r += " /\\";
            p += " \\/";
        }
        r += "\nO  ";
        for (; x-- > 2;) r += "/  ";
        r += "O\n" + p;
    }
    else if(n<0) {
        r += @" O
/ \
";
        for (--x; x-- > n;) r += @"\ /
 \
/ \
";
        r += @"\ /
 O";
    }
    return r;
}

Answer 8

सी # 199 197 196 बाइट्स

string f(int n){var u=n<0;int m=u?-n:n;string a="",b=" O ";for(;m-->0;)b+="\n/ \\\n\\ /\n "+(m==0?"O ":u?"\\ ":"/ ");for(;++m<3;)a+=string.Concat(b.Split('\n').Select(s=>s[m]))+"\n";return u?b:a;}

Ungolfed संस्करण:

    string f(int n)
    {
        var u = n < 0;
        int m = u ? -n : n;
        string a = "", b = " O ";
        for (; m-- > 0; ) b += "\n/ \\\n\\ /\n " + (m == 0 ? "O " : u ? "\\ " : "/ ");
        for (; ++m < 3;) a += string.Concat(b.Split('\n').Select(s => s[m])) + "\n"; 
        return u ? b : a;
    }

विचार ऊर्ध्वाधर डिस्प्ले से क्षैतिज प्रदर्शन को वर्णों के ट्रांसपोज़्ड मैट्रिक्स को प्रस्तुत करना है।

Comments

अच्छा - मुझे C # अभी तक ट्रांसपोज़िशन जवाब देने की कोशिश करने का मौका नहीं मिला था। ध्यान दें कि आप "\" और "/" गलत तरीके से क्रॉसओवर के लिए दौर है, और आप को बदल कर कुछ बाइट्स बचा सकते हैं for(;m>0;--m)करने के लिए for(;m-->0;)दोनों छोरों में

— जेम्स थोर्प

यह स्ट्रिंग: "\n/ \\\n\\ /\n "मेरे उत्तर के तरीकों के अनुसार भी छोटा किया जा सकता है - अर्थात उपयोग करें @"...", जहाँ प्रत्येक "\\" "\" बन जाता है और प्रत्येक "\ n" एक वास्तविक न्यूलाइन बन जाता है

— जेम्स थोरपे

ठीक है, मैंने समाधान को छोटा करने के लिए चर यू को पेश किया, लेकिन क्रॉसओवर के परीक्षण को पलटना भूल गया। लूप की स्थिति को छोटा करने के विचार के लिए धन्यवाद (हालांकि मैं दूसरे लूप को छोटा नहीं कर सकता क्योंकि मी तब 0 के बराबर है और मैं इसे इंडेक्स के रूप में उपयोग करता हूं)। न्यूलाइन ट्रिक के लिए, यह विंडोज़ के तहत काम नहीं करता है क्योंकि b.Split ('\ n') को b.Split ('\ n', '\ r') में बदल दिया जाना चाहिए, जिसमें 5 वर्ण होते हैं और केवल 3 की बचत होती है।

— विंसेंट रिपोल

आह निष्पक्ष पर्याप्त - मुझे लगता है कि मैंने ध्यान नहीं दिया था क्योंकि मैं कुछ भी नहीं विभाजित कर रहा था। मैं भी सिर्फ आप स्विच कर सकता है देखा bool uके लिए var uएक और पूरे बाइट के लिए :)

— जेम्स थोर्प

चूंकि आपके संस्करण ने किसी भी संस्करण का उपयोग नहीं किया, इसलिए मैं अनुचित लाभ नहीं लेना चाहता था। :)

— विंसेंट रिपोल

Answer 9

पायथन 3, 118 बाइट्स

x=int(input())
print("O"if x==0else" /\\"*x+"\nO "+" / "*(x-1)+" O\n"+" \\/"*x if x>0else(" O"+"\n/ \\\n\\ /\n \\"*-x)[:-1]+"O")

मेरा पहला कोड गोल्फ सबमिशन है, इसलिए यह बिल्कुल भी प्रभावशाली नहीं हो सकता है।

बस पायथन का उपयोग करता है ... यदि ... और ... तीन परिदृश्यों को अलग करने के लिए टर्नरी ऑपरेटर। यह एक छोटे तार को दोहराने के लिए एक स्ट्रिंग देता है जो एक निश्चित संख्या में प्रिंट करता है।

Answer 10

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

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

n->(if n==0 println("O")else m=abs(n);A=B=reshape(split(" / "*(n>0?"/":"\\")*" \\\\ /",""),(3,3));E=[" ";"O";" "];if m>1for i=2:m B=hcat(B,A)end end;B[:,1]=E;B=hcat(B,E);C=n>0?B:B';for i=1:size(C,1) println(join(C[i,:]))end end)

यह एक लैम्बडा फ़ंक्शन बनाता है जो एक पूर्णांक लेता है और उचित रूप से प्रारूपित डबल हेलिक्स प्रिंट करता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=n->(...)।

असंगठित + स्पष्टीकरण:

function f(n)
    if n == 0
        println("O")
    else
        m = abs(n)

        # Split the string into a 3x3 matrix with a slash on the left,
        # or a backslash for n < 0
        A = B = reshape(split(" / " * (n > 0 ? "/" : "\\") * " \\\\ /", ""), (3, 3))

        # We can get the O lines where needed by appending this
        E = [" "; "O"; " "]

        # Grow the helix by abs(n)
        if m > 1
            for i = 2:m
                B = hcat(B, A)
            end
        end

        # Exchange the first column for E
        B[:,1] = E

        # Add E onto the right
        B = hcat(B, E)

        # If n is negative, we actually want the transpose
        C = n > 0 ? B : B'

        # Print the rows of C
        for i = 1:size(C, 1)
            println(join(C[i,:]))
        end
    end
end

कुछ उदाहरण:

julia> f(1)
 /\
O  O
 \/

julia> f(-2)
 O 
/ \
\ /
 \
/ \
\ /
 O

Answer 11

पायथन 3, 135 बाइट्स

n=int(input());m=abs(n)-1;print({n:" O\n/ \\\n"+m*"\ /\n \\\n/ \\\n"+"\\ /\n O",m+1:n*" /\\"+"\nO"+"  /"*m+"  O\n"+" \/"*n,0:"O"}[n])

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

Answer 12

पर्ल, 91 97

अंत में ट्रांसपोज़िंग बहुत महंगी साबित हुई।

#!perl -n
print/-/?"\0\23"^" \\
/ \\
\\ /
"x-$_." O":-$_?" /\\"x$_.("*`"^" / "x$_." O
"." \\/"x$_):O

पिछला समाधान:

#!perl -n
$".="`"^"/ 
\\ /
/ \\
 "x abs.O;print/-/?$"=~y!/\\!\\/!r:/^0/?O:map{($"=~/^.{$_}(.)/mg,$/)}2,1,0

मुझे परखो ।

Comments

यह वास्तव में मीठा है। आप की जगह दो और बाइट्स बचा सकता है /^0/?O:etcके साथ$_?etc:O

— सिकंदर-ब्रेट

@ अलेक्जेंडर-ब्रेट को इनपुट पर ईओएल की आवश्यकता नहीं होगी, क्योंकि "0 \ n" सत्य का मूल्यांकन करता है।

— नटकी

आप शायद स्टड पर कोई ईओएल की आवश्यकता के साथ दूर हो सकते हैं :) इसके अलावा, आप 4 को बचा सकते हैं$".="\23"^"\\ / \\ \\ / "x abs."O ";print/-/?$":/^0/?O:map{reverse$/,$"=~/(.).{$_}$/mg}0..2

— अलेक्जेंडर-ब्रेट

@ अलेक्जेंडर-ब्रेट, यह पॉज़िटिव नंबर्स के लिए सेंटर लाइन में बैकस्लैश बनाता है, जो गलत है, है ना?

— नटकी

अरे यार, यही तो है जो मुझे तेज और ढीले खेलते हुए मिलता है। आप बिल्कुल सही कह रहे है। इसके अलावा, क्या मैंने उल्लेख किया है कि मैं वास्तव में इस सरणी-परिवर्तन विचार को पसंद करता हूं।

— अलेक्जेंडर-ब्रेट

Answer 13

स्कीम, 379 बाइट्स

कोड गोल्फ में मेरा पहला प्रयास और, दुर्भाग्य से, सबसे लंबे लोगों में से एक। :(

(define (h i) (define a string-append) (define (k n p q s e) (cond ((= i n) (p s (k (q n 1) p q s e))) ((= 0 n) e) (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\") (k (q n 1) p q s e))))) (if (= i 0) "O\n" (apply a (map (lambda (s) (a s "\n")) (if (> i 0) (k i (lambda (x y) (map a x y)) - '(" /" "O " " \\") '("\\" " O" "/")) (k i append + '(" O" "/ \\") '("\\ /" " O")))))))

Ungolfified:

(define (h i)
  (define a string-append)

  (define (k n p q s e)
    (cond ((= i n) (p s (k (q n 1) p q s e)))
          ((= 0 n) e)
          (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\")
                   (k (q n 1) p q s e)))))

  (if (= i 0) "O\n"
      (apply a (map (lambda (s) (a s "\n"))
                    (if (> i 0)
                        (k i (lambda (x y) (map a x y)) -
                           '(" /" "O " " \\")
                           '("\\" " O" "/"))
                        (k i append +
                           '(" O" "/ \\")
                           '("\\ /" " O")))))))

Answer 14

जावा, 282

विशेष रूप से अच्छा चर नामों के साथ मेरा पहला दृष्टिकोण:

class H{public static void main(String[]_){int N=Integer.parseInt(_[0]),í=N;String ì="/ \\\n\\ /\n",I=" o \n",i="",l=I;for(;í-->0;)i+=" /\\";i+="\no";for(í=N;í-->1;)i+="  /";i+="  o\n";for(í=N;í-->0;)i+=" \\/";for(í=1;í++<-N;)l+=ì+" \\ \n";System.out.println(N<0?l+ì+I:N>0?i:"o");}}

_{मुझे नहीं पता कि मैं ऐसा क्यों कर रहा हूं। कुछ मनोरंजक बात होनी चाहिए।}

Answer 15

जावा, 317

मेरा पहला कोड गोल्फ प्रयास।

public class t{public static void main(String[]e){int n=Integer.parseInt(e[0]);String s=new String(new char[n==0?0:(n>0?n:-n)-1]),u="\0";System.out.print(n==0?"O":n>0?s.replace(u," /\\")+" /\\\nO"+s.replace(u,"  /")+"  O\n"+s.replace(u," \\/")+" \\/":" O \n/ \\\n"+s.replace(u,"\\ /\n \\ \n/ \\\n")+"\\ /\n O \n");}}

Answer 16

पायथन 3, 165 बाइट्स

x,a,b,c,d=int(input())-1,'\ /',' / ','/ \\','\ /\n \\\n/ \\\n'
print([[' O\n/ \\\n'+d*abs(x+2)+'\ /\n O',' /'+a*x+'\\\nO '+b*x+' O\n \\'+c*x+'/'],'OO'][x==-1][x>-1])

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

Answer 17

पर्ल, 193 197 187 180 166 163B

-एक कमांडलाइन स्विच के लिए 1 बाइट पेनल्टी। साथ चलाएं echo 1|perl -M5.10.0 -n scratch.pl:

$_*=3;$s=($m=abs)==$_;$_?map{say if$_=join'',map{(map[/./g]," O ",(('/ \\', '\\ /',$s?' / ':' \\ ')x$m)[0..$m-2]," O")[$s?$_:$j][$s?$j:$_]}0..$m;$j++}0..$m:say'O'

व्हॉट्सएप के साथ:

$_ *= 3;
$s = ($m = abs) == $_;
$_ ? map{
      say if $_=join '', map {
       ( map[/./g],
          " O ",
          (('/ \\', '\\ /',$s?' / ':' \\ ') x $m)[0..$m-2],
          " O"
        )[$s ? $_ : $j][$s ? $j : $_]
       }0..$m;
      $j++
    } 0..$m
  : say 'O'

Comments

क्या यह पारंपरिक है जो -M5.10.0आपकी बाइट की गिनती में योगदान नहीं करता है? say है कोड गोल्फ के लिए आसान ...

— xebtl

@ TheSuitIsBlackNot ने कहा कि यह था (शीर्ष टिप्पणी में कोडगुल्फ .stackexchange.com/a/49762/19039 पर) - मेरा मानना ​​है कि यह एक भाषा संस्करण है।

— एलेक्जेंडर-ब्रेट

Answer 18

PHP, 341

$s='';$n=$argv[1];$l=PHP_EOL;if($n>0){for($i=0;$i<$n;$i++)$s.=" /\\";$s.=$l;for($i=0;$i<$n;$i++){if($i==0)$s.='o';if($i<$n-1)$s.='  /';if($i==$n-1)$s.='  o';}$s.=$l;for($i=0;$i<$n;$i++)$s.=" \\/";}else{$n=abs($n);for($i=0;$i<$n;$i++){if($i== 0)$s.=' o '.$l;$s.="/ \\".$l."\\ /".$l;if($i < $n-1)$s.=' \\ '.$l;if($i==$n-1)$s.=' o '.$l;}}echo $s;

अनप्लग्ड संस्करण

$s = '';
$n = $argv[1];
echo PHP_EOL;
if($n > 0)
{
    for($i=0;$i<$n;$i++)
    {
        $s.=" /\\";
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        if($i==0) { 
            $s.='o';
        }
        if($i < $n-1) {
            $s.='  /';
        }    
        if( $i == $n-1)
        {
            $s.='  o';
        }
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        $s.=" \\/";
    }
} else
{
    $n = abs($n);
    for($i=0;$i<$n;$i++)
    {
        if($i == 0) {
            $s.=' o '.PHP_EOL;    
        }    
        $s.="/ \\".PHP_EOL."\\ /".PHP_EOL;
        if($i < $n-1) {
            $s.=' \\ '.PHP_EOL;
        }    
        if( $i == $n-1) {
            $s.=' o '.PHP_EOL;
        }    
    }    
}

echo $s;

Answer 19

जेएवीए 377 384 बाइट्स

class F{public static void main(String[] a){int n=Integer.parseInt(a[0]);if(n>0){for(int i=0;i<n;i++)p(" /\\");p("\n");for(int i=0;i<n;i++){if(i==0)if(n>1)p("O  ");else p("O  O");else if(i==n-1)p("/  O");else p("/  ");}p("\n");for(int i=0;i<n;i++){p(" \\/");}}else{p(" O\n");for(int i=0;i<Math.abs(n);i++){p("/ \\\n\\ /\n O\n");}}}static void p(String s){System.out.print(s);}}

Answer 20

सी ++ 269 262 258

#include <string>
#include <iostream>
int main(){int i,j;std::cin>>i;std::string s,u,t;if(i>0){for(j=i;j;j--){s+=" /\\";t+="/  ";u+=" \\/";}t[0]='O';t+="O";s=s+'\n'+t+'\n'+u;}else{for(j=i;j;j++)s+=" \\\n/ \\\n\\ /\n";s[1]='O';s+=" O";}std::cout<<(i==0?"O":s);}

Answer 21

आर, 228 201

n=scan();z=cat;f=`for`;if(!n)z("O");if(n>0){f(i,1:n,z(" /\\"));z("\nO  ");if(n>1)f(i,2:n,z("/  "));z("O\n");f(i,1:n,z(" \\/"))};if(n<0){z(" O\n");f(i,-n:1,{z("/ \\\n\\ /\n ");if(i>1)z("\\\n")});z("O")}

कोड गोल्फ में मेरा पहला प्रयास। मुझे लगता है कि यह काम करता है लेकिन यह सूक्ष्म नहीं है।

n=scan(); # enter number here
z=cat;
if(!n) z("O\n");
if(n>0){
  z(" ");
  for(i in 1:n) z("/\\ ");
  z("\nO");
  if(n>1){
    for(i in 2:n) z("  /")
  };
  z("  O\n ");
  for(i in 1:n) z("\\/ ")
};
if(n<0){
  z(" O \n");
  for(i in -n:1){
    z("/ \\\n\\ /");
    if(i>1) z("\n \\\n")
  };
z("\n O ")
}

Answer 22

ग्रूवी, 142 134 129 125 120 118

a=args[0]as int;b="\n/ \\\n\\ /\n ";print!a?"O":a>0?" /\\"*a+"\nO  ${"/  "*(a-1)}O\n"+" \\/"*a:" O$b${"\\$b"*(1-a)}O"

अंत में अजगर 2 के साथ बंधे!

Answer 23

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

↙OＦ↔θ/¶\¶ \¶↗‖ＢO¿›Ｎ⁰⟲Ｔ

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

↙O

शीर्ष प्रिंट करें O, और कर्सर को एक स्थान नीचे और बाईं ओर छोड़ दें।

Ｆ↔θ/¶\¶ \¶

स्ट्रिंग्स को प्रिंट करें /, \और  \इनपुट की निरपेक्ष संख्या मान के लिए दोहराएं।

↗

पिछले पर वापस जाएँ \।

‖Ｂ

हेलिक्स के दाईं ओर बनाने के लिए प्रतिबिंबित करें। मैं यहाँ ऐसा इसलिए करता हूँ क्योंकि अन्यथा ↗असंदिग्ध रूप से पार्स नहीं होता।

O

\एक के साथ अंतिम ओवरराइट करें O।

¿›Ｎ⁰⟲Ｔ

यदि इनपुट सकारात्मक था तो कैनवास को घुमाएं।

Answer 24

कैनवास , 33 32 30 बाइट्स

 /¶O：╴⤢╷\ /¶ \×＋；↔＋──╴０＜？↷｝╴‽O

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

स्पष्टीकरण:

 /¶O:                           push " /\¶O" twice
     ╴⤢╷                        push the absolute value of the input, -1
        \ /¶ /×                 repeat "\ /¶ /" horizontally that many times
               ＋                append that horizontally to one of the first strings
                ;               and get the other, reverse it
                 ↔+             and then append it to the result of above. Now the top part of the helix is done
                   ──           vertically palindromize with no mirroring (works because of a misake - it just doesn't overlap smartly)
                     ╴0<? }     if the input is less than 0
                         ↷        rotate clockwise the whole thing
                           ╴‽   if the input is falsy (aka 0)
                             O    push O; implicitly output the top of stack

Answer 25

सी ++, 352

कम से कम उत्तर में नहीं, लेकिन C ++ में अब तक पहला :)

#include <iostream>
int main(int argc, char* argv[]){int a=argv[0][0]-'0';if(a==0){printf("o");}else if(a>0){for(int i =0; i < a;i++){printf(" /\\");}printf("\no");for(int i=0;i<a-1;i++){printf("  /");}printf("  o\n");for(int i=0;i<a;i++){printf(" \\/");}}else{printf(" o\n/ \\\n\\ /\n");for(int i=0;i>a+1;i--){printf("/ \\\n\\ /\n");}printf(" o");};}

यह परीक्षण करने के लिए व्हॉट्सएप के साथ C ++ शेल में है

Answer 26

प्रति 156

$==pop;print$=>0?' /\\'x$=.$/:'',$=>0?'O'.'  /'x$=."\bO
":'',$=>0?' \\/'x$=:'';print$=<0?" O":'';print"
/ \\
\\ /
 \\" for$=..-1;print$=<0?"\bO":!$=?"O":''

सुंदर सीधे आगे प्रयास, मेरा दूसरा गोल्फ। मुझे लगता है कि न्यूलाइन की गिनती 1 बाइट के रूप में सही है?

अब यह पता लगाने के लिए कि उन सभी ternaries को एक साथ कैसे जोड़ा जाए .. मेरे पास :'';हर जगह सुधार के लिए बहुत जगह है।

Answer 27

सी, 189 बाइट्स

char*h="6Er66 e66Ee 6rE66",*v="6e6 E6r r6E 6r6 6e6",*z="e",*u;b,m,w,c,p;f(n){b=n<0;u=b?v:n?h:z;for(m=b?4:1,w=n*(b?-3:3);u[p];p+=++c%((w+2)*m)==w*m?m:p%(6*m)==m*4?-m*3:0)putchar(u[p++]-22);}

व्हॉट्सएप और नई खबरों के साथ:

char *h="6Er66 e66Ee 6rE66",
     *v="6e6 E6r r6E 6r6 6e6",
     *z="e",
     *u;
b, m, w, c, p;
f(n) {
    b = n < 0;
    u = b ? v : n ? h : z;
    for (m = b ? 4 : 1, w = n * (b ? - 3 : 3);
         u[p];
         p += ++c % ((w + 2) * m) == w * m ? m : p % (6 * m ) == m * 4 ? - m * 3 : 0)
        putchar(u[p++] - 22);
 }

दृष्टिकोण के बारे में कुछ नोट्स:

• चरित्र सरणियों में पैटर्न को संग्रहीत करता है। विशेष पात्रों से बचने के लिए बैकस्लैश के एक गुच्छा की जरूरत से बचने के लिए उन्हें 22 पात्रों द्वारा स्थानांतरित किया जाता है।
• क्षैतिज, ऊर्ध्वाधर और शून्य के लिए अलग-अलग पैटर्न का उपयोग करता है। मैंने शुरू में एक एकल पैटर्न का उपयोग करने पर विचार किया था, और सिर्फ सकारात्मक और नकारात्मक मूल्यों के लिए इसे अलग तरह से ट्रेस किया। मैंने इसे लागू नहीं किया, लेकिन मुझे लग रहा था कि यह तर्क को थोड़ा और जटिल बना देगा। विशेष रूप से केंद्रीय स्लैश में दो मामलों के लिए विपरीत दिशा है। और टेबल इतनी बड़ी नहीं हैं, इसलिए यह अधिक आशाजनक लग रहा था।
• कोड मुख्य रूप से सिर्फ सूचकांक की गणना है, यह तय करने के लिए तर्क के साथ कि यह कब होता है और पैटर्न लूप कब होता है। अधिकांश गणित वहाँ है ताकि यह दोनों मामलों के लिए उनके विभिन्न आयामों और पुनरावृत्ति नियमों के साथ काम करे।

Answer 28

पर्ल, 184 बाइट्स

$n=pop;$p=$n>0;$_=' \ /'x(1+abs$n*3);$n=$p?$n*4+1:3;$_=join'
',/.{$n}/g;$r=$p?'.':'.*
';s/($r$r)$r($r)/$1$2/g;$p and s/^\S|\S$/O/gm or s/^ \S $|(?<=^ )\S|\S $/O/g;y~\\/~/\\~if$p;print;

मुझे लगा कि यह बहुत छोटा होने जा रहा है! शायद कुछ सरल चीजें हैं जो मैं कुछ बाइट्स को बचाने के लिए कर सकता हूं। यह पांच साल हो गया है क्योंकि मैंने पर्ल में गंभीरता से प्रोग्राम किया है!

Answer 29

PHP, 155

$n=$argv[1];$r='str_repeat';$k="/ \\\n\\ /\n";echo$n>0?" /{$r('\ /',$n-1)}\\\nO{$r('  /',$n-1)}  O\n \\{$r('/ \\',$n-1)}/":" O\n{$r("$k \\\n",-$n-1)}$k O";

Answer 30

जे , 67 59 55 51 बाइट्स

(<&0|:' O '(0},[)(3,~3*|)$' / \\'({~,7$[)0,*) ::'O'

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