53
\$\begingroup\$

The Illuminati commands you (with their mind control) to output the following string:

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

Rules:


Sandbox (I would leave it for the full 72 hours recommended by the sandbox FAQ, but with 7 upvotes and next to no negative feedback, 38 should be fine)

\$\endgroup\$
  • 7
    \$\begingroup\$ just a small note, you should read this meta question/answer \$\endgroup\$ – Rod Oct 27 '17 at 16:42
  • 8
    \$\begingroup\$ What's with all the downvotes? I get that some people dislike kolmogorov-complex but is this a valid reason to downvote? \$\endgroup\$ – ბიმო Oct 27 '17 at 16:59
  • \$\begingroup\$ @BruceForte probably that I had my own answer to start. \$\endgroup\$ – Stephen Leppik Oct 27 '17 at 17:00
  • 14
    \$\begingroup\$ @BruceForte personal opinion is a valid reason, tbh; though IMO it's absolutely rude against a newer user. \$\endgroup\$ – Magic Octopus Urn Oct 27 '17 at 18:27
  • 15
    \$\begingroup\$ I think this is a very nice ascii art challenge. The eye and pyramid point among the pattern take creativity to handle cleanly. \$\endgroup\$ – xnor Oct 27 '17 at 20:51

23 Answers 23

23
\$\begingroup\$

Charcoal, 25 21 bytes

G¬χ|_¶_|↗⁹↙^M³↓/o¶\‖B

Try it online! Link is to verbose version of code. Explanation:

  χ                     With sides of length 10
 ¬                      In the directions down and left
G                       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
            M³↓         Move down 3 characters
               /o¶\     Print the left half of the eye
                   ‖B  Reflect the canvas keeping the right edge
\$\endgroup\$
  • \$\begingroup\$ There it is! Was wondering how long it would be. \$\endgroup\$ – Stephen Leppik Oct 27 '17 at 16:59
  • 1
    \$\begingroup\$ @StephenLeppik I was on the phone :-( \$\endgroup\$ – Neil Oct 27 '17 at 17:00
  • \$\begingroup\$ Wait, is that the only reason? \$\endgroup\$ – Stephen Leppik Oct 27 '17 at 17:01
  • \$\begingroup\$ @StephenLeppik: well, that and depending how long before I noticed the notification for a new main post, I guess. \$\endgroup\$ – Neil Oct 27 '17 at 18:39
  • \$\begingroup\$ @DLosc < is one of the multidirectionals - when used with the Multiprint command it causes the string to be printed twice, once up right and once down right, but it can also be used as a shortcut for ↗↘ in other contexts too. \$\endgroup\$ – Neil Oct 27 '17 at 18:42
49
\$\begingroup\$

Vim, 40 bytes

-2 bytes thanks to DJMcMayhem

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

You can see it in action in this GIF made using Lynn's python script

In action

\$\endgroup\$
10
\$\begingroup\$

V, 37 bytes

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

Try it online!

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\_/

Explanation:

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...
                          \_/   " '\_/'
\$\endgroup\$
10
\$\begingroup\$

SOGL V0.12, 31 27 25 bytes

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

Try it Here!

 ^                         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

or a 24 byte version using ¼ (space to an antidiagonal) instead of ±§:

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

Try it Here!

\$\endgroup\$
8
\$\begingroup\$

Python 2, 103 101 98 95 bytes

-2 bytes thanks to Jonathan Frech
-3 bytes thanks to ovs

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

Try it online!

\$\endgroup\$
8
\$\begingroup\$

JavaScript (ES6), 95 92 bytes

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

Or 91 bytes with a leading new-line -- which I think is not allowed:

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

Demo

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

O.innerText = f()
<pre id=O></pre>

Formatted and commented

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
\$\endgroup\$
  • \$\begingroup\$ Leading whitespace is allowed. \$\endgroup\$ – Stephen Leppik Nov 13 '17 at 17:18
8
\$\begingroup\$

C (gcc), 124 122 120 119 117 115 118 bytes

-1 byte thanks to @xanoetux +3 missing the lowest level...

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

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Haskell, 110 107 bytes

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

Try it online!

Those 9 space at the beginning hurt.

How it works

"         ^\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 "_|"

Edit: -3 bytes thanks to @Laikoni:

\$\endgroup\$
4
\$\begingroup\$

PowerShell, 109 105 bytes

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

Try it online!

Saved 4 bytes thanks to Veskah.

\$\endgroup\$
3
\$\begingroup\$

05AB1E, 47 42 40 bytes

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

Try it online!

'/„_|ûûû«                                # 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.

Stupid version: „_|3×"_|/o\|".;„_|2×û"_|_\_/_".;


Other, less stupid version (but still worse):

05AB1E, 42 bytes

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

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Bubblegum, 48 bytes

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...

Try it online!

\$\endgroup\$
2
\$\begingroup\$

PHP, 123+3 bytes

+3 bytes for the weird tab counting. (it still moves the cursor 8 spaces in any console!)

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";

Note: The first character after echo" is a tab character!

Run with -nr or try it online.

other version, same length:

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";
\$\endgroup\$
  • \$\begingroup\$ What about Eclipse? I haven't used it in a while but I remember that its tabs were 4 spaces. \$\endgroup\$ – Stephen Leppik Oct 27 '17 at 22:51
  • \$\begingroup\$ @StephenLeppik Eclipse is an editor, not a shell. \$\endgroup\$ – Titus Oct 27 '17 at 23:05
  • \$\begingroup\$ It still has a console. Not to mention that the SE markdown editor and <pre> tag font both have 4-space tabs \$\endgroup\$ – Stephen Leppik Oct 27 '17 at 23:44
2
\$\begingroup\$

Retina, 79 73 bytes


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

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Ruby, 92 bytes

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

Excel VBA, 104 Bytes

Anonymous VBE immediate window function that confirms the truth.

Version A:

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

Version B:

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

Python 2, 154 bytes

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

Try it online!

-3 bytes using bytearray thanks to Rod
-1 byte thanks to bobrobbob

\$\endgroup\$
1
\$\begingroup\$

Javascript 90 bytes (if default parameter a=9 is required then 92 bytes)

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

\$\endgroup\$
  • \$\begingroup\$ All extraneous arguments must be included in the byte total so this counts as 91 bytes \$\endgroup\$ – Stephen Leppik Oct 31 '17 at 13:34
1
\$\begingroup\$

Java 8, 156 bytes

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","_|")

Explanation:

Try it here.

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)
\$\endgroup\$
1
\$\begingroup\$

Julia, 152 141 139 130 127 120 113 112 bytes

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\\|"\"_\\_/")

Explained:

#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\\|"
    \"_\\_/"
)
\$\endgroup\$
1
\$\begingroup\$

C# (.NET Core), 174 153 bytes

()=>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}","/_","^",@"|_\
","/_|_",@"|_|_|_|_|_\
")

Try it online!

An inefficient way of building the pyramid, but interesting working through it.

Acknowledgements

-21 bytes thanks to @someone

\$\endgroup\$
1
\$\begingroup\$

C# (.NET Core), 144 bytes

This one may seem quite boring, because it is quite boring.

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

JavaScript, 117 bytes

I know for a fact I'm not beating any of the golfing languages, but at least I can give my own solution.

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

Here's a demo:

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);

Explanation:

$=>                                       // 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)
\$\endgroup\$
  • 4
    \$\begingroup\$ It's not recommended to answer straight away, let people make their own solutions. \$\endgroup\$ – Okx Oct 27 '17 at 16:42
0
\$\begingroup\$

Javascript, 238 bytes

My very first try at codegolfing :D

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>

\$\endgroup\$
  • 1
    \$\begingroup\$ Welcome to the site! \$\endgroup\$ – caird coinheringaahing Oct 31 '17 at 14:36
  • \$\begingroup\$ Hardcoding is definitely shorter than what you have here. You can shorten this with a few ES6 features: function`s` instead of function('s'), a=> instead of ()=>, fill(x) instead of map(e=>x), [...s] instead of s.split(''), move a statement into the for initialization, etc. \$\endgroup\$ – Stephen Leppik Oct 31 '17 at 15:21

protected by Community Aug 31 '18 at 8:28

Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).

Would you like to answer one of these unanswered questions instead?

Not the answer you're looking for? Browse other questions tagged or ask your own question.