Elixir Christmas Tree Puzzle

[emson]

Use your elixir coding skills to create a Christmas tree

Your code should create a triangle of 0 characters that is 9 rows high. At the top of the tree should be a star * and at the bottom there should be a trunk H. The star and trunk should be aligned, and the start should be directly above the top of the tree. The start and trunk are addional rows, therefore the entire tree is a total of 11 characters high.

http://elixirgolf.com/articles/elixir-christmas-tree-puzzle/

1. Please add your solutions as comments to this Github issue
2. Remember to add your Twitter handle (I will link to it if you get a mention)
   Many thanks, Ben
   When the puzzle is over I'll write them up on http://elixirgolf.com and link back to your Twitter handle

[notexactlyawe]

Assuming you have h defined beforehand as the number of rows of 0s you want

import String;a=duplicate(" ",h-1);IO.puts"#{a}*";for i<-1..h do IO.puts"#{duplicate(" ",h-i)}#{duplicate("0",i*2-1)}"end;IO.puts"#{a}H"

I believe 136 characters. This goes down to 134 when replacing h with 9 (h-1 then cancels down to 8).
twitter: @notexactlyawe

[emson]

Great @notexactlyawe you don't need the h=9 for this puzzle - it's all a fixed size. Also you can remove a few brackets:

import String;a=duplicate " ",8;IO.puts"#{a}*";for i<-1..h do IO.puts"#{duplicate " ",9-i}#{duplicate "0",i*2-1}"end;IO.puts"#{a}H"

So you're at 131 chars!

[notexactlyawe]

Cool, thanks :)

[vanstee]

Got it down to 101 chars using List.duplicate/2.

d=&List.duplicate/2;p=&IO.puts d.(32,9-&1)++&2;p.(1,'*');for i<-1..9,do: p.(i,d.(48,2*i-1));p.(1,'H')

I think there might be a way to get a little lower with String.rjust, but the least I could do with that one was 117.

@vanstee on twitter as well.

Edit: D'oh not sure why I included the spaces on the right side.

[henrik]

My "own" solution, 104 characters (the linebreak is significant and counts as a single character):

d=&String.duplicate/2;s=d.(" ",8);IO.puts [s,"*
",(for i<-0..8,do: [d.(" ",8-i),d.("0",i*2+1),10]),s,?H]

10 is the ASCII code for a newline.

If I borrow @vanstee's List.duplicate trick (clever!), I can get down to 99 characters:

d=&List.duplicate/2;s=d.(32,8);IO.puts [s,"*
",(for i<-0..8,do: [d.(32,8-i),d.(?0,i*2+1),10]),s,?H]

32 is the ASCII code for a space. ? (questionmark-space) also works but gives a warning.

All these solutions make use of Elixir's wonderful chardata concept, where IO.puts accepts nested arrays of strings or codepoints and joins them into a string.

henrik on Twitter.

[stoft]

My feeble attempts started out something like this (before I realized I was printing 17 lines instead of 17 zeroes...):

       *
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       0
       H

which evolved into this (I think I've got the beginnings of a nice console game though)

       *
       0
      0 
     0  
    0   
   0    
  0     
 0      
0       
0        
0         
0          
0           
0            
0             
0              
0               
       H

and then into the most lopsided tree ever:

       *
       0
      00
     000
    0000
   00000
  000000
 0000000
00000000
000000000
0000000000
00000000000
000000000000
0000000000000
00000000000000
000000000000000
0000000000000000
       H

It was cracking me up quite a bit though. 😂

[stoft]

And the hilarity just continues!

      *
       0
       000
       00000
       0000000
       000000000
       00000000000
       0000000000000
       000000000000000
                       H

       *
       00
       0  
       0  0
       0    
       0    0
       0      
       0      0
       0        
       0        0
       0          
       0          0

[stoft]

Finally! My humble solution of way too many chars (I have yet to look at the other solutions mind you):

for x <- 0..10, y = (x < 1 && "*" || x > 9 && "H" || "0"), z = 1 < x && x < 10 && String.ljust("0", x - 1, ?0)||"", do: IO.puts(String.rjust(z, 8) <> y <> z)

[stoft]

...and a solution that's 2 chars shorter than my previous one! (well aware that I can shave whitespace and similar from my previous solution) But this one is so "stupid" I have to post it. :)

IO.puts "        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
        H"

[stoft]

My original solution with trimmings (pun intended), 117 chars (which I'm pretty happy with):

for x<-0..10,y=x<1&&"*"||x>9&&"H"||"0",z=1<x&&x<10&& String.rjust("0",x-1,?0)||"",do: IO.puts String.rjust(z,8)<>y<>z

edit: @stoftis on twitter

[stoft]

And now reading through the comments I realized I probably duplicated @vanstee 's solution he mentioned but never posted. :)

[emson]

That's great... although I think the tree needs to be a bit more festive:

d=&List.duplicate/2;s=d.(32,8);IO.puts [s,"* ",(for i<-0..8,do: [d.(32,8-i),d.(Enum.random(~W(> = < ~ ~)),i*2+1),10]),s,?H]

[stoft]

Oh I agree!

d=&List.duplicate/2;s=d.(32,8);IO.puts [s,IO.ANSI.yellow <> "* ",(for i<-0..8,do: [d.(32,8-i),d.(Enum.random([IO.ANSI.green, IO.ANSI.red]) <> Enum.random(~W(> = < ~ ~)),i*2+1),10]),s,?H]

🎅 🎄 ⛄ 🎁

[emson]

Or this one is even better...

d=&List.duplicate/2;s=d.(32,8);IO.puts [s,"* ",(for i<-0..8,do: [d.(32,8-i),(for x<-1..i*2+1,into: [],do: Enum.random ~W(~ x o ~ ~)),10]),s,?H]

Which gives:

        *
       ~ox
      ~o~~~
     ~~~~~~o
    ~~o~~~~~~
   ~x~~~x~x~x~
  ~x~~x~~oxo~o~
 ~~~ox~o~o~~~~ox
~~~ooox~~o~o~~~xx
        H

[henrik]

Hehe, I've also been meaning to make a festive one.

This one assumes your terminal allows ANSI blinking. Did some things to keep it short but I haven't gone full golf on it:

import IO.ANSI;r=reset;b=blink_slow;g=green;y=yellow;d=&List.duplicate/2;s=d.(32,8);t=Stream.cycle([[g,?/],[red,?o],[g,?\\],[y,b,?i,r]]);IO.puts [s,y,b,"*\n",r,(for i<-0..8,do: [d.(32,8-i),Enum.take(t,i*2+1),10]),s,r,?H]

Even without blinking enabled in the terminal, you could probably use IO.ANSI.clear and a timer if anyone wants to go further with this :D