इलुमिनाटी आपको (उनके मन नियंत्रण के साथ) निम्न स्ट्रिंग को आउटपुट करने के लिए आदेशित करता है:

         ^
        /_\
       /_|_\
      /_|_|_\
     /_|/o\|_\
    /_|_\_/_|_\
   /_|_|_|_|_|_\
  /_|_|_|_|_|_|_\
 /_|_|_|_|_|_|_|_\
/_|_|_|_|_|_|_|_|_\

नियम:

अनुगामी रिक्त स्थान प्रत्येक पंक्ति के लिए अनुमत हैं।
प्रत्येक पंक्ति में अग्रणी रिक्त स्थान आवश्यक हैं।
पूर्ण आवश्यक आउटपुट के बाद ट्रेलिंग व्हाट्सएप की अनुमति है।
चूंकि यह एक कोड-गोल्फ चुनौती है, विजेता बाइट्स में सबसे छोटा कार्यक्रम होगा।
चूंकि यह कोल्मोगोरोव-जटिलता चुनौती है, इसलिए हार्डकोडेड आउटपुट की अनुमति है।
स्टैंडर्ड लोफॉल्स लागू होते हैं।
अपडेट: आप रिक्त स्थान के बजाय टैब का उपयोग कर सकते हैं, जिसमें प्रत्येक टैब 4 स्थानों के रूप में गिना जाता है। अगर आप किसी कारण से चाहते हैं।

सैंडबॉक्स (मैं सैंडबॉक्स FAQ द्वारा अनुशंसित पूरे 72 घंटों के लिए इसे छोड़ दूंगा, लेकिन 7 upvotes और बिना किसी नकारात्मक प्रतिक्रिया के बगल में, 38 ठीक होना चाहिए)

code-golf ascii-art kolmogorov-complexity

— Nissa
स्रोत

7

बस एक छोटा सा नोट, आपको यह मेटा प्रश्न / उत्तर

— रॉड

8

सभी डाउनवोट्स के साथ क्या है? मुझे लगता है कि कुछ लोग कोलमोगोरोव-कॉम्प्लेक्स को नापसंद करते हैं, लेकिन क्या यह पतन का एक वैध कारण है?

— ।

@BruceForte शायद शुरू करने के लिए मेरे पास अपना जवाब था।

— निसा

14

@ ब्रूसफोर्ट व्यक्तिगत राय एक मान्य कारण है, tbh; हालांकि IMO यह एक नए उपयोगकर्ता के खिलाफ बिल्कुल अशिष्ट है ।

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

15

मुझे लगता है कि यह एक बहुत अच्छी एस्की कला चुनौती है। पैटर्न के बीच आंख और पिरामिड बिंदु सफाई से निपटने के लिए रचनात्मकता लेते हैं।

— xnor

23

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

Ｇ¬χ|_¶_|↗⁹↙^Ｍ³↓/o¶\‖Ｂ

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

  χ                     With sides of length 10
 ¬                      In the directions down and left
Ｇ                       Draw a closed polygon (implicit side)
   |_¶_|                Filled with |_ and _| on alternate lines
        ↗⁹               Draw a line of 9 /s
          ↙^            Draw a ^ and move the cursor down and left
            Ｍ³↓         Move down 3 characters
               /o¶\     Print the left half of the eye
                   ‖Ｂ  Reflect the canvas keeping the right edge

— नील
स्रोत

वो रहा! सोच रहा था कि ऐसा कब तक होगा।

— निसा

1

@StephenLeppik I फोन पर था :-(

— नील

रुको, यह एकमात्र कारण है?

— निस्टा

@StephenLeppik: अच्छी तरह से, और इससे पहले कि मैंने एक नए मुख्य पद के लिए अधिसूचना पर ध्यान दिया हो, मैं निर्भर करता हूं।

— नील

@ डलास मल्टीडायरेक्शनल में <से एक है - जब Multiprintइसे कमांड के साथ उपयोग किया जाता है, तो यह स्ट्रिंग को दो बार प्रिंट करने का कारण बनता है, एक बार राइट और एक बार राइट डाउन, लेकिन इसे ↗↘अन्य संदर्भों में भी शॉर्टकट के रूप में उपयोग किया जा सकता है।

— नील

49

विम, 40 बाइट्स

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

9i_|␛r\I/␛qqYPxR /␛q8@qr^4jhR/o\␛jr/2hr\

आप इसे इस GIF में एक्शन में देख सकते हैं जो लिन की पाइथन स्क्रिप्ट का उपयोग करके किया गया है

— H.PWiz
स्रोत

10

वी , 37 बाइट्स

9i|_á\|r/òÄó_|
>òC ^4jhR/o\j2hR\_/

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

Hexdump:

00000000: 3969 7c5f 1be1 5c7c 722f f2c4 f35f 7c0a  9i|_..\|r/..._|.
00000010: 3ef2 4320 5e1b 346a 6852 2f6f 5c1b 6a32  >.C ^.4jhR/o\.j2
00000020: 6852 5c5f 2f                             hR\_/

स्पष्टीकरण:

9i                              " Insert 9 copies of...
  |_                            "   '|_'
    <esc>                       " Return to normal mode
         á\                     " Append a backslash
           |                    " Move to the first character
            r/                  " Replace it with a forward slash
              ò                 " Recursively...
               Ä                "   Duplicate this line (upwards)
                ó               "   Remove one instance of..
                 _|             "     '_|'
>                               "   Indent this line with one space
 ò                              " End the loop
  C ^                           " Change this line (previously '/_\') to ' ^'
     <esc>                      " Return to normal mode
          4j                    " Move down 4 lines
            h                   " Move one character to the left
             R                  " Write this text over existing characters...
              /o\               "   '/o\'
                 <esc>          " Return to normal mode
                      j         " Move down a line
                       2h       " Move two characters to the left
                         R      " Write this text over existing characters...
                          \_/   " '\_/'

— DJMcMayhem
स्रोत

10

SOGL V0.12 , 31 27 25 बाइट्स

 ^9∫Ƨ_|m└Κ}¹±§"/o¶\_”95žΓ

यह कोशिश करो!

 ^                         push "^"
  9∫      }                do 9 times, pushing counter
    Ƨ_|                      push "_|"
       m                     mold that to the counter
        └Κ                   prepend "/"
           ¹               collect the lines in an array - ["^", "/_", "/_|", ..., "/_|_|_|_|_"]
            ±              reverse each                    ["^", "_/", "|_/", ..., "_|_|_|_|_/"]
             §             reverse as ascii-art:
                            ["         ^",
                             "        /_",
                             "       /_|",
                             ...,
                             "/_|_|_|_|_"]
              "/o¶\_”      push "/o
                                 \_"
                     95ž   insert that at [9; 5]
                        Γ  palindromize horizontally

या एक 24 बाइट संस्करण का उपयोग कर ¼(एक एंटीडिओगल के लिए स्थान) इसके बजाय ±§:

 ^9∫Ƨ_|m└Κ}¹¼"/o¶\_”95žΓ

यह कोशिश करो!

— dzaima
स्रोत

8

पायथन 2 , 103 101 98 95 बाइट्स

^{-2 बाइट्स की}^{बदौलत}^{जोनाथन}
^{फ्रीच -3 बाइट्स ओव्स की बदौलत}

for i in range(10):print(9-i)*' '+['^','/_%s\\'%['|_'*~-i,'|/o\|_','|_\_/_|_'][i%6/4*i%3]][i>0]

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

— छड़ी
स्रोत

8

जावास्क्रिप्ट (ईएस 6), 95 92 बाइट्स

f=(n=9,s='')=>n--?f(n,s+' ')+s+`/${n-4?n-3?'_|'.repeat(n):'_|/o\\|':'_|_\\_/_|'}_\\
`:s+`^
`

या एक प्रमुख नई लाइन के साथ 91 बाइट्स - जो मुझे लगता है कि अनुमति नहीं है:

f=(n=9,s=`
`)=>n--?f(n,s+' ')+s+`/${n-4?n-3?'_|'.repeat(n):'_|/o\\|':'_|_\\_/_|'}_\\`:s+`^`

डेमो

कोड स्निपेट दिखाएं

f=(n=9,s='')=>n--?f(n,s+' ')+s+`/${n-4?n-3?'_|'.repeat(n):'_|/o\\|':'_|_\\_/_|'}_\\
`:s+`^
`

O.innerText = f()

<pre id=O></pre>

स्निपेट का विस्तार करें

प्रारूपित और टिप्पणी की गई

f = (n = 9, s = '') =>    // n = line counter, s = leading spaces
  n-- ?                   // if we haven't reached the top:
    f(n, s + ' ') +       //   do a recursive call with one more leading space
    s +                   //   append the leading spaces
    `/${                  //   append the left border
      n - 4 ?             //   if this is not the 4th row:
        n - 3 ?           //     if this is not the 3rd row:
          '_|'.repeat(n)  //       append the brick pattern
        :                 //     else (3rd row):
          '_|/o\\|'       //       append the top of the eye
      :                   //   else (4th row):
        '_|_\\_/_|'       //     append the bottom of the eye
    }_\\\n`               //   append the right border + line-feed
  :                       // else:
    s + `^\n`             //   append the top of the pyramid and stop the recursion

— Arnauld
स्रोत

अग्रणी व्हाट्सएप की अनुमति है।

— निसा

8

C (gcc) , 124 122 120 119 117 115 118 बाइट्स

-1 बाइट की बदौलत @xanoetux +3 को सबसे निचले स्तर की याद आ रही है ...

f(i){for(printf("%*c",i=10,94);--i;printf("\n%*c%s_\\",i,47,i^6?i^5?"_|_|_|_|_|_|_|_|_|"+i*2:"_|_\\_/_|":"_|/o\\|"));}

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

— cleblanc
स्रोत

5

हास्केल, 110 107 बाइट्स

"         ^\n"++do z<-[1..9];([z..8]>>" ")++'/':g z++"_\\\n"
g 4="_|/o\\|"
g 5="_|_\\_/_|"
g x=[2..x]>>"_|"

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

शुरुआत में उन 9 जगहों पर चोट लगी।

यह काम किस प्रकार करता है

"         ^\n"++         -- first line, followed by
do                       -- we use the "do" syntatic sugar for monads,
                         -- here the list monad 
   z<-[1..9]             -- for all 'z' from [1..9] perform the following
                         -- and collect the results in a single list
     ([z..8]>>" ")++'/'  --   make the spaces for the current line and
                         --   the left wall '/'
     g z                 --   call g to make the inner part
     "_\\\n"             --   append '_', '\' and a NL

g 4="_|/o\\|"            -- line 4 and 5 are implemented directly
g 5="_|_\\_/_|"
g x=[2..x]>>"_|"         -- all other lines are some copies of "_|"

संपादित करें: -3 बाइट्स

— nimi
स्रोत

4

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

filter f{' '*$_+'/'+'_|'*(8-$_)+'_\'}
' '*9+'^'
8|f
7|f
6|f
'     /_|/o\|_\
    /_|_\_/_|_\'
3..0|%{$_|f}

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

Veskah के लिए धन्यवाद 4 बाइट्स सहेजे गए।

— AdmBorkBork
स्रोत

3

05AB1E , 47 42 40 बाइट्स

'/„_|ûûû«η'^0ǝ.∞.C":;<IJK"Çv"/o\\_/"Nèyǝ

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

'/„_|ûûû«                                # Push bottom left tier of pyramid.
         η                               # All prefixes of...
          '^0ǝ                           # Replace the tip.
              .∞.C                       # Mirror, Center.
                  ":;<IJK"Ç              # Push [58,59,60,73,74,75].
                           v"/o\\_/"Nèyǝ # Replace those indexes with the eye.

बेवकूफ संस्करण: „_|3×"_|/o\|".;„_|2×û"_|_\_/_".;

अन्य, कम बेवकूफ संस्करण (लेकिन अभी भी बदतर):

05AB1E , 42 बाइट्स

•~µÎт•η4¾ǝ•Σ}•4ǝ•3x1•5ǝεS"|_/\^o"sèJ}€.∞.C

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

— जादू ऑक्टोपस Urn
स्रोत

2

बबलगम , 48 बाइट्स

00000000: 5380 8138 2e18 4b3f 3e86 0bce ac01 72e0  S..8..K?>.....r.
00000010: 6c30 0fc6 d1cf 8f01 71e1 cae2 218a e12a  l0......q...!..*
00000020: 6ba0 ea61 7c84 085c 0021 0417 4188 0100  k..a|..\.!..A...

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

— OVS
स्रोत

2

PHP, 123 + 3 बाइट्स

+ 3 अजीब टैब गिनती के लिए बाइट्स। (यह अभी भी कर्सर को किसी भी कंसोल में 8 स्थान पर ले जाता है!)

for($i=10;--$i;)$r.=str_pad(str_pad("
",$i)."/",20-$i,"_|")."\\";$r[48]=$r[65]="/";$r[50]=$r[63]="\\";$r[49]=o;echo"   ^$r";

नोट: echo"टैब वर्ण के बाद पहला वर्ण है!

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

अन्य संस्करण, समान लंबाई:

for(;$i++<9;)$r.=str_pad(str_pad("
",10-$i)."/",10+$i,"_|")."\\";$r[48]=$r[65]="/";$r[50]=$r[63]="\\";$r[49]=o;echo"    ^$r";

— टाइटस
स्रोत

ग्रहण के बारे में क्या? मैंने कुछ समय में इसका उपयोग नहीं किया है लेकिन मुझे याद है कि इसके टैब 4 स्थान थे।

— निसा

@StephenLeppik ग्रहण एक संपादक है, शेल नहीं।

— टाइटस

इसमें अभी भी एक कंसोल है। उल्लेख नहीं है कि एसई मार्कडाउन एडिटर और <प्री> टैग फॉन्ट दोनों में 4-स्पेस टैब हैं

— निसा

2

रेटिना , 79 73 बाइट्स


/8x
8
$*
+`^(.*)\Sx
 $1x¶$&
 x
 ^
/111x
/1/o\|x
/1111x
/1x_/1x
1
_|
x
_\

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

— OVS
स्रोत

2

रूबी, 92 बाइट्स

10.times{|i|s=' '*(10-i)+(i<1??^:"/#{"_|"*~-i}_\\");i/2==2&&s[9,3]="/o\\_/"[i%2*2,3];puts s}

— स्तर नदी सेंट
स्रोत

2

एक्सेल VBA, 104 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो सत्य की पुष्टि करता है।

संस्करण A:

?Spc(9)"^":For i=0To 8:[A1]=i:?Spc(8-i)"/_"[If(A1=3,"|/o\|_",If(A1=4,"|_\_/_|_",Rept("|_",A1)))]"\":Next

संस्करण B:

?Spc(9)"^":For i=0To 8:[A1]=i:?Spc(8-i)"/_"IIf(i=3,"|/o\|_",IIf(i=4,"|_\_/_|_",[Rept("|_",A1)]))"\":Next

— टेलर स्कॉट
स्रोत

2

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

l=bytearray
a,b=' _';g=[l(a*9+"^"+a*9)]+[l(a*(8-k)+"/%s\\"%"|".join(b*k+b))for k in range(9)]
g[4][8:11]=l("/o\\")
g[5][8:11]=l("\\_/")
for r in g:print r

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

-3 बाइट्स का उपयोग bytearrayरॉड
-1 बाइट के लिए धन्यवाद बोब्रोबोब के लिए धन्यवाद

— HyperNeutrino
स्रोत

1

जावास्क्रिप्ट 90 बाइट्स (यदि डिफ़ॉल्ट पैरामीटर a = 9 आवश्यक है तो 92 बाइट्स)

A=(a,x=``)=>a?A(a-1,x+" ")+x+"/".padEnd(a*2,a^5?a^4?"_|":"_|/o\\|":"_|_\\_/")+`\\
`:x+`^
`
console.log(A(9))

स्निपेट का विस्तार करें

— DanielIndie
स्रोत

सभी विलोम तर्कों को बाइट कुल में शामिल किया जाना चाहिए ताकि यह 91 बाइट्स के रूप में गिना जाए

— निसा

1

जावा 8, 156 बाइट्स

v->"".format("%1$9s^\n%1$8s/a%1$7s/ba%1$6s/bba     /b/o\\|a    /b_\\_/ba   /bbbbba  /bbbbbba /bbbbbbba/bbbbbbbba","").replace("a","_\\\n").replace("b","_|")

स्पष्टीकरण:

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

v->                        // Method with empty unused parameter and String return-type
  "".format(               //  Format the following String (`%1$Ns` = N spaces)
      "%1$9s^\n            //            ^
       %1$8s/a             //           /_\
       %1$7s/ba            //          /_|_\
       %1$6s/bba           //         /_|_|_\
            /b/o\\|a       //        /_|/o\|_\
           /b_\\_/ba       //       /_|_\_/_|_\
          /bbbbba          //      /_|_|_|_|_|_\
         /bbbbbba          //     /_|_|_|_|_|_|_\
        /bbbbbbba          //    /_|_|_|_|_|_|_|_\
       /bbbbbbbba","")     //   /_|_|_|_|_|_|_|_|_\
    .replace("a","_\\\n")  //  Replace all "a" with "_\" + new-line
    .replace("b","_|")     //  Replace all "b" with "_|"
                           // End of method (implicit / single-line return-statement)

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

संदर्भ के लिए, हार्ड-कोडित 179 बाइट्स है ।

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

1

जूलिया, 152 141 139 130 127 120 113 112 बाइट्स

q="_|";a+b=" "^a*b;a\b=replace(a,q^3,q*b,1);~n=n<0?9+"^\n":~(n-1)*(8-n+"/$(q^n)_\\\n");print(~8\"/o\\|"\"_\\_/")

व्याख्या की:

#Define constant q to abbreviate this string
q="_|";

#Redefine the addition operator to compactly provide whitespace 
#where needed
a+b=" "^a*b;

#Redefine the inverse division operator so we can substitute 
#"_|_|_|" with "_|"*b very compactly
a\b=replace(a,q^3,q*b,1);

#Redefine the bitwise not operator to generate pyramid layers
#Defines them recursively, calling itself to generate previous 
#layers before appending its own. 
#The base case generates the tip. 
~n=n<0?9+"^\n":~(n-1)*(8-n+"/$(q^n)_\\\n");

#Print to output
print(

    #Pyramid with 8 body layers
    ~8

    #Then patch in the eye
    \"/o\\|"
    \"_\\_/"
)

— eaglgenes101
स्रोत

1

सी # (.NET कोर) , 174 153 बाइट्स

()=>string.Format(@"{1,10}
{0,10}\
{0,9}{2}{3,10}{2}{0,7}|/o\{2}{3,8}\_/_{2}{0,5}{4}  {3}{4} {3}|_{4}{3}|_|_{4}","/_","^",@"|_\
","/_|_",@"|_|_|_|_|_\
")

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

पिरामिड के निर्माण का एक अक्षम तरीका है, लेकिन इसके माध्यम से काम करना दिलचस्प है।

स्वीकृतियाँ

-21 बाइट्स @someone को धन्यवाद

— Ayb4btu
स्रोत

1

सी # (.NET कोर) , 144 बाइट्स

यह काफी उबाऊ लग सकता है, क्योंकि यह काफी उबाऊ है।

()=>@"         ^
        /_\
       /z\
      /z|_\
     /_|/o\|_\
    /z\_/z\
   /z|z|z\
  /z|z|z|_\
 /z|z|z|z\
/z|z|z|z|_\".Replace("z","_|_")

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

— कोई व्यक्ति
स्रोत

0

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

मैं एक के लिए जानते हैं तथ्य यह है मैं गोल्फ भाषाओं में से किसी की धड़कन नहीं हूँ, लेकिन कम से कम मैं अपने खुद के समाधान दे सकते हैं।

$=>[...Array(10)].map((e,i)=>' '.repeat(9-i)+(i--?`/${['_|/o\\|','_|_\\_/_|'][i-3]||'_|'.repeat(i)}_\\`:'^')).join`
`

यहाँ एक डेमो है:

var f = $=>[...Array(10)].map((e,i)=>' '.repeat(9-i)+(i--?`/${['_|/o\\|','_|_\\_/_|'][i-3]||'_|'.repeat(i)}_\\`:'^')).join`
`;
console.log(f());
console.log(f.toString().length);

स्निपेट का विस्तार करें

स्पष्टीकरण:

$=>                                       // outer function start
[...Array(10)]                            // create an array to map
.map(…)                                   // map it
    (e,i)=>                               // mapping function start
    ' '.repeat(9-i)                       // spaces for padding
    +(i--?…:'^')                          // use the carat if at the top of the pyramid
        `/${…}_\\`                        // otherwise, make the sides + steps
            ['_|/o\\|','_|_\\_/_|'][i-3]  // use the patterns for the eye, if in the correct rows
            ||'_|'.repeat(i)              // otherwise, make the "bricks" structure
.join`
`                                         // join all the rows into a string (yes this part has a newline in it)

— Nissa
स्रोत

4

सीधे जवाब देने की अनुशंसा नहीं की जाती है, लोगों को अपना समाधान करने दें।

— ओकेक्स

0

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

कोडगॉल्फिंग पर मेरा पहला प्रयास: डी

var f=()=>{let b=x=>' '.repeat(x),g='\\',h='/',i=1,st=[(b(9)+'^').split('')];for(;i<10;i++)st.push((b(9-i)+h+st.map(i=>'_').join('|')+g).split(''));st[4][8]=st[5][10]=h;st[4][9]='o';st[5][8]=st[4][10]=g;return st.map(s=>s.join('')).join('\n');}

document.getElementById("display").innerHTML = f();
console.log(f.toString().length);

<pre id="display">
</pre>

स्निपेट का विस्तार करें

— Apolo
स्रोत

1

साइट पर आपका स्वागत है!

— caird coinheringaahing

हार्डकोडिंग निश्चित रूप से छोटी है जो आपके यहाँ है। : आप कुछ ES6 सुविधाओं के साथ इस छोटा कर सकते हैं function`s` के बजाय function('s'), a=>के बजाय ()=>, fill(x)के बजाय map(e=>x), [...s]के बजाय s.split(''), में एक बयान ले जाने के forप्रारंभ, आदि

— Nissa

इल्लुमिनाती की पुष्टि करें

नियम:

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

विम, 40 बाइट्स

वी , 37 बाइट्स

SOGL V0.12 , 31 27 25 बाइट्स

पायथन 2 , 103 101 98 95 बाइट्स

जावास्क्रिप्ट (ईएस 6), 95 92 बाइट्स

डेमो

प्रारूपित और टिप्पणी की गई

C (gcc) , 124 122 120 119 117 115 118 बाइट्स

हास्केल, 110 107 बाइट्स

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

05AB1E , 47 42 40 बाइट्स

05AB1E , 42 बाइट्स

बबलगम , 48 बाइट्स

PHP, 123 + 3 बाइट्स

रेटिना , 79 73 बाइट्स

रूबी, 92 बाइट्स

एक्सेल VBA, 104 बाइट्स

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

जावास्क्रिप्ट 90 बाइट्स (यदि डिफ़ॉल्ट पैरामीटर a = 9 आवश्यक है तो 92 बाइट्स)

जावा 8, 156 बाइट्स

जूलिया, 152 141 139 130 127 120 113 112 बाइट्स

सी # (.NET कोर) , 174 153 बाइट्स

स्वीकृतियाँ

सी # (.NET कोर) , 144 बाइट्स

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

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