32
7
Pyramid Scheme is a language being developed by @ConorO'Brien. In Pyramid Scheme, the code that you write looks like this:
^ ^
/ \ /3\
/ \ ---
/ + \
^-------^
/9\ /3\
/123\ ---
-----
Now, that code has two obvious qualities: It's difficult to parse, and it's difficult to write. Conor has solved the first one, however it will be your job to solve that second issue.
The above code is processed by the PyramidScheme interpreter into a nested string array, like this:
[["+", ["9123", "3"]], "3"]
Your task is to write a program or function, which given a nested array of strings, outputs or returns the recreated PyramidScheme code. You may assume that the input array will always be valid.
A pyramid is an isosceles triangle. The top is ^
, the sides slope diagonally away with /
and \
, and the bottom is -
. The two bottom corners are either empty or contain the start of other pyramids, which are arguments. The middle is filled with the pyramid's name, ignoring line breaks.
Here's how the parser converts the code into a useable format. First, it scans for a top-level pyramid. If it takes no arguments, it represents it with a single string and moves on. Otherwise, it represents is as an array ["name",[arg1,arg2]]
or ["name",[arg1]]
. The arguments are the pyramids at the bottom left and bottom right of the pyramid, which may be either string or more arrays described as above. You may notice that this somewhat resembles Lisp, in which case you may also have noticed the awful pun that is the language name. After the pyramid is fully represented, the parser moves on to the next one.
This is code-golf, shortest code wins!
Test Cases: These are not the only valid outputs, these are example of valid outputs.
[["+", ["9123", "3"]], "3"]
^ ^
/ \ /3\
/ \ ---
/ + \
^-------^
/9\ /3\
/123\ ---
-----
[["out", [["chr", ["72"]], ["chr", ["101"]]]], ["out", [["chr", ["108"]]]], ["out", [["chr", ["108"]]]], ["out", [["chr", ["111"]]]]]
^ ^ ^ ^
/ \ / \ / \ / \
/out\ /out\ /out\ /out\
^-----^ -----^----- -----^
/ \ / \ / \ / \
/chr\ /chr\ /chr\ /chr\
^----- -----^ -----^ ^-----
/ \ / \ / \ / \
/72 \ /101\ /108\ /111\
----- ----- ----- -----
[ ["+", [ ["asdfghjkl"], ["do", [ "1" ]] ]] ]
^
/ \
/ + \
/ \
^-------^
/a\ /d\
/sdf\ /o \
/ghjkl\ ^-----
-------/1\
---
Notice in the second test case, the second and third out
pyramid both have a ["chr", ["108"]]
as a parameter, which is collapsed into one pyramid stack shared by two top-level ones. This is a valid optimization your code may support, but it is completely optional; scoring is not based on the length of your output.
For the curious, the first case displays 9126 3
due to implicit printing of toplevel pyramids, the second one prints Hello
, and the last one is a syntax error, included just because it has a neat structure.
You may assume that the input only contains printable ASCII, excluding spaces, ^
, /
, \
, and -
. The input will always be valid, and contain at least one pyramid. There is no limit on the size of the array or the input strings, however you may write your code as if your language's default integer type was infinite precision and that your computer has arbitrary memory. If taking input as a single string, you may use anything reasonable (comma, space, etc. as long as it's in printable ascii and not "
or []
) to delimit arrays. You do not have to include brackets surrounding the entire thing, and instead take multiple arrays separated by your delimiter.
Your output does not have to be golfed, you may insert extra space or make your pyramids larger than necessary. Toplevel pyramids should be on the first line. Output should be a string with newlines or a list of strings.
Anyone who does include a version of their code which optimally golfs the pyramids may receive some rep in the form of upvotes/bounties (but probably just upvotes).
8Sierpinski would love this language. – mbomb007 – 2017-01-31T17:37:51.710
4Totally didn't post this challenge because I'm too lazy to format triangles properly... – Pavel – 2017-01-31T17:39:48.820
@KodosJohnson Input can be a native array. – Pavel – 2017-02-01T00:31:05.810
how can you have a function with more than two arguments? – Destructible Lemon – 2017-02-01T04:49:08.770
@DestructibleWatermelon The input will never contain an array such that it will require passing two arguments to a pyramid, as this is impossible in Pyramid Scheme. – Pavel – 2017-02-01T04:52:50.503
huh, so it is actually rather different than lisp aside from ascii art syntax. – Destructible Lemon – 2017-02-01T05:41:19.440
@DestructibleWatermelon Not really, Lisp lists with more than two elements are actually stored internally as
(a (b ( c (d))))
, and Pyramid Lisp has a function which takes two args and returns them as a lsit iirc. (Everything I just said might be wrong) – Pavel – 2017-02-01T05:46:26.170This is a challenge that I will love to see some good answers for. – Christopher – 2017-02-01T16:16:38.850
Just to recap: the top level array can have any number of elements, while the subarrays will only have 1 or 2. Right? – edc65 – 2017-02-03T13:32:50.627
@edc65 correct. – Pavel – 2017-02-03T16:02:27.727
Since you said that top-level pyramids *should* be on the first line, does that mean they don't have to be? I mean, could each pyramid be placed under the preceding pyramid? – Kodos Johnson – 2017-02-04T00:16:51.657
@KodosJohnson No, they have to be on the first line. – Pavel – 2017-02-04T00:53:09.740
@Pavel, I understand how linked lists work, you know. I think the function you refer to would be cons? If that were the case eval would also be needed I believe – Destructible Lemon – 2017-02-04T22:16:05.573
@DestructibleWatermelon I know neither how normal Lisp works, nor how Pyramid Scheme works. I think PS has those functions, but there's not actually a documentation; everything I know comes from reading the interpreter's source. – Pavel – 2017-02-04T22:24:32.317
How should it behave if a string is something like "["]" – fəˈnɛtɪk – 2017-02-15T17:14:43.763
@LliwTelracs No need to escape characters. If you want to, you may support that. – Pavel – 2017-02-15T23:14:55.317