Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
Given an integer n>0, write a program that will output an "isosceles" Triangle out of #'s of height n.
Examples:
n=3
#
###
#####
n=1
#
n=5
#
###
#####
#######
#########
This would be invalid:
#
###
#####
#######
#########
Ｇ↗↘Ｎ#
Try it online! Link is to verbose version of code. Explanation: The Ｇ draws a filled polygon, where the ↗↘ specifies the sides to follow (the polygon is automatically closed) and the Ｎ inputs the size and the # specifies the fill character. Using Ｇ↖↙Ｎ# also works of course.
Alternate solution, also 5 bytes:
Ｇ^Ｎ#⟲
Try it online! Link is to verbose version of code. Explanation: The ^ is a shortcut for two diagonal directions ↘↙ (sadly there is no shortcut for the above diagonals in the required order as < is ↘↗ and > is ↙↖) so the triangle has to be rotated into position using ⟲.
"$args"..1|%{" "*--$_+"#"*++$i;$i++}
Loops from input $args down to 1, each iteration constructing a string consisting of the appropriate number of spaces plus a number of # marks that starts at 1 and increments by 2 every iteration. Those strings are left on the pipeline, and implicit output gives us newlines for free.
def f(n,i=1):1/n;print" "*~-n+"#"*i;f(n-1,i+2)
Basically the same solution as Jonathan Allan, but a function that prints and terminates with error, if that's allowed here. The 1/n is used to halt execution where n=0. Maybe there's a way to do that shorter by stuffing in a /n or %n somewhere.
Multiple 8 bytes programs are possible:
·ÅÉ'#×.c: Try it online or verify all test cases.L'#×€û.c: Try it online or verify all test cases.L·<'#×.c: Try it online or verify all test cases.'#×ηj€û»: Try it online or verify all test cases.Explanations:
· # Double the (implicit) input-integer
# i.e. 3 → 6
ÅÉ # Pop and push a list of all positive odd values below this doubled value
# → [1,3,5]
'#× '# Repeat "#" that many times as string
# → ["#","###","#####"]
.c # Centralize this list (which implicitly joins by newlines)
# → " #\n ###\n#####"
L # Push a list in the range [1, (implicit) input-integer]
# i.e. 3 → [1,2,3]
'#× '# Repeat "#" that many times as list
# → ["#","##","###"]
€û # Palindromize each
# → ["#","###","#####"]
.c # Centralize this list (which implicitly joins by newlines)
# → " #\n ###\n#####"
L # Push a list in the range [1, (implicit) input-integer]
# i.e. 3 → [1,2,3]
· # Double each value
# → [2,4,6]
< # Decrease each by 1
# → [1,3,5]
'#×.c '# Same as the first answer above
'#× '# Repeat "#" the (implicit) input-integer amount of times as string
# i.e. 3 → "###"
η # Take the prefixes of that string
# → ["#","##","###"]
j # Pad spaces to each to make the total length equal to the (implicit) input
# i.e. 3 → [" #"," ##","###"]
€û # Palindromize each
# → [" # "," ### ","#####"]
» # Join by newlines
# → " # \n ### \n#####"
For each of these programs the resulting string is then output implicitly (with trailing newline).
Lx<'#×.c, for an almost ASCII-only 8-byter.
\$\endgroup\$
'#×ηj€û». :)
\$\endgroup\$
Feb 7, 2020 at 10:41
Saved 5 11 bytes thanks to S.S.Anne!!!
Saved 6 bytes thanks to gastropner!!!
Saved a byte thanks to Stephen!!!
i;j;f(n){for(i=0;i++<n;)for(j=0;j<i*2;)printf(j++?"#":"\n%*s",n-i,"");}
g.times{} instead of (1..g).map{} to save 3 bytes (you'll need to change 2*n-1 to 2*n+1 as well).
\$\endgroup\$
' #'(#~|.,.1++:)i.
-1 byte thanks to FrownyFrog
Let's do 3:
i. Produces:
0 1 2
|.,.1++: - Reverse |. produces 2 1 0 and 1 + the double +: produces 1 3 5. Then we zip ,. those together:
2 1
1 3
0 5
' #'#~ copies each character in the 2-character string # (space and pound) according to the mask specified above, and pads the end of the first two rows with spaces, so every row is 5 characters:
#
###
#####
|
&@ (n-$)~@#(2$-1
|
terms in sequence are separated by newline
& output first n terms in sequence
each term is:
@ " " *
(n-$) n - index
~ concat
@# "#" *
(2$-1 2 * index - 1
Prompts for integer:
(-⌽⍳n)⌽⊃(1+2×⍳n←⎕)⍴¨'#'
:&<~P2&ZvZc
Consider input 3 as an example.
: % Implicit input. Range
% STACK: [1 2 3]
&< % Pairwise less-than comparison
% STACK: [0 0 0;
1 0 0
1 1 0]
~ % Negate, elementwise
% STACK: [1 1 1;
0 1 1;
0 0 1]
P % Flip vertically
% STACK: [0 0 1;
0 1 1;
1 1 1]
2&Zv % Reflect horizontally, without repeating last column
% STACK: [0 0 1 0 0;
0 1 1 1 0;
1 1 1 1 1]
Zc % Replace nonzeros by '#' and zeros by ' '
% STACK: [' # '
' ### ';
'#####']
% Implicit display
n=input();v=1
while n:n-=1;print' '*n+'#'*v;v+=2
A fun 49 with an extra space of padding is:
s=' '*input()+'#'
while'#'>s:print s;s=s[1:]+'##'
n-=1 to the start of the loop to get rid of them. I haven't found anything shorter than your solution; I suspect it's optimal.
\$\endgroup\$
#
Wolfram codes describe a family of celular automata. While most behave in very simple ways, some of them show very complex behaviour. Rule 110 is even Turing complete.
Rule 222 is one of the "simple" ones. After n generations, it produces a triangle of n levels, as specified in the challenge. A synonymous cellular automata in this case is Rule 254.
-6 thanks to streetster!
{(-x+!x)$(1+2*!x)#'"#"}
29 bytes previous solution+explanation:
{(-x+!x)$|:'x#x("##",)\"# "}
{ } /lambda with implicit arg `x`
x("##",)\"# " /function composition - cumulatively join (,) "##" to "# " x times and return intermediate results ("# ";"### ";"##### ") etc
x# /take x items
|:' /reverse each
(-x+!x) /enumerate x and subtract x from each (x=3 -> -3+0 1 2)
$ /pad, left-pads when left arg is negative
>þ`UŒBị⁾ #Y
A full program that takes an integer argument and prints a triangle. If a monadic link returning a list of Jelly strings is acceptable, the final byte can be saved for 10 bytes.
>þ` | Outer table using greater than and 1..n as both left and right argument
U | Reverse order of inner lists
ŒB | Bounce inner lists (i.e. repeat each one in reversed order without duplicating the final character)
ị⁾ # | Index into [" ", "#"]
Y | Join with newlines
2|*J' j|*iSj'#j|*iT2enq\[Z[unQ
Not left aligned, but functionally an isosceles triangle. Takes input as N.
2|* # N*2
J # Duplicate this number
' j|* # 2N spaces
iS # [2N..1] spaces as list
j # Swap back
'#j|* # 2N hashes
iT # [1..2N] hashes as list
2en # Take each odd
q\[Z[ # Zip together, and concatenate
un # Add new lines between each element
Q # Pretty print
i,m;f(n){m=n*2;for(i=m*n;i--;)putchar(i%m?abs(i%m-n)<n-i/m?35:32:10);}
n,i=input(),1
exec"print(n-i)*' '+(2*i-1)*'#';i+=1;"*n
Based on Jitse's Python 3 solution.
r=replicate
f x=unlines[r(x-n)' '++r(2*n-1)'#'|n<-[1..x]]
The unlines function is often helpful for ASCII art problems.
╒_'#*mñ\x *^my ═n
Explanation:
╒ # Push a list in the range [1, (implicit) input-integer]
# 3 → [1,2,3]
_ # Duplicate this list on the stack
'#* '# Repeat "#" the values amount of time as string
# → ["#","##","###"]
mñ # Palindromize each
# → ["#","###","#####"]
\ # Swap to get the duplicated [1, input] list at the top again
x # Reverse this to [input, 1]
# → [3,2,1]
* # Repeat a space the values amount of time as string
# → [" "," "," "]
^ # Zip the two lists together
# → [["#"," "],["###"," "],["#####"," "]]
my # Join each inner pair together
# → ["# ","### ","##### "]
═ # Pad leading spaces to each string to make them all of equal length
# → [" # "," ### ","##### "]
n # And join this list by newlines
# → " # \n ### \n##### "
# (after which the entire stack is output implicitly as result)
｛#×］±│
Explanation:
｛ # Map over the range [1, input]:
#× # Repeat "#" the value amount of times
］± # After the map: interpret the array as a 2D string, and reverse it
│ # And palindromize it horizontally with 1 overlap
# (after which it is output implicitly as result)
procedure f(n,i)
/i&i:=1
write(right(repl("#",i),n+i))
n>1&f(n-1,i+2)
end
é─C:UÅ≤┘.
My first Stax answer. :)
Try it online or try it online unpacked (10 bytes).
Explanation (of the unpacked version):
'#* '# Repeat "#" the (implicit) input-integer amount of times as string
# i.e. 3 → "###"
|[ # Get the prefixes of this string
# → ["#","##","###]
|> # Padding leading spaces up to a length equal to the longest string
# → [" #"," ##","###"]
m # Map over each line:
|p # Palindromize the line
# → [" # "," ### ","#####"]
m # And the map also prints each line with trailing newline afterwards
# → " # \n"
# " ### \n"
# "#####\n"
for($j=$argn+$i=1;--$j;$i+=2)printf("%{$j}s%'#{$i}s\n",'','');
Muuuuch better version with string formatting. I knew there was something, PHP is a templating language after all.. It couldn't be that bad for this kind of job!!
EDIT: saved 1 byte and removed the extra leading space by moving $i++ to the printf
EDIT2: saved 2 bytes with new strategy by @GuillermoPhillips (thanks!)
ORIGINAL NAIVE ANSWER:
for($t='#';$i++<$argn;$s.=' ',$t="#$t#"){$r[$i*2]="$t\n";$r[($argn-$i)*2+1]=$s;}ksort($r);echo join($r);
printf.. If you have something for this one I'd be glad
\$\endgroup\$
p->{for(int c=1;p>0;c+=2)System.out.println(new String(new char[p--]).replace('\0',' ')+new String(new char[c]).replace('\0','#'));}
See also JDK 13 answer
# to make your first line a title (so #Java 8, 151 bytes in this case). As for golfs: 1) since you're using Java 8, you can use a lambda, so void t(int p) can become p->. 2) int c=1;while(p>0){...;p--;c+=2;} can become for(int c=1;p>0;c+=2)...; and change the p-1 to --p. 3) In addition, using Java 11+, you can use "#".repeat(int) instead of new String(new char[int]).replace('\0','#'). In total: 76 bytes.
\$\endgroup\$
Feb 7, 2020 at 10:11
(1!)
_!0=""
i!n=r n ' '++r i '#'++'\n':(i+2)!(n-1)
r=replicate
-10 bytes thanks to @Laikoni.
You can try it online!
"\n"++ can be '\n':. Defining f with two arguments instead of one tuple as argument would save some more bytes, and defining f as infix operator would be even shorter. Finally, the g= is usually not counted by convention. All together 62 bytes: Try it online!
\$\endgroup\$
g= outside the byte counted part.
\$\endgroup\$
#? \$\endgroup\$