Code Golf

#5: Post edited by

General Sebast1an‭ · 2021-08-12T15:55:09Z (over 3 years ago)

Copy Link

Raw

Markdown

Towering Cistercian Representation

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214), [Codidact Sandbox Link](https://codegolf.codidact.com/articles/279223)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ . ⌷ ___. ⌷ . ⌷ ___. ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ ' ⌷ ' ⌷ ___' ⌷ ___' ⌷
```
(all of these are 4 rows in height.)
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped, and `.` and `'` should be swapped. [Here's how they should look.](https://dzaima.github.io/paste#0y80sKsovSk1RKEstKslMTszJqbTi4jJUUFB41LNdwQhKG0NpEyhtCqXNFKAMcxjDAsawhDEMFLhgzPj4eDCtoKAPpmOg4jAaCPRQGUAdqAy4WXBaH0rHoNEKCjUEGBhm6cP5MWg0YbMQflPASiPJq8ME1LGLcHFxAQA)
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
|___
\ | /
\ | /
\|/
|
|
|
|
___| /
| /
|/
|
|
|
|
|
|___
|
|
|
|
|
|
|
|
|
|
|
```
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of 4 `|` characters between them.
# Scoring
~~This is code-golf. Shortest answer in each language wins.~~
[1]: https://i.stack.imgur.com/JmmEq.png

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214), [Codidact Sandbox Link](https://codegolf.codidact.com/articles/279223)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ . ⌷ ___. ⌷ . ⌷ ___. ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ ' ⌷ ' ⌷ ___' ⌷ ___' ⌷
```
(all of these are 4 rows in height.)
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped, and `.` and `'` should be swapped. [Here's how they should look.](https://dzaima.github.io/paste#0y80sKsovSk1RKEstKslMTszJqbTi4jJUUFB41LNdwQhKG0NpEyhtCqXNFKAMcxjDAsawhDEMFLhgzPj4eDCtoKAPpmOg4jAaCPRQGUAdqAy4WXBaH0rHoNEKCjUEGBhm6cP5MWg0YbMQflPASiPJq8ME1LGLcHFxAQA)
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
|___
\ | /
\ | /
\|/
|
|
|
|
___| /
| /
|/
|
|
|
|
|
|___
|
|
|
|
|
|
|
|
|
|
|
```
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of 4 `|` characters between them.
# Scoring
This is <a class="badge is-tag">code-golf</a>. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

#4: Post edited by

Razetime‭ · 2020-12-13T16:02:39Z (about 4 years ago)

Copy Link

Raw

Markdown

~~[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214)~~
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ . ⌷ ___. ⌷ . ⌷ ___. ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ ' ⌷ ' ⌷ ___' ⌷ ___' ⌷
```
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped, and `.` and `'` should be swapped. [Here's how they should look.](https://dzaima.github.io/paste#0y80sKsovSk1RKEstKslMTszJqbTi4jJUUFB41LNdwQhKG0NpEyhtCqXNFKAMcxjDAsawhDEMFLhgzPj4eDCtoKAPpmOg4jAaCPRQGUAdqAy4WXBaH0rHoNEKCjUEGBhm6cP5MWg0YbMQflPASiPJq8ME1LGLcHFxAQA)
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
~~___~~
\ | /
\ | /
\|/
|
|
|
~~| /~~
| /
___|/
|
|
|___
|
|
|
|
|
|
|
|
|
```
~~(scroll through for the full symbol)~~
~~Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of three `|` characters between them.~~
# Scoring
This is code-golf. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214), [Codidact Sandbox Link](https://codegolf.codidact.com/articles/279223)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ . ⌷ ___. ⌷ . ⌷ ___. ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ ' ⌷ ' ⌷ ___' ⌷ ___' ⌷
```
(all of these are 4 rows in height.)
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped, and `.` and `'` should be swapped. [Here's how they should look.](https://dzaima.github.io/paste#0y80sKsovSk1RKEstKslMTszJqbTi4jJUUFB41LNdwQhKG0NpEyhtCqXNFKAMcxjDAsawhDEMFLhgzPj4eDCtoKAPpmOg4jAaCPRQGUAdqAy4WXBaH0rHoNEKCjUEGBhm6cP5MWg0YbMQflPASiPJq8ME1LGLcHFxAQA)
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
|___
\ | /
\ | /
\|/
|
|
|
|
___| /
| /
|/
|
|
|
|
|
|___
|
|
|
|
|
|
|
|
|
|
|
```
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of 4 `|` characters between them.
# Scoring
This is code-golf. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

#3: Post edited by

Razetime‭ · 2020-12-10T07:22:12Z (about 4 years ago)

Copy Link

Raw

Markdown

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
~~1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0~~
~~___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ ⌷ ___ ⌷ ⌷ ___ ⌷~~
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
~~⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ ___| ⌷ ___| ⌷~~
```
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
~~They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped.~~
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
___
\ | /
\ | /
\|/
|
|
|
| /
| /
___|/
|
|
|___
|
|
|
|
|
|
|
|
|
```
(scroll through for the full symbol)
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of three `|` characters between them.
# Scoring
This is code-golf. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ . ⌷ ___. ⌷ . ⌷ ___. ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ ' ⌷ ' ⌷ ___' ⌷ ___' ⌷
```
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped, and `.` and `'` should be swapped. [Here's how they should look.](https://dzaima.github.io/paste#0y80sKsovSk1RKEstKslMTszJqbTi4jJUUFB41LNdwQhKG0NpEyhtCqXNFKAMcxjDAsawhDEMFLhgzPj4eDCtoKAPpmOg4jAaCPRQGUAdqAy4WXBaH0rHoNEKCjUEGBhm6cP5MWg0YbMQflPASiPJq8ME1LGLcHFxAQA)
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
___
\ | /
\ | /
\|/
|
|
|
| /
| /
___|/
|
|
|___
|
|
|
|
|
|
|
|
|
```
(scroll through for the full symbol)
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of three `|` characters between them.
# Scoring
This is code-golf. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

#2: Post edited by

Razetime‭ · 2020-12-09T12:32:23Z (about 4 years ago)

Copy Link

Raw

Markdown

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ ⌷ ___ ⌷ ⌷ ___ ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ ___| ⌷ ___| ⌷
```
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value, mirroring horizontally if they are on the left, and vertically if they are on the bottom.
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
___
\ | /
\ | /
\|/
|
|
|
| /
| /
___|/
|
|
|___
|
|
|
|
|
|
|
|
|
```
(scroll through for the full symbol)
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of three `|` characters between them.
# Scoring
This is code-golf. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214)
Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)
Given a positive integer, draw its Cistercian representation as ascii art.
[![enter image description here][1]][1]
## The Challenge
Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
Tens|Units
|
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1 ⌷ 2 ⌷ 3 ⌷ 4 ⌷ 5 ⌷ 6 ⌷ 7 ⌷ 8 ⌷ 9 ⌷ 0
___ ⌷ ⌷ ⌷ ⌷ ___ ⌷ ⌷ ___ ⌷ ⌷ ___ ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ | ⌷ | ⌷
⌷ ___ ⌷ \ ⌷ / ⌷ / ⌷ | ⌷ | ⌷ ___| ⌷ ___| ⌷
```
As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value.
They should be mirrored horizontally if they are on the left.
They should be mirrored vertically if they are on the bottom i.e. the lines should be reversed, `\` and `/` should be swapped.
The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
T|U
|
Th|H
|
Hth|Tth
|
TM|M
```
like a tower of sorts.
You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.
Hence, given an input number, say, 12345, you should get the following:
`00012345 → 5432,1000`
which turns into:
```
4|5
|
2|3
|
0|1
|
0|0
```
which becomes:
```
___
\ | /
\ | /
\|/
|
|
|
| /
| /
___|/
|
|
|___
|
|
|
|
|
|
|
|
|
```
(scroll through for the full symbol)
Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of three `|` characters between them.
# Scoring
This is code-golf. Shortest answer in each language wins.
[1]: https://i.stack.imgur.com/JmmEq.png

#1: Initial revision by

Razetime‭ · 2020-12-09T04:27:05Z (about 4 years ago)

Copy Link

Raw

Markdown

Towering Cistercian Representation

[SE Sandbox Link](https://codegolf.meta.stackexchange.com/a/20479/80214)

Inspired by [this video.](https://www.youtube.com/watch?v=9p55Qgt7Ciw&ab_channel=Numberphile)

Given a positive integer, draw its Cistercian representation as ascii art.

[![enter image description here][1]][1]

## The Challenge

Cistercian numerals are a decimal-based number representation system which use simple line based drawings to represent 4-digit numerals. Their structure is as follows:
```
     Tens|Units
         |
Thousands|Hundreds
```
The digits are represented as follows (in the units place):
```
1   ⌷ 2   ⌷ 3   ⌷ 4   ⌷ 5   ⌷ 6    ⌷ 7    ⌷ 8    ⌷ 9    ⌷ 0   
___ ⌷     ⌷     ⌷     ⌷ ___ ⌷      ⌷ ___  ⌷      ⌷ ___  ⌷
    ⌷     ⌷ \   ⌷   / ⌷   / ⌷    | ⌷    | ⌷    | ⌷    | ⌷
    ⌷     ⌷  \  ⌷  /  ⌷  /  ⌷    | ⌷    | ⌷    | ⌷    | ⌷
    ⌷ ___ ⌷   \ ⌷ /   ⌷ /   ⌷    | ⌷    | ⌷ ___| ⌷ ___| ⌷

```

As you can see, there are some repeating patterns within the symbols:
```
5 → 4 + 1
7 → 6 + 1
8 → 6 + 2
9 → 6 + 1 + 2
```
In order to represent a general Cistercian number, you will have to place the digits in the correct place for their value, mirroring horizontally if they are on the left, and vertically if they are on the bottom.

The fun part is when you stack a Cistercian representation on top of another one to accommodate more digits e.g.:
```
  T|U  
   |   
 Th|H  
   |   
Hth|Tth
   |   
 TM|M 
```
like a tower of sorts. 

You will need to stack as many 4 part towers as the number requires, and you will need to prepend 0's to the input if it's length is not a multiple of 4.

Hence, given an input number, say, 12345, you should get the following:

`00012345 → 5432,1000`

which turns into:
```
4|5
 |
2|3
 |
0|1
 |
0|0
```
which becomes:

```
     ___
 \  |  /
  \ | /
   \|/
    |
    |
    |
    |  /
    | /
 ___|/
    |
    |
    |___
    |
    |
    |
    |
    |
    |
    |
    |
    |

```
(scroll through for the full symbol)

Note that this is created by making two towers for the 4 digit numbers `2345` and `0001`, stacking them, and adding a link of three `|` characters between them.

# Scoring

This is code-golf. Shortest answer in each language wins.

  [1]: https://i.stack.imgur.com/JmmEq.png

code-golf ascii-art

Communities

Post History