text
stringlengths 180
608k
|
|---|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/17209/edit).
Closed 1 year ago.
[Improve this question](/posts/17209/edit)
You have a program which creates an index for a catalogue. The last step is missing: it must find and consolidate page ranges within the list of pages for each entry.
Each entry is currently an array of unique integers in order, e.g:
```
[18,19,20,21,22,47,56,57,62,67,68,69,70]
```
Write a function which returns a consolidated array of ranges and individual pages as appropriate.
Individual pages can be converted to strings or remain as integers. Either of these would be valid results from the example input:
```
["18-22",47,"56-57",62,"67-70"] // valid
["18-22","47","56-57","62","67-70"] // valid
```
[Answer]
## Mathematica, 74
Assuming that replacing [] with {} in I/O is allowed:
```
t=ToString;f=Split[#,#2<#+2&]/.{s_Integer,___,e_}:>t@s<>"-"<>t@e/.{x_}:>x&
```
>
> f[{18, 19, 20, 21, 22, 47, 56, 57, 62, 67, 68, 69, 70}]
>
>
> {"18-22", 47, "56-57", 62, "67-70"}
>
>
>
The `Split` part should be quite fast (because someone else probably spent a lot of time optimizing) - the pattern matching part might be a bit slower in comparison. If speed is the main criterium, then there will be other ways to process the `Split` result (let´s see how the Q develops). For an input of 10^6 entries this takes about 2.7s on my (average) laptop (2.2GHz i7), of which about 1s goes to `Split`.
[Answer]
In JavaScript,
```
function catalogue(arr) {
if (!arr.length) return [];
for (var cat = [], first, prev = first = arr[0], i = 1, l = arr.length; i <= l; ++i) {
i === l || prev + 1 !== arr[i]
? (cat.push(first + (first === prev ? "" : "-" + prev)), prev = first = arr[i])
: ++prev;
}
return cat;
}
catalogue([18, 19, 20, 21, 22, 47, 56, 57, 62, 67, 68, 69, 70]);
// ["18-22","47","56-57","62","67-70"]
```
Minified version (153 characters):
```
function f(b){if(!b.length)return[];for(var g=[],e,c=e=b[0],d=1,h=b.length;d<=h;++d)d===h||c+1!==b[d]?(g.push(e+(e===c?"":"-"+c)),c=e=b[d]):++c;return g}
```
[Answer]
# Haskell
```
module Pages (ranges) where
ranges =
let f (a, b) | a == b = show a
| a /= b = show a ++ "-" ++ show b
in map f . ranges'
ranges' [] = []
ranges' (h:t) =
unpack (range h h t)
where unpack (t, l) = t : ranges' l
range :: Int -> Int -> [Int] -> ((Int, Int), [Int])
range a b [] = ((a, b), [])
range a b l@(h:t) | b+1 == h = range a h t
| otherwise = ((a, b), l)
```
[Answer]
**Javascript 271 bytes**
A relatively simple application of reduce. If we are going to golf it, it minifies down to 271 chars.
**Minified:**
```
function f(a){function d(a,b,c){c=(a+"").split("-");return 2>c.length?a+1==b?[!1,a+"-"+b]:[!0,b]:+c.pop()+1==b?[!1,c[0]+"-"+b]:[!0,b]}return a.reduce(function(a,b,c,e){if("number"==typeof a)return[d(a,b)[1]];e=a.length-1;c=d(a[e],b);c[0]?a[e+1]=c[1]:a[e]=c[1];return a})}
```
**Unminified**
```
function g(p,c,i){
i=(p+"").split("-");
if(i.length==1) return (p+1==c)?[false,p+"-"+c]:[true,c];
return ((+i[i.length-1])+1==c)?[false,i[0]+"-"+c]:[true,c];
}
function f(arr){
return arr.reduce(function(p,c,i){
if ( typeof p =="number") {
return [g(p,c)[1]];
}
else {
i=g(p[p.length-1],c);
if (i[0])
p[p.length]=i[1];
else
p[p.length-1]=i[1];
return p;
}
});
}
alert(JSON.stringify(f([18,19,20,21,22,47,56,57,62,67,68,69,70])));
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/10558/edit).
Closed 2 years ago.
[Improve this question](/posts/10558/edit)
You're writing a program for a new automated roulette croupier to be installed in a major casino. Unfortunately, the last guy bailed out on the company and published buggy software. You're stuck with a thousand burned flash chips with only a few kilobytes of space to store a working program. Can you do it?
The task is to write a program which will accurately handle bets, wins and losses of a roulette game.
It will be run as a session. When it initialises, players place their bets which are sent through STDIN. Once all bets have been received, the input for where the ball landed is given. The program must then calculate the winnings for each of the players and the casino.
A single zero wheel is assumed. Assume dollars will be bet (not chips) and that the input is always valid. You only need to support the "outside bets" and numbered bets (lists of numbers, not named.) Payouts are described on the [Wikipedia article](http://en.wikipedia.org/wiki/Roulette#Bet_odds_table).
Outside bet names: c1, c2, c3 (1st-3rd column), d1, d2, d3 (1st-3rd dozen), o (odd), e (even), r (red), b (black), 1-18, 19-36.
Example session (`>` indicates input, `<` indicates output):
```
> 7 800
```
Place a bet on the number "7" only, for $800.
```
> 8,9,10,11 50
```
Place a bet on the range "8,9,10,11", for $50.
```
> c1 2000
```
Place a bet on "1st column" (1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34) for $2000.
```
> ok
> 7
```
All players done. Pocketed in 7.
```
< 1 28800
< 2 0
< 3 6000
```
Payout details: #1 gets 36x original bet (35-to-1), #2 did not win and #3 gets 3x original bet (2-to-1)
```
< c -34750
```
Casino is down $34,750.
**Deciding the winner**
* Code space is critical so the smaller the program the better. The smallest program implementing all of the described features will be the winner, unless bonus features are present, in which case the best overall program will be decided based on the combination of size and features supported.
* The program must implement at least the bets described above, but support for other types, as well as number bets such as splits and baskets will be considered and may add bonus points.
[Answer]
## Python, 443 440 chars
```
R=range
N=37
V=91447186090
M={'e':R(0,N,2),'o':R(1,N,2),'r':[i for i in R(N)if V>>i&1],'b':[i for i in R(1,N)if~V>>i&1],'1-18':R(1,19),'19-36':R(19,N)}
for i in R(1,4):M['c%d'%i]=R(i,N,3);M['d%d'%i]=R(i*12-11,i*12+1)
for i in R(1,N):M[`i`]=[i]
B=[]
r=raw_input()
while'ok'!=r:x,k=r.split();B+=[(sum((M[y]for y in x.split(',')),[]),int(k))];r=raw_input()
z=input()
c=0
i=1
for b,k in B:v=36/len(b)*k*(z in b);print i,v;c+=k-v;i+=1
print'c',c
```
Makes `M`, a map from bet names to a list of numbers that win that bet. Then it reads the bets in, storing each one as a pair (list of numbers, dollar amount) in the list `B`. Finally, reads in the spin `z` and computes the payouts.
[Answer]
## Python (548)
Wow, the biggest thing I've done in a while.
```
r=[];R=range
for i in[1,12,19,30]:r+=R(i,i+7+i%2*2,2)
a=[];b='01';c=''
while'ok'!=c:
if'c'in c:c=R(int(c[1]),37,3)
if'd'in c:c=R(1+(int(c[1])-1)*12,13+(int(c[1])-1)*12)
if'r'in c:c=r
if'b'in c:c=filter(lambda x:x not in r,R(1,36))
if'o'in c:c=R(1,36,2)
if'e'in c:c=R(2,36,2)
if'-'in c:e=18*(c[1]>'-');b[0]=R(1+e,19+e)
if"'"in`c`:c=map(int,b[0].split(','))
a+=[[c,b[1]]];b=raw_input().split();c=b[0]
a=a[1:]
i=input()
z=[(i in p[0])*int(p[1])*(36/len(p[0])+1)-int(p[1])for p in a]
for j,k in enumerate(z):print j+1,max(k,0)
print"c",-sum(z)
```
Things that can probably be compressed:
* generating the numbers for things like `e`, `o`, `d2`
* the math formula for calculating `z`
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** [Update the question](/posts/8763/edit) so it's [on-topic](/help/on-topic) for Code Golf Stack Exchange.
Closed 11 years ago.
[Improve this question](/posts/8763/edit)
What is the most compact way to encode/save DNS names in memory?
For example, storing "www.google.com" as a string in .NET will result in the object being encoded as UTF-16, and it will consume twice as much memory as plain ASCII... but for the purpose of storing DNS names, ASCII is overkill.
The only characters that are needed are:
* A..Z (case insensitive)
* 0..9
* Hyphen
* underscore
* period
* Asterisk (not legal DNS, but used in ACLs such as \*.google.com) always as a leading character, never elsewhere.
A total of 40 characters.. which fits within single byte with plenty room to spare.
My code golf question/challenge is what is the most compact way to store a string of characters in memory and maximizing in memory storage?
The inspiration for this challenge [came from this blog entry.](http://msmvps.com/blogs/jon_skeet/archive/2011/04/05/of-memory-and-strings.aspx)
[Answer]
You could interpret it as a base 39 number. Since only the first character can be an asterisk, you can encode it as the sign. If i use the characters as digits in the order you named them, `www.google.com` would be `10903065870001232914011` in decimal and `24f0e6f41d8ecd3a65b` in hex, which could be stored in 10 bytes.
`*.google.com` would be `-310664672884413873` in decimal and `fbb04c2040762a4f` in hex, if you store it in 8 bytes.
[Answer]
Oh, that's easy. You just zip it.
] |
[Question]
[
Given n points, choose a point in the given list such that the sum of distances to this point is minimum ,compared to all others.
Distance is measured in the following manner.
For a point (x,y) all 8 adjacent points have distance 1.
```
(x+1,y)(x+1,y+1),(x+1,y-1),(x,y+1),(x,y-1),(x-1,y)(x-1,y+1),(x-1,y-1)
```
**EDIT**
More clearer explanation.
A function foo is defined as
```
foo(point_a,point_b) = max(abs(point_a.x - point_b.x),abs(point_a.y - point_b.y))
```
Find a point x such that sum([foo(x,y) for y in list\_of\_points]) is minimum.
Example
**Input:**
```
0 1
2 5
3 1
4 0
```
**Output**
```
3 1
```
Eg:
Distance between (4,5) and 6,7) is 2.
This can be done in O(n^2) time, by checking the sum of each pair.
Is there any better algorithm to do it?
[Answer]
I can imagine a scheme better than O(n^2), at least in the common case.
Build a [quadtree](http://en.wikipedia.org/wiki/Quadtree) out of your input points. For each node in the tree, compute the number and average position of the points within that node. Then for each point, you can use the quadtree to compute its distance to all other points in less than O(n) time. If you're computing the distance from a point p to a distant quadtree node v, and v doesn't overlap the 45 degree diagonals from p, then the total distance from p to all the points in v is easy to compute (for v which are more horizontally than vertically separated from p, it is just `v.num_points * |p.x - v.average.x|`, and similarly using y coordinates if v is predominately vertically seperated). If v overlaps one of the 45 degree diagonals, recurse on its components.
That should beat O(n^2), at least when you can find a balanced quadtree to represent your points.
[Answer]
## Python
```
def median(lst):
""" sort of median of a list """
return sorted(lst)[len(lst) / 2]
def median_point(points):
xs = [point[0] for point in points]
ys = [point[1] for point in points]
return (median(xs), median(ys))
points = [
(0, 1),
(2, 5),
(3, 1),
(4, 0),
]
print median_point(points) # (3, 1)
```
It calculates the median of the x and y coordinates separately. I'm not positive that that's correct in all cases, but it kind of seems like it might be. It's O(n log n).
[Answer]
## Scala
```
object Median extends App
{
var(xMin,yMin,xMax,yMax,a,x)=(100000000,100000000,-100000000,-100000000,"",Array.fill(2)(""))
var points=Array((100000000,100000000))
a=readLine
while(a!=null)
{
x=a.split(" ")
if(x(0).toInt<xMin)xMin=x(0).toInt
if(x(1).toInt<yMin)yMin=x(1).toInt
if(x(0).toInt>xMax)xMax=x(0).toInt
if(x(1).toInt>yMax)yMax=x(1).toInt
points=points:+((x(0).toInt,x(1).toInt))
a=readLine
}
var middlex=(xMax-xMin)/2
var middley=(yMax-yMin)/2
var meanPoint=(100000000,100000000)
var shortestDistance=100000000
points.map(x=>
{
var s=(math.abs(x._1-middlex).max(math.abs(x._2-middley)))
if(s<shortestDistance)
{
shortestDistance=s
meanPoint=x
}
})
println(meanPoint)
}
```
Takes in the points, keeping track of the highest and lowest values of `x` and `y`.
Uses those values to find the midpoint of the square defined by `xMin`,`yMin`,`xMax`,`yMax`.
Finds the point with the shortest distance to that midpoint.
Never was very good with that Big O business, so I couldn't tell you what it is for this algorithm.
[Answer]
## Haskell, 136 characters
```
main=interact$show.n.q.map read.words
n x=snd$minimum$map(\p@(a,b)->(sum$map(\(x,y)->max(abs$a-x)$abs$b-y)x,p))x
q[]=[]
q(x:y:z)=(x,y):q z
```
] |
[Question]
[
I am sorry for the very long description. But i think some information of how `/proc/self/cmdline` works and how it can be used to get a integer input was necessary.
You may skip the sections you don't need.
While part of this task is related to C and Linux, it can be done in any almost language that can start other programs / OS where programs can be started with arguments.
##### Background
For golfed C programs (and possible others) that takes a number as input, it can be shorter to just use a `argv` string and interpret the bytes of it as a integer and don't bother with parsing a ASCII string (decimal) representation of the number. In C this can be done by `main(a,v)int **v{a=*v[1]...`. This is shorter than parsing a ASCII string like this `main(a,v)int **v{a=atoi(v[1])...`. The problem is that it isn't that trivial to create an argument list so that `a=*v[1]` contains a desired value.
So the idea came to make a new code golf task to create a program that creates such a layout.
##### Memory layout
The following applies to Linux but the task should also work on a different OS with a similar way to start a program as the `exec*()`-family on Linux (it doesn't matter if a new process is started or if the current one is replaced).
I also don't care if the hack of `int a=*v[1]` works on your platform or not.
The arguments and the `/proc/$PID/cmdline` have the following layout:
```
V--- argv[0] points here V--- argv[1] points here
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| . | / | a | . | o | u | t |\0 | A | R | G | 1 |\0 | A | R | G | 2 |\0 | ...
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
^------Program name---------^ ^---Argument 1--^ ^---Argument 2--^
Interpret this 4 bytes as integer:^-----------^
```
>
> The command-line arguments appear in this file as a set of strings separated by null bytes ('\0'), with a further null byte after the last string.
>
>
>
##### Task
Write a program that takes a number as input and call a program in a way that `/prog/$PID/cmdline` of that program contains the binary representation of that number (or would contain it if it would run on Linux, what matters are is which arguments you give to the called program).
This means, you have to call a program with possible multiple arguments. This arguments have to contain the the binary byte representation of that desired number. For every 0-byte inside this number, you have to generate a new argument, but for every non-0-byte you have to continue using the same argument.
You may or may not use this memory layout for the integer 0x12003400 (assuming little endian):
```
V--- pointer 1 points here
V--- pointer 2 points here
V--- pointer 3 points here
+----+----+----+----+----+
|0x00|0x34|0x00|0x12|0x00| <- last 0x00 ends the string of pointer 3
+----+----+----+----+----+
```
Or this
```
V--- pointer 1 points here
V--- pointer 2 points here
V--- pointer 3 points here
+----+ +----+----+ +----+----+
|0x00| ... |0x34|0x00| ... |0x12|0x00|
+----+ +----+----+ +----+----+
```
Or any other layout with similar effect.
And may or may not call the program like this `execl("./program_name",pointer1,pointer2,pointer3,NULL);`
##### Rules
* **Write a full running program** that calls a other programs with some of the arguments created like mentioned before.
* While i observed this layout on Linux, the task should also work on other OSs with the following rules:
+ You can call a other program with multiple arguments where each argument is `'\0'`-terminated and doesn't contain any `'\0'` byte inside the argument.
+ It uses 8 bit per byte.
* **The number is given as a written ASCII string or a user input in a base you choose**. If needed a prefix (like `0x`) can be required.
* You must set the arguments before or while calling. It isn't allowed to pause the called program and somehow overwrite `argv` in it.
* You can use signed integers, unsigned integers or floating point numbers. They have to use at least 4 bytes and need to have a fixed size.
* For integer, at least 2^32-1 different values have to be supported, for floats at least 2^31 different values have to be supported.
* The name of the called program can be hardcoded or a different parameter (it doesn't matter from where you get it). But it has to be a valid program name (not `.`, `/`, `..` ...) and it is different from the current program name.
* The number can be placed at any `argv`-number, including 0 as long as it doesn't change the name of the called program. But it has to be always at the same one.
* There can be any amount of arguments after the number is represented, as long as it is still possible to call a program.
* You can choose the endianness.
* The number format has no padding bits.
##### Examples
A non-golfed example in C:
```
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main( int argc, char **argv )
{
if(argc<2)
{ exit(1); }
int n = atoi( argv[1] ); //the number we should give to the called program
unsigned char buffer[512]; //contains the binary representation of the number + 0-bytes
memset( buffer, 0, sizeof buffer ); //Set all to 0 so the last argument ends automatically
memcpy( buffer, &n, sizeof n ); //add the binary representation to the buffer
unsigned char *args[4]; //pointers to the start of the "strings" containing the number
args[0] = buffer; //first argument always starts at the beginning
size_t position = 0; //position in the buffer
for( size_t i = 0; i<3; i++ ) //loop for all relevant arguments
{
//As long as the current byte is not 0, it is still part of the previous argument
while( buffer[position]!='\0' )
{ position++; }
position++; //The ending 0 is still part of the previous argument
args[i+1] = &buffer[position];
}
execl( "./a.out", "./a.out", args[0], args[1], args[2], args[3], NULL );
perror( "execv" );
return 0;
}
```
Example program to be called (not part of the task):
That works when the layout it the same, little endian
```
#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>
int main( int argc, uint32_t **argv )
{
uint32_t a = *argv[1];
printf( "%"PRIu32"\n", a );
}
```
That should work independent of how `argv` is positioned in memory.
```
#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>
int main( int argc, char **argv )
{
uint32_t result = 0; //should contain the number passed as binary representation to argv
unsigned index = 1; //Which argv the current byte is from. Start with argv[1]
unsigned positionInString = 0; //Current byte inside the current argv[n]
//32 bit number with 4 bytes
for(unsigned byte = 0; byte<4; byte++ )
{
if( index>=argc )
{
fprintf( stderr, "argv is not big enough\n" );
return 1;
}
//Get a single byte
uint8_t currentValue = argv[index][positionInString] ;
//move it to the correct place. Little endian
result |= ( (uint32_t) currentValue ) << (8*byte);
positionInString++;
if( !currentValue ) //use next argument when current argument ends
{
index++;
positionInString=0;
}
}
printf( "result %"PRIu32"\n", result );
}
```
[Answer]
# Python, 64 bytes
*-2 bytes thanks to corvus\_192*
```
import os
os.execl(*"aa",*int(input()).to_bytes(4).split(b'\0'))
```
Uses big endian and assumes binary is named "a".
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/248857/edit).
Closed 1 year ago.
[Improve this question](/posts/248857/edit)
I have recently been on a quest to create really really slow sorting algorithms that make Bogosort seem like it is the best.
The task is simple: **Sort an array of integers in as long average time as possible, with the average Bachmann–Landau notation begin as high as possible, while keeping the best case performance fast**
# The rules:
* Everything happening has to be productive in some sense. Using a slow function to generate numbers is not counted as productive (unless that is one of the faster ways to get those exact numbers, and your algorithm depends on them for some reason).
* Best case\* time performace has to be \$o(2^n)\$ (i.e. faster than \$2^n\$).
\*The fast best case is not allowed to be on already sorted data.
# You need:
* Specify language
* The code / pseudocode
* An explanation + big O-notation for best and average case.
# Scoring:
Scoring will be based in order of this list:
* Highest average big O-notation
* Being deterministic
* Fastest best case
* Working on sets that are not [strictly totally ordered](https://en.wikipedia.org/wiki/Total_order)
* Earliest submission
For example, if two submissions have the same average runtime, but only one of them is deterministic, that one will win. If they are both either deterministic or non-deterministic, they are judged based on the fastest best case, and so on.
## Example:
fastSort works by giving every item a randomly generated number, putting the lowest one first, then recursively sorting the rest based on those new values. If the resulting array is not sorted, then it loops until it is.
The random marking of card numbers have a \$\frac{1}{n!}\$ chance of being correct, so it will on average take \$n!\$ attempts to select the right numbers, and for each of these attempts, the method calls itself with 1 lower length. Thus the average time complexity becomes:
$$
\begin{align}
T(n) &= n! \cdot T(n-1) \\
&= n! \cdot (n-1)! \cdot T(n-2) \\
&= n! \cdot (n-1)! \cdot (n-2)! \cdot ... \cdot 2! \cdot 1! \cdot T(0) \\
&= T(0) \cdot \prod\_{k=1}^n n! := T(0) \cdot sf(n)) = \underline{O(sf(n))}
\end{align}
$$
\$\big[sf(x)\$ is the [superfactorial](https://en.wikipedia.org/wiki/Superfactorial)\$\big]\$
The best case, excluding the case of already sorted data, is if the initial labeling is correct on every level down. This will cause the algorithm to go as many steps down as it takes to come to a part where the rest of the elements are already sorted, and then go back up again. The best of these cases is if only two elements have been swapped, in which case, it only goes 1 level down, and thus has a best case runtime of \$O(n)\$.
Looking at space efficiency:
Every step down needs to store n-(#steps) numbers, so the maximum amount of numbers needed at any given time is:
$$
\sum\_{k=1}^n k = \frac{n^2+n}{2} = O(n^2)
$$
Since the only time we compare the actual inputs, is in checking whether the array is sorted, means that it will work on any partially ordered set.
I have chosen to call it fastSort for obvious reasons. Here is a possible pseudocode-implementation (nothing language specific):
```
class Card<T>
{
T value
stack<int> cards
}
function fastSortHelper(cardArr: array<Card<T>>, offset: int)
{
if (offset >= cardArr.length) then return
while (cardArr is not sorted based on their top card)
{
push 1 random number to every cards stack
find the element with the smallest top card, and swap it with the first.
fastSortHelper(cardArr, offset + 1)
pop the top number from every cards stack
}
}
function fastSort (arr: array<T>, start: int, end: int)
{
int length := end - start
array<Card<T>> cardArr[length]
initialize cardArr with the values from arr in [start, end), and an empty stack
while (cardArr is not sorted based on their values)
{
push 1 random number to every cards stack
find the element with the smallest top card, and swap it with the first.
fastSortHelper(cardArr, 1)
pop the top number from every cards stack
}
move the values from cardArr back into arr, in the correct range
}
```
[Answer]
# [Python 3](https://docs.python.org/3/), \$O\left(n^2\left(max\left(a\right)-min\left(a\right)+1\right)^{n-1}\right)\$
```
import itertools
def sort(a):
m, n, l = min(a), max(a), len(a)
for possible in itertools.product(range(m, n + 1), repeat=l):
if (
all(possible.count(i) == a.count(i) for i in possible) and
all(i <= j for i, j in zip(possible, possible[1:]))
):
return list(possible)
```
[Try it online!](https://tio.run/##ZVBBbsMgELz7FXMEBUVx01NUXhL1QGOcboUBAZaafN5d3IREynCAGe3MrIiX8h38flloiiEVULGphOBy1w12RGZNGHnowJgUvIKDxkSeVYXJ/K63s5WvQ2NIiCFn@nIW5B@B25jCMJ@KSMafrahh2KBnd7LRmqLdraaCRohGKoxz4h67PYXZF0ESWsM8WK2m2nkflDB@wEsO4UPj539c8YMdV4otXjX/sT98Stn8T/tVJFvm5OEol@aVS0zE26z/duzVu3pT@5rxLO9Uz2fH8vIH "Python 3 – Try It Online")
When input only contains \$k\$ and \$k+1\$ each \$\frac{n}{2}\$ times. Its complexity is \$O\left(2^{\frac{n}{2}}\cdot n^2\right)\$.
] |
[Question]
[
Consider the equation $$\frac x {y+z} + \frac y {x+z} + \frac z {x+y} = n$$ for positive integers \$x, y, z\$ and \$n \ge 4\$. Your code will receive \$n\$ as an input, and output three integers \$x, y\$ and \$z\$ such that the equation holds. You may assume that a solution always exists.
## Background
This equation is a little bit of a [meme](https://i.stack.imgur.com/RxqtE.jpg) equation; it's famously difficult to solve, and even the lowest case of \$n = 4\$ took hundreds of years to do so. In [this paper](https://ami.uni-eszterhazy.hu/uploads/papers/finalpdf/AMI_43_from29to41.pdf), the authors present maximum sizes (in digit lengths) for various different \$n\$s, all of which are crazy large. It's pretty clear that a standard brute force approach of iterating through all triples is never going to find the smallest solution for any \$n\$.
However, some pretty clever approaches using [elliptic curves](https://en.wikipedia.org/wiki/Elliptic_curve) (a curve in the form \$y^2 = x^3 + ax + b\$ for constants \$a, b\$) managed to find a solution for \$n = 4\$:
$$\begin{align\*}
x & = 36875131794129999827197811565225474825492979968971970996283137471637224634055579 \\
y & = 154476802108746166441951315019919837485664325669565431700026634898253202035277999 \\
z & = 4373612677928697257861252602371390152816537558161613618621437993378423467772036
\end{align\*}$$
Your task is to find these solutions.
## Challenge
Given some positive integer \$n \ge 4\$, you should output three positive integers \$x, y, z\$ such that
$$\frac x {y+z} + \frac y {x+z} + \frac z {x+y} = n$$
You may output any one solution, in any reasonable format and manner, but you must output exactly *one* solution. You may assume that you will only receive inputs where a solution exists.
Additionally, your answer may not fail due to floating point issues.
## Scoring
This is a [fastest-code](/questions/tagged/fastest-code "show questions tagged 'fastest-code'") challenge, so you should aim for speed over conciseness. I will time each submission on my computer, so:
* You must use a freely available language (that's free as in beer)
* Please provide testing instructions
* If the language is obscure, or requires additional packages/modules, please provide a link to a page where I can download the interpreter
My computer specifications are:
MacBook Pro (16-inch, 2019). Processor: 2.3 GHz 8-Core Intel Core i9. Memory: 16 GB 2667 MHz DDR4. Graphics: AMD Radeon Pro 5500M 4 GB. Retina Display: 16-inch (3072 × 1920). Storage: 208 GB available.
Please test your submission on \$n = 4\$ before submitting, and include a preliminary time (which I will replace with an official score in due time).
### !! The only valid inputs for \$n ≤ 10\$ are supposedly `4`, `6`, and `10`.
[Answer]
# [PARI/GP](https://pari.math.u-bordeaux.fr), 0.02s for n=4 on ATO
```
fromellpoint(n, x, y) = [ 8 * (n + 3) - x + y, 8 * (n + 3) - x - y, -8 * (n + 3) - 2 * (n + 2)* x]
{ findellpoint(e, n) =
my(s, h);
h = 1;
until(#s > 0,
h *= 10;
s = [ p | p <- ellratpoints(e, h), ellmul(e, p, 6) ]);
s[1]
}
{ f(n) =
my(e, x, y, a, b, c);
e = ellinit([0, 4 * n^2 + 12 * n - 3, 0, 32 * (n + 3), 0]);
[x, y] = g = findellpoint(e, n);
while([a, b, c] = fromellpoint(n, x, y);
a <= 0 || b <= 0 || c <= 0,
[x, y] = elladd(e, g, [x, y]));
[a, b, c] * denominator([a, b, c])
}
print(f(input))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bZJRaoNAEIahj57ih77s2hWMCSWQpBcRW0zUuKDroitNaHqSvqQPpXfqaTqrRlPShYWZn2G-f2b341vHtXzZ6_P5qzWZt_y5W2d1VaZFoSupDFMCB4EjxwYhlnDBFB4w5_BwoOAobkTPit5fNbhkAXdxiBznDZlUyUhJBRQhHNApj6wRyPmqy3ICz_qwVUYW7L7BE3zRKX2BSxX-ahSazqrGie7aAzHq2HSYxnJyLqxWtoXNtMAjRzTAmnAWOe-dO3btJ-2XIBALbAV2Q3lKJGollTQs9AUWNKV6DmjMmR1Y0eBzQV4xD6ZtkHDBhbZpRE32dG_30Re95rJIWTiQbfW_7zPNH2O9gY_TCdsx2nXRtLSRTH3iJLG8vRhUfnE3Il0kqapKqWJT1ZMVblela-siY1Lp1nDef6LhL50_F33wCw)
Not really optimized. PARI/GP has some built-in functions for elliptic curves, so I just use them.
You can download PARI/GP [here](https://pari.math.u-bordeaux.fr/download.html).
When you test the code, just save the code into a file, e.g., `a.gp`, and run `echo 4 | gp -fq a.gp` (replace `4` with your input `n`).
] |
[Question]
[
Looking at the following hackerrank problem:
<https://www.hackerrank.com/challenges/flatland-space-stations>
You are given a number n where cities can be at indices 0 to n-1 and also given an unsorted list of indices of cities where there are stations. The goal is to find the maximum distance from a city to a station. For example, for n=5 and the station list [0,4], the answer would be 2 since index 2 is 2 away from both 0 and 4 and all other stations at indices 0-4 are closer to one of 0 or 4.
---
I'm particularly interested in a short Python3 solution. The function body takes in the number n and a list c (like [0,4] in the example). After some revisions, I came up with the 69 character function body below:
```
c.sort();return max(t-s for s,t in zip([-c[0]]+c,c+[2*n-c[-1]-1]))//2
```
Curious about whether anyone can come up with a shorter body.
[Answer]
Distance solution:
# [Python 3](https://docs.python.org/3/), 52 Bytes
```
return max(min(abs(l-c)for l in s)for c in range(n))
```
[Try it online!](https://tio.run/##bYpBCsIwEADvfcUed2GFaLNI/Yp6iDXVQLstmwj6@mgFb85pGGZ5lfusbb3GAQIqZzo08OFULZaHKUzhiVNSDJeM46anYTYYISnkr/arWtBbRCWqiyUtGFD46NifiZpf2Tr3v3kWz63w3vNOuOtYWNapvgE "Python 3 – Try It Online")
Index solution (added after my first two comments):
~~# [Python 3](https://docs.python.org/3/), 59 bytes
```
return max((min(abs(l-c)for l in s),c)for c in range(n))[1]
```
[Try it online!](https://tio.run/##bYpBCsIwEADvfcUed2GF1GaR@pW2h1hTDbTbkkTQ10eLeHNuM8z2yvdVm3L1EzhUTnSu4ENfos@PqLC4J@ISFN0l4XwYaVojzBAUEvHXxt2i05tHJerqoWwxaEaHwp1hOxBVv1Ib879ZFsuN8MnyUbhtWVj2qbwB "Python 3 – Try It Online")~~
Edit: Switched back to Distance solution,
Thanks to Jonathan Allan for -1 Byte
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
Ｉ⌈Ｅθ⌊↔⁻ηι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzexIjO3NBdIF2gU6ij4ZuaBuY5Jxfk5pSWpGkCB0mKNDB2FTE0IsP7/P9pUJ9pAxyQ29r9uWQ4A "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
θ First input
Ｅ Map over implicit range
ι Current value
η Second input
↔⁻ Absolute difference
⌊ Minimum
⌈ Maximum
Ｉ Cast to string
Implicitly print
```
[Answer]
# [Perl 5](https://www.perl.org/), 51 bytes
```
sub{max(map{$i=$_-1;min(map abs$i-$_,@_)}1..shift)}
```
[Try it online!](https://tio.run/##zdbdToMwFADge57iSBoD5GwBRlUgKPcad6NXuBCmoI3jZ7SLM4RnZ8Am2xvYXjRt2nPypWmbU6X1hnYkCzq@Wzd5stfypGoIC0g8s/ycFcMckjUnbEZiDGO9teZz/sUyobedD1I3JStrTWbf0EUUIxOdFQT3YK9QPp9lYmShOwIdqYBnn33yLST1mWijgzd4NyotSZR/PvN8A10q0Qle@BykDi4o3jpoU3RdpEiPZ/mPb0aR@/sDRW/k9g1d/quRAgkXiWBlwZGk@yp9F@mHHoQk9iXwkc9SBNckG5zhBNX9cbmqWSFg2ALpFiY8PIBafqvggWoYxvPyBZaPV@pliNqPhsTH0FNYMCV4K/rdreT3a8dTeGJceN6rYBvY/mh9xQB9FaFLURl0Bw "Perl 5 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~56~~ 55 bytes
```
function(n,l)max(apply(abs(sapply(1:n-1,`-`,l)),2,min))
```
[Try it online!](https://tio.run/##jYxBCoMwEEX3PckMfCGxGcRCzxJTixDQUZoI9vRpSrcuunvw3v@vsoTDP2PKPq8@5ZDjqvcy7Tp@iRQz14LCts1vCo9E6Yf2po3F0Aw1YLRYojKfnZFgJAPHfDmz1pg/vIM4XAWdQyvoewikDsoH "R – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ḶạṂ¥€Ṁ
```
[Try it online!](https://tio.run/##ASMA3P9qZWxsef//4bi24bqh4bmCwqXigqzhuYD///81/1swLCA0XQ "Jelly – Try It Online")
**5 bytes** if you allow indexing from 1:
```
ạṂ¥€Ṁ
```
## Explanation
```
ḶạṂ¥€Ṁ Main dyadic link
Ḷ [0..n-1]
€ Map
¥ (
ạ Absolute difference [from each station position]
Ṃ Minimum
¥ )
Ṁ Maximum
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 8 bytes
```
:q-|X<X>
```
Try it at [MATL Online](https://matl.io/?code=%3Aq-%7CX%3CX%3E&inputs=5%0A%5B0%3B4%5D&version=22.4.0)
**Explanation**
```
% Implicitly grab the first input, N as an integer
: % Create an array from 1...N
q % Subtract one from each element to get a 0-based range: 0...N-1
- % Implicitly grab the second input (a column vector) and subtract the
% the two, broadcasting this out into a matrix of distances between
% all cities and stations where each city is a column and the distance
% to each station is on each row
| % Take the absolute value of the result
X< % Compute the minimum value of each column (e.g. distance of each
% city to closest station)
X> % Compute the maximum value of these distances (furthest city
% from any station)
% Implicitly display the result
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
FINαßM
```
Inputs in the order \$n,s\$
[Try it online](https://tio.run/##yy9OTMpM/f/fzdPv3MbD833//zflijbQMYkFAA) or [verify some more test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWVC6H@3CL9zGw/P9/1fq6MZ8z862lQn2kDHJDZWRyHa0MAAjWOiY2qiY2yqY26iY2SqY2mpY6pjGhsbCwA).
**Explanation:**
```
F # Loop `N` in the range [0, (implicit) input `n`):
I # Push input-list `s`
Nα # Get the absolute difference of each value in `s` with `N`
ß # Pop and leave the minimum of the list
M # Push a copy of the largest number on the stack to the top of the stack
# (after the loop, the top of the stack is output implicitly as result)
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 12 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
ê├ô_ï-±╓\;]╙
```
[Try it online.](https://tio.run/##y00syUjPz0n7///wqkdT5hzeEn94ve6hjY@mTo6xjn00deb//6YKBjomXIYGBnDaRMfURMfYVMfcRMfIVMfSUsdUxxQA)
Or alternatively:
```
rhêa*m-±mÄ╓╙
```
[Try it online.](https://tio.run/##y00syUjPz0n7/78o4/CqRK1c3UMbcw@3PJo6@dHUmf//myoY6JhwGRoYwGkTHVMTHWNTHXMTHSNTHUtLHVMdUwA)
**Explanation:**
```
ê # Push all inputs as list (`n` and `s` are merged as single list)
├ # Extract the first item: pop and have list `s` and integer `n` separated on
# the stack
ô # Loop `n` amount of times, using 6 characters as inner code-block:
_ # Duplicate list `s`
ï # Push the 0-based loop index
- # Subtract it from each value in list `s`
± # Take the absolute value of each
╓ # Pop and push the minimum
\ # Swap so list `s` is at the top again for the next iteration
; # Discard the remaining `s` after the loop
] # Wrap all minima on the stack into a list
╙ # Pop and push the maximum
# (after which the entire stack is output implicitly as result)
```
```
r # Push a list in the range [0, (implicit) input `n`)
h # Get its length (without popping): `n`
ê # Push input-list `s`
a # Wrap the list into a list
* # Multiply it to the length, so we have a list of `n` amount of lists `s`
m- # Subtract the values in the two lists from one-another
# (which required the lists to be of equal length)
± # Take the absolute value of each
m # Map over each inner list,
Ä # using 1 character as inner code-block:
╓ # Pop and push the minimum
╙ # Pop and push the maximum
# (after which the entire stack is output implicitly as result)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-h`](https://codegolf.meta.stackexchange.com/a/14339/), 10 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ÆVËaXÃÍÎÃÍ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWg&code=xlbLYVjDzc7DzQ&input=NQpbMCw0XQ)
] |
[Question]
[
In an attempt to “liberate” their fellow birds, a group of highly intelligent hens are
attempting to compromise the zoo’s security system. To get access to the zoo’s mainframe,
the hens first need to guess the administrative password. The hens know that the password
is a string built from up to 62 possible characters: a, b, c, ..., z, A, B, C, ..., Z, 0, 1, ... 9.
They also know that no character appears more than once in the password, which
means that it has a maximum length of 62 (and a minimum length of 1). The password
is case-sensitive.
We define a guess be close if and only if the real password can be obtained by inserting
additional characters among the letters and numbers of the original guess. In other words,
a guess is close if it is a (not necessarily contiguous) subsequence of the password. Every
time the hens guess a password, the zoo’s security system will do one of three things:
* If the guess is exactly equal to the password, it will print ‘C’ and grant the hens
access to the mainframe.
* If the guess close but not exactly equal to the password, it will print ‘Y’.
* If the guess is neither close nor exactly equal to the password, it will print ‘N’.
The mainframe permits at most 750 guesses before it locks further attempts and alerts
the zoo officials of suspicious activity. The hens have hired you to guess the password
before you use all of your allotted attempts.
There will be no initial input. Every time your program makes a guess, the grader will
output ‘C’, ‘Y’, or ‘N’, which your program can then read via the usual input channel.
The grader will only respond to the first 750 guesses. Make sure that you end each
guess with a new line.
*This question was adapted from the 2020 mBIT Computing Olympiad.*
**Test Program made by me in Python 3 (works):**
```
from functools import cmp_to_key
def ask(s):
print(s)
c = input()
if c == 'C':
exit()
return c == 'Y'
def cmp(a, b):
return -1 if ask(a + b) else 1
ret = []
for i in range(48, 58):
if ask(chr(i)):
ret.append(chr(i))
for i in range(65, 91):
if ask(chr(i)):
ret.append(chr(i))
for i in range(97, 123):
if ask(chr(i)):
ret.append(chr(i))
ret = "".join(sorted(ret, key=cmp_to_key(cmp)))
print(ret)
```
I think it can be condensed even further, but that sample is just to show what the program is trying to ask. I do not own this question and all rights are to 2020 mBIT. The rules are simple. **Do not just print answers and shortest one wins in any language.**
[Answer]
### Python 3.7, 162 bytes
```
import string as S,functools as F
A=lambda s:'N'!=Input(s+'\n')
print(''.join(sorted(filter(A,S.ascii_letters+S.digits),key=F.cmp_to_key(lambda a,b:1-2*A(a+b)))))
```
Tries characters one-by-one to see which ones are in the password. Then sorts those letters using a comparison function. To compare 'A' and 'B', check to see if 'AB' returns 'Y'. If is does, then 'A' comes before 'B', otherwise 'A' comes after 'B'.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/199209/edit).
Closed 4 years ago.
[Improve this question](/posts/199209/edit)
This should be easy: given an arbitrary string, your program will give it a name.
# Requirements
Your program will accept an input of a UTF8 string, and output a string representing the input's "name", how you define this name is arbitrary, but it must comply with some conditions.
# I/O Ranges
The input will at most be 382 UTF 8 characters long (making the input space 1112064^382 long). Don't ask me why this number, it was random. Your program must support all of them. Consider not forcing you to deal with arbitrary input size an act of mercy.
You can use any character set to build your output space. ASCII, Unicode, only Wingdings characters, etc. all are fair game. This output space must be smaller than the input space (easy enough), and name collisions must be uniformly distributed (every name will refer to roughly the same number of input strings, ~1% fluctuation is the max. accepted difference).
Yes I'm asking you to build a watered down hash function. Just in case you're wondering.
Name collisions must be sufficiently rare that it does not happen in everyday use. 1 in \$2^{100}\$ sounds reasonable enough a limit. This forces your output space to be at least 7540 bits long (the input space is a little larger than \$2^{7640}\$). (I tried cheating my own challenge by only outputting 0 and 1, you are not allowed to cheat like I did).
# Conditions
1. Name collisions must be rare enough (see above) and must not be, by any method, deliberately generated. This is similar to hash collisions.
2. Name space must be smaller that input space (whats the point of having a name longer than the string)
3. Your program must be deterministic. Same string must be assigned the same name every time.
# Winning
The program with a name of at most 10 characters long and pronounceable (edit: since someone pointed out pronounceable is hard to define, this condition is now changed to <=10 characters of **the same spoken language**) wins. If this win condition is not met, scoring is lowest byte wins as usual.
The same language above means any **one** of the languages that people use. If one language uses some characters from another, that is fine as long as it is within normal use. (French uses English characters, for example) Mixing different language's characters that are not within formal use is not allowed (e.g. Korean characters and English alphabets)
Also give your program's name in the answer, even though it is unlikely to be <=10 characters and/or unpronounceable. I am curious what your program is called.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
₂∍
```
[Try it online!](https://tio.run/##7Y9NbsMgEIXXvgVXidxEyI5UtWmVZgkMdBhsRy4C7CyzyqaXzEVc7K66i1R1EamfxBvm8TMzRy@k1dN0PZ@vl89pEr9ESgV/gjbv@HLMPS7S3hX@Jn6M64GMQ@HBIDXCLcHlFM13yKfCI4EhN5s62fAxJh2sHvsU7Fgsmoo@2DTmHfhghR8h2HxdCU8OcDiRYwrJDQIY9uSSBkxWQ@htQpgfoFp0UDSXc@Cbvqj44Wm/3j6/HvbrzSMvVzv@tlvVVckfyqre8opX9SYvTvnriHmSrGCauNSaDRYNgZddbDslmYpSd62RmtDIQBilGpCiZOBnJ2UfiTX/3Ia7V74A "05AB1E – Try It Online")
---
### Explanation
```
₂ - 26
∍ - Extend/shorten to this length
```
Extend will repeat the string until it is length 26, shorten will remove chars from the right until it is length 26.
This means that some strings will be slightly more likely (the repeated ones since `ab, abab, ababab, ababababab` etc all produce `ababababababababababababab`, but it will fall within the 1%, since these cases of collision only occur for strings below length 26.
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes (Winning)
```
HSAsèJ₆∍
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fI9ix@PAKr0dNbY86etG4AA "05AB1E – Try It Online")
Program's name: faegdahbbafaegdahbbafaegdahbbafaegda
---
### Explanation
```
HSAsèJ - Convert it to a string of the first 10 letters of the english alphabet
₆∍ - Extend shorten to base 36 (10^36 > 2^100)
```
Can definitely be shorter, but why bother. It wins.
] |
[Question]
[
**This question already has an answer here**:
[Calculate the a ^ b WITHOUT using \*, / and ^ [duplicate]](/questions/78942/calculate-the-a-b-without-using-and)
(1 answer)
Closed 5 years ago.
The challenge is to implement a function or program that takes two numbers, \$x\$ and \$y\$ and return the result of \$x^y\$.
The program cannot use any other mathematical operation other than \$+\$ or \$-\$, so no multiplication or division. Functions built into languages are also not allowed.
The code in the least amount of bytes wins.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 7 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit infix function. *y* is left argument and *x* is right argument.
```
(+/⍴)/⍴
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X0Nb/1HvFk0Q8T/tUduER719j/qmevo/6mo@tN74UdtEIC84yBlIhnh4Bv83UkhTMOYyAZJGXCC2oQGXoQGIBwA "APL (Dyalog Unicode) – Try It Online")
`⍴` cyclically reshape (gives *y* copies of *x*)
`(`…`)/` reduce by the following function:
 `⍴` cyclically reshape to left argument copies of right argument
‚ÄÉ`+/`‚ÄÉsum
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
lambda x,y:y>1and sum(x for _ in range(f(x,y-1)))or x
```
[Try it online!](https://tio.run/##PcpBCoMwEADAu6/YY7KsYDaeCu1LBInYtEJdJUZIXh9zsddh9hy/m3Dxz6H83DrNDhLlR34ZJzMc56oS@C3ACItAcPJ5K6/qaI3Wunoqe1gkgleWek1gEfvmJiZbiRHtn0xHXM10iFwu "Python 2 – Try It Online")
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/176301/edit).
Closed 5 years ago.
[Improve this question](/posts/176301/edit)
Given an array `A` of integers, there exists at least one positive integer p such that `A[i] == A[j]` for all `i` and `j` for which `i % p == j % p == 0`. Find the smallest p.
Examples:
* Input array: `[1, _, 1, _, 1, _, 1, _, 1]`. Output: 2
* Input array: `[1, _, _, 1, _, _, 1, _, _]`. Output: 3.
* Input array: `[1, _, _, _, 1, _, _, _, 1]`. Output: 4
[Answer]
# Python 3, 47 bytes
```
f=lambda l,d=1:f(l,d+1)if~-len({*l[::d]})else d
```
[Try It Online](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRIUcnxdbQKk0DSGsbamam1enmpOZpVGvlRFtZpcTWaqbmFKcqpPxPyy9SyFHIzFOI5uKMNtRRMNJRQCFjdbCLA0kkKWMdBROYFAobQ42pjoKZjoK5joKFjoIlUDbWiouzoCgzr0QD6FRNzf8A)
[Answer]
# [Python 3](https://docs.python.org/3/), 43 bytes
```
f=lambda l,n=1:2>len({*l[::n]})or-~f(l,n+1)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRIUcnz9bQysguJzVPo1orJ9rKKi@2VjO/SLcuTQMop22o@T8tv0ghRyEzTyGaizPaUEfBSEcBhYzVwS4OJJGkjHUUTGBSKGwMNaY6CmY6CuY6ChY6CpZAWQUoiDYGqzCG6IGLmiBzIHpNwdqBpClQLtaKi7OgKDOvRAPoI03N/wA "Python 3 – Try It Online")
Assumes the list is non-empy. Outputs `True` as `1`, though for 1 byte this can be fixed by changing `2>` to `1//`.
**44 bytes:**
```
f=lambda l,n=1:{l[0]}=={*l[::n]}or-~f(l,n+1)
```
[Try it online!](https://tio.run/##bY/BCsIwEETP7VfssdEVjGmrBvIlIYeKBAsxKaEXKfXX49KqtOgeht15M4ftHv0teJGSVa65X64NOPSKy8HpvRmVGjZOS@nNGOLuaQuCW86SDREctB50nmmOcEBYqcH/PukCCYTyg1b7T6ZCqBGOCCeEM1F4jxZTQsydr1suj7lbTXXSipiRedbF1vcFfcRYegE "Python 3 – Try It Online")
```
f=lambda l,n=1:l[:-n:n]==l[n::n]or-~f(l,n+1)
```
[Try it online!](https://tio.run/##bY@9DsIwDITn9ik8NsIdQhp@IuVJogxFKKJScKqoCwuvHqwWUCvwcLLvuxs8PqZbIlVKsLG/X649RCQrTXSmJUPe2ujI8JJy@wwNw50UJaQMEQYCV1dOIuwRNurxv8@6Qgqh@6DN/pPRCAeEI8IJ4cwU3uPUnFBL5@t262Pp6rnOqpl5U1djHmhq@CMhygs "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
Assuming this is meant to be [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") for now.
```
mJE€TḢ
```
**[Try it online!](https://tio.run/##y0rNyan8/z/Xy/VR05qQhzsW/f//P9pcR8FCR8FSRwHIMNBRMDQGs0xjAQ "Jelly – Try It Online")**
[Answer]
# Pyth, 7 bytes
```
f!t{%TQ
```
Try it [here](http://pyth.herokuapp.com/?code=f%21t%7B%25TQ&input=%5B3%2C1%2C4%2C3%2C1%2C5%2C3%2C9%2C2%2C3%5D&debug=0). Pyth is at a disadvantage because it uses only printable ASCII; optimally encoded this would be \$7 \* \log\_{256} 95 = 5.749\$ bytes.
```
f Find the first positive integer T such that
!t there is only one element in
{ the list obtained by taking unique elements
%TQ of every Tth element of the input.
```
[Answer]
# Java 8, 85 bytes
A lambda from a primitive array type to `int`.
```
l->{for(int d=0,i;;)for(i=++d;;i+=d){if(i>=l.length)return d;if(l[i]!=l[i-d])break;}}
```
[Try It Online](https://tio.run/##XVDLasMwEDw7X7ENBCwii/TdxnWgl0IPPeUYQlEs2VWiyEaSU4Lxt6frR5NSEKt9zKxGs@UHHm3F7lRWG61SSDV3Dj64MlCPgqHpPPd4HQolYI@jcOmtMvlqDdzmjrTIYIuLWOWVZlllUq8Kw96G5EUXLZjCu/Eyl3YBGSQnHS3qrLChMh5EMqMqjklXJ9OpiGM1TQSpVRaqRaKZlib3X8RKX1kDIsa@Xqn1VYIxEmuysZLv4qY5BUGMYvoHUV/KnXSQgJHfcG62coP6msKMwv/Y0D/DvndH4aZLnilE95hdMOczgC8TZNx2VCQ8UHik8IQLunnTKsSfQtgr6kR@wrwX27sZLI/Oyz0rKs9K9NrrX9MZMvfch@OJm8NEjClcnH@1lh8d80UPDbvFhELGeFnq41AT0gpoRnia0w8)
## Ungolfed
```
l -> {
for (int d = 0, i; ;)
for (i = ++d; ; i += d) {
if (i >= l.length)
return d;
if (l[i] != l[i - d])
break;
}
}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 10 bytes
```
@ëX â ÊÉ}f
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=QOtYIOIgysl9Zg==&input=WzEsMiwxLDEsMSwyLDFdCi1R)
Explanation:
```
@ }f :Get the first integer X which returns 0 from:
ëX : Get every Xth item in the input
â : Get the unique values of that list
Ê : Count how many there are
É : Subtract 1
```
[Answer]
# Powershell, 82 bytes
```
(($a=$args)|%{($i++)}|?{"$a"-match"^(\d+)(( -?\d+){$_} \1)*( -?\d+){0,$_}$"})[0]+1
```
Test script:
```
$f = {
(($a=$args)|%{($i++)}|?{"$a"-match"^(\d+)(( -?\d+){$_} \1)*( -?\d+){0,$_}$"})[0]+1
}
@(
,(1 , 1,1,1,1,1)
,(2 , 1,-2,1,3,1,-4,1,5)
,(2 , 1,-2,1,3,1,-4,1,5,1)
,(3 , 1,-2,1,1,3, 4,1,5,1) # 1 may be in place '_'
,(4 , 1,-2,3,4,1, 5,1,6,1)
,(5 , 1,2,3,4,5,1)
) | % {
$expected, $a = $_
$result = &$f @a
"$($result-eq$expected): $result"
}
```
Explanation:
`Regexp` match on `array.toString()` which equivalent `array.join(' ')`.
[Answer]
# Python 3, 64 Bytes
A recursive approach.
```
f=lambda x,s=1:s if x[::s].count(x[0])==len(x[::s])else f(x,s+1)
```
[Try it Online](https://tio.run/##dY1RC8IgFIXf@xX3UUlCc70I@yXiwyqlgbmRDuzX2zLbWG1cPFzu@c6xf4Zb53hKprbN/XxtIBIvPLQGohTCq8OlG1xAUVKF69pqhz53rK3XYNCI7xlO/aN1AZBBkhE4Ehi1ysqzvi@KMIx3v@BETaHTOsi/7LwvwGWCkvL@y2gxN@x5tsy1Sp7rcopU63@WyWZ6AQ)
# Python 3, ~~82~~ 81 Bytes
-1 byte thanks to Jakob!
```
lambda x:[x[::i].count(x[0])==len(x[::i])for i in range(1,len(x)+1)].index(1>0)+1
```
[Try it Online!](https://tio.run/##bY1BDsIgEEX3nmKWEEkDUjdN6kWQRbWtktShaWqCp0fE2molk/lh5r/59I/xalH6tjz6rrqd6gpcoZwqCqOzs73jSJzimpZl1yB572lrBzBgEIYKLw0RLHp0K6jODNaNI@LAw@j7weAIpCVKMNgxCJpHlVFfG03pZo3NzHyyT2HyQy7vL@yX52zqdRCfrKS5VNr6D5MxKF6wPPXXVMHyTw)
[Answer]
# Japt, 6 bytes
I think this is right, the spec isn't all that clear. Assumes, as the spec would seem to suggest, that the number we're looking for will always appear first in the array and the `_`s must all be different from that number.
```
ð¶Ug)æ
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8LZVZynm&input=WzcsIDgsIDksIDcsIDAsIDEzLCA3LCA1XQ==)
```
:Implicit input of array U
ð :0-based indices of elements
¥ : Equal to
Ug : First element of U
) :End indexing
æ :First truthy (non-zero) element
```
] |
[Question]
[
**This question already has answers here**:
[Gamma Function Golf](/questions/63887/gamma-function-golf)
(12 answers)
Closed 5 years ago.
# Introduction
We know that the factorial notation is valid for all natural numbers. However, Euler had extended it for all positive real numbers, as well as for complex numbers by defining a function, which is known as the Gamma Function. It is represented by Γ.
# Challenge
You will be given a non-negative floating point number, say 'n' (with a maximum of 2 decimal places in it), and you need to output the factorial of that number correct to at least 3 decimal places. Assume all inputs to be valid, and n <= 7.
Now talking about Gamma function, there is an integral which can be used to find the value of any factorial. You may choose to use it. You can find more information [here](https://en.wikipedia.org/wiki/Gamma_function). The Gamma function is recursive in nature. One important property, which would probably be useful to you is:
Γ(n) = (n-1)! , which means that, n! = Γ(n) . n
Also note that we really do not need to know Γ(n) for all values of n. For instance, look at the number 4.5 - we can write its factorial as:
```
4.5! = 4.5 * 3.5 * 2.5 * 1.5 * 0.5! = 59.0625 * 0.5!
```
So here we need only the value of 0.5! , which means the value of Γ(1.5). Also, similarly, we can find the factorial of any decimal if we know the values of factorials of numbers between 0 and 1, i.e, values of gamma function of numbers between 1 and 2. You need it, so that is why there is a table below for your help:
[](https://i.stack.imgur.com/CB4Z9.png)
Using this table, we can see that 0.5!, i.e, the value of Γ(1.5) = 0.88623, which gives our result: (4.5)! = 59.0625 \* 0.88623 = 52.3429594 , which is indeed a good result. Similarly,
```
(5.7)! = (5.7)*(4.7)*(3.7)*(2.7)*(1.7)*(0.7)! = 454.97457 * 0.90864 = 413.408093
```
Also, if you do not wish to use the table for calculating the gamma function, here is a simple integral to help you out:
[](https://i.stack.imgur.com/jPhnh.png)
Remember that you can provide your answers only up to 3 decimal places if you want to. But the value should have minimum error. Like, +- 0.003 is acceptable.
You are free to decide in what way you want to compute the factorial - whether by the integral, or by the table, or using any other method.
# Examples
Please note that here the answer is correct to 3 decimal places.
```
2.4 -> 2.981
3.9 -> 20.667
2.59 -> 3.675
1.7 -> 1.545
0.5 -> 0.886
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code wins!
[Answer]
# [Perl 5](https://www.perl.org/), `-p` 40 bytes
Very slow. One run takes about 13 minutes for me.
```
#!/usr/bin/perl -p
$\=5e8**++$_/$_;$\/=1+$'/$_ for//..5e8}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lxtYw1VxLS1tbJV5fJd5aJUbf1lBbRR3IVkjLL9LX19MDytdW//9vqmf@L7@gJDM/r/i/bsF/XV9TPQM9QwMA "Perl 5 – Try It Online")
The TIO link uses `1e7` instead of `5e8` to avoid timeouts and is therefore not accurate enough
# Old version, `-p` 60 bytes, not accurate enough
Uses a Stirling approximation. But even with the first correction term that is pretty inaccurate for small n. So instead I approximate `(n+2)!/(n+2)/(n+1)`.
Notice that I don't bother trying to get the first 3 digits right, but the relative error seems to properly be `< 0.001` in the range `[0, 7]`. E.g. `0!` outputs `0.999481433067179` which would be `1.000` if rounded to 3 digits.
```
#!/usr/bin/perl -p
$_=(($_+=2)/exp 1)**$_*(2+1/6/$_)/$_/($_-1)*sqrt$_*atan2 1,0
```
[Try it online!](https://tio.run/##DcopDsAgEEDRqyAQLGVNwHGEnmGCQDRpgAKip@8U8dX7vYw7IFJIjFGQyXNT3k4cF4KCYF46Ew0FvjN7UBvmM9a2vHL1xB0WMX6tr6vViaqjOoO22tkf "Perl 5 – Try It Online")
[Answer]
# Community wiki for built-in solutions
This answer is intended to collect answers that are simply [built-ins](https://codegolf.meta.stackexchange.com/q/14443). It's a community wiki, so anybody can edit in without approval. Go ahead and include any **built-in only** solution here, following [xnor's proposal](https://codegolf.meta.stackexchange.com/a/11218) and according to [our consensus](https://codegolf.meta.stackexchange.com/a/14397).
## [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
!
```
[Try it online!](https://tio.run/##y0rNyan8/1/xv87hdpVHTWuyHjXMUdC1U3jUMBfEjfz/30jPREfBWM9SR8FIzxRIGuqZ6ygY6JkCAA "Jelly – Try It Online")
## [J](http://jsoftware.com/) , 1 byte
```
!
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/Ff9rcnGlJmfkK6QpGOmZWv4HAA "J – Try It Online")
## [2sable](https://github.com/Adriandmen/2sable), 1 byte
```
!
```
[Try it online!](https://tio.run/##MypOTMpJ/f9f8f9/Iz1TSwA "2sable – Try It Online")
## [Pyth](https://github.com/isaacg1/pyth), 2 bytes
```
.!
```
[Try it online!](https://tio.run/##K6gsyfj/X0/x/38jPVNLAA "Pyth – Try It Online")
## [R](https://www.r-project.org/), 9 bytes
```
factorial
```
[Try it online!](https://tio.run/##K/qfpmCj@z8tMbkkvygzMed/mkZxcmKehqYml5GeCZexniWQNrXkMtQz5zLQM/0PAA "R – Try It Online")
## [Stax](https://github.com/tomtheisen/stax/), 2 bytes
```
|F
```
[Try and debug online!](https://staxlang.xyz/#c=%7CF&i=8&a=1)
## [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 3 bytes
```
#!&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78r8FVbaRnoqNgrGepo2CkZwokDfXMdRQM9Exr/yv@19TXDyjKzCv5DwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 1 byte
```
!
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R2wRFIKVgpGfClaZgrGfJBWKbgihDPXMgaaBnCgA "APL (Dyalog Unicode) – Try It Online")
In APL, the factorial primitive has always included the entire domain of the gamma function.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/90685/edit).
Closed 7 years ago.
[Improve this question](/posts/90685/edit)
In Golfenhagen, The people are allowed, and encouraged, to melt down old coins for scrap metal, if the smelter can make a profit off of it. There are 5 coins that make the Golfenhagen mint. The half-penny(0.5)(H), the penny(1)(P), the tea (5)(T), the flag (10)(F), and the driver (25)(D). Golfenhagen also mints bills, in the form of 100(O), 500(E), 1000(N), and 2500(Y). Recently, the price of metals has plumetted to an all time low, and so everybody is trying to give their coins away, as they are worth less than the bills.
A humble software engineer decides to write a program that will guarantee that those who pay with cash will always get at least 9 coins back on any purchase whose net difference is bigger than 3 cents.
## Your challenge:
Take on the role of developer, and write a program that takes one input (the net difference of the money handed out and the purchase total) and outputs the correct change.
## You must:
* Make your program put out a nominal of 9 coins with any decimal, except where the difference is less than 5 cents (5).
* Make your program output a diverse set of coins, all coins MUST be able to be outputted by your program. no giving change in exclusively in halfcents.
* Use the dollar bills where applicable.
* This is a golf, the shortest code wins
## Examples:
>
> 301
>
> OODDDTTTTTP
>
>
>
This is a valid output. There are two dollars ("OO"), and 9 coins ("DDDTTTTTP ").
>
> 5693
>
> 2Y1E1O2D3F2T3P
>
>
>
This is also valid output, as it specifies the currency type and quantities, and has 10 coins.
>
> 412
>
> OOOODPP
>
>
>
This is not valid output, as it only uses 3 coins.
>
> 20
>
> 10P20H
>
>
>
This is not valid, see the second rule
Code example of a change counter for the least change possible. (as requested per cold golf)
```
package lookup;
public class Main {
static void main(String[]s) {
int changeincents = 53;
int quartercount = 0;
int dimecount = 0;
int nickelcount = 0;
int pennycount = 0;
while(changeincents >= 25){//value of a quarter
quartercount++;
changeincents-=25;
}
while(changeincents >= 10){
dimecount++;
changeincents-=10;
}
while(changeincents >= 5){
nickelcount++;
changeincents-=5;
}
while(changeincents >= 1){
pennycount++;
changeincents--;
}
}
}
```
Good luck!
[Answer]
## Haskell, ~~177~~ 165 bytes
Thanks to @Lynn.
```
f n|n>2504='Y':f(n-2500)|n>1004='N':f(n-1000)|n>504='E':f(n-500)|n>104='O':f(n-100)|n>29='D':f(n-25)|n>14='F':f(n-10)|n>9='T':f(n-5)|n>6='P':f(n-1)|0<1=[1..2*n]>>"H"
```
In a readable format:
```
f n
| n > 2504 = "Y" ++ f(n-2500)
| n > 1004 = "N" ++ f(n-1000)
| n > 504 = "E" ++ f(n-500)
| n > 104 = "O" ++ f(n-100)
| n > 29 = "D" ++ f(n-25)
| n > 14 = "F" ++ f(n-10)
| n > 9 = "T" ++ f(n-5)
| n > 6 = "P" ++ f(n-1)
| 0 < 1 = replicate (2*n) 'H'
```
Just give out the biggest denomination which still leaves more than 5 cents to fill with halfcoins.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 7 years ago.
[Improve this question](/posts/89398/edit)
Every year, [Dyalog Ltd.](http://www.dyalog.com/) holds a student competition. [The challenge there](http://www.dyalog.com/student-competition.htm) is to write *good* APL code. However, this is a [multiple-holes](/questions/tagged/multiple-holes "show questions tagged 'multiple-holes'") (common theme is manipulation of data of any type and structure, especially special handling of empty data) [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") version of the Phase I problems – open to any language. Enjoy!
# Objective
Write ten complete programs (or functions, etc.) to solve the below problems using any one language. The point is that you must select a language that is good at various tasks, as opposed to the common golfing strategy of choosing the right tool for the (single) task. You may not use one solution as subroutine in another solution, and your score is the total byte count of all ten programs together.
Passing all the test cases is sufficient to be a valid submission.
# Closing Date
18 August 2016.
# Related: possibility of real world prizes
If you chose to use Dyalog APL ([free download](http://goo.gl/9KrKoM)), you may also want to participate in [the original competition](http://www.dyalog.com/student-competition.htm), but note that the objective there is to submit quality code – not necessarily short code. If you are a student, you can win USD 100 for Phase I. Phase II (not included here) can win you up to USD 2000 and a free trip to Scotland.
# The problems
## Problem 1 – Statistics - Mean
Write a program that takes a numeric array and gives the mean (average) of the array.
**Test cases:**
`[1,2,3,4,5,6]` → `3.5`
`[]` → `0`
`17` → `17`
`[[1,2,3,4],[5,9]]` → `4`
# Problem 2 – Statistics - Median
Write a program that takes numeric data and gives the median of the data. The median is the number separating the higher half of the data from the lower half. The median can be found by arranging all the observations from lowest value to highest value and picking the middle one. If there is an even number of observations, then there is no single middle value; the median is then defined to be the mean of the two middle values.
**Test cases:**
`[1,2,3,4,5,6,7,8,9]` → `5`
`[[1,8,2],[7,3,6,4,5]]` → `4.5`
`[]` → `0`
`7` → `7`
`[1,1,1,9,1]` → `1`
`[1,3,9,1]` → `2`
# Problem 3 – Statistics - Mode
Write a program that takes a numeric list and gives the mode, most common value, of the list. If more than one number occurs the greatest number of times, return all such numbers.
**Test cases:**
`[2,2,1,4,3,2,5,1,2]` → `2` or `[2]`
`[]` → `[]`
`[1,2,3,4,1,2]` → `[1,2]`
# Problem 4 – Just Meshing Around
Write a program that takes strings or two numeric lists and gives the inputs shuffled into a string/list formed by alternately taking successive elements from each input. (This is known as a Faro shuffle.) The inputs do not have to be the same length. Begin with the first input.
**Test cases:**
`'MENS'` `'EKES'` → `'MEEKNESS'`
`'Dyalog'` `'APL'` → `'DAyPaLlog'`
`'APL'` `'Dyalog'` → `'ADPyLalog'`
`[1,3,5,7]` `[2,4,6,8]` → `[1,2,3,4,5,6,7,8]`
`''` `'Hello'` → `'Hello'`
`'Hello'` `''`→ `'Hello'`
`''` `''` → `''`
# Problem 5 – You're Unique, Just Like Everyone Else
Write a program that takes a list or string and gives elements or characters that occur only once in the input.
**Test cases:**
`[1,2,3,4,5]` → `[1,2,3,4,5]`
`[1,2,3,4,5,4,3,2,1]` →`[5]`
`'hello world'` → `'he wrd'`
`'aabbcc'` → `''`
`''` → `''`
# Problem 6 – Shorter Ones to the Front
Write a program that takes a list and sorts it by the length of each element. Note: an element of the list can be single number, in which case it must be counted as length 1.
**Test cases:**
`['one','two','three','four','five','six']` → `['one','two','six','four','five','three']`
`[[2,4,3],[4,5],1,[7,3]]` → `[1,[4,5],[7,3],[2,4,3]]` (sorting is not necessary)
`[]` → `[]`
`[[],[2,2],1]` → `[[],1,[2,2]]`
# Problem 7 – 3's and 5's
Write a program that takes a numeric list and returns all elements that are divisible by 3 or 5.
**Test cases:**
`[1,2,3,4,5,6,7,8,9,10]` → `[3,5,6,9,10]`
`[]` → `[]`
`[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]` → `[-10,-9,-6,-5,-3]` (sorting is not necessary)
# Problem 8 – Separating Out the Negative
Write a program that takes a numeric list and gives a two element list whose first element contains the values less than 0 (zero) in the input and the second element contains all values greater than or equal to 0 (zero).
**Test cases:**
`[0,1,-2,3,-4,-5,6,7,8,-9,10]` → `[[-2,-4,-5,-9],[0,1,3,6,7,8,10]]`
`[1,2,3,4,5]` → `[[],[1,2,3,4,5]`
`[-1,-2,-3,-4,-5]` → `[[-1,-2,-3,-4,-5],[]]`
`[]` → `[[],[]]`
# Problem 9 – Delimited Text
Write a program that takes two strings where the first string is delimiter**s** in the second string. The program should give the delimited text as a list of strings.
**Test cases:**
`','` `'comma,delimited,values'` → `['comma','delimited','values']`
`' '` `'break up words'` → `['break','up','words']`
`','` `','` → `['','']`
`','` `'hello world'` → `['hello world']`
`','` `''` → `['']`
`',;'` `'multi,delimited;values'` → `['multi','delimited','values']`
# Order Total
Write a program which takes list of prices and a list which indicates the count ordered of each corresponding item and gives the total cost for the order.
**Test cases:**
`[2.99,4.99,1.99]` `[5,0,2]` → `18.93`
`[2.99,4.99,1.99]` `[0,0,0]` → `0`
`[123.00]` `[0]` → `0`
`[2.00 0.00]` `[3,4]` → `6`
`[]` `[]` → `0`
---
I have explicit permission to post this challenge here from the original author of the competition. Feel free to verify by following the [provided link](http://www.dyalog.com/student-competition.htm) and contacting the author. I gave the original competition author the link to this page within the minute I posted it, so they can check if I submit someone's answer as my own.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~88~~ ~~86~~ 84 bytes
## Problem 1: Mean (6 bytes)
```
.O.n]Q
```
[Test suite.](http://pyth.herokuapp.com/?code=.O.n%5DQ&test_suite=1&test_suite_input=%5B1%2C2%2C3%2C4%2C5%2C6%5D%0A%5B%5D%0A17%0A%5B%5B1%2C2%2C3%2C4%5D%2C%5B5%2C9%5D%5D&debug=0)
## Problem 2: Median (~~23~~ 21 bytes)
```
~~.O,hJ.x.<S\*2K.n]QlK]0eJ~~
.O<.x.<S*2K.n]QtlK]02
```
[Test suite.](http://pyth.herokuapp.com/?code=.O%3C.x.%3CS%2a2K.n%5DQtlK%5D02&test_suite=1&test_suite_input=%5B1%2C2%2C3%2C4%2C5%2C6%2C7%2C8%2C9%5D%0A%5B%5B1%2C8%2C2%5D%2C%5B7%2C3%2C6%2C4%2C5%5D%5D%0A%5B%5D%0A7%0A%5B1%2C1%2C1%2C9%2C1%5D%0A%5B1%2C3%2C9%2C1%5D&debug=0)
## Problem 3: Mode (7 bytes)
```
{.x.M/Q
```
[Test suite.](http://pyth.herokuapp.com/?code=%7B.x.M%2FQ&test_suite=1&test_suite_input=%5B2%2C2%2C1%2C4%2C3%2C2%2C5%2C1%2C2%5D%0A%5B%5D%0A%5B1%2C2%2C3%2C4%2C1%2C2%5D&debug=0)
## Problem 4: Interleave (3 bytes)
```
.iF
```
[Test suite.](http://pyth.herokuapp.com/?code=.iF&test_suite=1&test_suite_input=%27MENS%27%2C%27EKES%27%0A%27Dyalog%27%2C%27APL%27%0A%27APL%27%2C%27Dyalog%27%0A%5B1%2C3%2C5%2C7%5D%2C%5B2%2C4%2C6%2C8%5D%0A%27%27%2C%27Hello%27%0A%27Hello%27%2C%27%27%0A%27%27%2C%27%27&debug=0)
## Problem 5: Unique (7 bytes)
```
fq1/QTQ
```
[Test suite.](http://pyth.herokuapp.com/?code=fq1%2FQTQ&test_suite=1&test_suite_input=%5B1%2C2%2C3%2C4%2C5%5D%0A%5B1%2C2%2C3%2C4%2C5%2C4%2C3%2C2%2C1%5D%0A%27hello+world%27%0A%27aabbcc%27%0A%27%27&debug=0)
## Problem 6: Sort (6 bytes)
```
ol.n]N
```
[Test suite.](http://pyth.herokuapp.com/?code=ol.n%5DN&test_suite=1&test_suite_input=%5B%27one%27%2C%27two%27%2C%27three%27%2C%27four%27%2C%27five%27%2C%27six%27%5D%0A%5B%5B2%2C4%2C3%5D%2C%5B4%2C5%5D%2C1%2C%5B7%2C3%5D%5D%0A%5B%5D%0A%5B%5B%5D%2C%5B2%2C2%5D%2C1%5D&debug=0)
## Problem 7: Divisibility (10 bytes)
```
f!*%T3%T5Q
```
[Test suite.](http://pyth.herokuapp.com/?code=f%21%2a%25T3%25T5Q&test_suite=1&test_suite_input=%5B1%2C2%2C3%2C4%2C5%2C6%2C7%2C8%2C9%2C10%5D%0A%5B%5D%0A%5B-1%2C-2%2C-3%2C-4%2C-5%2C-6%2C-7%2C-8%2C-9%2C-10%5D&debug=0)
## Problem 8: Separate (10 bytes)
```
,Jf<T0Q-QJ
```
[Test suite.](http://pyth.herokuapp.com/?code=%2CJf%3CT0Q-QJ&test_suite=1&test_suite_input=%5B0%2C1%2C-2%2C3%2C-4%2C-5%2C6%2C7%2C8%2C-9%2C10%5D%0A%5B1%2C2%2C3%2C4%2C5%5D%0A%5B-1%2C-2%2C-3%2C-4%2C-5%5D%0A%5B%5D&debug=0)
## Problem 9: Split (12 bytes)
```
~~AQu.ncRHGG]H~~
u.ncRHGQ]E
```
[Test suite.](http://pyth.herokuapp.com/?code=u.ncRHGQ%5DE&test_suite=1&test_suite_input=%27%2C%27%0A%27comma%2Cdelimited%2Cvalues%27%0A%27+%27%0A%27break+up+words%27%0A%27%2C%27%0A%27%2C%27%0A%27%2C%27%0A%27hello+world%27%0A%27%2C%27%0A%27%27%0A%27%2C%3B%27%0A%27multi%2Cdelimited%3Bvalues%27&debug=0&input_size=2)
## Problem 10: Dot-product (4 bytes)
```
s*VF
```
[Test suite.](http://pyth.herokuapp.com/?code=s%2aVF&test_suite=1&test_suite_input=%5B2.99%2C4.99%2C1.99%5D%2C%5B5%2C0%2C2%5D%0A%5B2.99%2C4.99%2C1.99%5D%2C%5B0%2C0%2C0%5D%0A%5B123.00%5D%2C%5B0%5D%0A%5B2.00%2C0.00%5D%2C%5B3%2C4%5D%0A%5B%5D%2C%5B%5D&debug=0)
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 7 years ago.
[Improve this question](/posts/84334/edit)
There are numerous reasons for trying to obfuscate input. These include preventing decompiling, and being a nuiscance.
---
With this in mind your challenge should your choose to accept it is to write a meta-obfuscator. Your code must in some Language X receive input as a String, and output a program in language X that outputs the input String.
---
Rules
1. Standard loopholes disallowed
2. It should be hard to tell whether the output prints anything (I.E the code should be heavily obfuscated)
3. Your program should be testable
4. Cryptographic approaches are permitted, but it should not be obvious.
5. Try to submit an interesting solution as this is a popularity contest
---
Winning Criterion
Although it is up to you to decide which question deserves your upvote. Here are the guidelines.
1. Hardest to reverse engineer output based on the source code (i.e most encrypted/obfuscated)
2. Effort and quality of answer
---
tl;dr
Output a program which prints the input, but make it hard to understand what is going on. Although many people have discussed this (especially for javascript) and even python. I have seen no formal repository of such programs in any arbitrary languages.
[Answer]
# Java
Just out of curiosity I decided to write a simple block of code that outputs code that does not look obfuscated.
Here is the generator code
```
package metaobfuscate;
import java.util.Random;
import java.util.Scanner;
/**
*
* @author rohan
*/
public class MetaObfuscate {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String s = (new Scanner(System.in)).nextLine().toLowerCase();
int i = 0;
int numChar = s.length();
String randomlyGenerated;
String alphabet = " abcdefghijklmnopqrstuvwxyz!?.";
do {
Random rand = new Random(i);
randomlyGenerated = "";
i++;
for (int j = 0; j < numChar; j++) {
randomlyGenerated += alphabet.charAt((int) (rand.nextDouble() * alphabet.length()));
}
} while (!s.equals(randomlyGenerated));
i--;
System.out.println("import java.util.Random;\n//Simple demonstration of generating random characters");
System.out.println("public class RandomNessTest {");
System.out.println("\t//args are the command line arguments");
System.out.println("\tpublic static void main(String[] args){");
System.out.println("\tRandom rand = new Random(" + i + ");//replace the seed with whatever seed you want");
System.out.println("\t//the seed was generated by random keyboard mashing");
System.out.println("\tString alphabet = \" abcdefghijklmnopqrstuvwxyz!?.\";");
System.out.println("\tfor(int i = 0;i<" + numChar + ";i++)");
System.out.println("\t\tSystem.out.print(alphabet.charAt((int)(rand.nextDouble()*alphabet.length())));");
System.out.println("\t//print out a few random characters");
System.out.println("\t}\n}");
}
}
```
It takes in whatever string you wish to obfuscate and outputs a program that looks reliable as output. It takes exponential runtime with larger strings, but it works great for strings of length 1-5. The outputted program claims to be a tutorial, and is even formatted nicely!
```
import java.util.Random;
//Simple demonstration of generating random characters
public class RandomNessTest {
//args are the command line arguments
public static void main(String[] args){
Random rand = new Random(2727915);//replace the seed with whatever seed you want
//the seed was generated by random keyboard mashing
String alphabet = " abcdefghijklmnopqrstuvwxyz!?.";
for(int i = 0;i<5;i++)
System.out.print(alphabet.charAt((int)(rand.nextDouble()*alphabet.length())));
//print out a few random characters
}
}
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 7 years ago.
[Improve this question](/posts/78109/edit)
For the last day of the semester, I decided to have some fun with my students and I showed them Code Golf... poor guys, they're addicted now.
The goal was to compete against the other students to solve those problems with what would be very usual rules for you. They had to use C# (because it's the language they are learning right now) so please do the same.
The length of each method must be the shortest **including the method signature**!
# Tasks
Write functions that do the following:
1. **Input:** `string`, `int`.
**Output:** `string`.
**Description:** the output string repeats the input string as many times as the input int.
**Example:** `a("Hi", 5)` returns `"HiHiHiHiHi"`.
2. **Input:** `int`.
**Output:** `int`.
**Description:** the output is the quantity of prime numbers lower or equal to the input.
**Example:** `b(10)` returns `4`. `b(100)` returns `25`.
3. **Input:** `object[]`.
**Output:** `object[]`.
**Description:** returns the input without the `null` values.
**Example:** `c(new object[] { "Hello", 42, null, new Program(), null, null, false })` returns an array containing `[Hello, 42, Program instance, false]`.
4. **Input:** `int`.
**Output:** `int`.
**Description:** the output is the sum of all the integers from 1 to int input.
**Example:** `d(4)` returns `10` (because 1 + 2 + 3 + 4 = 10).
5. **Input:** `char`.
**Output:** `char`.
**Description:** the output is the input char with the other case. non-letters don't need to be checked.
**Example:** `e('a')` returns `'A'`. `e('A')` returns `'a'`. `e('-')` may have unexpected results.
6. **Input:** `string`, `int`.
**Output:** `bool`.
**Description:** true if and only if the length of the input string is a multiple of the input int.
**Example:** `f("Programmer", 5)` returns `true`. `f("Programming", 5)` returns `false`.
7. **Input:** `string`.
**Output:** `boolean`.
**Description:** true if and only if the input string is a palindrome.
**Example:** `g("level")` returns `true`. `g('label')` returns `false`.
# Their solutions
I took the best of each task that they presented to me.
1. 64
2. 135
3. 105
4. 30
5. 71
6. 45
7. 83
Total: 533
(I will write their complete answers when the challenge is over).
# Your rules
* Use C# to be evaluated equally to my students.
* Write each task on a separate line **with the method signature** (`string a(string s,int i)`), it is part of the answer.
* Write your best score for each task so we know what score matches what task.
* Write the sum of all task scores in the title of your answer.
* The shortest overall score wins, but honorary mention may be awarded to the lowest score of a given task.
*Note:* It is not impossible that many of you have the same answer, my students did without cheating. Please consider that someont who has the same answer as you may simply have taken the same path and did not steal your idea.
---
**FAQ:**
* **Why should people here use C#? It's not the best language for code golfing !**
I know, but I would like to have some examples from pros like you to show them what a real golfer would do in their shoes.
[Answer]
# Score: 387
1. `string a(string s,int n){return string.Join(s,new string[n+1]);}` (64)
2. `int b(int n){bool p=true;for(int i=2;i<n;i++)if(n%i<1)p=false;return n<2?0:b(n-1)+(p?1:0);}` (91)
3. `object[]c(object[]l){return l.Where(x=>x!=null).ToArray();}` (59)
4. `int d(int n){return(n+1)*n/2;}` (30)
5. `char e(char c){return(char)(c<97?c+32:c-32);}` (45)
6. `bool f(string s,int n){return s.Length%n<1;}` (44)
7. `bool g(string s){return s.SequenceEqual(s.Reverse());}` (54)
Total: 387
] |
[Question]
[
**This question already has answers here**:
[Write the shortest self-identifying program (a quine variant)](/questions/11370/write-the-shortest-self-identifying-program-a-quine-variant)
(48 answers)
Closed 7 years ago.
A narcissist program is simple. It is related to a quine.
If the input is equal to it's source code, it prints a truthy value, if not it prints a falsy one. That is it.
Rules:
* It can't read it's own file.
* This is code-golf, so the shortest answer wins.
* Hash functions are *not* allowed. This trivializes it into just string matching.
* The submission may be a function.
An example would be:
Code:
```
someprogramhere
```
Input:
```
someprogramhere
```
Output:
```
1
```
Or input:
```
a
```
Output:
```
0
```
Your code most certainly won't be `someprogramhere`, but you get the idea.
Go code.
[Answer]
# JavaScript ES6, 14 bytes
```
$=_=>_==`$=`+$
```
Simple modification of the traditional "bling quine".
] |
[Question]
[
I'm retiling my kitchen with different coloured tiles. In fact, it's going to have at least 2 colours - and 26 colours as a maximum.
But, I'm fussy. I want this wall to look random, but sometimes [random isn't random enough](https://apple.stackexchange.com/questions/23194/why-isnt-itunes-shuffle-random).
So, when I lay out my tiles, I don't want to have any the same colour next to each other in the 4 Cartesian directions. Diagonally adjacent is (of course) fine.
Acceptable:
```
┌───┐
│ A │
└───┘
```
```
┌───┬───┬───┐
│ A │ B │ A │
├───┼───┼───┤
│ B │ A │ B │
└───┴───┴───┘
```
```
┌───┬───┬───┐
│ A │ B │ C │
├───┼───┼───┤
│ C │ A │ B │
└───┴───┴───┘
```
Unacceptable:
```
┌───┬───┬───┐
│ A │ B │ A │
├───┼───┼───┤
│ A │ A │ B │
└───┴───┴───┘
```
```
┌───┬───┬───┐
│ A │ C │ C │
├───┼───┼───┤
│ C │ A │ B │
└───┴───┴───┘
```
Given input in the form `A B N` where `A` is the width, `B` is the height and `N` is the number of colours - an integer from 2 to 26 - you need to output a grid like so:
Input:
```
5 6 4
```
Example output:
```
A B C D A
B A D A C
A D C D A
B C B A B
D A D C A
B C A D C
```
The input will be given as a) 3 arguments to a function or b) as 3 separate input statements or b) as `A B N`. Input will always be valid.
All colours have to be used and all valid tilings have to have a non-zero probability of being generated.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest code wins.
[Answer]
## Python 2, ~~151~~ 149 bytes
```
from random import*
W,H,N=input()
L='x'*W
exec"M='';exec'M+=sample(set(map(chr,range(65,65+N)))-{L[len(M)],M[-1:]},1)[0];'*W;L=M;print' '.join(L);"*H
```
Takes input comma-separated via STDIN, e.g. `10, 10, 2`.
[Answer]
# CJam, ~~53~~ ~~52~~ 51 bytes
```
q~:L,'Af+a*a*{_::mR_:|,L<\_z:O|N*2ew::=|:|}g;OSf*N*
```
This will take a *long* time if **AB** is too large or **N** is too small.
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=q~%3AL%2C'Af%2Ba*a*%7B_%3A%3AmR_%3A%7C%2CL%3C%5C_z%3AO%7CN*2ew%3A%3A%3D%7C%3A%7C%7Dg%3BOSf*N*&input=3%204%205).
[Answer]
# Python2, 177 bytes
```
from random import *
W,H,N=input()
A,l={chr(c)for c in range(65,65+N)},[" "*W]
for h in range(H):
s=""
for c in l[h]:s+=sample(A-{s[-1:],c},1)[0]
l+=[s]
print"\n".join(l[1:])
```
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/60312/edit).
Closed 8 years ago.
[Improve this question](/posts/60312/edit)
I created a programming language for manipulating strings called [Stringy](https://github.com/m654z/Stringy). It's very different from other programming languages, since you only have one string (for manipulation) and some variables. With the various commands you can manipulate that one string. I created it because it might be useful for some challenges here. (challenged tagged *string*)
What could I add to this to make it better/more useful for challenges here?
Examples for the language can be found at GitHub at `examples.txt`. It might be a bit hard to understand though.
[Answer]
OK, I said I'd put my comments into a more comprehensible form so here they are.
1. Don't separate commands. Having to use `;` every time you want to use a different command is costly. My recommendation on the interpreter side is to parse one character at a time and read more if the command necessitates it.
2. Add regex (to be honest, I don't know much regex -- it's somewhere on my list of things to learn -- but it seems logical to add it)
3. On the topic of not separating commands with `;`, allow for whitespace to be removeable.
4. Add loops of some sort.
5. Add conditionals and conditional tests (equals, not, and, or, etc.)
6. Add a newline reserved character (`n`, perhaps?)
7. Add reserved characters for variables
8. You have uppercase and lowercase commands, why not add a capitalization one (one that capitalizes the string as if it were a sentence and maybe also capitalizes proper nouns that it can identify).
9. Add a command to count how many instances of a string are in another.
10. Add a length command to get the length of a string.
11. Add a terminate/break command.
12. Add an equivalent of Python's `ord` and `chr` functions.
13. Add a split at numerical value command (splits at a certain length), and add an alternative to that which splits at every multiple of the numerical value (e.g. for a string of length 10 at 3,6,9 if given the argument 3).
14. Add a duplication command (akin to Python's `"String"*x`)
You'll notice that some of these involve numbers -- I think that even for String challenges having a way of working with numbers is good. Perhaps have a stack for storing numbers that is accessed when certain commands are used (e.g. the length command pushes the length onto the number stack and then the split at numerical value uses this length to split the stack).
I'll add more ideas as I think of them, but I feel like my suggestions are pushing this in the direction of a more general-purpose golf language. Hopefully this input helps regardless of whether you use it or not.
] |
[Question]
[
C/C++ use double quotes `""` for making string literals. If I want the double-quote itself, or certain other characters, to appear in the string, I have to escape them, like so:
```
char *s2 = "This is not \"good\".\nThis is awesome!\n";
```
Here, I used `\"` to represent a double-quote, and `\n` to represent the newline character. So, if my program prints the string, I see
```
This is not "good".
This is awesome!
```
However, if I examine the string in a debugger (Visual Studio or gdb), it shows me the escaped form - the one that would appear in the source code. This is good because it allows to unambiguously identify whether the string contained that `\` backslash character verbatim or as part of an escape-sequence.
The goal of this challenge is to do the same job the debuggers do, but better - the escaped string must contain as few escaping characters as possible! The input to your program (or subroutine) is a string of arbitrary 8-bit bytes, and the output must be suitable for putting into the following boilerplate C code:
```
#include <stdio.h>
int main() {char str[] =
"### the escaped string goes here ###";
puts(""); // put a breakpoint here to examine the string
puts(str); return 0;}
```
---
For example:
Input (hexdump, 3-byte string): `64 0a 06`
Output: `d\n\6`
Here, `\006` or `\x6` have the same meaning as `\6`, but longer and are therefore unacceptable. Likewise, `\012` and `\xa` have the same meaning as `\n`, but only `\n` is an acceptable encoding for the byte with the value 10.
---
Another example:
Input (hexdump, 5-byte string): `61 0e 38 02 37`
Output: `a\168\0027`
Here, code `0x0e` is escaped as `\16`, and parsed successfully by the C compiler because `8` is not a valid octal digit. However, the code `0x02` is escaped as `\002`, not `\2`, to avoid confusion with the byte `\27`.
Output: `a\168\2\67` - another possible form
---
See [Wikipedia](https://en.wikipedia.org/wiki/Escape_sequences_in_C) for the exact definition of escaping in C.
Additional (reasonable) rules for this challenge:
* Output must be printable ASCII (no tab characters; no characters with codes above 126)
* The input can be in the form of a string or an array of 8-bit elements. If your language doesn't support it, use the closest alternative. In any case, there should be no UTF encoding for input.
* No [trigraphs](https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C), so no need to escape the `?` character
* No need to handle the null character (code 0) in input - let it be an end-of-string marker, or a regular byte like others - whatever is more convenient
* Code golf: shortest code is the best
* You are not allowed to vandalize the Wikipedia article to bend the rules :)
---
P.S. Summary of the Wikipedia article:
```
Input byte | Output | Note
0x01 | \1 | octal escape
0x02 | \2 | octal escape
0x03 | \3 | octal escape
0x04 | \4 | octal escape
0x05 | \5 | octal escape
0x06 | \6 | octal escape
0x07 | \a | alarm
0x08 | \b | backspace
0x09 | \t | tabulation
0x0a | \n | newline
0x0b | \v | vertical tabulation
0x0c | \f | form feed
0x0d | \r | return
0x0e | \16 | octal escape
0x0f | \17 | octal escape
... | | octal escape
0x1f | \37 | octal escape
0x22 | \" | escape with a backslash
0x5c | \\ | escape with a backslash
0x7f | \177 | octal escape
0x80 | \200 | octal escape
... | | octal escape
0xff | \377 | octal escape
other | | no escape
```
[Answer]
# JavaScript (ES6) 152
First time ever that .reduceRight seems useful. (But probably the good old .map can do better). The point is, I need to see the next character before deciding whether to output a short or long octal escape.
```
f=s=>[...s].reduceRight((a,c)=>
((x=c.charCodeAt())==34|c==(q='\\')?q+c:x>31&x<127?c:q+('abtnvvr'[x-7]||(a>='0'&a<'8'?512+x:x).toString(8).slice(-3)))+a
)
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 years ago.
[Improve this question](/posts/58311/edit)
I am a teacher who was given a problem a few years ago. Every year since I have given it to my advanced students as a bonus assignment, but in ~10 years only 8 solved it, each with a slightly different approach. The problem is as follows:
You have some input **(from stdin)**, in the following format (the `//comments` are not included in the input):
```
6 //Route Begin
1 2 //Route data...
1 3
3 4
3 5
4 6
5 6
2 3
2 4
0 0 //Route end
4 //Route Begin
2 3 //Route Data...
3 4
5 1
1 6
7 8
8 9
2 5
5 7
3 1
1 8
4 6
6 9
0 0 //Route end
// continued...
```
The input begins with the destination, an integer. It is followed by a 'map' of all streets in the city. Each line represents a connection, so you can get from street 1 to street 2, and vice-versa. On every rout you start at street 1, then work your way to your destination.
**The objective:** List all possible routes, and tell the user the shortest one (least amount of street changes).
Also, the code beads to be human readable.
So you would wont to output something like:
```
Destination 1 (6):
1 2 3 4 6
1 2 3 5 6
1 2 4 3 5 6
1 2 4 6
1 3 2 4 6
1 3 4 6
1 3 5 6
There are 7 routes from the truck station to street 6.
The shortest of these is the route "1 2 4 6", with 4 streets.
Destination 2 (4):
1 3 2 5 7 8 9 6 4
1 3 4
1 5 2 3 4
1 5 7 8 9 6 4
1 6 4
1 6 9 8 7 5 2 3 4
1 8 7 5 2 3 4
1 8 9 6 4
There are 8 routes from the truck station to street 4.
The shortest of these is the route "1 3 4", with 3 streets.
```
Now personally, I rather java or python (and java is preferred more), but I leave this open ended to my students, so they can choose any language they like.
The original document is [here](https://drive.google.com/file/d/0B9fv7C5AiA8EU01GVGp1Uk51NXc/view?usp=sharing)
**HOW TO WIN:** Create the described program in a readable programming language, with the following criteria:
- Readable
- takes the input from the user(stdin/file)
- Is mildly easy to understand.
[Answer]
**Javascript (1159)**
```
function h(g,e){var b=[],d=0,c=null,f=0;g.split("\n").forEach(function(a){a=a.replace(/\s*\/\/.*?$/,"");switch(d){case 0:c={};f=a;d++;break;case 1:a=a.split(" "),"0"===a[0]&&"0"===a[1]?(b.push(c),a=[],k(f,c,null,null,a),e.push([f,a]),d=0):(c[a[0]]||(c[a[0]]=[]),c[a[1]]||(c[a[1]]=[]),c[a[0]].push(a[1]),c[a[1]].push(a[0]))}})}
function k(g,e,b,d,c){b||(b="1",d=[]);d.push(b);var f=[];if(g!=b){if(e[b].forEach(function(a){-1==d.indexOf(a)&&(a=k(g,e,a,d.slice(),c))&&f.push(a)}),f.length)return f}else return c.push(d),d}
(function(g,z){var e=[];h(g,e);e.forEach(function(b){document.write("Destination "+b[0]+z);var d=99,c=-1;b[1].forEach(function(b,a){document.write(b.join(", ")+z);b.length<d&&(d=b.length,c=a)});document.write("There are "+b[1].length+" routes from the fire station to street "+b[0]+z);document.write('The shortest of these is the route "'+b[1][c].join(" ")+'", with '+d+" streets"+z)})})("6 //Route Begin\n1 2 //Route data...\n1 3\n3 4\n3 5\n4 6\n5 6\n2 3\n2 4\n0 0 //Route end\n4 //Route Begin\n2 3 //Route Data...\n3 4\n5 1\n1 6\n7 8\n8 9\n2 5\n5 7\n3 1\n1 8\n4 6\n6 9\n0 0 //Route end\n// continued...\n","<br>");
```
notes:
* Just used "regular" javascript code, then minified it using Closure
Compiler
* Route data embedded, could have been alot shorter without a "parser". That would mean the data should be JSON encoded ..
Unminified version (added per request):
```
function parseInput(input, data)
{
var output = [];
var lines = input.split("\n");
var state = 0;
var route = null;
var routeDest = 0;
lines.forEach(function(val){
val = val.replace(/\s*\/\/.*?$/, "");
switch(state)
{
case 0:
route = {};
routeDest = val;
state++
break;
case 1:
var conn = val.split(" ");
if (conn[0] === "0" && conn[1] === "0")
{
output.push(route);
var innerData = [];
calculateRoutes(routeDest, route, null, null, innerData);
data.push([routeDest, innerData]);
state = 0;
}
else
{
if (!route[conn[0]])
{
route[conn[0]]=[]
}
if (!route[conn[1]])
{
route[conn[1]]=[]
}
route[conn[0]].push(conn[1]);
route[conn[1]].push(conn[0]);
}
break;
}
});
return output;
}
function calculateRoutes(dest, data, curr, from, returnData)
{
if (!curr)
{
curr = "1";
from = [];
}
from.push(curr);
var routes = [];
if (dest != curr)
{
data[curr].forEach(function(val){
if (from.indexOf(val) == -1)
{
var route = calculateRoutes(dest, data, val, from.slice(), returnData);
if (route)
{
routes.push(route);
}
}
});
if (routes.length)
{
return routes;
}
}
else
{
returnData.push(from);
return from;
}
}
function printRoutes(routeInfo)
{
var data = [];
parseInput(routeInfo, data);
data.forEach(function(val){
console.log("Destination " + val[0]);
var shortLen = 99;
var shortId = -1;
val[1].forEach(function(ele, id){
console.log(ele.join(", "));
if (ele.length < shortLen)
{
shortLen = ele.length;
shortId = id;
}
});
console.log("There are " + val[1].length + " routes from the fire station to street " + val[0]);
console.log("The shortest of these is the route \"" + val[1][shortId].join(" ") + "\", with " + shortLen + " streets");
});
}
var nl = "\n"
printRoutes("6 //Route Begin" + nl +
"1 2 //Route data..." + nl +
"1 3" + nl +
"3 4" + nl +
"3 5" + nl +
"4 6" + nl +
"5 6" + nl +
"2 3" + nl +
"2 4" + nl +
"0 0 //Route end" + nl +
"4 //Route Begin" + nl +
"2 3 //Route Data..." + nl +
"3 4" + nl +
"5 1" + nl +
"1 6" + nl +
"7 8" + nl +
"8 9" + nl +
"2 5" + nl +
"5 7" + nl +
"3 1" + nl +
"1 8" + nl +
"4 6" + nl +
"6 9" + nl +
"0 0 //Route end" + nl +
"// continued..." + nl);
```
The unminified version uses `console.log` for output instead of `document.write`. Because `document.write` gives a better experience as a code snippet than `console.log`.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 9 years ago.
[Improve this question](/posts/45659/edit)
Happy Valentine's Day! To celebrate this day of love and happiness (or sadness and loneliness for those of us who are single...), let's write some code to create some [hearts](http://en.wikipedia.org/wiki/Heart_(symbol))!
Specifically, if you take this challenge upon you, you are to write code to output a heart/hearts as an **image file**, with the ability to easily change the dimensions of the image (both width and height, separately). You could take input into your program to get the dimensions, or two simple variables that can be changed would be enough (or a couple constants). If you do opt for the variables, no more than two tokens of the program should be changed to adjust the size.
So for instance, you could write a program to output this image (with variable width and height, of course):
However, that heart isn't that interesting. It's just a plain heart. I challenge you to create the most creative and interesting heart that you can!
[Answer]
# Java
```
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import static java.lang.Math.PI;
import static java.lang.Math.cbrt;
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;
public class Heart {
public static double scale(int x, int range, double l, double r) {
double width = r - l;
return (double) x / (range - 1) * width + l;
}
public static void main(String[] args) throws IOException {
BufferedImage img = new BufferedImage(1000, 1000, BufferedImage.TYPE_INT_RGB);
final double max_heart = 0.679; // This is the approximate max value that can come out of the heart function (found by trial and error)
double max = 0.0;
for (int x = 0; x < img.getWidth(); x++) {
for (int y = 0; y < img.getHeight(); y++) {
double xv = scale(x, img.getWidth(), -1.2, 1.2);
double yv = scale(y, img.getHeight(), -1.3, 1);
double heart = heart(xv, yv);
int r = 0xFF;
int gb = (int) (0xFF * (max_heart - heart));
int rgb = (r << 16) | (gb << 8) | gb;
img.setRGB(x, y, rgb);
}
}
ImageIO.write(img, "png", new File("location/heart.png"));
}
public static double heart(double xi, double yi) {
double x = xi;
double y = -yi;
double temp = 5739562800L * pow(y, 3) + 109051693200L * pow(x, 2) * pow(y, 3) - 5739562800L * pow(y, 5);
double temp1 = -244019119519584000L * pow(y, 9) + pow(temp, 2);
if (temp1 < 0) {
return topHeart(x, y, temp, temp1);
}
double temp2 = sqrt(temp1);
double temp3 = cbrt(temp + temp2);
if (temp3 != 0) {
double part1 = (36 * cbrt(2) * pow(y, 3)) / temp3;
double part2 = 1 / (10935 * cbrt(2)) * temp3;
double looseparts = 4.0 / 9 - 4.0 / 9 * pow(x, 2) - 4.0 / 9 * pow(y, 2);
double sqrt_body = looseparts + part1 + part2;
if (sqrt_body >= 0) {
return sqrt(sqrt_body);
} else {
return -1;
}
} else {
return Math.sqrt(Math.pow(2.0 / 3, 2) * (1 - Math.pow(x, 2)));
}
}
private static double topHeart(double x, double y, double temp, double temp1) {
//complex arithmetic
double[] temp3 = cbrt_complex(temp, sqrt(-temp1));
double[] part1 = polar_reciprocal(temp3);
part1[0] *= 36 * cbrt(2) * pow(y, 3);
double[] part2 = temp3;
part2[0] /= (10935 * cbrt(2));
toRect(part1, part2);
double looseparts = 4.0 / 9 - 4.0 / 9 * pow(x, 2) - 4.0 / 9 * pow(y, 2);
double real_part = looseparts + part1[0] + part2[0];
double imag_part = part1[1] + part2[1];
double[] result = sqrt_complex(real_part, imag_part);
toRect(result);
if (Math.abs(result[1]) < 1e-5) {
return result[0];
}
return -1;
}
public static double[] cbrt_complex(double a, double b) {
double r = Math.hypot(a, b);
double theta = Math.atan2(b, a);
double cbrt_r = cbrt(r);
double cbrt_theta = 1.0 / 3 * (2 * PI * Math.floor((PI - theta) / (2 * PI)) + theta);
return new double[]{cbrt_r, cbrt_theta};
}
public static double[] sqrt_complex(double a, double b) {
double r = Math.hypot(a, b);
double theta = Math.atan2(b, a);
double sqrt_r = Math.sqrt(r);
double sqrt_theta = 1.0 / 2 * (2 * PI * Math.floor((PI - theta) / (2 * PI)) + theta);
return new double[]{sqrt_r, sqrt_theta};
}
public static double[] polar_reciprocal(double[] polar) {
return new double[]{1 / polar[0], -polar[1]};
}
public static void toRect(double[]... polars) {
for (double[] polar: polars) {
double a = Math.cos(polar[1]) * polar[0];
double b = Math.sin(polar[1]) * polar[0];
polar[0] = a;
polar[1] = b;
}
}
}
```
To scale, just change the x/y dimensions of this line (the first line in the main function):
```
BufferedImage img = new BufferedImage(1000, 1000, BufferedImage.TYPE_INT_RGB);
```
Output (for a size of `1000` by `1000`):
---
On wikipedia, [there is a 3D heart shown](http://en.wikipedia.org/wiki/Heart_(symbol)#mediaviewer/File:Heart3D.png). This was my inspiration; I thought to myself, "Why not use a 3D heart and use the Z output as color?" So that's exactly what I did. However, I didn't use the exact same formula; I used this implicit equation for a 3D heart:
I played around in Mathematica, (I think I switched `z` and `y`) and solved for `z`, yielding this really ugly equation (click for full size):
[](https://i.stack.imgur.com/BErrd.png)
Then, I "simply" implemented the function in Java. Okay, it wasn't so simple. I had to do some checks to avoid exceptions (no sqrts of negative numbers). But there is one case where we do need to take a sqrt of a negative number (IE delve into the complex world) in order to get a real output. That's why I have the `topOfHeart` function; it does the computation for that part. If I replace the call to that function with `return -1`, this is the image I get instead (smallified):
[](https://i.stack.imgur.com/nTiPl.png)
A couple interesting things to note:
* I do a lot of `return -1` to show that I reached an invalid value, but I don't handle this in the `main` function. This results in a color of `0xFFADAD` - a lovely shade of pink
* The complex number functions are semi-interesting. I switch between polar and rectangular coordinates, since polar coordinates make multiplicative operations easier, while rectangular coordinates make additive operations easier.
+ `cbrt_complex` and `sqrt_complex` are actually very interesting. [Using wolframalpha](http://www.wolframalpha.com/input/?i=%28r%20e%5E%28I%20theta%29%29%5E%281%2Fn%29), I found this formula for the nth root of a complex number (polar form):
+ taking the reciprocal of a polar coordinate complex number is easy: `r eiθ` -> `1/r e-iθ`
+ multiplying by a real number `d` is also easy: `r eiθ` -> `d r eiθ`
[Answer]
# Bash: 16 characters
```
echo -e "\u2665"
```
output (when unicode supported)
```
♥
```
Ah wait, it must be an image?
# ImageMagick: 137 characters
```
w=99
h=199
convert -size ${w}x$w -gravity center -font WebDings -fill red label:Y h.gif
convert h.gif -resize ${w}x$h\! h2.gif
```
output (when WebDings font installed)
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 9 years ago.
[Improve this question](/posts/45113/edit)
I'm currently trying to solve a tricky/silly challenge and i've come to a dead end.
The challenge is basically to form a one-liner /bin/sh compatible command line
which essentially outputs "Hello World" without directly typing White space or Tab characters in the command itself.
for example something like -
```
echo Hello World
```
would be invalid since we used white space twice in the command line.
Any ideas?
[Answer]
One which works in `dash`, so I suppose it is `sh` compatible;
```
IFS=@;command=echo@Hello@World;$command
```
] |
[Question]
[
**This question already has answers here**:
[Solve the knapsack problem](/questions/3731/solve-the-knapsack-problem)
(5 answers)
Closed 9 years ago.
Because there isn't enough xkcd on PPCG...
## Challenge
The challenge is the same as above - given a menu and a total price, you need to find what the customer ordered.
The menu will be supplied as a text file in the format:
```
Name:Price
Name:Price
```
The path to the menu file and the total price should be supplied via argv or STDIN.
If you wish, the menu may be supplied via STDIN/argv (instead of newlines, separate each item by commas).
The output should be a list of values. If there are multiple answers, output all of them.
# Example
Menu:
```
Burger:12.60
Pepsi:3.50
Lobster Thermidore:33.10
Ice Cream:23.00
```
Total Price: `68.70`
The output is:
```
Burger
Lobster Thermidore
Ice Cream
```
## Winning
The fastest code given an undisclosed problem wins. The speed will be taken five times and averaged.
[Answer]
# Python 2 - Naive implementation - 224
Well, let's start with ["the most naive algorithm"](http://en.wikipedia.org/wiki/Subset_sum_problem#Exponential_time_algorithm) as some kind of reference solution:
```
import itertools
path = input()
total = input()
with open(path) as f:
menu = map(lambda l: l.split(':'), f.read().split('\n'))
names, prices = zip(*menu)
prices = map(float, prices)
for i in range(len(menu)):
for comb in itertools.combinations(range(len(menu)), i):
if sum(prices[c] for c in comb) == total:
for i in comb:
print names[i]
```
**Input:**
```
"data.txt"
68.70
```
**Output:**
```
Burger
Lobster Thermidore
Ice Cream
```
**Complexity:**
```
O(2^N * N)
```
--> exponential in the number of menu items `N` (of course)
---
**Edit:**
To reflect the new winning criterion I golfed it down quite a bit:
```
from itertools import*
S=str.split
f,t=S(input())
m=[S(l,':')for l in S(open(f).read(),'\n')]
R=range(len(m))
F=float
for i in R:
for C in combinations(R,i):
if sum(F(m[c][1])for c in C)==F(t):
for j in C:print m[j][0]
```
The input format changed to `data.txt 68.70` (both on one line separated with a whitespace).
] |
[Question]
[
Create a program that output's itself as a series of punch cards:
**Rules:**
* You can use any programming language.
* The output (i.e. punch cards) can be ASCII art.
* Each line of code must be able to be punched into a single 80 column x 9 row punch card - i.e. you can only use 80 characters.
* To fit in the 9 rows you need to encode your characters using 4-bit BCD.
* Extra kudos if you use an old programming language like FORTRAN.
**Background**
* You can find out more about computer punch cards [here](http://en.wikipedia.org/wiki/Punched_card).
* Doug Jones paper on [punch card codes](http://homepage.cs.uiowa.edu/~jones/cards/codes.html).
[Answer]
# Ruby - 925
I'll get the ball rolling. Run as "ruby hammer.rb hammer.rb".
Golfed
```
def z x
l=x.unpack u='C*'
d=[]
(0..9).each do|i|d<<[].fill(48+i,0,80);end
d<<a=[].fill(32,0,80)
d<<a.dup
h=Hash.new
i=0;' abcdefghi'.unpack(u).each do|c|h[c-32]=[i,11];h[c]=[i,11,0];i+=1;end
i=0;' jklmnopqr'.unpack(u).each do|c|h[c-32]=[i,10];h[c]=[i,10,11];i+=1;end
i=0;' stuvwxyz'.unpack(u).each do|c|h[c-32]=[i,0];h[c]=[i,0,10];i+=1;end
h[47]=[1,0]
i=0;'0123456789-&'.unpack(u).each do|c|h[c]=[i];i+=1;end
i=0;' :#@\'="'.unpack(u).each do|c|h[c]=[i,8];i+=1;end
i=0;' [.<(+|'.unpack(u).each do|c|h[c]=[i,8,11];i+=1;end
i=0;' ]$*);^'.unpack(u).each do|c|h[c]=[i,8,10];i+=1;end
i=0;' \,%_>?'.unpack(u).each do|c|h[c]=[i,8,0];i+=1;end
h[32]=[]
i=0;l.slice(0,80).each do|c|h[c].each do|r|d[r][i]=215;end;i+=1;end
puts' %s'%('_'*81)
puts' /%-80s |'%l.pack(u)
puts' / %s |'%d[11].pack(u)
puts' / %s |'%d[10].pack(u)
(0..9).each do|i|puts'| %s |'%d[i].pack(u);end
puts'|%s|'%('_'*84)
end
ARGF.each do|l|z l.chop;end
```
Ungolfed
```
def punch029(line) # line is array of ASCII characters in ordinal (integer) form
chad=[]
(0..9).each do |i| chad<<[].fill(48+i,0,80) end
chad<<[].fill(32,0,80)
chad<<[].fill(32,0,80)
r10 = 10-10
r11 = 11-1
r12 = 12-1
# Reward "bad" input characters with all-row multi-punch.
# hash = Hash.new( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] )
#
# OR
#
# Reward "bad" input characters by letting Ruby puke. (Jam the machine.)
hash = Hash.new
'0123456789-&'.unpack('C*').each_with_index do|c,i| hash[c]=[i] end
' ABCDEFGHI'.unpack('C*').each_with_index do|c,i| hash[c]=[i,r12] end
' JKLMNOPQR'.unpack('C*').each_with_index do|c,i| hash[c]=[i,r11] end
' /STUVWXYZ'.unpack('C*').each_with_index do|c,i| hash[c]=[i,r10] end
' :#@\'="'.unpack('C*').each_with_index do|c,i| hash[c]=[i,8] end
' [.<(+|'.unpack('C*').each_with_index do|c,i| hash[c]=[i,8,r12] end
' ]$*);^'.unpack('C*').each_with_index do|c,i| hash[c]=[i,8,r11] end
' \,%_>?'.unpack('C*').each_with_index do|c,i| hash[c]=[i,8,r10] end
' abcdefghi'.unpack('C*').each_with_index do|c,i| hash[c]=[i,r12,r10] end
' jklmnopqr'.unpack('C*').each_with_index do|c,i| hash[c]=[i,r11,r12] end
' stuvwxyz'.unpack('C*').each_with_index do|c,i| hash[c]=[i,r10,r11] end
hash[32] = [] # fix space
hole = 215
line.slice(0,80).each_with_index do |c, index|
hash[c].each do |row| chad[row][index] = hole end
end
puts ' %s' % ('_'*81)
puts ' /%-80s |' % line.pack('C*')
puts ' / %s |' % chad[11].pack('C*')
puts ' / %s |' % chad[10].pack('C*')
(0..9).each do |i|
puts '| %s |' % chad[i].pack('C*')
end
puts "|%s|" % ('_'*84)
end
# 1 2 3 4 5 6 7 8
#2345678901234567890123456789012345678901234567890123456789012345678901234567890
ARGF.each do |line|
punch029(line.chomp.unpack('C*'))
end
```
] |
[Question]
[
**This question already has answers here**:
[Convert 1, 2, 3, 4, 5, 6, 7, 8, and 9 to "one", "two", "three", etc](/questions/32151/convert-1-2-3-4-5-6-7-8-and-9-to-one-two-three-etc)
(73 answers)
[Converting integers to English words](/questions/12766/converting-integers-to-english-words)
(14 answers)
Closed 9 years ago.
Here's a simple one.
In the *shortest code possible*, given an arbitrary number such as `567421`, print it out in words:
```
five
six
seven
four
two
one
```
You may assume the input is an integer that is already provided in a one-letter variable such as `n`.
[Answer]
Python
```
for i in `n`:print' ottffssennwhoiieiieoruvxvgn ere ehe e nt'[int(i)::9]
```
"Inspired" by <https://codegolf.stackexchange.com/a/32156/18638>
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/23286/edit).
Closed 9 years ago.
[Improve this question](/posts/23286/edit)
Ever programmer knows, that programs need to be predictable. Any code that is not predictable will do something undefined and therefore most likely crash or worse. But when I tried to figure out what Java's `lazySet()` method does, I came up with the idea
**Is it possible to write a program that is unpredictable, yet works fine and does something useful/interesting?**
So that will be your task. Do not avoid chaos, but utilize it. Whether you use the actual lazySet, thread timing, random or uninitialized variables is up to you. The following rules apply:
1. The code-path must be unpredictable. That is: if I would debug it, the program would take a "random" path each time.
2. The program must do something useful/interesting and handle all possible (unpredictable) states somehow. No crashes! (Core dumps are neither useful nor interesting!)
3. You are not allowed to check something in a loop till it has the desired value. You must work with whatever is stored in there and do something with it.
4. You can use any language, except those specifically optimized for this contest.
This is a **creative question** so the one with the most votes wins. Please note that programs doing common stuff like gambling, printing random numbers or generating RPG loot are too well-known to be considered interesting. Please surprise us.
Bonus points should be given for:
* The creativity of the choice/design of unpredictability (Math.random isn't that creative).
* The creativity in management of unpredictability.
* Everything genius. ;)
[Answer]
# Ruby
This works only on Windows.
```
if aTerribleErrorOccurredAndWeNeedToKillTheScriptNow
c = ($$ % 94 + 33).chr
puts "#{c * 50}\n#{c + "KILLING SCRIPT".center(48) + c}\n#{c * 50}"
`taskkill /PID #{$$} /F`
end
```
The process ID, `$$`, is unpredictable. However, this will always kill the currently running script, while printing an error message bordered by an unpredictable character like this:
```
##################################################
# KILLING SCRIPT #
##################################################
```
Of course, `exit` or `quit` do the same thing, but this one kills Ruby forcefully with the OS! And it also bypasses `at_exit` handlers.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/20986/edit).
Closed 10 years ago.
[Improve this question](/posts/20986/edit)
Rules (not too restrictive; flexible):
1.Must be able to draw shapes on command (e.g., I type in "square" and a square is drawn).
Minimum completed shapes that can be drawn on command: Square, Circle, Triangle, Pentagon.
2.Must also be able to also draw shapes vertex-by-vertex, specified by a command function that gives the user an input to determine line segment lengths between points in succession.
The program has to give the option to make polygons as well, but incomplete 2-D shapes, circles, unclosed planes, and non-polygons shall be allowed.
Winner: Most votes.
[Answer]
# Logo
Just install it!
Then things like triangles, squares, pentagons and circles are defined as:
```
to triangle :length
polygon :length 3
end
to square :length
polygon :length 4
end
to pentagon :length
polygon :length 5
end
to circle :length
polygon :length 360
end
to polygon :length :sides
repeat :sides [forward :length right 360/:sides]
end
```
Easy peasy lemon squeezy...
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/10756/edit).
Closed 2 years ago.
[Improve this question](/posts/10756/edit)
In my essay "[Use the 24-hour clock](http://joezeng.com/opinion/24hourclock.html)", I claim that trying to represent the 12-hour clock directly in data is a terrible exercise in patchy, inelegant programming:
>
> "No problem, we'll just use computers to do these calculations for us." Yes, but computers need to be programmed. And trying to account for AM and PM directly in a computer program, especially the extremely tricky way we've encoded it, with 12 representing 0, is prone to bugs and programming mistakes, which can cost millions at the airport in scheduling mishaps. As it is, it's much easier for computers to work in 24-hour time in internal calculations, and then convert the times to 12-hour time for easy human reading, instead of having to deal with dozens of notational issues as would be the case when using 12-hour time directly. In which case, why not just get rid of the whole 12-hour conversion and work with 24-hour time in the first place?
>
>
>
Here's your chance to prove me wrong. Your task is to build a `Clock` class that supports the following functions:
* `addHours(x)`, that advances the clock by `x` hours (or moves back `|x|` hours if `x` is negative)
* `addMinutes(x)`, that advances the clock by `x` minutes.
* `diffMinutes(c1, c2)` that gives the time difference from clock `c1` to clock `c2` in minutes (which always assumes that c1 and c2 are representing times in the same day). If `c2` is earlier than `c1`, the time should be negative.
and has the following *publicly accessible* variables:
* `hours`, which represents the hour digit of the clock, from 1 to 12.
* `minutes`, which represents the minute digit of the clock, from 0 to 59.
* `ampm`, which is `true` if the clock is AM and `false` if the clock is PM.
as well as a setter and getter method (e.g. `setHours(hours)` and `getHours()`) for each. (You may assume that the setters and getters will always be passed valid values.) The reason the variables must be publicly accessible is to ensure that the internal data representation of the clock is also in a 12-hour format, to fit the data representation of the clock described in the essay.
Your code must pass all the unit tests contained in [this file](http://joezeng.com/code/12hrc_ut1.txt) (translated to the programming language of your choice) except for test 0.2, which should be removed for this problem. (If the descriptions of the corner cases and their resultant times start to make your head spin, that's good. It means that my point about the strangeness of the notation is verified. It certainly made *my* head spin trying to make sure I had all the corner cases covered.)
Your score is calculated based on the number of operators and function calls in your class code, rather than the number of characters (so don't golf your code, make it readable but still short). Lowest score wins, of course.
Note: This problem has a part 2, namely, to create a 12-hour clock that uses 24-hour time in its internal representation. If my hypothesis is true, the winner of that problem will have a much lower score than the winner of this problem.
[Answer]
## Python (38)
Full code with tests [here](http://codepad.org/LlxYi6aM). A ton of the tests were wrong, so I modified them. Most of the changes are marked with the string "patch" in a comment, but I'm sure I forgot to mark some.
It was completely unclear if `diffMinutes(a, b)` was `abs(a-b)`, `a-b` or `b-a`, so I went with `b-a` because I had to change less tests that way.
Also, `ampm` is a terrible variable name. `isAM` would be a far more readable name, and `isPM` would be preferable, as true and false are often associated with 1 and 0, and PM is a higher/later value.
The interesting part (getters and setters in the link above):
```
def getMinutesFromMidnight(clock):
return clock.hours * 60 % 720 + 720 * (not clock.ampm) + clock.minutes
def diffMinutes(a,b):
return getMinutesFromMidnight(b) - getMinutesFromMidnight(a)
class Clock(object):
def __init__(self):
self.hours = 12
self.minutes = 0
self.ampm = True
def addHours(self, hours):
self.addMinutes(hours * 60)
def addMinutes(self, minutes):
minutes = getMinutesFromMidnight(self) + minutes
self.hours = minutes / 60 % 12 or 12
self.minutes = minutes % 60
self.ampm = minutes % 1440 < 720
```
] |
[Question]
[
Consider an \$n \times n\$ grid of integers which is part of an infinite grid. The top left coordinate of the \$n \times n\$ grid of integers is \$(0, 0)\$.
The task is to find a circle which when overlaid on the grid gives the largest sum of values inside it. The constraints are:
* The circle has its centre at \$(x, x)\$ for some value \$x\$ which is not necessarily an integer. Notice that both dimensions have the same value.
* The radius of the circle is \$r\$ and is not necessarily an integer.
* The circle must include the point \$(0, 0)\$ within it.
* All points outside of the \$n \times n\$ grid contribute zero to the sum.
* The center of the circle can be outside the \$n \times n\$ grid provided the other conditions are met.
Here is a picture of a \$10 \times 10\$ grid with two circles overlaid.
[](https://i.stack.imgur.com/n3fwY.png)
The larger circle has its center at \$(-20, -20)\$.
The two parameters are therefore \$x\$ and \$r\$. Although there are in principle an infinite number of options, in fact only a finite subset are relevant.
The matrix in this case is:
```
[[ 3 -1 1 0 -1 -1 -3 -2 -2 2]
[ 0 0 3 0 0 -1 2 0 -2 3]
[ 2 0 3 -2 3 1 2 2 1 1]
[-3 0 1 0 1 2 3 1 -3 -1]
[-3 -2 1 2 1 -3 -2 2 -2 0]
[-1 -3 -3 1 3 -2 0 2 -1 1]
[-2 -2 -1 2 -2 1 -1 1 3 -1]
[ 1 2 -1 2 0 -2 -1 -1 2 3]
[-1 -2 3 -1 0 0 3 -3 3 -2]
[ 0 -3 0 -1 -1 0 -2 -3 -3 -1]]
```
The winning criterion is worst case time complexity as a function of \$n\$. That is using big Oh notation, e.g. \$O(n^4)\$.
[Answer]
# [Python 3](https://docs.python.org/3/), O(n^4)
```
def CPos(x1, y1, x2, y2):
return (x1*x1-x2*x2+y1*y1-y2*y2)/2/(x1-x2+y1-y2)
def f(A):
Ret = A[0][0]
n = len(A)
for baseY in range(n):
for baseX in range(n):
if baseY == 0 and baseX == 0:
continue
dBase = abs(baseX - baseY)
Sum = 0
Buf = [[[CPos(baseX, baseY, 0, 0), 1], 0, 0]]
for y in range(n):
for x in range(n):
d = abs(x - y)
if x+y <= baseX+baseY:
Sum = Sum + A[y][x]
if d > 0 and x+y < baseX+baseY:
Buf += [[[CPos(baseX, baseY, x, y), 2], -A[y][x]]]
else:
if d < 0:
Buf += [[[CPos(baseX, baseY, x, y), 0], A[y][x]]]
Buf = sorted(Buf, key=lambda k: k[0]) # Radix sort
i = 0
if Ret < Sum:
Ret = Sum
while len(Buf[i]) < 3:
Sum = Sum + Buf[i][1]
if Buf[i][0] != Buf[i+1][0]:
if Ret < Sum:
Ret = Sum
i = i + 1
return Ret
```
[Try it online!](https://tio.run/##jVNNj5swED3Dr3DVCwSjtc0tCpV2@weq7aWVxYEU00XJmhUQ1fz6dD6cKM22UiUDnnkzb96Mzdu6vIy@Op8714vPX8Y5C1qKFZ5g4GvybZpMbjlNXgCyCboMZhNMserNqsvVbCDkwTxkBBTkytMUyfrsEZOf3SJq8WhVAytNPBhH5wFLk36cxL6d3XcxeDG1/qfLPKZcgW/3QDL0MaOuhRKt72IcmhSQ/Bj9MviTQ6N7AhAKtvs547iS03NEv55eAVO4fTr1sLXW0gQoVHKkFApWLoVueNs0mIAK13fqyB3eu5MuigggYM3ZB62EYhW7mlsoqFyMj9rwXcDs1saGJiKQ1olPsXki@Fs@dVT8q6UAJwstGWipjOxN5HfH2W1vS@0ug/1PUgWkf3DybOdxWlyXgSHFwa31sX3dd604bMUB7kUuPornthsCxdFBX44GROAV2uEwWAjfKDDR@vUyHB3dKKC2AzDtRMVxtzNk0GruEjijQzXiQ81GodHcXg/nrupdXRI4ALO@/h@An9@mwS9Zn1lbyVJLLRV@cIFtcMHQrQJ3JRWDBj9GVuA35EdDot/AG66dLTFW08MQkkWgNOS9FKASCiH2YDQBCqFIR0FUmbJJZ2TU0txoYumsDfeGwiTLB25kpnZIIUdzYhU1Nnl@/g0 "Python 3 – Try It Online")
For each point assume the circle go through it(`Base[XY]`), then radius decrease from infinity. Store when the points enter/leave circle, sort it and only consider these step.
] |
[Question]
[
Write a program that precisely clones GNU `cat` version 8.32, which is
installed on my computer.
In any case, if called with the same arguments, same stdin, and same files,
your program's output to both stdout and stderr must by byte-for-byte identical
to that of GNU `cat`, and the exit code must be the same. This applies to both
valid and invalid commands. It must be impossible to distinguish between GNU
`cat` and your program without inspecting the file content or analyzing performance.
As usual, arguments starting with hyphens are considered options, except that
`--` indicates that arguments after that point are not options. `cat -- --help`
reads a file literally called `--help` from the current directory. Options and
non-options may be freely mixed, except no options are allowed after `--`.
`cat` has no options that take arguments. Options may be long or short. Long options begin with two hyphens, and must be given
separately. Short options begin with one hyphen and can be combined; `cat -v -E -T` can be combined into `cat -vET` with precisely the same effect.
The options are documented in the output of `cat --help`:
```
Usage: cat [OPTION]... [FILE]...
Concatenate FILE(s) to standard output.
With no FILE, or when FILE is -, read standard input.
-A, --show-all equivalent to -vET
-b, --number-nonblank number nonempty output lines, overrides -n
-e equivalent to -vE
-E, --show-ends display $ at end of each line
-n, --number number all output lines
-s, --squeeze-blank suppress repeated empty output lines
-t equivalent to -vT
-T, --show-tabs display TAB characters as ^I
-u (ignored)
-v, --show-nonprinting use ^ and M- notation, except for LFD and TAB
--help display this help and exit
--version output version information and exit
Examples:
cat f - g Output f's contents, then standard input, then g's contents.
cat Copy standard input to standard output.
GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/cat>
or available locally via: info '(coreutils) cat invocation'
```
There are some exceptions to the requirement for a perfect clone. Your program
does not have to properly handle file read errors except "file not found" and
"permission denied," and it does not need to be internationalized.
Calling GNU `cat` is cheating.
Because `cat` 8.32 is not available on all systems, a Python reference implementation is provided. I believe it meets the challenge requirements, although it is entirely ungolfed. Any variation between GNU cat and this program, except as allowed in this challenge, is a bug in this program. You are welcome to use it as the basis of an answer if you would like.
```
#!/usr/bin/env python3
import sys
import getopt
try:
full_opts, file_names = getopt.gnu_getopt(
sys.argv[1:],
"AbeEnstTuv",
longopts=[
"show-all",
"number-nonblank",
"show-ends",
"number",
"squeeze-blank",
"show-tabs",
"show-nonprinting",
"help",
"version",
],
)
except getopt.GetoptError as e:
invalid_option = str(e)[7:-15]
if invalid_option.startswith("--"):
print(f"cat: unrecognized option '{invalid_option}'", file=sys.stderr)
else:
letter = invalid_option[1]
print(f"cat: invalid option -- '{letter}'", file=sys.stderr)
print("Try 'cat --help' for more information.", file=sys.stderr)
sys.exit(1)
raw_opts = [opt[0] for opt in full_opts]
opts = []
for raw_opt in raw_opts:
if raw_opt in ["-A", "--show-all"]:
opts.append("--show-nonprinting")
opts.append("--show-ends")
opts.append("--show-tabs")
elif raw_opt == "-e":
opts.append("--show-nonprinting")
opts.append("--show-ends")
elif raw_opt == "-t":
opts.append("--show-nonprinting")
opts.append("--show-tabs")
elif raw_opt == "-u":
pass
elif raw_opt.startswith("--"):
opts.append(raw_opt)
else:
opts.append(
{
"-b": "--number-nonblank",
"-E": "--show-ends",
"-n": "--number",
"-s": "--squeeze-blank",
"-T": "--show-tabs",
"-v": "--show-nonprinting",
}[raw_opt]
)
help_text = """Usage: cat [OPTION]... [FILE]...
Concatenate FILE(s) to standard output.
With no FILE, or when FILE is -, read standard input.
-A, --show-all equivalent to -vET
-b, --number-nonblank number nonempty output lines, overrides -n
-e equivalent to -vE
-E, --show-ends display $ at end of each line
-n, --number number all output lines
-s, --squeeze-blank suppress repeated empty output lines
-t equivalent to -vT
-T, --show-tabs display TAB characters as ^I
-u (ignored)
-v, --show-nonprinting use ^ and M- notation, except for LFD and TAB
--help display this help and exit
--version output version information and exit
Examples:
cat f - g Output f's contents, then standard input, then g's contents.
cat Copy standard input to standard output.
GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/cat>
or available locally via: info '(coreutils) cat invocation'"""
version_text = """cat (GNU coreutils) 8.32
Copyright (C) 2020 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Written by Torbjorn Granlund and Richard M. Stallman."""
nonprinting = {
b"\x00": b"^@",
b"\x01": b"^A",
b"\x02": b"^B",
b"\x03": b"^C",
b"\x04": b"^D",
b"\x05": b"^E",
b"\x06": b"^F",
b"\x07": b"^G",
b"\x08": b"^H",
b"\x0b": b"^K",
b"\x0c": b"^L",
b"\r": b"^M",
b"\x0e": b"^N",
b"\x0f": b"^O",
b"\x10": b"^P",
b"\x11": b"^Q",
b"\x12": b"^R",
b"\x13": b"^S",
b"\x14": b"^T",
b"\x15": b"^U",
b"\x16": b"^V",
b"\x17": b"^W",
b"\x18": b"^X",
b"\x19": b"^Y",
b"\x1a": b"^Z",
b"\x1b": b"^[",
b"\x1c": b"^\\",
b"\x1d": b"^]",
b"\x1e": b"^^",
b"\x1f": b"^_",
b"\x7f": b"^?",
b"\x80": b"M-^@",
b"\x81": b"M-^A",
b"\x82": b"M-^B",
b"\x83": b"M-^C",
b"\x84": b"M-^D",
b"\x85": b"M-^E",
b"\x86": b"M-^F",
b"\x87": b"M-^G",
b"\x88": b"M-^H",
b"\x89": b"M-^I",
b"\x8a": b"M-^J",
b"\x8b": b"M-^K",
b"\x8c": b"M-^L",
b"\x8d": b"M-^M",
b"\x8e": b"M-^N",
b"\x8f": b"M-^O",
b"\x90": b"M-^P",
b"\x91": b"M-^Q",
b"\x92": b"M-^R",
b"\x93": b"M-^S",
b"\x94": b"M-^T",
b"\x95": b"M-^U",
b"\x96": b"M-^V",
b"\x97": b"M-^W",
b"\x98": b"M-^X",
b"\x99": b"M-^Y",
b"\x9a": b"M-^Z",
b"\x9b": b"M-^[",
b"\x9c": b"M-^\\",
b"\x9d": b"M-^]",
b"\x9e": b"M-^^",
b"\x9f": b"M-^_",
b"\xa0": b"M- ",
b"\xa1": b"M-!",
b"\xa2": b'M-"',
b"\xa3": b"M-#",
b"\xa4": b"M-$",
b"\xa5": b"M-%",
b"\xa6": b"M-&",
b"\xa7": b"M-'",
b"\xa8": b"M-(",
b"\xa9": b"M-)",
b"\xaa": b"M-*",
b"\xab": b"M-+",
b"\xac": b"M-,",
b"\xad": b"M--",
b"\xae": b"M-.",
b"\xaf": b"M-/",
b"\xb0": b"M-0",
b"\xb1": b"M-1",
b"\xb2": b"M-2",
b"\xb3": b"M-3",
b"\xb4": b"M-4",
b"\xb5": b"M-5",
b"\xb6": b"M-6",
b"\xb7": b"M-7",
b"\xb8": b"M-8",
b"\xb9": b"M-9",
b"\xba": b"M-:",
b"\xbb": b"M-;",
b"\xbc": b"M-<",
b"\xbd": b"M-=",
b"\xbe": b"M->",
b"\xbf": b"M-?",
b"\xc0": b"M-@",
b"\xc1": b"M-A",
b"\xc2": b"M-B",
b"\xc3": b"M-C",
b"\xc4": b"M-D",
b"\xc5": b"M-E",
b"\xc6": b"M-F",
b"\xc7": b"M-G",
b"\xc8": b"M-H",
b"\xc9": b"M-I",
b"\xca": b"M-J",
b"\xcb": b"M-K",
b"\xcc": b"M-L",
b"\xcd": b"M-M",
b"\xce": b"M-N",
b"\xcf": b"M-O",
b"\xd0": b"M-P",
b"\xd1": b"M-Q",
b"\xd2": b"M-R",
b"\xd3": b"M-S",
b"\xd4": b"M-T",
b"\xd5": b"M-U",
b"\xd6": b"M-V",
b"\xd7": b"M-W",
b"\xd8": b"M-X",
b"\xd9": b"M-Y",
b"\xda": b"M-Z",
b"\xdb": b"M-[",
b"\xdc": b"M-\\",
b"\xdd": b"M-]",
b"\xde": b"M-^",
b"\xdf": b"M-_",
b"\xe0": b"M-`",
b"\xe1": b"M-a",
b"\xe2": b"M-b",
b"\xe3": b"M-c",
b"\xe4": b"M-d",
b"\xe5": b"M-e",
b"\xe6": b"M-f",
b"\xe7": b"M-g",
b"\xe8": b"M-h",
b"\xe9": b"M-i",
b"\xea": b"M-j",
b"\xeb": b"M-k",
b"\xec": b"M-l",
b"\xed": b"M-m",
b"\xee": b"M-n",
b"\xef": b"M-o",
b"\xf0": b"M-p",
b"\xf1": b"M-q",
b"\xf2": b"M-r",
b"\xf3": b"M-s",
b"\xf4": b"M-t",
b"\xf5": b"M-u",
b"\xf6": b"M-v",
b"\xf7": b"M-w",
b"\xf8": b"M-x",
b"\xf9": b"M-y",
b"\xfa": b"M-z",
b"\xfb": b"M-{",
b"\xfc": b"M-|",
b"\xfd": b"M-}",
b"\xfe": b"M-~",
b"\xff": b"M-^?",
}
if "--help" in opts or "--version" in opts:
for opt in opts:
if opt == "--help":
print(help_text)
sys.exit(0)
if opt == "--version":
print(version_text)
sys.exit(0)
if not file_names:
file_names = ["-"]
index = 1
exit_code = 0
for file_name in file_names:
if file_name == "-":
is_file = False
f = sys.stdin.buffer
else:
is_file = True
try:
f = open(file_name, "rb")
except FileNotFoundError:
print(
f"cat: {file_name}: No such file or directory", file=sys.stderr
)
exit_code = 1
continue
except PermissionError:
print(f"cat: {file_name}: Permission denied", file=sys.stderr)
exit_code = 1
continue
last_blank = False
while True:
line = f.readline()
if line:
blank = line == b"\n"
if blank and last_blank and "--squeeze-blank" in opts:
continue
last_blank = blank
number = ("--number-nonblank" in opts and not blank) or (
"--number" in opts and not "--number-nonblank" in opts
)
prefix = f"{index:>6}\t".encode("utf-8") if number else b""
if "--show-ends" in opts:
line = line.replace(b"\n", b"$\n")
if "--show-tabs" in opts:
line = line.replace(b"\t", b"^I")
if "--show-nonprinting" in opts:
for key, value in nonprinting.items():
line = line.replace(key, value)
sys.stdout.buffer.write(prefix + line)
sys.stdout.buffer.flush()
if number:
index += 1
else:
break
if is_file:
f.close()
sys.exit(exit_code)
```
[Answer]
# Python, 5179 bytes
```
a=b'\n'
Z=False
N='number'
v='version'
Y='--'+v
X='--help'
W='--squeeze-blank'
V='--'+N
O=f'--{N}-nonblank'
S='--show-'
I=S+'tabs'
H=S+'ends'
F=S+'nonprinting'
G=S+'all'
C="coreutils"
D="GNU "+C
s=" "
t="standard"
T=" output"
o=t+T
i=t+" input"
E=" and exit\n"
c="'s contents"
q="equivalent to -v"
f=f"Usage: cat [OPTION]... [FILE]...\nConcatenate FILE(s) to {o}.\n\nWith no FILE, or when FILE is -, read {i}.\n\n -A, {G}{s*11}{q}ET\n -b, {O} {N} nonempty{T} lines, overrides -n\n -e{s*23}{q}E\n -E, {H}{s*10}display $ at end of each line\n -n, {V}{s*13}{N} all{T} lines\n -s, {W}{s*6}suppress repeated empty{T} lines\n -t{s*23}{q}T\n -T, {I}{s*10}display TAB characters as ^I\n -u{s*23}(ignored)\n -v, {F} use ^ and M- notation, except for LFD and TAB\n{s*6}{X} display this help{E}{s*6}{Y} {T} {v} information{E}\nExamples:\n cat f - g Output f{c}, then {i}, then g{c}.\n cat{s*8}Copy {i} to {o}.\n\n{D} online help: <https://www.gnu.org/software/{C}/>\nFull documentation <https://www.gnu.org/software/{C}/cat>\nor available locally via: info '({C}) cat invocation'"
g=f'cat ({D}) 8.32\nCopyright (C) 2020 Free Software Foundation, Inc.\nLicense GPLv3+: GNU GPL {v} 3 or later <https://gnu.org/licenses/gpl.html>.\nThis is free software: you are free to change and redistribute it.\nThere is NO WARRANTY, to the extent permitted by law.\n\nWritten by Torbjorn Granlund and Richard M. Stallman.'
E=print
from sys import*
from getopt import*
try:b,J=gnu_getopt(argv[1:],'AbeEnstTuv',[G[2:],O[2:],H[2:],N,W[2:],'show-tabs',F[2:],'help',v])
except GetoptError as c:
K=str(c)[7:-15]
if K[:2]=='--':E(f"cat: unrecognized option '{K}'",file=stderr)
else:d=K[1];E(f"cat: invalid option -- '{d}'",file=stderr)
E("Try 'cat --help' for more information.",file=stderr);exit(1)
e=[A[0]for A in b]
A=[]
a=A.append
for D in e:
if D in['-A',G]:a(F);a(H);a(I)
elif D=='-e':a(F);a(H)
elif D=='-t':a(F);a(I)
elif D=='-u':0
elif D[:2]=='--':a(D)
else:a({'-b':O,'-E':H,'-n':V,'-s':W,'-T':I,'-v':F}[D])
h={b'\x00':b'^@',b'\x01':b'^A',b'\x02':b'^B',b'\x03':b'^C',b'\x04':b'^D',b'\x05':b'^E',b'\x06':b'^F',b'\x07':b'^G',b'\x08':b'^H',b'\x0b':b'^K',b'\x0c':b'^L',b'\r':b'^M',b'\x0e':b'^N',b'\x0f':b'^O',b'\x10':b'^P',b'\x11':b'^Q',b'\x12':b'^R',b'\x13':b'^S',b'\x14':b'^T',b'\x15':b'^U',b'\x16':b'^V',b'\x17':b'^W',b'\x18':b'^X',b'\x19':b'^Y',b'\x1a':b'^Z',b'\x1b':b'^[',b'\x1c':b'^\\',b'\x1d':b'^]',b'\x1e':b'^^',b'\x1f':b'^_',b'\x7f':b'^?',b'\x80':b'M-^@',b'\x81':b'M-^A',b'\x82':b'M-^B',b'\x83':b'M-^C',b'\x84':b'M-^D',b'\x85':b'M-^E',b'\x86':b'M-^F',b'\x87':b'M-^G',b'\x88':b'M-^H',b'\x89':b'M-^I',b'\x8a':b'M-^J',b'\x8b':b'M-^K',b'\x8c':b'M-^L',b'\x8d':b'M-^M',b'\x8e':b'M-^N',b'\x8f':b'M-^O',b'\x90':b'M-^P',b'\x91':b'M-^Q',b'\x92':b'M-^R',b'\x93':b'M-^S',b'\x94':b'M-^T',b'\x95':b'M-^U',b'\x96':b'M-^V',b'\x97':b'M-^W',b'\x98':b'M-^X',b'\x99':b'M-^Y',b'\x9a':b'M-^Z',b'\x9b':b'M-^[',b'\x9c':b'M-^\\',b'\x9d':b'M-^]',b'\x9e':b'M-^^',b'\x9f':b'M-^_',b'\xa0':b'M- ',b'\xa1':b'M-!',b'\xa2':b'M-"',b'\xa3':b'M-#',b'\xa4':b'M-$',b'\xa5':b'M-%',b'\xa6':b'M-&',b'\xa7':b"M-'",b'\xa8':b'M-(',b'\xa9':b'M-)',b'\xaa':b'M-*',b'\xab':b'M-+',b'\xac':b'M-,',b'\xad':b'M--',b'\xae':b'M-.',b'\xaf':b'M-/',b'\xb0':b'M-0',b'\xb1':b'M-1',b'\xb2':b'M-2',b'\xb3':b'M-3',b'\xb4':b'M-4',b'\xb5':b'M-5',b'\xb6':b'M-6',b'\xb7':b'M-7',b'\xb8':b'M-8',b'\xb9':b'M-9',b'\xba':b'M-:',b'\xbb':b'M-;',b'\xbc':b'M-<',b'\xbd':b'M-=',b'\xbe':b'M->',b'\xbf':b'M-?',b'\xc0':b'M-@',b'\xc1':b'M-A',b'\xc2':b'M-B',b'\xc3':b'M-C',b'\xc4':b'M-D',b'\xc5':b'M-E',b'\xc6':b'M-F',b'\xc7':b'M-G',b'\xc8':b'M-H',b'\xc9':b'M-I',b'\xca':b'M-J',b'\xcb':b'M-K',b'\xcc':b'M-L',b'\xcd':b'M-M',b'\xce':b'M-N',b'\xcf':b'M-O',b'\xd0':b'M-P',b'\xd1':b'M-Q',b'\xd2':b'M-R',b'\xd3':b'M-S',b'\xd4':b'M-T',b'\xd5':b'M-U',b'\xd6':b'M-V',b'\xd7':b'M-W',b'\xd8':b'M-X',b'\xd9':b'M-Y',b'\xda':b'M-Z',b'\xdb':b'M-[',b'\xdc':b'M-\\',b'\xdd':b'M-]',b'\xde':b'M-^',b'\xdf':b'M-_',b'\xe0':b'M-`',b'\xe1':b'M-a',b'\xe2':b'M-b',b'\xe3':b'M-c',b'\xe4':b'M-d',b'\xe5':b'M-e',b'\xe6':b'M-f',b'\xe7':b'M-g',b'\xe8':b'M-h',b'\xe9':b'M-i',b'\xea':b'M-j',b'\xeb':b'M-k',b'\xec':b'M-l',b'\xed':b'M-m',b'\xee':b'M-n',b'\xef':b'M-o',b'\xf0':b'M-p',b'\xf1':b'M-q',b'\xf2':b'M-r',b'\xf3':b'M-s',b'\xf4':b'M-t',b'\xf5':b'M-u',b'\xf6':b'M-v',b'\xf7':b'M-w',b'\xf8':b'M-x',b'\xf9':b'M-y',b'\xfa':b'M-z',b'\xfb':b'M-{',b'\xfc':b'M-|',b'\xfd':b'M-}',b'\xfe':b'M-~',b'\xff':b'M-^?'}
if X in A or Y in A:
for Q in A:
if Q==X:E(f);exit(0)
if Q==Y:E(g);exit(0)
if not J:J=['-']
R=1
L=0
for G in J:
if G=='-':S=Z;M=stdin.buffer
else:
S=True
try:M=open(G,'rb')
except FileNotFoundError:E(f"cat: {G}: No such file or directory",file=stderr);L=1;continue
except PermissionError:E(f"cat: {G}: Permission denied",file=stderr);L=1;continue
T=Z
while True:
C=M.readline()
if C:
N=C==a
if N and T and W in A:continue
T=N;U=O in A and not N or V in A and not O in A;i=f"{R:>6}\t".encode('utf-8')if U else b''
if H in A:C=C.replace(a,b'$\n')
if I in A:C=C.replace(b'\t',b'^I')
if F in A:
for(j,k)in h.items():C=C.replace(j,k)
stdout.buffer.write(i+C);stdout.buffer.flush()
if U:R+=1
else:break
if S:M.close()
exit(L)
```
A golfed version of the example I wrote for the question.
] |
[Question]
[
**This question already has an answer here**:
[Gotta Match Them All! Write a regex to match the original 151 Pokemon but no subsequent Pokemon](/questions/47582/gotta-match-them-all-write-a-regex-to-match-the-original-151-pokemon-but-no-sub)
(1 answer)
Closed 5 months ago.
What is the shortest regular expression (REGEX) you can create for file extensions for all of the following image file formats (photographs, paintings, sketches, and drawings)?
```
.ACAD
.AFD
.AFP
.AOM
.AOMA
.APNG
.ASCII
.AVIF
.AVIFAV
.BMP
.BPG
.CABAC
.CDEC
.CDR
.CDRAW
.CGM
.CHEVC
.CIEC
.CIPA
.CMYK
.COLLADA
.CRT
.CWC
.DEEP
.DGN
.DML
.DRAW
.DXFDXF
.DXML
.ECW
.EMF
.EPS
.ERDAS
.EXIF
.FAMF
.FCCBY
.FDRW
.FIFF
.FITS
.FLIF
.FPGF
.FRIFF
.FVRML
.FXD
.GEM
.GIF
.GIMP
.GLE
.GMNG
.GMPEG
.GPNG
.GSVG
.HDR
.HEIF
.HEIFFAVIFAVHEIFAV
.HEVC
.HPGL
.HSF
.HVIF
.ICC
.ICO
.IESC
.IESCD
.IGES
.ILBM
.IMAGINE
.IMAGINEIMG
.IMG
.IMML
.INDD
.IPA
.ISGI
.ISO
.JFIF
.JFIFJPEG
.JPEG
.JPEGHDR
.JPEGJPEG
.JPG
.JPL
.JPS
.KKRA
.LCM
.LPCL
.LXAML
.LZW
.LZWLZW
.MANIAC
.MDP
.MEMF
.MML
.MOV
.MPO
.MSID
.MSIDSID
.MWMF
.NAPLPS
.NASA
.OBJ
.OCR
.ODG
.OGEX
.OGL
.PAM
.PBM
.PCB
.PCLIP
.PCPT
.PCX
.PDF
.PGFTZ
.PGM
.PGML
.PICT
.PLBM
.PLY
.PNG
.PNM
.PNS
.POVR
.PPDN
.PPM
.PPSP
.PRC
.PSD
.PST
.PXMP
.QCC
.RAW
.RGBE
.RGIS
.RIFF
.RISCOS
.RSX
.SAI
.SAISAI
.SISO
.STEP
.STL
.SUSKP
.SVG
.SVGC
.SWF
.SXML
.TARGA
.TGATGA
.TIF
.TIFF
.TVG
.TVP
.VDI
.VICAR
.VML
.VRML
.WEBP
.WMF
.WPM
.XCF
.XGL
.XISF
.XML
.XMP
.XPS
.XVL
```
---
# Scoring Function
The scoring function will be the number of ASCII characters in your regex
Note: only [ASCII](https://en.wikipedia.org/wiki/ASCII) characters are allowed in this competition.
---
May the best **regex** win!
[Answer]
# 752 bytes
```
^\.((HEIFFAVIFAVHE|AV)IFAV|(IMAGINEIM|J(PEG|FIF)JPE|GMPE|APN|G([MP]N|SV)|BP)G|I(MAGINE|ESC)|M(SIDSID|OV)|((JPEG)?HD|POV|OC)R|(C(OLLAD|IP)|T(GAT|AR)G|KKR|IP)A|(MANIA|C(HEV|DE|IE|W)|CABA|HEV|PR)C|(LZWLZ|C?DRA|FDR|EC)W|(SAISA|ASCI|ISG)I|(DXFDX|F(RIF|IF|PG)|(EX|FL)I|H(VI|S)|FAM|M[EW]M|RIF|EM|PD|SW|WM)F|(R(ISCO|GI)|E(RDA|P)|FIT|IGE|XP)S|NA(PLPS|SA)|FCCBY|I(ESCD|C[CO]|MG|SO)|P(G(FTZ|ML)|P(DN|M)|CPT|ICT|C[BX]|LY|N[GMS]|S[DT])|V(ICAR|DI)|(P(CLI|PS|XM)|S(USK|TE)|DEE|GIM|BM|MD)P|((FVR|LXA|SX)M|DX?M|HPG|IMM|LPC|VR?M|MM)L|A(VIF|OM)|HEIF|J(PEG|FIF)|MSID|A(OMA|F[DP])|CMYK|(ACA|IND|FX)D|OGEX|R(GBE|AW|SX)|S(VGC|ISO|TL)|T(IFF|V[GP])|(ILB|P(LB|[AB])|CG|GE|LC)M|W(EBP|PM)|X(ISF|M[LP]|[GV]L|CF)|CDR|LZW|PGM|S(AI|VG)|[TG]IF|JP[GLS]|O(BJ|DG|GL)|DGN|CRT|QCC|GLE|MPO)$
```
Naïve impementation, created with the help of [this tool](https://www.javainuse.com/rexgenerator)
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 2 years ago.
[Improve this question](/posts/230476/edit)
Given an array \$A\$ of size \$n\$.
You have to find the number of subsets such that their product is in the form of \$p\_1 \times p\_2 \times p\_3 \dots\$
where \$p\_1, p\_2, p\_3, \dots\$ are prime numbers. No prime number should appear more than once, i.e. the product is "squarefree".
Example:
Lets pick an array \$A\$ of size \$5\$. \$A[5] = \{2, 3, 15, 55, 21\}\$
The subsets in our answers should be \$\{2,3\}, \{2, 15\}, \{2, 55\}, \{2, 21\}, \{2, 3, 55\}, \{2, 55, 21\}, \{3, 55\}, \{55, 21\}\$.
Lets take \$\{2, 3, 55\}\$ The product will be \$2 \times 3 \times 55 = 2 \times 3 \times 5 \times 11\$. Thus all prime numbers with power of 1.
We can't take for example \$\{3, 15\}\$ because \$3 \times 15 = 3^2 \times 5\$. Condition not satisfied.
Therefore our answer should be number of subsets i.e. here 8.
Constraints: \$2\leq A\_i<10^9\$,
\$1\leq n<10^5\$
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `s`, 16 bytes
```
ṗ'L1>;ƛΠǐ:UL$L"≈
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=s&code=%E1%B9%97%27L1%3E%3B%C6%9B%CE%A0%C7%90%3AUL%24L%22%E2%89%88&inputs=%5B2%2C%203%2C%2015%2C%2055%2C%2021%5D&header=&footer=)
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/219421/edit).
Closed 2 years ago.
[Improve this question](/posts/219421/edit)
# Introduction
This challenge was originally the ["Among Us"](https://github.com/ChocolateOverflow/Writeup-YASCON_CTF_2020/tree/master/Misc/Among_us) challenge in the "Misc" category of YASCON CTF 2020. (The link includes an answer to that challenge. Click at your own risk.)
You're given a lot of files, 1 of which is different from every other files. Your job is to find that 1 different file.
# Challenge
* Input: the file names of all the files to be searched through.
* Output: the name of the 1 different file.
It is guaranteed to have at least 3 files, exactly 1 of which is different file.
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Least bytes wins.
# Example Input and Output
Input:
>
> 1.txt 2.jpg 3.png 4.mp3
>
>
>
Output:
(`3.png` is different)
>
> 3.png
>
>
>
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 71 bytes
```
x=>x.find(u=>!x.filter(v=>(R=n=>[...read(n,'binary')]+'')(u)==R(v))[1])
```
[Try it online!](https://tio.run/##jc6xDoIwFIXh3aeoU@@N2ARwbSefAN0IA8JtrEpL2kLg6TEGWY3bP3w5OY96rEPjTR@PoTct@c7ZJ82Llssk1SS0sS0MUu0/@YrkYZQKCmmlKoUQnuoWbMJvxtZ@5lgdOEcYUMoCRsQyrXBxQYQ5ROqAU3N37OI6YleaIlMsFXGKHHe/TPbLnI3W5MnGTed/LJ6@pvfGRtBQ8vVHwni2Rb7FiivE5Q0 "JavaScript (SpiderMonkey) – Try It Online")
---
66 bytes
```
x=>x.find(u=>!x.filter(v=>(R=n=>read(n,'binary')+'')(u)==R(v))[1])
```
works on my computer. But I cannot make it run on TIO. Maybe due to the version of SpiderMonkey.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/217002/edit).
Closed 3 years ago.
[Improve this question](/posts/217002/edit)
## The Goal
The goal of this question is to put a twist on **[this question](https://codegolf.stackexchange.com/questions/193357/convert-a-string-of-digits-from-words-to-an-integer)**. Your answer should be able to convert an array of words associated with integers into those integers. As an extra challenge, allow support for , `+`, `-`, and `_` in between numbers such as `sixty seven`, `sixty+seven`, `sixty-seven`, or `sixty_seven`.
## Examples
General Example: `one, twenty-two, eleven, thirty+five, forty eight` => `1, 22, 11, 35, 48`.
General Example: `ninety_two, eighty one, zero, seventy+seven, nine` => `92, 81, 0, 77, 9`.
Javascript/Node.JS Example: `['five', 'twenty+eight', 'fifty_two', 'thirty', 'zero']` => `[5, 28, 52, 30, 0]`
## Assumptions
* There are no negative numbers
* The applicable numbers only need to be `0-99`
* The array will not be empty
## Scoring
As this is code-golf, let the answer with the fewest amount of bytes win. Good luck.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 127 bytes
```
a=>a.map(s=>s.replace(/[a-z]+/g,s=>t+=Buffer(`3!S~0?.']5~g)~~~#I*~{2"&+,/-~4~$%q~(1`)[parseInt(s,36)%620%546%115%37]-33,t=0)|t)
```
[Try it online!](https://tio.run/##bY5LT4QwFIX3/gp8IK28hmHAFWPibtYuCZlp8JapwRbbyoTR9K8jD9HEuDwn937feSEtUaVkjfa5eIaeZj3JtiR4JQ1S2VYFEpqalIDCnPjnwg0rb6i1mz2@UwoSHeLLJ7N6CJwiMRU2xlzv7szH@urW9ULfbMyN/WZQdMB5Q6SCHddIeXGK7XS9spNNakdRYsf3hR/Hns5W@FPjvhRciRqCWlSIotwRHBzPcvQJuO58fRJjghpa4FN/ZFJ3LmXtdEbFkCxg1VE7BcYXf2mccdDdfsGMd531rTiDnFo1sgemWhzj07@0xTqPc2ftuILRX8m88EcwcPov "JavaScript (Node.js) – Try It Online")
Below is a summary of the hash function, which gives a result in \$[0..36]\$ with a few unused slots.
```
string | base 36 -> dec. | mod 620 | mod 546 | mod 115 | mod 37
-------------+-----------------+---------+---------+---------+--------
'zero' | 1652100 | 420 | 420 | 75 | 1
'one' | 31946 | 326 | 326 | 96 | 22
'two' | 38760 | 320 | 320 | 90 | 16
'three' | 49537526 | 146 | 146 | 31 | 31
'four' | 732051 | 451 | 451 | 106 | 32
'five' | 724298 | 138 | 138 | 23 | 23
'six' | 36969 | 389 | 389 | 44 | 7
'seven' | 47723135 | 495 | 495 | 35 | 35
'eight' | 24375809 | 509 | 509 | 49 | 12
'nine' | 1097258 | 478 | 478 | 18 | 18
'ten' | 38111 | 291 | 291 | 61 | 24
'eleven' | 882492287 | 407 | 407 | 62 | 25
'twelve' | 1807948346 | 446 | 446 | 101 | 27
'thirteen' | 2310701170991 | 351 | 351 | 6 | 6
'fourteen' | 1229565944111 | 371 | 371 | 26 | 26
'fifteen' | 33766692143 | 423 | 423 | 78 | 4
'sixteen' | 62095095599 | 619 | 73 | 73 | 36
'seventeen' | 80156542487855 | 95 | 95 | 95 | 21
'eighteen' | 1137277763375 | 115 | 115 | 0 | 0
'nineteen' | 1842973464623 | 103 | 103 | 103 | 29
'twenty' | 1807950886 | 506 | 506 | 46 | 9
'thirty' | 1782948454 | 194 | 194 | 79 | 5
'forty' | 26350054 | 54 | 54 | 54 | 17
'fifty' | 26054566 | 306 | 306 | 76 | 2
'sixty' | 47912902 | 542 | 542 | 82 | 8
'seventy' | 61849184038 | 278 | 278 | 48 | 11
'eighty' | 877529158 | 378 | 378 | 33 | 33
'ninety' | 1422047446 | 566 | 20 | 20 | 20
```
] |
[Question]
[
**This question already has answers here**:
[Narcissistic Quine [duplicate]](/questions/198515/narcissistic-quine)
(11 answers)
Closed 4 years ago.
Simple task, write a program/function that returns error **if and only if** presented with itself.
The program must give a valid output for any input other than itself.
For the error part, you can only use errors already built in errors that comes with your language of choice. New/ self-defined error messages are not allowed.
The output should be of the same type as the input. (int, float, string, array, boolean, etc.) Except in the case if presented with itself of course.
Standard loopholes forbidden, lowest byte wins.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 20 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
"34çìD«QiF"34çìD«QiF
```
Outputs the input if it's not equal to the program. If it is equal, it will output the error:
>
> \*\* (RuntimeError) Could not convert `"34çìD«QiF"34çìD«QiF` to integer.
>
>
>
[Try it online.](https://tio.run/##yy9OTMpM/f9fydjk8PLDa1wOrQ7MdEPh4JMDAA)
**Explanation:**
It's based on this base quine: [`"34çìD«"34çìD«`](https://tio.run/##yy9OTMpM/f9fydjk8PLDa1wOrUaw/v8HAA).
```
"34çìD«QiF" # Push string "34çìD«QiF"
34ç # Push 34, converted to a character: '"'
ì # Prepend it to the string: '"34çìDJQiF'
D« # Append a copy of itself: '"34çìDJQiF"34çìDJQiF'
Qi # If it's equal to the (implicit) input-string:
F # Start a loop, using the (implicit) input-string as argument,
# resulting in the error
# (implicit else: use the implicit input as implicit output)
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/196663/edit).
Closed 4 years ago.
[Improve this question](/posts/196663/edit)
You get a string which contains an integer between `1000` and `99999999` as input. The input string might contain leading zeroes but cannot be longer than 8 characters.
Your goal is to output **all dates between** `6th of December 1919` and `5th of December 2019` which fit the input in these formats:
* day - month - year (dmy)
* month - day -year (mdy)
* year - month - day (ymd)
Days and months can be either one or two digits. Years can be either two or four digits. **Also don't forget the leap years!**
---
Your output dates must be all in the same format (choose one). Its days, months and years must be clearly distinguishable (choose a separator or encode them like YYYYMMDD).
You are free to leave any duplicate dates in your output (you're a good boy if you remove them though). If there are no dates to return, return nothing.
Examples:
```
Input: "1234"
Output: 1934-02-01, 2012-03-04, 1934-01-02
Input: "01234"
Output: 1934-01-02, 1934-02-01
Input: "01211"
Output: 2001-11-01, 2011-01-01, 2001-01-11
Input: "30288"
Output: 1988-02-03, 1988-02-30, 1988-03-02
Input: "999999"
Output:
```
Shortest code in bytes wins. Have fun!
[Answer]
# [Ruby](https://www.ruby-lang.org/), 234 bytes
```
require'date'
a,b,g=%w(%Y%-m%d %Y%m%d %Y%-m%-d %Y%m%-d %-m%d%Y %m%d%Y %-m%-d%Y %m%-d%Y %d%-m%Y %d%m%Y %-d%-m%Y %-d%m%Y),Date.new(1920)-26,gets
(b..b+36524).map{|d|puts d.to_s if(a+a.map{|x|x.tr(?Y,?y)}).map{|x|d.strftime(x)}.member?g}
```
[Try it online!](https://tio.run/##NY2xDoMgFEV3v4KFCBGI2takQ@PSn3BqIKBxoLWAUVP9douobzk55w7P9GJaV6O@fWtULLlTccSJIM0DDghWkGoogecBr/TwjdsKKwAPhHX3nXJLgQH0dBoCJk//j73VgLJ7nmKaF6RRzkZIMCaSS3HLr5hp3v1mOXe9s0Ay93lZ0NaIJ3xfxnlkzqCyIuWEF3xGyawztWu1QiNemFZaKFM2y7qmmb8/ "Ruby – Try It Online")
I'm willing to bet that this can be shortened this significantly (with regex maybe), but I'm not clever or knowledgable enough to figure that out.
If we are allowed to print the date object itself instead of a string, change `puts d.to_s` to `p d`.
] |
[Question]
[
At 1998, Brian Kernighan, while working on the book "The Practice of Programming", wanted to demonstrate realisation of regular expression engine. But struggled to find *small* engine, that cod could fit in the book.
So Brian Kernighan asked Rob Pike to write one for him, and Rob [did it](http://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html) gracefully. Here is original source:
```
/* match: search for regexp anywhere in text */
int match(char *regexp, char *text)
{
if (regexp[0] == '^')
return matchhere(regexp+1, text);
do { /* must look even if string is empty */
if (matchhere(regexp, text))
return 1;
} while (*text++ != '\0');
return 0;
}
/* matchhere: search for regexp at beginning of text */
int matchhere(char *regexp, char *text)
{
if (regexp[0] == '\0')
return 1;
if (regexp[1] == '*')
return matchstar(regexp[0], regexp+2, text);
if (regexp[0] == '$' && regexp[1] == '\0')
return *text == '\0';
if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
return matchhere(regexp+1, text+1);
return 0;
}
/* matchstar: search for c*regexp at beginning of text */
int matchstar(int c, char *regexp, char *text)
{
do { /* a * matches zero or more instances */
if (matchhere(regexp, text))
return 1;
} while (*text != '\0' && (*text++ == c || c == '.'));
return 0;
}
```
# Rules
* Write regex engine that supports the same operations, as Rob's:
+ Any char (as symbol)
+ `.` to match any char
+ `^` to match start of the string
+ `$` to match end of the string
+ `*` to match any count of char from zero
* Auxiliary code do not count (to accept input, for example)
* Make the shortest solution and beat Rob Pike!
## Input
Two strings: one for regex, one for match.
## Output
* `True` (in your language), if regex matches string
* `False` (in your language), if regex do not match string
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 39 bytes
```
->\a{&{?/<{a}>/}}o{S:g/<-[.*$^]>/'$/'/}
```
[Try it online!](https://tio.run/##JcexDoIwEADQvV9xwwVaYrnNQbF8hCNCcpWeMUEhMJGm3141Ti9vCet0zK8dCoFLtu7GsYgtNZGTo5TmeD09qLFdXeHQOyqRSkpZ5hX09HyHzYB1yAf0EBXAxjuIRjYavTmrlAf297oSVF/HID@6sf/3Aw "Perl 6 – Try It Online")
Simply evaluates the input as a regex, adding quotes to avoid any special characters Perl 6 uses. This takes input curried, as `f(regex)(string)`, though it could be a *lot* shorter if I can just return a regex object.
] |
[Question]
[
**This question already has answers here**:
[Base Conversion With Strings](/questions/69155/base-conversion-with-strings)
(9 answers)
Closed 5 years ago.
This is a code golf puzzle: shortest byte count wins. The program should do the following ([standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) obviously forbidden):
1. Input a hexadecimal number
2. Convert to octal
3. Then interpret the digits as if in decimal (765 octal -> 765 decimal)
4. Divide the number by two
5. Convert to hexadecimal
## Example:
Input: 4a3d
Output: 5809.8
```
4a3d -> 45075 -> 45075 -> 22537.5 -> 5809.8
```
[Answer]
# Javascript,~~56~~ ~~53~~ 52 bytes
-3 bytes thanks to @ovs
-1 byte thanks to @Arnauld
```
p=parseInt,a=>(p(p(a,16)[s='toString'](8))/2)[s](16)
```
toString on an integer converts the integer to a string in that base.
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z@cn1ecn5Oql5OfrqHxv8C2ILGoONUzr0Qn0dZOowAIE3UMzTSji23VS/KDS4oy89LVYzUsNDX1jYCCsRpAuf@aGkomicYpSpqa/wE "JavaScript (Node.js) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 30 bytes
```
{(:16($_).base(8)/2).base(16)}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WsPK0ExDJV5TLymxOFXDQlPfCMo0NNOs/V@cWKmQpqFukmicoq5p/R8A "Perl 6 – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Display "Happy Easter!"](/questions/76331/display-happy-easter)
(26 answers)
Closed 6 years ago.
Ouput the following banner:
```
_____ _ _____ _ __
/ ____| | | / ____| | |/ _|
| | ___ __| | ___ | | __ ___ | | |_
| | / _ \ / _` |/ _ \ | | |_ |/ _ \| | _|
| |___| (_) | (_| | __/ | |__| | (_) | | |
\_____\___/ \__,_|\___| \_____|\___/|_|_|
```
The code that has the fewest bytes wins! I'm interested to see what clever formulas some of you come up with, bare in mind I just created this in notepad with no clever formula in mind so you may not be likely in finding one.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 128 bytes
```
“UyɠȯaẹṇṾƊSḳẋƘø;ṫṃ42MọẆẇB3tʂñṅƈṠUẈṣcC\ÑḢ¦¿$Ọỵịnß⁻ȥ2¶ø⁸Ḥ¢ȮN÷ẹƘḣƘßFĠC⁸⁴ʠe'ȮƊẹġƒhSṅsɼĖḟṘʋÆỌVKɠeḌ⁽ṗ?=ƈƥḍP⁴ĿḳaɲƬ*ṪñṪ’ṃ“_/|\`( ),”s46Y
```
[Try it online!](https://tio.run/##TY/PSwJBFMfv/hVzCNIQFky6RAQJXaIIxCBYWCOECOliF2EObpGKPw51KIPCTbODhdHvmd1K2F0G9b94@49sMztqzuHNe@/z3ve9d5jJZvO@7xVuUvmhMXjeA5MCLQH9ZZUkkDcwq6zhkGWgj0BP47FNsOpgFsEsrS0ej06cF6BnrAzUSIHJv/Z@QnXOgbTsB7s/B1YNrA@wqkdO09OtQSdmfzrE0wmQe7s16G05X3wcawBp8yHNdddIcOjp7yMjMz/osQqn7h27OEjyKbnht3sJpAm0Mao6Ra69szE0MkBqnv4D9Gp1hZVZB0h9mwu4fb773vCVPS0A7Yotu17hml/AD9UUrKbDKBL1Cre5@NKu7/sIIU08NH3/7izQRIhCCClBGk9qMJq4s4BneYhDUyyFBMbSD4CmSSICLNTH5bwXqcKmAx3ujytkJHulejAyrEWQsGNRRQKMJiTI893V4CJhFeFHNazKlSUIIgVrWKT@AA "Jelly – Try It Online")
This is just a direct compression, no tricks :).
] |
[Question]
[
**This question already has answers here**:
[Find the capacity of 2D printed objects](/questions/69298/find-the-capacity-of-2d-printed-objects)
(12 answers)
Closed 6 years ago.
**Imagine a histogram.** Pour an infinite amount of water on to it. Then stop. How much water does the histogram hold?
Let's say we have a histogram with columns of these heights:
1 3 2 1 4 1 3
That would look like this:
```
#
# # #
## # #
#######
1321413
```
If we pour an infinite amount of water on this histogram, some of those holes will fill up, and we'll end up with this:
```
#
#..#.#
##.#.#
#######
1321413
```
Apparently, this histogram can hold 5 slots of water.
**Your task**, should you choose to accept it, is to calculate the number of slots of water that a given histogram can hold. You may accept the input as a list, string, array, matrix, bitmap or whatever format you like. The output should be nothing but a single integer, in any format you like.
The input will only contain column heights between 1 and 1000, and the input size is between 1 and 1000 columns.
**Test cases:**
```
1 -> 0
2 1 2 -> 1
1 3 2 1 4 1 3 -> 5
1 3 5 7 6 4 2 1 -> 0
7 1 1 1 1 1 1 1 1 1 7 -> 54
2 6 3 5 2 8 1 4 2 2 5 3 5 7 4 1 -> 35
```
If you're looking for possible ways to solve this problem, [here's four](https://www.youtube.com/watch?v=ftcIcn8AmSY).
This is code golf, so the least bytes of source code wins.
[Answer]
# [Retina](https://github.com/m-ender/retina), 16 bytes
```
(?<=# *) (?= *#)
```
[Try it online!](https://tio.run/##K0otycxL/P9fw97GVllBS1NBw95WQUtZ8/9/BTBQ5lJQBtMIljKIpQxmKHMpwwAA "Retina – Try It Online") Link includes test case. Works by counting the spaces which are surrounded by `#`s.
[Answer]
# [Python 2](https://docs.python.org/2/), 68 bytes
```
lambda l:sum(min(max(l[:i+1]),max(l[i:]))-v for i,v in enumerate(l))
```
[Try it online!](https://tio.run/##dU1BDsIgELz7ij1CxEOpbQ2Jv/BWOWCk6SZAG4Sqr6@UpsaLyWR3dmdndnyHfnB87s7X2Sh7uysw4hEtseiIVS9iWoH7QlK2DigkpYcJusEDsgnQgXbRaq@CJobS@dmj0XDxUYsdwOjRBegIujEGkuS2kLuWMygY8MRSKxPL8zHX8rutGDQM6ixwtviafPEPzZpcb@bET1swz6h@cpdv8gM "Python 2 – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Write the shortest self-identifying program (a quine variant)](/questions/11370/write-the-shortest-self-identifying-program-a-quine-variant)
(48 answers)
Closed 7 years ago.
A standard (but disputed) test of self-awareness is the mirror test: An animal is considered self aware if it can recognize itself in the mirror.
Your task is to write a program that is self-aware according to this test. More exactly:
* The program reads input in whatever form is suitable for your language.
* If the input contains a mirror image of its own source code, it produces a truthy value, otherwise a falsey value.
* A valid mirror image is the exact source of the program with the order of characters reversed, with no extra characters in between. As a special exception, for systems/languages that don't use single characters to terminate/separate lines (e.g. using a CR/LF sequence), the line termination sequence is allowed, but not required to be kept intact on reversal. However the program must be consistent in its treatment of lines.
For example, on a system using CR/LF as line separator, the sequence `AB<cr><lf>CD` may be reversed either to `DC<cr><lf>BA` (keeping the line ending intact) or to `DC<lf><cr>BA` (completely reversing the character sequence).
* The mirror image must be detected also if it is preceded or followed by junk, even if that junk contains reversed fragments of the code.
This is code golf; the shortest entry wins.
Note this is *not* the same as [this question](https://codegolf.stackexchange.com/questions/11370) because of (a) the reversal of the code, and (b) the fact that it has to tolerate junk before and after the reversed code, including junk that is very similar to the actual reversed code.
[Answer]
## [Retina](http://github.com/mbuettner/retina), 1 byte
```
x
```
[Try it online!](http://retina.tryitonline.net/#code=eA&input=enl4eXo)
Prints a positive integer when the input contains at least one "reversed" copy of the source and `0` otherwise.
Any character that isn't a backtick or a regex metacharacter (`[()?*+\\^$.`) would work.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 7 years ago.
[Improve this question](/posts/90335/edit)
In the following markup without changing it or using JS, implement the behavior to show only the `ul` element of `div` which name is clicked in the first `ul` (before `div`). Name is content of `li` in top `ul` and it matches the content of the first `li` in `ul` you want to show. Elements that have `{content}` are just fillers and have no meaning for problem.
```
<ul>
<li class="head"><a href="#favorites">Favourite dishes</a></li>
<li><a href="#breakfasts"><i>Breakfasts</i></a></li>
<li><a href="#dinners"><i>Dinners</i></a></li>
<li><a href="#suppers"><i>Suppers</i></a></li>
</ul>
<div>
<ul id="breakfasts">
<li class="head">Breakfasts</li>
<li>{Breakfast 1}</li>
<li>{Breakfast 2}</li>
<li>{Breakfast 3}</li>
</ul>
<ul id="dinners">
<li class="head">Dinners</li>
<li>{Dinner 1}</li>
<li>{Dinner 2}</li>
<li>{Dinner 3}</li>
</ul>
<ul id="suppers">
<li class="head">Dinners</li>
<li>{Supper 1}</li>
<li>{Supper 2}</li>
<li>{Supper 3}</li>
</ul>
<ul class="favorites">
<li class="head">Favourites</li>
<li>{Favourite 1}</li>
<li>{Favourite 2}</li>
<li>{Favourite 3}</li>
</ul>
</div>
```
This problem really has the solution and was very interesting for me, so I decided to post it here even if it's not very practical.
Hint: you have to use `:target` pseudo-class.
[Answer]
I think your hint gave too much away:
```
div>ul:target{
display: block;
}
div>ul{
display: none;
}
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 7 years ago.
[Improve this question](/posts/85611/edit)
What could be the shortest code for filtering the following array in Javascript without any library?
My code is:
```
filtered_obj = _.where(obj, { name: "Alpha" });
```
This uses a JS library called `underscore`.
Test case:
```
objs = [{'id':1,'name':'Alpha'},{'id':2,'name':'Beta'},
{'id':3,'name':'Gamma'},{'id':4,'name':'Eta'},
{'id':5,'name':'Alpha'},{'id':6,'name':'Zeta'},
{'id':7,'name':'Beta'},{'id':8,'name':'Theta'},
{'id':9,'name':'Alpha'},{'id':10,'name':'Alpha'}];
filtered_obj =[{'id':1,'name':'Alpha'},{'id':5,'name':'Alpha'},
{'id':9,'name':'Alpha'},{'id':10,'name':'Alpha'}]
```
[Answer]
# 45 bytes
```
filtered_obj=objs.filter(n=>n.name=='Alpha');
```
This uses the [`filter` function for arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter).
[Ideone it!](http://ideone.com/pYx19v)
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/83503/edit).
Closed 7 years ago.
[Improve this question](/posts/83503/edit)
Your task is to write a self referential program similar to a quine. The objective is to write a program that will generally print to stdout twice whatever the input is. But when it receives the input of "Tell me about your source" it should output its source (like a quine). Also if it receives the query "tell me about your length". It should output its length in utf-8 characters. Like always all standard loopholes are disabled. This is code golf in any language of your choosing.
Sample Input
```
2
```
Sample Output
```
4
```
Sample Input
```
Tell me about your source
```
Sample Output
```
x
```
Sample Input
```
Tell me about your length
```
Sample Output
```
1
```
Clarifications:
The input will always be valid your program is always going to receive valid input. Your code is not required to recognize invalid input.
[Answer]
# Javascript - ~~93~~ ~~92~~ 89 bytes
Defines a function `f`. Not sure of a better way to return.
```
f=n=>{y="Tell me about your ";x="f="+f;return n==y+"source"?x:n==y+"length"?x.length:2*n}
```
] |
[Question]
[
This question got me nostalgic: [Build a word generator!](https://codegolf.stackexchange.com/questions/78964/build-a-word-generator)
In the '80s I wrote a simple word generator in under 42kB (code and working memory) that would take a collection of strings and use them to create new words and phrases.
Your task is to recreate this program in as few bytes as possible, with a few minor updates.
Your program will take the input and ensure that there are two spaces after each sentence. Each sentence should end with a full-stop (`.`). There must not be three consecutive spaces anywhere in the text. Line breaks should be replaced by a single space. There should only be two spaces after a sentence and nowhere else.
Record the number of times each character triplet appears. If you're using regex to break up the text `/\X/` is a good way to match a Unicode glyph (could be multiple codepoints, not necessarily a single codepoint). For the purposes of counting, assume that there are two spaces at the start of the text and two spaces at the end.
Hopefully, you now have some good data to work with! Randomly select a triplet where the first two characters are both spaces. For example, if the only two matching triplets are `[' ', ' ', 'I'] => 3` and `[' ', ' ', 'A'] => 7` there should be a 30% chance of selecting `I` and a 70% chance of selecting `A`. Shift the characters along and randomly select one of the next triplets. If `A` was the first character selected the next triplets might be `[' ', 'A', 'n'] => 2`, `[' ', 'A', 't'] => 2` and `[' ', 'A', 's'] => 3`. Randomly select one using the correct weightings and so on. Repeat until the last two characters are both spaces, then output the string generated if it's 100 characters or longer. If the output is less than 100 characters, repeat the process again, adding to the existing string until it is at least 100 characters long.
You should end up with output something like below, which looks almost like the input language. As my test input I used the first chapter of Charles Dickens' [A Tale of Two Cities](https://archive.org/stream/ataleoftwocities00098gut/98.txt) but you can use any text you feel like. Please provide a link to your input text (preferably not copyrighted) and a sample of the output.
>
> In harithe dir, in hadede Fards fouses, by we aws, mand by nouse St. Merty exce, he th at ing ithe inceir farce, a Capir bod day, one defor ond rodmane of the ce witsethe after seas a pleark parison a prion to eves hund Parglairty the beere tielaires, and wrece to ente comses itic plaw andozene hich tat andiver, a he pent wer thneople, the werseved froads se sebron theire mands inge Woodmage larestown ther Ligh, sed and was the withaved broce pers. Brity-fired of bust a din humakings th, incre pas of the amonoblis the a kne Chrooteres, to offle ound lies yeargland this thing by on the goil ituarivesdozen, moolurd instive the whe only a king was thelfe one divery. Und the intren a king thiging ors, and he tow, afty out pas musears, thot he in aces, it it Fran, tho the blets be anglaters ouseticiodmand whimeng was by the primed tord a ce a dirience.
>
>
>
### TL;DR
Build sentences from test input by analysing the frequency of the character triplets, and using those frequencies to randomly select each character in sequence.
You can pre-format your text to make sure it matches the input requirements. It doesn't have to contribute to your byte-count.
If your language can't cope with Unicode at all, limit the input to ASCII characters. Ideally, your program should be able to cope with combining marks (accents and the like) if they are encoded separately but it doesn't have to. It shouldn't affect the output much, although it's possible you might get weird output in rare cases. e.g. if `é` is encoded as two codepoints, `e`+combining acute accent, it SHOULD (but doesn't HAVE to) treat it as a single glyph.
[Answer]
# Ruby, 88 bytes
Port from the Python answer by @Blue with a few modifications because it's still the shortest way to do things in Ruby as well...
```
->s{o=e=' ';(s[x=rand(s.size-2),2]==o[-2,2]?o+=s[x+2]:0)while o.size<100||o[-2,2]!=e;o}
```
Alternate version using selection and sampling, **99 bytes**
```
->s{o=e=' ';o+=s[(0..s.size-2).select{|i|s[i,2]==o[-2,2]}.sample+2]while o.size<100||o[-2,2]!=e;o}
```
[Answer]
# Python 2.7, ~~156~~ ~~149~~ ~~135~~ 131 bytes
Screw efficiency, as long as it's short.
Saved 7 bytes thanks to @TuukkaX on the import statement
Saved 14 bytes thanks to @KevinLau-notKenny for negative list indice trick and if statement.
Saved 4 bytes by changing the randint
Notice that the second level uses tabs, but SE renders as 4 spaces.
```
from random import*
def r(i):
o=' '
while len(o)<100or o[-2:]!=' ':
x=randint(2,len(i))
if i[x-2:x]==o[-2:]:o+=i[x]
return o
```
[Answer]
## PowerShell, 141 bytes
```
param($d)$o=' '
while($o.Length-lt100-or$o.EndsWith(' ')){if(($s=$d[($x=Get-Random $d.Length)-2]+$d[$x-1])-eq$o[-2]+$o[-1]){$o+=$d[$x]}}$o
```
It's a port of @Blue's answer as well. Assuming pre-formatted text, as mentioned in the question.
e.g.
```
PS U:\posh> .\New-RandomStory.ps1 @'
It was the best of times, it was the worst of times,
it was the age of wisdom, it was the age of foolishness,
it was the epoch of belief, it was the epoch of incredulity,
it was the season of Light, it was the season of Darkness,
it was the spring of hope, it was the winter of despair,
we had everything before us, we had nothing before us,
we were all going direct to Heaven, we were all going direct
the other way--in short, the period was so far like the present
period, that some of its noisiest authorities insisted on its
being received, for good or for evil, in the superlative degree
of comparison only.
'@
It wincres the befor evil, its the all going redulight, fort, the of it we best waso forst waso fo
```
] |
[Question]
[
# Input
A single string, which contains no whitespace, as a command-line argument.
# Output
If the string is not a valid [algebraic notation](https://en.wikipedia.org/wiki/Algebraic_notation_%28chess%29) pawn promotion, produce no output and exit. If the string is a valid pawn promotion, convert it to [ICCF numeric notation](https://en.wikipedia.org/wiki/ICCF_numeric_notation) and print the result, followed by a newline.
A valid algebraic notation pawn promotion consists of:
* A letter from a to h indicating the pawn's departure column (known as a "file" in chess);
* Optionally, "x" followed by the file of the pawn's arrival square if it has captured a piece in promoting;
* "1" or "8" depending on which side promoted; and
* "=" followed by one of "Q", "R", "B", "N" to indicate the chosen piece;
* Optionally, "+" to indicate the move was a check or "#" to indicate the move was a checkmate.
An valid ICCF numeric notation pawn promotion consists of:
* Two digits indicating the coordinates of the square from which the pawn departed (the files are numbered and not lettered as in algebraic notation);
* One digit indicating the file on which the pawn arrived, in case it has captured a piece while promoting (this does not officially comply with the standard, but I prefer keeping all moves as 4 digits for simplicity); and
* One digit to indicate the chosen piece: 1 for queen, 2 for rook, 3 for bishop, 4 for knight.
# Examples
```
e1=Q => 5251
cxd8=B => 3743
axh8=R => no output (a-pawns cannot capture on h-file)
h8=N+ => 8784
```
[Answer]
## JavaScript (ES6), 166 bytes
```
s=>(g=n=>parseInt(m[n][0],19)-9,m=s.match(/^([a-h]x)?([a-h][18]=[QRBN])[+#]?$/))?m[1]&&g(2)+~g(0)&&g(0)+~g(2)?'':''+g(0)+(m[2][1]-1|2)+g(2)+" QRBN".search(m[2][3]):''
```
The validation makes this horribly long. Without validation, it's only 108 bytes:
```
s=>s.replace(/(.x)?(..=.).*/,([a],_,[c,d,,f])=>g(a)+(d-1|2)+g(c)+" QRBN".search(f),g=f=>parseInt(f,19)-9+'')
```
] |
[Question]
[
**This question already has answers here**:
[Counter counter](/questions/51877/counter-counter)
(24 answers)
Closed 8 years ago.
Given an input string, determine the number of regions that a page will be split into.
Consider the letter `P`. It has one enclosed region within the letter. Assume that each letter splits the page by one or more regions (i.e. a box is drawn around the character).
## Input
A string of 0 or more characters. You may assume that the string contains only characters from the following sets:
* +0 regions: Spaces , tabs `\t`, and new lines `\n`
* +1 region: `CEFGHIJKLMNSTUVWXYZcfhijklmnrstuvwxyz12357~!^*()-_=+[]{}\'|:;",.?/<>`
* +2 regions:`ADOPQRabdeopq469@#`
* +3 regions: `Bg08$%&`
You may take the input as a function argument, standard input, command-line argument, whatever works best for your language.
## Output
An integer representing the number of regions split by the given input. Output can be a return value or standard output (but not stderr).
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest solution in bytes win.
## Test cases
* (empty string or only whitespace) === 1
* `-1` === 3
* `100%` === 11
* `Hello world!` === 16
* `May the force be with you` === 28
* `do {$busTickets-=2;} while ($transit != false)` === 54
* `return @$_GET['foo'] ?? $$var % $var || $g8 << ; //# Syntax error` === 80
Feel free to use the demo in my JavaScript answer (with a compatible browser of course) to run test cases.
## Visual representation
Note: The visual representation for the characters `g` and `0` (zero) may not be entirely correct depending on the monospaced font that your computer has installed.
For the purposes of this challenge, assume that the bottom of the `g` has a closed loop and the `0` has a slash through it.
```
(function() {
'use strict';
[
'CEFGHIJKLMNSTUVWXYZcfhijklmnrstuvwxyz12357~!^*()-_=+[]{}\\\'|:;"<,>.?/`',
'ADOPQRabdeopq469@#',
'Bg08$%&'
].forEach(function(set, i) {
set.split('').sort().forEach(function(letter) {
var p = document.querySelectorAll('section[data-letter-regions="' + (i + 1) + '"]')[0];
console.log(p)
var el = document.createElement('span');
el.setAttribute('class', 'letter');
el.textContent = letter;
p.appendChild(el);
});
});
}());
```
```
h1 {
font-family: sans-serif;
}
section + section {
border-top: medium solid purple;
}
.letter {
font-family: Consolas, 'Droid Sans Mono', monospace;
font-size: 3em;
line-height: 1;
padding: 3px;
margin: 3px;
display: inline-block;
border: thin solid darkgray;
}
```
```
<section data-letter-regions=1>
<h1>1 region</h1>
</section>
<section data-letter-regions=2>
<h1>2 regions</h1>
</section>
<section data-letter-regions=3>
<h1>3 regions</h1>
</section>
```
[Answer]
## JavaScript (ES6), 94 bytes
```
f=x=>[...x].reduce((p,z)=>p+!!z.trim()+2*/[Bg08$%&]/.test(z)+/[ADOPQRabdeopq469@#]/.test(z),1)
```
### Demo
As the code is in ES6, the demo only works in ES6-compatible browsers. At time of writing, this includes Firefox, Edge, and Chrome/Opera with experimental JavaScript features enabled.
```
f = x => [...x].reduce((p, z) => p + !!z.trim() + 2 * /[Bg08$%&]/.test(z) + /[ADOPQRabdeopq469@#]/.test(z), 1)
// Snippet stuff
var v = function() {document.getElementById('Z').textContent = f(this.value)};
document.getElementById('I').addEventListener('keyup', v, false);
document.getElementById('I').addEventListener('change', v, false);
```
```
textarea {width: 100%}
```
```
<p><label>Input: <textarea id=I></textarea></label></p>
<p>Output: <output id=Z>1</output></p>
```
] |
[Question]
[
The [Myriad System](http://googology.wikia.com/wiki/-yllion) is an alternative system for naming large numbers proposed by Donald Knuth in 1981.
In this system, numbers up to 999 are named as they are normally, but 1000 is not given a special name and is instead named as "ten hundred"; the next benchmark number being 10000, or "one myriad" (which, of course, comes from an ancient greek word meaning 10000).
From here one myllion is defined as one myriad \* one myriad, one byllion as one myllion \* one myllion, one tryllion as one byllion \* one byllion, and so forth.
The challenge here is to take a base-10 integer from the input and determine its name in this system.
Your input is guaranteed to be nonnegative and less than 10212=104096 (one [decyllion](http://googology.wikia.com/wiki/Decyllion))
Either a full program (in which case input can be taken from either stdin or a command line argument, and output must be sent to stdout) or a function (which takes the input as an argument and returns the output) is permissible.
The returned string should be formatted as per this Java program:
```
import java.math.*;
public class Myriadizer{
static BigInteger b=new java.util.Scanner(System.in).nextBigInteger(),c=b,TEN=BigInteger.TEN,d=TEN.pow(4),f=TEN.pow(2),e=BigInteger.ZERO;
static String[]strings={"six","seven","eight","nine","four","thir","fif"};
static String output="";
static void t(){
int i=0;
while(b.compareTo(d)>=0){
b=b.divide(d);
i++;
}
int k=b.intValue();
char[]binary=Integer.toString(i,2).toCharArray();
int q=48,bits=binary.length;
String r="yllion ";
s(k);
if(bits>0&&binary[bits-1]!=q)output+="myriad ";
if(bits>1&&binary[bits-2]!=q)output+="m"+r;
if(bits>2&&binary[bits-3]!=q)output+="b"+r;
if(bits>3&&binary[bits-4]!=q)output+="tr"+r;
if(bits>4&&binary[bits-5]!=q)output+="quadr"+r;
if(bits>5&&binary[bits-6]!=q)output+="quint"+r;
if(bits>6&&binary[bits-7]!=q)output+="sext"+r;
if(bits>7&&binary[bits-8]!=q)output+="sept"+r;
if(bits>8&&binary[bits-9]!=q)output+="oct"+r;
if(bits>9&&binary[bits-10]!=q)output+="non"+r;
if(bits>10&&binary[bits-11]!=q)output+="dec"+r;
b=c=c.subtract(d.pow(i).multiply(b));
if(b.compareTo(f)>=0)output+=",";
output+=" ";
if(b.compareTo(e)>0&&b.compareTo(f)<0)output+="and ";
}
static void s(int t){
if(t>99){
s(t/100);
output+="hundred ";
if(t%100>0)output+="and ";
s(t%100);
return ;
}
if(t==0)return;
if(t<13){
output+=(new String[]{
"one","two","three",
strings[4],"five",strings[0],strings[1],strings[2],strings[3],
"ten","eleven","twelve"
})[t-1]+" ";
return ;
}
if(t<20){
output+=(new String[]{
strings[5],strings[4],strings[6],strings[0],strings[1],strings[2],strings[3]
})[t-13]+"teen ";
return ;
}
output+=new String[]{"twen",strings[5],"for",strings[6],strings[0],strings[1],strings[2],strings[3]}[t/10-2]+"ty";
if(t%10>0){
output+="-";
s(t%10);
return;
}
output+=" ";
}
public static void main(String[]a){if(b.equals(e)){System.out.println("zero");return;}while(c.compareTo(e)>0)t();System.out.println(output.replaceAll("\\s+$","").replaceAll("\\s\\s+"," ").replaceAll("\\s,",","));}
}
```
Some details of this that should be noted:
* The terms in the main sum should be arranged in descending order
* The terms in any given product should be arranged in ascending order, and exactly one term in any given product should be under one myriad
* The terms in the main sum should be comma-separated, *unless the last is under one hundred* in which case the last two should be separated by the conjunction "and"
This is code golf, so the shortest program wins.
Some test cases:
```
0 = zero
100 = one hundred
1000 = ten hundred
10014 = one myriad and fourteen
19300 = one myriad, ninety-three hundred
100000 = ten myriad
1000000 = one hundred myriad
1041115 = one hundred and four myriad, eleven hundred and fifteen
100000000 = one myllion
1000000501801 = one myriad myllion, fifty myriad, eighteen hundred and one
94400000123012 = ninety-four myriad myllion, forty hundred myllion, twelve myriad, thirty hundred and twelve
10000000200000003000000040000000 = ten hundred myriad myllion byllion, twenty hundred myriad byllion, thirty hundred myriad myllion, forty hundred myriad
100000002000000030000000400000000 = one tryllion, two myllion byllion, three byllion, four myllion
```
[Answer]
# C, 698 bytes
Recursive approach, don't mind the memory leaks :) Explanation to come later.
```
#include <stdlib.h>
#define c char*
n;c r(c v){c p,*z,*o[]={"","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twen","thir","for","fif","six","seven","eigh","nine","hundred","myriad","m","b","tr","quadr","quint","sext","sept","oct","non","dec"};int s,l;long t;v+=strspn(v,"0");l=strlen(v);if(l<3)n=atoi(v),n<20?p=o[n],0:asprintf(&p,n%10?"%sty-%s":"%sty",o[n/10+18],o[n%10]);else s=(int)(log(l-1)/log(2))-1,z=v+l-(2<<s),t=strtol(z,0,10),p=r(z),*z=0,asprintf(&p,*p?"%s %s%s%s %s":"%s %s%s",r(v),o[s+28],s>1?"yllion":"",*p?t<100?" and":",":"",p);return p;}main(_,v)c*v;{puts(r(v[1]));}
```
## Examples
```
$ ./a.out 0
zero
$ ./a.out 100
one hundred
$ ./a.out 1000
ten hundred
$ ./a.out 10014
one myriad and fourteen
$ ./a.out 19300
one myriad, ninety-three hundred
$ ./a.out 100000
ten myriad
$ ./a.out 1000000
one hundred myriad
$ ./a.out 1041115
one hundred and four myriad, eleven hundred and fifteen
$ ./a.out 100000000
one myllion
$ ./a.out 1000000501801
one myriad myllion, fifty myriad, eighteen hundred and one
$ ./a.out 94400000123012
ninety-four myriad, forty hundred myllion, twelve myriad, thirty hundred and twelve
$ ./a.out 10000000200000003000000040000000
ten hundred myriad myllion, twenty hundred myriad byllion, thirty hundred myriad myllion, forty hundred myriad
$ ./a.out 100000002000000030000000400000000
one tryllion, two myllion and three byllion, four myllion
```
[Answer]
# Java, ~~1477~~ 1459 bytes
```
import java.math.*;class M{static BigInteger b=new java.util.Scanner(System.in).nextBigInteger(),c=b,k=BigInteger.TEN,d=k.pow(4),f=k.pow(2),e=BigInteger.ZERO;static String o="",s[]={"six","seven","eight","nine","four","thir","fif"},p=" ";static void s(int t){if(t>99){s(t/100);o+="hundred ";if(t%100>0)o+="and ";s(t%100);return;}if(t==0)return;if(t<13){o+=new String[]{"one","two","three",s[4],"five",s[0],s[1],s[2],s[3],"ten","eleven","twelve"}[t-1]+p;return;}if(t<20){o+=new String[]{s[5],s[4],s[6],s[0],s[1],s[2],s[3]}[t-13]+"teen ";return;}o+=new String[]{"twen",s[5],"for",s[6],s[0],s[1],s[2],s[3]}[t/10-2]+"ty";if(t%10>0){o+="-";s(t%10);return;}o+=p;}public static void main(String[]a){if(b.equals(e)){System.out.println("zero");return;}while(c.compareTo(e)>0){int i=0;while(b.compareTo(d)>=0){b=b.divide(d);i++;}char[]z=Integer.toString(i,2).toCharArray();int q=48,l=z.length;String r="yllion ";s(b.intValue());if(l>0&&z[l-1]!=q)o+="myriad ";if(l>1&&z[l-2]!=q)o+="m"+r;if(l>2&&z[l-3]!=q)o+="b"+r;if(l>3&&z[l-4]!=q)o+="tr"+r;if(l>4&&z[l-5]!=q)o+="quadr"+r;if(l>5&&z[l-6]!=q)o+="quint"+r;if(l>6&&z[l-7]!=q)o+="sext"+r;if(l>7&&z[l-8]!=q)o+="sept"+r;if(l>8&&z[l-9]!=q)o+="oct"+r;if(l>9&&z[l-10]!=q)o+="non"+r;if(l>10&&z[l-11]!=q)o+="dec"+r;b=c=c.subtract(d.pow(i).multiply(b));if(b.compareTo(f)>=0)o+=",";o+=p;if(b.compareTo(e)>0&&b.compareTo(f)<0)o+="and ";};System.out.println(o.replaceAll("\\s+$","").replaceAll("\\s\\s+"," ").replaceAll("\\s,",","));}}
```
] |
[Question]
[
**This question already has answers here**:
[Tips for golfing in Befunge](/questions/16090/tips-for-golfing-in-befunge)
(15 answers)
Closed 8 years ago.
What general tips do you have for golfing in Befunge 93? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to Befunge 93 (e.g. "remove comments" is not an answer). Please post one tip per answer.
[Answer]
As little white space as possible.
If you have a 10x5 (50) code, can you make it into a 6x8 (48):
```
some code
goes here
and it is
exactly 50
characters
```
goes to
```
put a bi
t of cod
e here a
nd count
all of 4
0 chars!
```
] |
[Question]
[
**This question already has answers here**:
[Length of String Using Set Theory](/questions/25642/length-of-string-using-set-theory)
(21 answers)
Closed 8 years ago.
Write a program in any language that takes a single natural number *n* as input and generates a [Pyth](https://github.com/isaacg1/pyth) program that, in turn, produces, using nested lists, the nested set given by S(n), where:
>
> *S(0) = ∅*
>
> *S(n+1) = S(n) ∪ {S(n)}*
>
>
>
S(n) giving the set representation of the corresponding [ordinal number](http://en.wikipedia.org/wiki/Ordinal_number).
Using the list representation required by this question, this gives (as the final output from the generated Pyth program):
```
0->[]
1->[[]]
2->[[],[[]]]
3->[[],[[]],[[],[[]]]]
```
Etc.
Again, the challenge is to write a program in another language for generating the corresponding Pyth program.
This is code golf, so shortest full program wins.
[Answer]
# Pyth, 11 10 bytes
```
"u+G]G"z\]
```
*"Answers must be at least 30 characters."*
] |
[Question]
[
**This question already has answers here**:
[Convert a bytes array to base64](/questions/26584/convert-a-bytes-array-to-base64)
(13 answers)
Closed 8 years ago.
Write two functions of one line each that can encode and decode base64.
* Use any language you want, but if the language can naturally be converted to a single line (e.g. javascript) then any block of code separated by an end-of-line character is counted as a line.
* The functions must be self-contained. They cannot reference outside variables or imported libraries, with the exception of a single input argument.
* Expanding on the previous point, you cannot define constants or variables for use inside the function. For instance, if your function references `alphabet` as the collection of base64 symbols, replace every instance of `alphabet` with a literal of the same value.
* The functions must be one line each, not counting the function definition itself. For example, in languages like Visual Basic, functions are a minimum of three lines due to the beginning and end lines being a required part of the function definition. This is acceptable as long as the code that does the base64 conversion is only one line.
* Do not use built in functions such as javascript's `atob` or `btoa`.
Here's my functions written in python. I can't find a way to make these smaller.
```
def tobase64(m):
return ''.join(['ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'[int(z[::-1].zfill(6)[::-1],2)] for z in [''.join([bin(ord(x))[2:].zfill(8)for x in m])[y:y+6] for y in range(0,len(m)*8,6)]])+''.join(['=' for x in range(-len(m)%3)])
```
and the decoder
```
def fromb64(m):
return ''.join([chr(int(w,2)) for w in [(''.join([''.join([bin('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.index(x))[2:].zfill(6) for x in m if x in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'])[y:y+8] for y in range(0,len(''.join([bin('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.index(x))[2:].zfill(6) for x in m if x in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'])),8)])+'a')[:-(len(m)-len(m.replace('=','')))*2-1][z:z+8] for z in range(0,len(''.join([bin('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.index(x))[2:].zfill(6) for x in m if x in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'])),8)] if len(w) == 8])
```
[Answer]
## Python 2, 437 characters
As a first improvement to your Python solution, you can cut down on the references to the long string of characters 'abc...ABC...0123456789+/':
```
def fromb64(m):
return (lambda A:''.join([chr(int(w,2)) for w in [(''.join([''.join([bin(A.index(x))[2:].zfill(6) for x in m if x in A])[y:y+8] for y in range(0,len(''.join([bin(A.index(x))[2:].zfill(6) for x in m if x in A])),8)])+'a')[:-(len(m)-len(m.replace('=','')))*2-1][z:z+8] for z in range(0,len(''.join([bin(A.index(x))[2:].zfill(6) for x in m if x in A])),8)] if len(w)==8]))('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')
```
This is just (lambda A: {{what you did, but with that string replaced by A}})(that string).
] |
[Question]
[
**This question already has answers here**:
[Solving Mastermind in 6 or less moves](/questions/5226/solving-mastermind-in-6-or-less-moves)
(3 answers)
Closed 9 years ago.
This is a code golf challenge to see the shortest implementation of an automated guesser in the pen and paper game [bulls and cows](http://en.wikipedia.org/wiki/Bulls_and_cows).
The game works as follows:
A (usually 4 digit) secret code with only distinct integers 0-9 is picked by one player. A second player guesses codes that each receive a rank. This rank contains 1 bull for every digit that is correctly placed in the guess, and 1 cow for every digit in the guess that is in the secret code, but not in the correct location within the code.
The code should assume a format as follows:
* The combination will be a 4 digit number containing only distinct digits 0-9. (eg. 0123 is valid, 0112 is not)
* After each guess, you will be given a string as a response telling you how many bulls and how many cows are in your answer. It will be formatted as xByC, in which x is the number of bulls and y is the number of cows. (i.e. 4B0C means you have won). You can assume that a made-up method called "rateGuess", which takes your guess as a string will provide the response.
[Answer]
# [Pyth](http://pyth.herokuapp.com) - 11 bytes
This will *eventually* guess the correct answer. On average 2500 tries. Literally just takes random guesses no matter what the input is. Since you can't define rateGuess in pyth just takes (uneeded) input from stdin and outputs to stdout.
```
Ofql{T4^UT4
O Pick random
f filter
ql{T4 set length is four (checks for duplicates)
^ 4 Caretesian product with 4 repeats
UT Unary range till 10
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 9 years ago.
[Improve this question](/posts/41666/edit)
The goal is to find a way better than the current best known way of encoding the index of a child HTML element, so that encoded indices have the following property.
```
if (index_i >= index_p) {
assert(encoding(index_i).indexOf(encoding(index_p)) == 0);
}
if (index_i < index_p) {
assert(encoding(index_i).indexOf(encoding(index_p)) !== 0);
}
```
The current best known way of doing this is with a form of unary encoding (without the usual trailing zero. So, for example, when `index_p = 10`:
* `encoding(index_p) == "11111111111"` true
* `index_i = 9; encoding(index_i) == "1111111111"` true
* `"11111111111".indexOf("1111111111") !== 0` true
* `"1111111111".indexOf("11111111111") == 0` true
**Application**
An application of this is being able to use `document.querySelectorAll` for obtaining all child elements "greater than" a certain index, via utilisation of the "starts with" attribute selector, `^=`.
For example, if we have a set of 100 div elements, and each div element has been given an attribute `ei` equal to its encoded index value. If our goal is to obtain a list of the **last 51** of div elements, one way to do this is to request:
`document.querySelectorAll('div[ei^='+Array(50).join("1")+']');`
However, if we have interesting numbers of divs (1000, 10000), then we use a lot of memory storing these attribute indexes. So we get the typical "memory" vs "speed" tradeoff for setting up this indexing system.
The question is : **is there a way to do the same thing, using an encoded index, such that it is shorter than this pseudo-unary version?**
***Motivation***
One motivation that contributes to this question post here is the following subtle point: the elements may not necessarily be in the indexed order.
This unusual occurrence is by no means something that one would expect in ordinary use of the DOM, but if we are absolutely positioning the elements based on their indices, and we are swapping, inserting and deleting the elements, then it is possible to have a meaningful piece of HTML where document order is actually not related to the rendering order that ends up meaning something to somebody. And in such a case, we may still need to look at a range of elements, such as, all elements with an index larger than 72, and with an indexing method with properties like those described above, then we can use the starts with attribute selector to gather together this set.
[Answer]
You could always try something of the form
```
<tag h="111" t="11111" o="1">
```
where you use your unary encoding for each of the hundreds (`h`), tens (`t`) and ones (`o`) attributes.
A greater-than CSS selector would then look like
```
tag[h^="1111"],tag[h="111"][t^="111111"],tag[h="111"][t="11111"][o^="1"] { ... }
```
but frankly, if your tags are just retaining some property that persists in spite of reordering, etc., why not just run a script that selects the last `n` marked tags on DOM load and assigns the class `iamlast`, then use the `.iamlast` CSS selector?
] |
[Question]
[
**This question already has answers here**:
[Basic Algebraic Expansion](/questions/33248/basic-algebraic-expansion)
(3 answers)
Closed 9 years ago.
I was annoyed the other day when I got a point off in math class because I didn't distribute the factors of my function.
That is, I put (x+2)(x-3) when I should have put x^2 - x - 6.
Your job is to write a program that takes a string with the expression and convert it to the expanded form so I don't miss future points.
## Rules
* Any letters within the lowercase English alphabet can be used as "x" (for example: (a+1)(c+3)).
* All exponents in answer must be in the form (variable)^n where n is the power
* variables can be assumed to be 1 character long. That is, ab == a \* b
* Your answer should not contain the "\*" character
* The spaces before and after a + or - must be present. Otherwise, no spaces are permitted, except for trailing spaces.
* You must account for exponents outside of parentheses, so (x+1)^n.
## Specifications
* You may create a program or function that takes a string parameter
* Your program must output the correct expression to STDOUT or a text file
* You may assume that all factors will be surrounded by parentheses. For example, x(x+1) will always be (x)(x+1).
* There will never be any other operation besides multiplication between parenthesis. This will never happen: (x)+(x+1).
* You may assume there will never be any nested parentheses/exponents.
* Order of the resulting expression should be highest exponents first, as per usual math standards. Otherwise, order does not matter.
* You may assume single digit exponents
* Built in expansion libraries/functions are not allowed, as the comments mention below
## Examples
```
(x+1)(x+2) --> x^2 + 3x + 2
(a)(a-4) --> a^2 - 4a
(c+1)^3 --> c^3 + 3c^2 + 3c + 1
(a+1)(f-2) --> af - 2a + f - 2
(x-2)(x+4)(x-5)(x+10) --> x^4 + 7x^3 - 48x^2 - 140x + 400
(x+a+c)(b+g) --> xb + xg + ab + ag + cb + cg
(r+4)^2(b) --> br^2 + 8br + 16b
```
This is code-golf, so shortest program wins!
## Bonus
-25 bytes to anyone who makes their program compatible with [complex numbers](http://en.wikipedia.org/wiki/Complex_number)
[Answer]
# JavaScript (E6) 834
While waiting for some clarification by OP, I start recycling my answer from [this other question](https://codegolf.stackexchange.com/questions/33248/basic-algebraic-expansion)
It's more than what is required here, so it could be golfed more.
I have modified the spacing and added sorting by higher exponent (of any variable).
```
G=x=>x.replace(/\d/g,n=>' '.repeat(n-2)).length,
K=x=>Object.keys(x).sort((a,b)=>G(b)-G(a)),
A=(p,q,s,t,c)=>[(c=(s+1)*q[t]+~~p[t])?p[t]=c:delete(p[t])for(t in q)],
M=(p,q,t,c,o,u,f,r,v={})=>([A(v,(r={},[(c=p[f]*q[t])&&(r[o={},(u=f+t)&&(u.match(/[a-z]\^?\d*/ig).map(x=>o[x[0]]=~~o[x[0]]+(~~x.slice(2)||1)),K(o,u=k).map(i=>u+=o[i]>1?i+'^'+o[i]:i)),u]=c)for(f in p)],r),k)for(t in q)],v),
E=(p,n)=>--n?M(p,E(p,n)):p,
O=n=>{for(l=0;h(o=s.pop())>=h(n);)a=w.pop(b=w.pop()),o=='*'?a=M(a,b):o>d?a=E(a,b[k]):A(a,b,o),w.push(a);s.push(o,n)},
X=e=>(l=k='',w=[],s=[d='@'],h=o=>'@)+-*^('.indexOf(o),
(e+')').match(/\D|\d+/g).map(t=>(u=h(t))>5?(l&&O('*'),s.push(d)):u>1?O(t):~u?s.pop(s.pop(O(t)),l=1):(l&&O('*'),l=1,w.push(v={}),t<d?v[k]=t|0:v[t]=1)),
K(p=w.pop()).map(i=>(k+=(c=p[i])>1?s+c+i:c<-1?c+i:(c-1?'-':s)+(i||1),s=' + ')),k.replace(/-/g,' - ')||0)
```
**Test** in FireFox/FireBug console
```
;["(x+1)(x+2)","(a)(a-4)","(c+1)^3","(a+1)(f-2)","(x-2)(x+4)(x-5)(x+10)","(x+a+c)(b+g)","(r+4)^2(b)"]
.map(x => console.log(x + " -> " + X(x)))
```
*Output*
```
(x+1)(x+2) -> x^2 + 3x + 2
(a)(a-4) -> a^2 - 4a
(c+1)^3 -> c^3 + 3c^2 + 3c + 1
(a+1)(f-2) -> af + f - 2a - 2
(x-2)(x+4)(x-5)(x+10) -> x^4 + 7x^3 - 48x^2 - 140x + 400
(x+a+c)(b+g) -> xb + ab + cb + xg + ag + cg
(r+4)^2(b) -> r^2b + 8rb + 16b
```
[Answer]
## Mathematica 11-25=-14 40-25=15 characters
Really too easy in this language:
```
f=TraditionalForm@Expand@ToExpression@#&
```
Usage:
```
f["(x+2)(x-3)"]
```
Output:
x2 - x - 6
And it's even shorter if you allow input that isn't a string (and don't care about term order):
```
f=Expand@ToExpression@#&
```
Used as follows for the same output:
```
f[(x+2)(x-3)]
```
Mathematica can natively support complex numbers.
EDIT: technically this answer fails because it will take ab (without spaces) as a single variable instead of a\*b as per the rules.
EDIT2:Changed so it will output in the required order
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/26067/edit).
Closed 9 years ago.
[Improve this question](/posts/26067/edit)
Example given an image which width and height is a power of two .
**First step :** Divide each image into Cartesian coordinate quadrants
```
_____ _____
| | |
| 2 | 1 |
|_____|_____|
| | |
| 4 | 3 |
|_____|_____|
```
**Second step :** Divide each quadrant to another four quadrants and add new quadrant id after the old one , like this :
```
_____ _____ _____ _____
| | | | |
| 22 | 21 | 12 | 11 |
|_____|_____|_____|_____|
| | | | |
| 23 | 24 | 13 | 14 |
|_____|_____|_____|_____|
| | | | |
| 32 | 31 | 42 | 41 |
|_____|_____|_____|_____|
| | | | |
| 33 | 34 | 43 | 44 |
|_____|_____|_____|_____|
```
**And so on...**
```
_____ _____ _____ _____ _____ _____ _____ _____
| | | | | | | | |
| 222 | 221 | 212 | 211 | 122 | 121 | 112 | 111 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 223 | 224 | 213 | 214 | 123 | 124 | 113 | 114 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 232 | 231 | 242 | 241 | 132 | 131 | 142 | 141 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 233 | 234 | 243 | 244 | 133 | 134 | 143 | 144 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 322 | 321 | 312 | 311 | 422 | 421 | 412 | 411 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 323 | 324 | 313 | 314 | 423 | 424 | 413 | 414 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 332 | 331 | 342 | 341 | 432 | 431 | 442 | 441 |
|_____|_____|_____|_____|_____|_____|_____|_____|
| | | | | | | | |
| 333 | 334 | 343 | 344 | 433 | 434 | 443 | 444 |
|_____|_____|_____|_____|_____|_____|_____|_____|
```
**Until number of quadrants is equal to the number of pixels**
Should return a 2d array of quadruple coordinates .
Inspired from : <https://i.stack.imgur.com/Ib88h.jpg>
[Answer]
## Mathematica, ~~95~~ 86 bytes
Since the method of input has not been specified, I'm simply expecting the resolution to be saved as an integer in the variable `n`
```
r={{""}};Do[r=ArrayFlatten[r/.q_String:>{{q<>"2",q<>"1"},{q<>"3",q<>"4"}}],{Log2@n}];r
```
With indentation:
```
r = {{""}};
Do[
r = ArrayFlatten[
r /. q_String :> {{q <> "2", q <> "1"}, {q <> "3", q <> "4"}}
],
{Log2@n}
];
r
```
] |
[Question]
[
**This question already has answers here**:
[Twinkle Twinkle Little Star](/questions/272/twinkle-twinkle-little-star)
(19 answers)
Closed 10 years ago.
Try to regenerate the olympic theme song, "Bugler's Dream" using the programming language of your choice. The language/platform used must be able to emit the physical sound. Only playing the main melody (trumpets) is required, but doing more would be great.
You must generate all the tones yourself - you cannot play back a midi/wav or any other sound file.
Here are the sound files for reference:
<http://www.jonfullmer.com/music-of-the-month/buglers_dream/buglers_dream.mp4>
<http://www.armory.com/~keeper/1/bugdream.mid>
Good luck!
[Answer]
# Mathematica 2576
**Code**
```
Sound[{{d, {0., 1.2}}, {a, {0., 1.2}}, {e, {0., 1.2}}, {f, {1.2, 2.2}}, {e, {1.2, 2.2}}, {e, {2.2, 2.4}}, {f, {2.2, 2.4}}, {a, {2.4, 3.}}, {c, {2.4, 3.}}, {b, {3., 3.6}}, {e, {3., 3.6}}, {d, {3.6, 4.2}}, {a, {3.6, 4.2}}, {e, {3.6, 4.2}}, {a, {4.2, 4.8}}, {c, {4.2, 4.8}}, {b, {4.8, 5.4}}, {e, {4.8, 5.4}}, {b, {5.4, 5.8}}, {e, {5.4, 5.8}}, {b, {5.8, 6.}}, {e, {5.8, 6.}}, {b, {6., 6.6}}, {e, {6., 6.6}}, {d, {6.6, 6.9}}, {a, {6.6, 6.9}}, {b, {6.9, 7.2}}, {e, {6.9, 7.2}}, {c, {7.2, 7.5}}, {a, {7.2, 7.5}}, {a, {7.5, 7.6}}, {c, {7.5, 7.6}}, {b, {7.6, 7.8}}, {e, {7.6, 7.8}}, {d, {7.8, 8.1}}, {a, {7.8, 8.1}}, {a, {8.1, 8.4}}, {c, {8.1, 8.4}}, {b, {8.4, 9.6}}, {e, {8.4, 9.6}}, {d, {9.6, 10.8}}, {a, {9.6, 10.8}}, {e, {9.6, 10.8}}, {f, {10.8, 11.8}}, {e, {10.8, 11.8}}, {e, {11.8, 12.}}, {f, {11.8, 12.}}, {a, {12., 12.6}}, {c, {12., 12.6}}, {b, {12.6, 13.2}}, {e, {12.6, 13.2}}, {d, {13.2, 13.8}}, {a, {13.2, 13.8}}, {e, {13.2, 13.8}}, {a, {13.8, 14.4}}, {c, {13.8, 14.4}}, {b, {14.4, 15.}}, {e, {14.4, 15.}}, {b, {15., 15.4}}, {e, {15., 15.4}}, {b, {15.4, 15.6}}, {e, {15.4, 15.6}}, {b, {15.6, 16.2}}, {e, {15.6, 16.2}}, {d, {16.2, 16.5}}, {a, {16.2, 16.5}}, {b, {16.5, 16.8}}, {e, {16.5, 16.8}}, {c, {16.8, 17.1}}, {a, {16.8, 17.1}}, {a, {17.1, 17.2}}, {c, {17.1, 17.2}}, {b, {17.2, 17.4}}, {e, {17.2, 17.4}}, {d, {17.4, 17.7}}, {a, {17.4, 17.7}}, {a, {17.7, 18.}}, {c, {17.7, 18.}}, {e, {18., 19.2}}, {a, {18., 19.2}}, {c, {18., 19.2}}, {d, {19.2, 20.4}}, {a, {19.2, 20.4}}, {e, {19.2, 20.4}}, {f, {20.4, 21.4}}, {e, {20.4, 21.4}}, {e, {21.4, 21.6}}, {f, {21.4, 21.6}}, {a, {21.6, 22.2}}, {c, {21.6, 22.2}}, {b, {22.2, 22.8}}, {e, {22.2, 22.8}}, {d, {22.8, 23.4}}, {a, {22.8, 23.4}}, {e, {22.8, 23.4}}, {a, {23.4, 24.}}, {c, {23.4, 24.}}, {b, {24., 24.6}}, {e, {24., 24.6}}, {b, {24.6, 25.1}}, {e, {24.6, 25.1}}, {b, {25.1, 25.2}}, {e, {25.1, 25.2}}, {b, {25.2, 25.8}}, {e, {25.2, 25.8}}, {d, {25.8, 26.1}}, {a, {25.8, 26.1}}, {b, {26.1, 26.4}}, {e, {26.1, 26.4}}, {c, {26.4, 26.7}}, {a, {26.4, 26.7}}, {a, {26.7, 26.9}}, {c, {26.7, 26.9}}, {b, {26.9, 27.}}, {e, {26.9, 27.}}, {d, {27., 27.3}}, {a, {27., 27.3}}, {a, {27.3, 27.6}}, {c, {27.3, 27.6}}, {b, {27.6, 28.8}}, {e, {27.6, 28.8}}, {d, {28.8, 30.}}, {a, {28.8, 30.}}, {e, {28.8, 30.}}, {f, {30., 31.}}, {e, {30., 31.}}, {e, {31., 31.2}}, {f, {31., 31.2}}, {a, {31.2, 31.8}}, {c, {31.2, 31.8}}, {b, {31.8, 32.4}}, {e, {31.8, 32.4}}, {d, {32.4, 33.}}, {a, {32.4, 33.}}, {e, {32.4, 33.}}, {a, {33., 33.6}}, {c, {33., 33.6}}, {b, {33.6, 34.2}}, {e, {33.6, 34.2}}, {b, {34.2, 34.7}}, {e, {34.2, 34.7}}, {b, {34.7, 34.8}}, {e, {34.7, 34.8}}, {b, {34.8, 35.4}}, {e, {34.8, 35.4}}, {d, {35.4, 35.7}}, {a, {35.4, 35.7}}, {b, {35.7, 36.}}, {e, {35.7, 36.}}, {c, {36., 36.3}}, {a, {36., 36.3}}, {a, {36.3, 36.4}}, {c, {36.3, 36.4}},{b, {36.4, 36.6}}, {e, {36.4, 36.6}}, {d, {36.6, 36.9}}, {a, {36.6, 36.9}}, {a, {36.9, 37.2}}, {c, {36.9, 37.2}}, {e, {37.2, 38.4}}, {a, {37.2, 38.4}}, {c, {37.2, 38.4}}}
/. {n_, t_} :> SoundNote[n, Round[t, .1], "Trumpet", SoundVolume -> 0.7]]
/. {a -> "C#5", b -> "D#5", c -> "F4", d -> "F5", e -> "G#4", f -> "G#5"}
```
---
## Output
Bugler's Dream, Trumpet track.
---
## Saving to file
```
Export["bugler.mid", bugler]
```
>
> bugler.mid
>
>
>
] |
[Question]
[
For this challenge, write program `A` that when given no input, prints the code for `A` (a quine), but when given input, the output will be modified. The input for `A` will be 0 or more statements in whichever language `A` is programmed. The output of `A` will be the code for program `B` which runs the input to `A` and then does the function of `A`. If the input to `A` ends with a comment, then `B` will only run the input of `A`.
---
Example: (assume that the source is `main=makeAQuine` in Haskell)
*
input: none
output: `main=makeAQuine`
*
input: `putStrLn"Hello, world!"`
output: `main=putStrLn"Hello, world!">>makeAQuine`
*
input: `{-`
output: `main=return`
*
input: `putStr"Hello, world!!"{-`
output: `main=putStr"Hello, world!!"`
---
Whoever has the fewest bytes/chars wins, but you can subtract 20 from your count for each of
* Comment Freindly: Accepts line-comments *and* block-comments
* Multiline Input: Accepts more than one statement as input
[Answer]
# Python, 83 (- Comment Bonus)
```
import sys;v=sys.argv
for a in v[1:]:print(a)
if v[-1].find('#')>=0:quit()
print(open(__file__).read())
```
If the source is ASCII and line endings are '\n', it's 103 bytes long.
There are issues that make me unsure about how many comment bonus points it would get, or if it's a complete answer at all.
* it uses '#' to detect a comment in the last argument, which:
+ only detects line comments
+ detects '#' as a comment even if it's inside a string, which is wrong.
* if the arguments contain an unfinished string comment (which, if triple-quoted, is as close as it gets to a block comment), running B indeed will only execute A's input, but then finish with a SyntaxError.
It does, however, accept an arbitrary number of input statements, so it gets at least 20 bonus if it is a valid answer.
[Answer]
# Befunge '98, 74
There are no comments in Befunge, so I guess I can't subtract those 20. On the other hand, you can pass as many Befunge statements as you like, so I get that 20. Actual length of the code is 94.
```
0>:#;1+:0gff2++-#;_01-0pac+:y+>:#;1+:y#;_1->:#;1+::y:!j,#;_#;1+:y\1-\#;_0>:0#;g,1+:01-0g`!#;_@
```
Two things to note:
* if the input contains spaces, program B will not behave correctly, because the first part of A scans east from (0,0) until it finds a space, to determine the code's length. You can pass several arguments separated by spaces, but no arguments containing spaces like "why not".
* Befunge is a 2D language, but this quine only handles linear input correctly. With 2D input, B will only be able to execute A if the input ends at its last line, execution flowing east. Even then, A in B will only output the first line of B.
However, AFAIK it's not possible to pass command line arguments containing newlines?
Using one character more (and a LOT of time and memory), we can instead scan west until we wrap around and find the eastern-most non-space, which produces correct (but equally slow) B even if A gets input containing spaces:
```
0>:#;1-:0gff2++-!#;_01-0pac+:y+>:#;1+:y#;_1->:#;1+::y:!j,#;_#;1+:y\1-\#;_0>:0#;g,1+:01-0g`!#;_@
```
## Explanation:
1. `0>:#;1+:0gff2++-#;_` ensures that a 0 is on top of the stack, duplicates TOS, skips the `;`, increments TOS, gets cell (TOS, 0), subtracts 32 (`' '`) from its content, skips the next `;`, turns west if not 0 (was not a space). Heading west, it skips over `:#;...;` and turns back east at the `>`.
2. `01-0pac+:y+` puts the determined length to cell (-1, 0), calculates 22 and executes `y` to get the number of stacks, adds that to the 22, resulting in the correct argument to `y` for obtaining the size of the top-most stack, after which `y` would return the args. Using this method, B will operate correctly even if B creates more stacks before A in B executes.
3. `>:#;1+:y#;_1-` duplicates the incremented previous result (now pointing to the first char of args), gets a char using `y`, and repeats until that char is '\0'. This is to skip the first argument (which is the file name of the program). Finally, it decrements the counter so that the following code will find the same '\0' again.
4. `>:#;1+::y:!j,#;_` does much the same thing as step 3.), ie. it reads one argument through `y`, but it prints each char of it except the delimiting '\0'.
5. `#;1+:y\1-\#;_` checks if there follows another '\0' and in case there isn't, it decrements the counter so that the first character of each argument doesn't get truncated, and goes west, skipping over `:#;...;_#;...;`, back to step 4.)
6. ```
0>:0#;g,1+:01-0g`!#;_@
```
initializes a new TOS counter to 0, then enters a loop to get cell (TOS, 0), print it, increment the counter, get cell (-1, 0) and terminate if that's less than the counter, else repeat.
[Answer]
## JavaScript, 25
65 characters, minus 40 bonus points. Complete with abuse of `escape`! \o/
```
(_=$=>eval(prompt()+";alert(unescape('(_="+escape(_)+")()'))"))()
```
But for fewer characters, shell is always good.
## zsh, −28
```
cat|zsh
<$0
```
[Answer]
## [GTB](http://timtechsoftware.com/gtb "GTB"), 12
```
`_~_+":prgmA
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** [Update the question](/posts/7142/edit) so it's [on-topic](/help/on-topic) for Code Golf Stack Exchange.
Closed 11 years ago.
[Improve this question](/posts/7142/edit)
I am trying my hand at writing super small programs. I wrote a simple "tree" display program for showing a graphical representation of a folder hierarchy. I have made it small in all the ways I can think of. I was just wondering if you guys had more creative ways to "minify" it further. Here is the small version as well as a human-readable version.
```
import os,os.path as p
def w(c,d,s):
a=os.listdir(c);s=s+'|';i=0
for f in a:
print s+'--'+f;j=p.join(c,f);
if p.isdir(j):w(j,d+1,s[:-i==len(a)-1]+' '*(d+1));i=i+1
def t(c):print c;w(c,0,'')
t(p.curdir)
```
That's a total of 236 bytes
```
import os
def treeWrap(curdir,depth,pipeStr):
files = os.listdir(curdir)
pipeStr = pipeStr + '|'
for f in files:
print pipeStr + '--' + f
if os.path.isdir(os.path.join(curdir,f)):
dir = os.path.join(curdir,f)
if files.index(f) == (len(files)-1):
treeWrap(dir,depth+1,pipeStr[:-1] + ' '*(depth+1))
else:
treeWrap(dir,depth+1,pipeStr + ' '*(depth+1))
def tree(curdir):
print curdir
treeWrap(curdir,0,'')
tree(os.path.curdir)
```
Oh, in addition, does anyone know how I can use the unicode ├,└,─ in this program? Whenever I use them they appear as garbage in the console and the idle interpreter.
[Answer]
There is a bug with your minified version: `s[:-0]` gives you the empty string, not the complete string as you anticipate with `s[:-i==len(a)-1]`. To rectify this, you will need to either ignore preceding bars or calculate the a little more thoroughly. The shorter version would be to ignore preceding bars and not worry about passing spacing to further recursions. Since it permits the removal of several variables, I worked your code to do this
Your `tree` function is only called once, I removed it.
`s=s+'|'` and `i=i+1` can be collapsed into `s+='|'` and `i+=1`
`os.path as p` can become `p=os.path` (Thanks [James](https://codegolf.stackexchange.com/users/3974/james))
`p.join(c,f)` can become `c+'/'+f` (Thanks [beary605](https://codegolf.stackexchange.com/users/4303/beary605))
New version:
```
import os,p=os.path
def w(c,d):
for f in os.listdir(c):
print ' '*(d+1)+'|--'+f;j=c+'/'+f
if p.isdir(j): w(j,d+1)
z=p.curdir;print z;w(p.curdir,0)
```
If you really wanted to go crazy, you can make put this all on one line and get it down to 143 bytes (on linux)
```
import os,p=os.path
def w(c,d):
for f in os.listdir(c):print' '*(d+1)+'|--'+f;j=c+'/'+f;w(j,d+1)if p.isdir(j)else 0
z=p.curdir;print z;w(z,0)
```
] |
[Question]
[
We need to produce a block cipher round function with a 1 bit round key size and a 7 bit message size with the highest level of cryptographic security according to our measure of security.
# Introduction
We are going to need new symmetric encryption functions. We are at the point where we cannot improve the performance of integrated circuits very much simply by shrinking transistors. Furthermore, we are approaching the limits of the energy efficiency of transistors using conventional irreversible computation. The only way to surpass these limits is to use reversible computation. But to get the most out of reversible computation, one needs to use algorithms that are designed for reversible computation. Since the AES encryption protocol was not designed for reversible computation, it is probably a good time for cryptographers to produce, evaluate, and standardize new symmetric encryption functions that are efficient on fully reversible hardware/software. And as a bonus, cryptographic functions are more resistant to side channel attacks when we run them on reversible hardware since irreversible computation not only leaks energy, but irreversible computation leaks some information that can be used to decipher what is being encrypted.
In addition to the need for new cryptographic functions, the rise of AI will bring rise to new cryptoanalytic techniques that can be used to better evaluate the security of block ciphers (this is my personal opinion based on my personal research). Cryptographers can also employ new techniques for evaluating block ciphers including the application of invariants that measure the level of cryptographic security of block ciphers and always give isomorphic block cipher round functions the same level of cryptographic security (this makes it impossible to artificially inflate the security value by relabeling all the possible messages and round keys). Spectral techniques are one way of assigning each block cipher or block cipher round function a specific number that measures its cryptographic security. In this challenge, we shall apply one of these spectral techniques to measure the cryptographic security of some very simple block cipher round functions.
The goal of this challenge is to produce a very simple block cipher round function that minimizes a measure of its cryptographic insecurity. Since this kind of block cipher round function has a microscopic 7 bit message size, it is subject to brute force attacks, and it will probably not have any practical use whatsoever, but we can still measure the level of its cryptographic security in various ways.
The participants in this challenge do not need to have prior experience with evaluating block ciphers and such prior experience may not help very much.
# Spectral radius
If \$X\$ is a matrix, then the spectral radius is the value
\$\rho(X)=\max\{|\lambda|:\lambda\,\text{is an eigenvalue of}\,X\}.\$ It is well known that \$\rho(X)=\lim\_{n\rightarrow\infty}\|X^n\|^{1/n}\$ and this limit does not depend on the matrix norm chosen.
The spectral radius of a complex matrix \$X\$ can often be easily computed. If \$v\_0\$ is an arbitrary vector and \$v\_{n+1}=\frac{Xv\_n}{\|Xv\_n\|}\$ for all \$n\$, then \$\|Xv\_n\|\$ will converge to the spectral radius \$\rho(X)\$ except in the case when \$X\$ has multiple eigenvalues with maximum absolute value.
# Challenge
Our goal is to produce a pair of permutations \$(P,Q)\$ of \$\{1,2,...,127,128\}\$ with the smallest associated spectral radius \$\rho((P\_2+Q\_2)/2)\$. The pair of permutations \$(P,Q)\$ should be thought of as the round function for a \$7\$ bit message and 1 bit round key size. If the round key is \$0\$, we perform the transformation \$x\mapsto P(x)\$ to the message \$x\$, and if the round key is \$1\$, then we perform the transformation \$x\mapsto Q(x)\$ to the message \$x\$. A lower spectral radius signifies a greater level of cryptographic security.
Let \$X=\{1,2,...,128\}\$. Let \$Y\$ be the collection of all unordered pairs of distinct elements in the set \$X\$. For example, \$Y\$ contains the pairs \$\{2,3\},\{56,57\},\{2,16\}\$ along with other pairs. The set \$Y\$ contains \$128\cdot 127/2=8128\$ elements.
If \$P\$ is a permutation of \$\{1,...,128\}\$, then the mapping \$P\$ induces a permutation \$P\_0\$ of \$Y\$ defined by letting \$P\_0(\{a,b\})=\{P(a),P(b)\}\$. Let \$U\$ be the real vector space generated by the basis \$Y\$. Let \$L\$ be the linear functional mapping \$U\$ to the field of real numbers defined by setting \$L(\{x,y\})=1\$ whenever \$x,y\$ are distinct. Let \$V=\ker(U)\$. Then \$V\$ is the subspace of \$U\$ generated by pairs \$\{u,v\}-\{x,y\}\$. We extend the mapping \$P\_0\$ to a linear operator \$P\_1:U\rightarrow U\$ by linearity. In other words,
\$P\_1(\alpha\_1\{x\_1,y\_1\}+\dots+\alpha\_n\{x\_n,y\_n\})=
\alpha\_1P\_0(\{x\_1,y\_1\})+\dots+\alpha\_nP\_0(\{x\_n,y\_n\})\$
\$=\alpha\_1\{P(x\_1),P(y\_1)\}+\dots+\alpha\_n\{P(x\_n),P(y\_n)\}.\$ Let \$ P\_2:V\rightarrow V\$ be the restriction of the operator \$P\_1\$. The operator \$P\_2\$ is the unique linear operator from \$V\$ to \$V\$ where
\$ P\_2(\{u,v\}-\{x,y\})=P\_1(\{u,v\})-P\_1(\{x,y\})\$ whenever \$\{u,v\},\{x,y\}\in Y\$
Our goal is to minimize the spectral radius \$\rho((P\_2+Q\_2)/2)\$ of the average \$(P\_2+Q\_2)/2\$.
Given a pair of permutations \$P,Q\$ of \$\{1,2,...,127,128\}\$, set
we produce a Markov chain on the set \$\{\{x,y\}:x,y\in\{1,\dots,127,128\},x\neq y\}\$ where we transition from \$\{x,y\}\$ to \$\{P(x),P(y)\}\$ with probability \$1/2\$ and from \$\{x,y\}\$ to \$\{Q(x),Q(y)\}\$ with probability \$1/2\$. This Markov chain is associated with a double stochastic matrix \$A\$. The doubly stochastic matrix \$A\$ has spectral radius \$1\$, but the second largest absolute value of an eigenvalue of \$A\$ measures how quickly powers \$A^n\$ of \$A\$ converge to the matrix where each entry is equal to each other. In other words, the second largest absolute value of an eigenvalue of \$A\$ measures how quickly iterating steps in the Markov chain approaches the uniform Markov chain. The second largest absolute value of an eigenvalue of \$A\$ is just the spectral radius \$\rho((P\_2+Q\_2)/2)\$.
The averaging operator \$(P\_2+Q\_2)/2\$ satisfies a weak version of the circular law; the eigenvalues of \$(P\_2+Q\_2)/2\$ should be non-uniformly distributed on the disk centered at zero with radius \$\sqrt(2)/2\$. Furthermore, if the permutations \$P,Q\$ are good enough, then the spectral radius of \$(P+Q)/2\$ should be approximately \$\sqrt(2)/2\$.
# Computing the spectral radius
One can easily use power iteration to compute the spectral radius of a sparse matrix except for one tiny but manageable problem. The matrix \$(P\_2+Q\_2)/2\$ will be a real matrix, and the eigenvalues of real matrices will be symmetric around the real number line. This means that imaginary eigenvalues of real matrices must always come in pairs. Now, since the real number line has zero area and since the eigenvalues of \$(P\_2+Q\_2)/2\$ satisfy the a sort of circular law (but for \$(P\_2+Q\_2)/2\$ the eigenvalues somewhat cluster near the boundary of the disk due to the unitarity of \$P\_2,Q\_2\$), the matrix \$(P\_2+Q\_2)/2\$ is more likely to have a pair of conjugate dominant eigenvalues rather than a single real dominant eigenvalue. One can instead use the Arnoldi iteration (which is a more advanced version of the power iteration) in order to find the dominant eigenvalue and spectral radius of \$(P\_2+Q\_2)/2\$.
# Format
In your answer, please specify the permutations P,Q that you use along with the spectral radius of \$(P\_2+Q\_2)/2\$ (which should be around \$\sqrt{2}/2\$).
There are two ways that you can specify your permutations.
1. You may write your permutations as tables. For example, `[4,5,6,1,2,3,7,8]` will denote the permutation of {1,...,7,8} where 1->4,2->5,3->6,4->1,5->2,6->3,7->7,8->8.
2. You may also write your permutations as products of disjoint cycles. For example, `(2,6)(3,7)(1,4,8,5)` will denote the permutation of {1,...,7,8} where 2->6,6->2,3->7,7->3,1->4,4->8,8->5,5->1.
# Sample answer (with reduced key size).
Here is a sample answer where (for simplicity) the permutation \$P\$ takes \$5\$ bits as input and out rather than \$7\$ bits (\$P\$ is a permutation of \$\{1,\dots,31,32\}\$).
P:`(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26)(27,28,29)(30,31)`
Q:`(1,31,29,23,27,12,16,8,6,10,17,2,9,5,24,11,14,7,30,4,19,32,26,15,3,20)(13,18,21,22,28)`
P:`[ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1, 28, 29, 27, 31, 30,32]`
Q:`[ 31, 9, 20, 19, 24, 10, 30, 6, 5, 17, 14, 16, 18, 7, 3, 8, 2, 21, 32, 1, 22, 28, 27, 11, 25, 15, 12, 13, 23, 4, 29,
26 ]`
Loss: \$\rho((P\_2+Q\_2)/2)\$=0.705873796001...
Observe that the loss is less than \$\sqrt{2}/2\$ but not by much. For this example, I made a moderate effort to minimize the value \$\rho((P\_2+Q\_2)/2)\$
We observe that the permutations \$P,Q\$ are uninterpretable, so for these permutations, no information about the algorithm used to produce \$P,Q\$ can be gained from the permutations \$P,Q\$ themselves. Here, the answerers are encouraged to post the code/pseudocode used for generating the permutations \$P,Q\$ or a description of the algorithm or technique used to produce \$P,Q\$.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 5 months ago.
[Improve this question](/posts/265087/edit)
There is a question to basically find the largest sum in an array, such that no two elements are chosen adjacent to each other. The concept is to recursively calculate the sum, while considering and not considering every element, and skipping an element depending on whether the previous element was selected or not.
I understand that this problem requires the use of Dynamic Programming, but doing so still gives me a TLE. Although my code is very similar to the solution code, I cannot figure out why am I getting a TLE (>1.9 seconds).
Here is my code:
```
class Solution{
public:
long long dp[1010][510];
long long maxSum(vector<int> &B, int K, int N, int i){
if (K == 0) return 0;
else if(i >= N){
return INT_MIN;
}
else{
if (dp[i][K] != INT_MIN) return dp[i][K];
dp[i][K] = max(maxSum(B, K, N, i+1), B[i] + maxSum(B, K-1, N, i+2));
return dp[i][K];
}
}
long long maximumBeauty(int N, int K, vector<int> &B){
int i = 0;
for (int i = 0; i<1010; i++){
for (int j = 0; j<510; j++){
dp[i][j] = INT_MIN;
}
}
return maxSum(B, K, N, i);
}
};
```
and here is the given solution:
```
class Solution{
public:
long long dp(int i, int j, int N, int K, vector<int> &B,
vector<vector<long long>> &cache){
if(j >= K){
return 0;
}
if(i >= N){
return -1e15;
}
if(cache[i][j] != -1e18){
return cache[i][j];
}
cache[i][j] = max((long long )B[i] + dp(i + 2, j + 1, N, K, B, cache),
dp(i + 1, j, N, K, B, cache));
return cache[i][j];
}
long long maximumBeauty(int N, int K, vector<int> &B){
vector<vector<long long>> cache(N, vector<long long> (K, -1e18));
long long ans = dp(0, 0, N, K, B, cache);
return ans;
}
};
```
I've tried initialising the DP array to different values, and calculate the sum individually and then compute the max, but I'm still getting a TLE. Please help me figure out the reason for getting a TLE in the first code.
]
|
[Question]
[
The ***[Catalan numbers](https://en.wikipedia.org/wiki/Catalan_number)*** ([OEIS](https://oeis.org/A000108)) are a sequence of natural numbers often appearing in combinatorics.
The nth Catalan number is the number of Dyck words (balanced strings of parenthesis or brackets such as `[[][]]`; formally defined as a string using two characters `a` and `b` such that any substring starting from the beginning has number of `a` characters greater than or equal to number of `b` characters, and the entire string has the same number of `a` and `b` characters) with length `2n`. The nth Catalan number (for \$n\ge0\$) is also explicitly defined as:
$$C\_n=\frac1{n+1}\binom{2n}n$$
Starting from \$n=0\$, the first 20 Catalan numbers are:
```
1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190...
```
# Challenge
Write a full program or function that takes a non-negative integer `n` via STDIN or an acceptable alternative, and outputs the nth Catalan number. Your program must work at minimum for inputs `0-19`.
## I/O
### Input
Your program must take input from STDIN, function arguments or any of the acceptable alternatives [per this meta post.](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) You can read the inputted number as its standard decimal represention, unary representation, or bytes.
* If (and only if) your language cannot take input from STDIN or any acceptable alternative, it may take input from a hardcoded variable or suitable equivalent in the program.
### Output
Your program must output the nth Catalan number to STDOUT, function result or any of the acceptable alternatives [per this meta post.](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) You can output the Catalan number in its standard decimal representation, unary representation or bytes.
The output should consist of the approriate Catalan number, optionally followed by one or more newlines. No other output can be generated, except constant output of your language's interpreter that cannot be suppressed (such as a greeting, ANSI color codes or indentation).
---
This is not about finding the language that is the shortest. This is about finding the shortest program in every language. Therefore, I will not accept an answer.
In this challenge, languages newer than the challenge are acceptable **as long as they have an implementation.** It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language. Other than that, all the standard rules of [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") must be obeyed. Submissions in most languages will be scored in bytes in an appropriate preexisting encoding (usually UTF-8). Note also that built-ins for calculating the nth Catalan number are allowed.
# Catalog
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 66127; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>
```
[Answer]
## C, ~~78~~ ~~52~~ ~~39~~ ~~34~~ 33 bytes
Even more C magic (thanks xsot):
```
c(n){return!n?:(4+6./~n)*c(n-1);}
```
`?:` [is a GNU extension](https://stackoverflow.com/a/2806311).
---
This time by expanding the recurrence below (thanks xnor and Thomas Kwa):
$$
\begin{equation}
\begin{split}
C\_0 & = 1 \\
C\_n & = \frac{2 (2n - 1)}{n + 1} C\_{n - 1} \\
& = \frac{2 (2n+2-3)}{n+1} C\_{n - 1} \\
& = 2 \left(2\frac{n+1}{n+1} - \frac{3}{n+1}\right) C\_{n - 1} \\
& = \left(4 - \frac{6}{n+1}\right) C\_{n - 1}
\end{split}
\end{equation}
$$
```
c(n){return n?(4+6./~n)*c(n-1):1;}
```
`-(n+1)` is replaced by `~n`, which is equivalent in two's complement and saves 4 bytes.
---
Again as a function, but this time exploiting the following recurrence:
$$
\begin{equation}
\begin{split}
C\_0 & = 1 \\
C\_n & = \frac{2 (2n - 1)}{n + 1} \cdot C\_{n - 1}
\end{split}
\end{equation}
$$
```
c(n){return n?2.*(2*n++-1)/n*c(n-2):1;}
```
`c(n)` enters an infinite recursion for negative `n`, although it's not relevant for this challenge.
---
Since calling a function seems an acceptable alternative to console I/O:
```
c(n){double c=1,k=2;while(k<=n)c*=1+n/k++;return c;}
```
`c(n)` takes an `int` and returns an `int`.
---
Original entry:
```
main(n){scanf("%d",&n);double c=1,k=2;while(k<=n)c*=1+n/k++;printf("%.0f",c);}
```
Instead of directly calculating the definition, the formula is rewritten as:
$$
\begin{equation}
\begin{split}
\frac{1}{n + 1} {2n \choose n} &= \frac{(2n)!}{(n!)^2 \cdot (n + 1)} \\
& = \frac{2n \cdot \ldots \cdot (n + 1)}{n! \cdot (n + 1)} \\
& = \frac{1}{n + 1} \cdot \frac{\prod\_{k = 1}^n (n + k)}{\prod\_{k = 1}^n k} \\
& = \frac{1}{n + 1} \cdot \prod\_{k = 1}^n \frac{n + k}{k} \\
& = \frac{1}{n + 1} \cdot \prod\_{k = 1}^n \left(1 + \frac{n}{k}\right) \\
& = \frac{1}{n + 1} (n + 1) \prod\_{k = 2}^n \left(1 + \frac{n}{k}\right) \\
& = \prod\_{k = 2}^n \left(1 + \frac{n}{k}\right)
\end{split}
\end{equation}
$$
The formula assumes `n >= 2`, but the code accounts for `n = 0` and `n = 1` too.
In the C mess above, `n` and `k` have the same role as in the formula, while `c` accumulates the product. All calculations are performed in floating point using `double`, which is almost always a bad idea, but in this case the results are correct up to `n = 19` at least, so it's ok.
`float` would have saved 1 byte, unfortunately it's not precise enough.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
Ḥc÷‘
```
[Try it online!](http://jelly.tryitonline.net/#code=4bikY8O34oCY&input=&args=NQ)
### How it works
```
Ḥc÷‘ Left argument: z
Ḥ Compute 2z.
c Hook; apply combinations to 2z and z.
÷‘ Divide the result by z+1.
```
[Answer]
## TI-BASIC, 11 bytes
```
(2Ans) nCr Ans/(Ans+1
```
Strangely, nCr has higher precedence than multiplication.
[Answer]
## CJam, 12 bytes
```
ri_2,*e!,\)/
```
[Try it online.](http://cjam.tryitonline.net/#code=cmlfMiwqZSEsXCkv&input=OA)
Beyond input 11, you'll need to tell your Java VM to use more memory. And I wouldn't actually recommend going much beyond 11. In theory, it works for any N though, since CJam uses arbitrary-precision integers.
### Explanation
CJam doesn't have a built-in for binomial coefficients, and computing them from three factorials takes a lot of bytes... so we'll have to do something better than that. :)
```
ri e# Read input and convert it to integer N.
_ e# Duplicate.
2, e# Push [0 1].
* e# Repeat this N times, giving [0 1 0 1 ... 0 1] with N zeros and N ones.
e! e# Compute the _distinct_ permutations of this array.
, e# Get the number of permutations - the binomial. There happen to be 2n-over-n of
e# of them. (Since 2n-over-n is the number of ways to choose n elements out of 2n, and
e# and here we're choosing n positions in a 2n-element array to place the zeros in.)
\ e# Swap with N.
)/ e# Increment and divide the binomial coefficient by N+1.
```
[Answer]
## Python 3, 33 bytes
```
f=lambda n:0**n or(4+6/~n)*f(n-1)
```
Uses the recurrence
```
f(0) = 1
f(n) = (4-6/(n+1)) * f(n-1)
```
The base case of 0 is handled as `0**n or`, which stops as `1` when `n==0` and otherwise evaluates the recursive expression on the right. The bitwise operator `~n==-n-1` shortens the denominator and saves on parens.
Python 3 is used for its float division. Python 2 could do the same with one more byte to write `6.`.
[Answer]
# Mathematica, ~~16~~ 13 bytes
```
CatalanNumber
```
Built-ins, amirite fellas :/
Non-builtin version (21 bytes):
```
Binomial[2#,#]/(#+1)&
```
A binomial-less version (25 bytes):
```
Product[(#+k)/k,{k,2,#}]&
```
[Answer]
## J, 8 bytes
```
>:%~]!+:
```
This is a monadic train; it uses the (2x nCr x)/(x+1) formula. Try it [here](https://a296a8f7c5110b2ece73921ddc2abbaaa3c90d10.googledrive.com/host/0B3cbLoy-_9Dbb0NaSk9MRGE5UEU/index.html#code=(%3E%3A%25%7E%5D!%2B%3A)5).
[Answer]
# pl, 4 bytes
```
☼ç▲÷
```
[Try it online.](http://pl.tryitonline.net/#code=4pi8w6filrLDtw&input=NQ)
## Explanation
In pl, functions take their arguments off the stack and push the result back onto the stack. Normally when there are not enough arguments on the stack, the function simply fails silently. However, something special happens when the amount of arguments on the stack is one off from the arity of the function -- the input variable `_` is added to the argument list:
```
☼ç▲÷
‚òº double: takes _ as the argument since there is nothing on the stack
ç combinations: since there is only one item on the stack (and arity is 2), it adds _ to the argument list (combinations(2_,_))
‚ñ≤ increment last used var (_)
√∑ divide: adds _ to the argument list again
```
In effect, this is the pseudocode:
```
divide(combinations(double(_),_),_+1);
```
[Answer]
# [Sesos](https://github.com/DennisMitchell/sesos), ~~94~~ ~~86~~ 68 bytes
8 bytes by changing the factorial-er from version 1 to version 2.
18 bytes by computing `n!(n+1)!` in one step. **Largely inspired by [Dennis' primality test algorithm](https://codegolf.stackexchange.com/a/86501/48934).**
Hexdump:
```
0000000: 16f8de a59f17 a0ebba 7f4cd3 e05f3f cf0fd0 a0ebde ..........L.._?......
0000015: b1c1bb 76fe18 8cc1bb 76fe1c e0fbda 390fda bde3d8 ...v.....v.....9.....
000002a: 000fbe af9d1b b47bc7 cfc11c b47bc7 cff1fa e07bda .......{.....{.....{.
000003f: 39e83e cf07 9.>..
```
[Try it online!](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMixhZGQgMixyd2QgMyxqbnoKZndkIDEsYWRkIDEKam1wCiAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLGZ3ZCAzLGpuegogIHJ3ZCAxLHN1YiAxLHJ3ZCAxLHN1YiAxLHJ3ZCAxCiAgam1wLHN1YiAxLGZ3ZCAzLGFkZCAxLHJ3ZCAzLGpuegogIGZ3ZCAxCmpuegpmd2QgMwpqbXAKICBqbXAKICAgIHN1YiAxLHJ3ZCAxCiAgICBqbXAsc3ViIDEscndkIDEsYWRkIDEscndkIDEsYWRkIDEsZndkIDIsam56CiAgICByd2QgMgogICAgam1wLHN1YiAxLGZ3ZCAyLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDMKICBqbnoKICByd2QgMQogIGptcCxzdWIgMSxqbnoKICByd2QgMQogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMwpqbnogCmZ3ZCAxCmptcAogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxhZGQgMSxyd2QgMixqbnoKICBmd2QgMSxzdWIgMSxmd2QgMQogIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICByd2QgMQpqbnoKcndkIDIKam1wCiAgam1wCiAgICBzdWIgMSxmd2QgMQogICAgam1wLHN1YiAxLGZ3ZCAxLGFkZCAxLGZ3ZCAxLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDIKICAgIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICAgIHJ3ZCAzCiAgam56CiAgZndkIDEKICBqbXAsc3ViIDEsam56CiAgZndkIDEKICBqbXAsc3ViIDEscndkIDIsYWRkIDEsZndkIDIsam56CiAgcndkIDMKam56IApmd2QgMQpqbXAKICBmd2QgMSxhZGQgMSxyd2QgMwogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxzdWIgMSxyd2QgMixqbnoKICBmd2QgMQogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxmd2QgMSxqbnoKICBmd2QgMQpqbnoKZndkIDEKcHV0&input=NA&debug=on)
Uses the formula `a(n) = (2n)! / (n!(n+1)!)`.
* The factorial-er: [version 1](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxhZGQgMSxyd2QgMixqbnoKZndkIDMKYWRkIDEKcndkIDIKam1wCiAgc3ViIDEKICBmd2QgMQogIGptcAogICAgc3ViIDEKICAgIGZ3ZCAxCiAgICBqbXAKICAgICAgc3ViIDEsZndkIDEsYWRkIDEsZndkIDEsYWRkIDEscndkIDIKICAgIGpuegogICAgZndkIDEKICAgIGptcAogICAgICBzdWIgMSxyd2QgMSxhZGQgMSxmd2QgMQogICAgam56CiAgICByd2QgMgogIGpuegogIGZ3ZCAxLGptcCxzdWIgMSxqbnoKICByd2QgMgogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMgogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxyd2QgMSxhZGQgMSxmd2QgMixqbnoKICBmd2QgMgogIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICByd2QgNApqbnoKZndkIDIKcHV0&input=NQ&debug=on) (in-place, constant memory), [version 2](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcAogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMgogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxyd2QgMSxhZGQgMSxmd2QgMixqbnoKICByd2QgMQogIHN1YiAxCmpuegpyd2QgMgpqbXAKICBqbXAKICAgIHN1YiAxLGZ3ZCAxCiAgICBqbXAsc3ViIDEsZndkIDEsYWRkIDEsZndkIDEsYWRkIDEscndkIDIsam56CiAgICBmd2QgMQogICAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLGZ3ZCAxLGpuegogICAgcndkIDIKICBqbnoKICBmd2QgMSxqbXAsc3ViIDEsam56LGZ3ZCAyCiAgam1wLHN1YiAxLHJ3ZCAzLGFkZCAxLGZ3ZCAzLGpuegogIHJ3ZCA0Cmpuegpmd2QgMQpwdXQ&input=NQ&debug=on) (in-place, linear memory)
* The multiplier: [here](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CnJ3ZCAxCmdldApqbXAKICBzdWIgMQogIGZ3ZCAxCiAgam1wLHN1YiAxLGZ3ZCAxLGFkZCAxLGZ3ZCAxLGFkZCAxLHJ3ZCAyLGpuegogIGZ3ZCAxCiAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLGZ3ZCAxLGpuegogIHJ3ZCAyCmpuegpmd2QgMwpwdXQ&input=MTIKMTM&debug=on) (in place, constant memory)
* The divider: [here](http://sesos.tryitonline.net/#code=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmZ3ZCAyCmdldApyd2QgMgpqbXAKICBmd2QgMwogIGFkZCAxCiAgcndkIDEKICBqbXAsc3ViIDEscndkIDEsYWRkIDEscndkIDEsc3ViIDEsZndkIDIsam56CiAgcndkIDEKICBqbXAsc3ViIDEsZndkIDEsYWRkIDEscndkIDEsam56CiAgcndkIDEKam56CmZ3ZCAzCnB1dA&input=MTU2CjEy&debug=on) (does not halt if not divisible)
## Assembler
```
set numin
set numout
get
jmp,sub 1,fwd 1,add 1,fwd 2,add 2,rwd 3,jnz
fwd 1,add 1
jmp
jmp,sub 1,rwd 1,add 1,rwd 1,add 1,rwd 1,add 1,fwd 3,jnz
rwd 1,sub 1,rwd 1,sub 1,rwd 1
jmp,sub 1,fwd 3,add 1,rwd 3,jnz
fwd 1
jnz
fwd 3
jmp
jmp
sub 1,rwd 1
jmp,sub 1,rwd 1,add 1,rwd 1,add 1,fwd 2,jnz
rwd 2
jmp,sub 1,fwd 2,add 1,rwd 2,jnz
fwd 3
jnz
rwd 1
jmp,sub 1,jnz
rwd 1
jmp,sub 1,fwd 2,add 1,rwd 2,jnz
fwd 3
jnz
fwd 1
jmp
jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
fwd 1,sub 1,fwd 1
jmp,sub 1,rwd 2,add 1,fwd 2,jnz
rwd 1
jnz
rwd 2
jmp
jmp
sub 1,fwd 1
jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
fwd 2
jmp,sub 1,rwd 2,add 1,fwd 2,jnz
rwd 3
jnz
fwd 1
jmp,sub 1,jnz
fwd 1
jmp,sub 1,rwd 2,add 1,fwd 2,jnz
rwd 3
jnz
fwd 1
jmp
fwd 1,add 1,rwd 3
jmp,sub 1,fwd 1,add 1,fwd 1,sub 1,rwd 2,jnz
fwd 1
jmp,sub 1,rwd 1,add 1,fwd 1,jnz
fwd 1
jnz
fwd 1
put
```
## Brainfuck equivalent
[This Retina script](http://retina.tryitonline.net/#code=TSFgKFtmcl13ZHxhZGR8c3ViKSBcZHxqbnp8am1wfGpuZXxub3AKam1wClsKam56Cl0Kc3ViIChcZCkKJDEkKi0KYWRkIChcZCkKJDEkKisKZndkIChcZCkKJDEkKj4KcndkIChcZCkKJDEkKjwKwrYK&input=c2V0IG51bWluCnNldCBudW1vdXQKZ2V0CmptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMixhZGQgMixyd2QgMyxqbnoKZndkIDEsYWRkIDEKam1wCiAgam1wLHN1YiAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLHJ3ZCAxLGFkZCAxLGZ3ZCAzLGpuegogIHJ3ZCAxLHN1YiAxLHJ3ZCAxLHN1YiAxLHJ3ZCAxCiAgam1wLHN1YiAxLGZ3ZCAzLGFkZCAxLHJ3ZCAzLGpuegogIGZ3ZCAxCmpuegpmd2QgMwpqbXAKICBqbXAKICAgIHN1YiAxLHJ3ZCAxCiAgICBqbXAsc3ViIDEscndkIDEsYWRkIDEscndkIDEsYWRkIDEsZndkIDIsam56CiAgICByd2QgMgogICAgam1wLHN1YiAxLGZ3ZCAyLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDMKICBqbnoKICByd2QgMQogIGptcCxzdWIgMSxqbnoKICByd2QgMQogIGptcCxzdWIgMSxmd2QgMixhZGQgMSxyd2QgMixqbnoKICBmd2QgMwpqbnogCmZ3ZCAxCmptcAogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxhZGQgMSxyd2QgMixqbnoKICBmd2QgMSxzdWIgMSxmd2QgMQogIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICByd2QgMQpqbnoKcndkIDIKam1wCiAgam1wCiAgICBzdWIgMSxmd2QgMQogICAgam1wLHN1YiAxLGZ3ZCAxLGFkZCAxLGZ3ZCAxLGFkZCAxLHJ3ZCAyLGpuegogICAgZndkIDIKICAgIGptcCxzdWIgMSxyd2QgMixhZGQgMSxmd2QgMixqbnoKICAgIHJ3ZCAzCiAgam56CiAgZndkIDEKICBqbXAsc3ViIDEsam56CiAgZndkIDEKICBqbXAsc3ViIDEscndkIDIsYWRkIDEsZndkIDIsam56CiAgcndkIDMKam56IApmd2QgMQpqbXAKICBmd2QgMSxhZGQgMSxyd2QgMwogIGptcCxzdWIgMSxmd2QgMSxhZGQgMSxmd2QgMSxzdWIgMSxyd2QgMixqbnoKICBmd2QgMQogIGptcCxzdWIgMSxyd2QgMSxhZGQgMSxmd2QgMSxqbnoKICBmd2QgMQpqbnoKZndkIDEKcHV0) is used to generate the brainfuck equivalent. Note that it only accepts one digit as command argument, and does not check if a command is in the comments.
```
[->+>>++<<<]>+
[[-<+<+<+>>>]<-<-<[->>>+<<<]>]>>>
[[-<[-<+<+>>]<<[->>+<<]>>>]<[-]<[->>+<<]>>>]>
[[->+>+<<]>->[-<<+>>]<]<<
[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>
[>+<<<[->+>-<<]>[-<+>]>]>
```
[Answer]
# Pyth, 8
```
/.cyQQhQ
```
[Try it online](http://pyth.herokuapp.com/?code=%2F.cyQQhQ&input=5&debug=0) or run the [Test Suite](http://pyth.herokuapp.com/?code=%2F.cyQQhQ&input=50&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19&debug=0)
### Explanation
```
/.cyQQhQ ## implicit: Q = eval(input())
/ hQ ## integer division by (Q + 1)
.c ## nCr
yQ ## use Q * 2 as n
Q ## use Q as r
```
[Answer]
# Julia, 23 bytes
```
n->binomial(2n,n)/(n+1)
```
This is an anonymous function that accepts an integer and returns a float. It uses the basic binomial formula. To call it, give it a name, e.g. `f=n->...`.
[Answer]
## Seriously, 9 bytes
```
,;;u)τ╣E\
```
Hex Dump:
```
2c3b3b7529e7b9455c
```
[Try it online](http://seriouslylang.herokuapp.com/link/code=2c3b3b7529e7b9452f&input=5)
Explanation:
```
, Read in evaluated input n
;; Duplicate it twice
u) Increment n and rotate it to bottom of stack
τ╣ Double n, then push 2n-th row of Pascal's triangle
E Look-up nth element of the row, and so push 2nCn
\ Divide it by the n+1 below it.
```
[Answer]
# JavaScript (ES6), 24 bytes
Based on the [Python answer](https://codegolf.stackexchange.com/a/66141/42545).
```
c=x=>x?(4+6/~x)*c(x-1):1
```
### How it works
```
c=x=>x?(4+6/~x)*c(x-1):1
c=x=> // Define a function c that takes a parameter x and returns:
x? :1 // If x == 0, 1.
(4+6/~x) // Otherwise, (4 + (6 / (-x - 1)))
*c(x-1) // times the previous item in the sequence.
```
I think this is the shortest it can get, but suggestions are welcome!
[Answer]
## Matlab, ~~35~~ 25 bytes
```
@(n)nchoosek(2*n,n)/(n+1)
```
## Octave, 23 bytes
```
@(n)nchoosek(2*n,n++)/n
```
[Answer]
# ùîºùïäùïÑùïöùïü, 3 chars / 6 bytes
```
Мƅï
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter.html?eval=true&input=4&code=%D0%9C%C6%85%C3%AF)`
Builtins ftw! So glad I implemented math.js early on.
# Bonus solution, 12 chars / 19 bytes
```
Мơ 2*ï,ï)/⧺ï
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter2.html?eval=true&input=19&code=%D0%9C%C6%A1%202*%C3%AF%2C%C3%AF%29%2F%E2%A7%BA%C3%AF)`
Ay! 19th byte!
Evaluates to pseudo-ES6 as:
```
nchoosek(2*input,input)/(input+1)
```
[Answer]
## Haskell, 27 bytes
```
g 0=1
g n=(4-6/(n+1))*g(n-1)
```
A recursive formula. There's got to be a way to save on parens...
Directly taking the product was 2 bytes longer:
```
g n=product[4-6/i|i<-[2..n+1]]
```
[Answer]
## Dyalog APL, 9 bytes
```
+∘1÷⍨⊢!+⍨
```
This is a monadic train; it uses the (2x nCr x)/(x+1) formula. Try it online [here](http://tryapl.org/?a=%28+%u22181%F7%u2368%u22A2%21+%u2368%29%20%u237315&run).
[Answer]
# C, ~~122~~ ~~121~~ ~~119~~ 108 bytes
```
main(j,v)char**v;{long long p=1,i,n=atoi(v[1]);for(j=0,i=n+1;i<2*n;p=(p*++i)/++j);p=n?p/n:p;printf("%d",p);}
```
I used gcc (GCC) 3.4.4 (cygming special, gdc 0.12, using dmd 0.125) to compile in a windows cygwin environment. Input comes in on the command line. It's similar to Sherlock9's Python solution but the loops are combined into one to avoid overflow and get output up to the 20th Catalan number (n=19).
[Answer]
# [Javagony](http://esolangs.org/wiki/Javagony), 223 bytes
```
public class C{public static int f(int a,int b){try{int z=1/(b-a);}catch(Exception e){return 1;}return a*f(a+1,b);}public static void main(String[]s){int m=Integer.parseInt(s[0])+1;System.out.println(f(m,2*m-1)/f(1,m)/m);}}
```
Fully expanded:
```
public class C {
public static int f(int a,int b){
try {
int z=1/(b-a);
} catch (Exception e){
return 1;
}
return a*f(a+1,b);
}
public static void main(String[] s){
int m=Integer.parseInt(s[0])+1;
System.out.println(f(m,2*m-1)/f(1,m)/m);
}
}
```
[Answer]
# R, ~~35~~ ~~28~~ 16 bytes
```
numbers::catalan
```
Edit: Use numbers package builtin.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
Dxcr>/
```
**Explanation:**
```
Code: Stack: Explanation:
Dxcr>/
D [n, n] # Duplicate of the stack. Since it's empty, input is used.
x [n, n, 2n] # Pops a, pushes a, a * 2
c [n, n nCr 2n] # Pops a,b pushes a nCr b
r [n nCr 2n, n] # Reverses the stack
> [n nCr 2n, n + 1] # Increment on the last item
/ [(n nCr 2n)/(n + 1)] # Divides the last two items
# Implicit, nothing has printed, so we print the last item
```
[Answer]
# R, 28 bytes
Not using a package, so slightly longer than a previous answer
```
choose(2*(n=scan()),n)/(n+1)
```
[Answer]
# [Oasis](http://github.com/Adriandmen/Oasis), 9 bytes
```
nxx¬´*n>√∑1
```
[Try it online!](http://oasis.tryitonline.net/#code=bnh4wqsqbj7DtzE&input=&args=MTk)
Oasis is a language designed by [Adnan](https://codegolf.stackexchange.com/users/34388/adnan) which is specialized in sequences.
Here, we shall use the following relationship kindly provided by [Stefano Sanfilippo](https://codegolf.stackexchange.com/a/66168/48934):
Currently, this language can do recursion and closed form.
To specify that `a(0)=1` is simple: just add the `1` at the end.
For example, if a sequence begins with `a(0)=0` and `a(1)=1`, just put `10` at the end.
Unfortunately, all sequences must be 0-indexed.
```
nxx¬´*n>√∑1 stack
1 a(0)=1
n push n (input) n
x double 2n
x double 4n
¬´ minus 2 4n-2
* multiply: second (4n-2)*a(n-1)
argument is missing,
so a(n-1) is used.
n push n (input) (4n-2)*a(n-1) n
> add 1 (4n-2)*a(n-1) n+1
√∑ integer division (4n-2)*a(n-1)/(n+1)
= ((4n-2)/(n+1))*a(n-1)
= ((4n+4-6)/(n+1))*a(n-1)
= ((4n+4)/(n+1) - 6/(n+1))*a(n-1)
= (4-6/(n+1))*a(n-1)
```
---
Closed-form:
## 10 bytes
```
nx!n!n>!*√∑
```
[Try it online!](http://oasis.tryitonline.net/#code=bnghbiFuPiEqw7c&input=&args=MTk)
```
nx!n!n>!*√∑
n push n (input)
x double
! factorial: stack is now [(2n)!]
n push n (input)
! factorial: stack is now [(2n)! n!]
n push n (input)
> add 1
! factorial: stack is now [(2n)! n! (n+1)!]
* multiply: stack is now [(2n)! (n!(n+1)!)]
√∑ divide: stack is now [(2n)!/(n!(n+1)!)]
```
[Answer]
# TeX, 231 bytes
```
\newcommand{\f}[1]{\begingroup\count0=1\count1=2\count2=2\count3=0\loop\multiply\count0 by\the\count1\divide\count0 by\the\count2\advance\count1 by4\advance\count2 by1\advance\count3 by1
\ifnum\count3<#1\repeat\the\count0\endgroup}
```
## Usage
```
\documentclass[12pt,a4paper]{article}
\begin{document}
\newcommand{\f}[1]{\begingroup\count0=1\count1=2\count2=2\count3=0\loop\multiply\count0 by\the\count1\divide\count0 by\the\count2\advance\count1 by4\advance\count2 by1\advance\count3 by1
\ifnum\count3<#1\repeat\the\count0\endgroup}
\newcount \i
\i = 0
\loop
\f{\the\i}
\advance \i by 1
\ifnum \i < 15 \repeat
\end{document}
```
[](https://i.stack.imgur.com/Wckg8.png)
[Answer]
# Japt, 16 bytes
Even Mathematica is shorter. `:-/`
```
U*2ª1 o àU l /°U
```
[Try it online!](http://ethproductions.github.io/japt?v=master&code=VSoyqjEgbyDgVSBsIC+wVQ==&input=Ng==)
### Ungolfed and explanation
```
U*2ª 1 o àU l /° U
U*2||1 o àU l /++U
// Implicit: U = input number
U*2||1 // Take U*2. If it is zero, take 1.
o àU // Generate a range of this length, and calculate all combinations of length U.
l /++U // Take the length of the result and divide by (U+1).
// Implicit: output result
```
Alternate version, based on the recursive formula:
```
C=_?(4+6/~Z *C$(Z-1):1};$C(U
```
[Answer]
# [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy), 13 Bytes
```
VV2*FVF/V1+F/
V Capture the input as a final global variable.
V Push it back.
2* Multiply it by 2
F Factorial.
VF Factorial of the input.
/ Divide the second to top by the first.
V1+ 1+input
F Factorial.
/ Divide.
```
This is a function in [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy). How to make it a program that does this, you ask? Concatenate `N`. c:
[Try it online!](http://vitsy.tryitonline.net/#code=VlYyKkZWRi9WMStGL04&input=&args=MQ)
[Answer]
# [Milky Way 1.5.14](https://github.com/zachgates7/Milky-Way), 14 bytes
```
':2K;*Ny;1+/A!
```
---
### Explanation
```
' # read input from the command line
: # duplicate the TOS
2 1 # push integer to the stack
K # push a Pythonic range(0, TOS) as a list
; ; # swap the TOS and the STOS
* # multiply the TOS and STOS
N # push a list of the permutations of the TOS (for lists)
y # push the length of the TOS
+ # add the STOS to the TOS
/ # divide the TOS by the STOS
A # push the integer representation of the TOS
! # output the TOS
```
or, alternatively, the *much* more efficient version:
---
# [Milky Way 1.5.14](https://github.com/zachgates7/Milky-Way), 22 bytes
```
'1%{;K£1+k1-6;/4+*}A!
```
---
### Explanation
```
' # read input from the command line
1 1 1 6 4 # push integer to the stack
%{ £ } # for loop
; ; # swap the TOS and the STOS
K # push a Pythonic range(0, TOS) as a list
+ + # add the TOS and STOS
k # push the negative absolute value of the TOS
- # subtract the STOS from the TOS
/ # divide the TOS by the STOS
* # multiply the TOS and the STOS
A # push the integer representation of the TOS
! # output the TOS
```
---
## Usage
```
python3 milkyway.py <path-to-code> -i <input-integer>
```
[Answer]
# Clojure/ClojureScript, 53 bytes
```
(defn c[x](if(= 0 x)1(*(c(dec x))(- 4(/ 6(inc x))))))
```
Clojure can be pretty frustrating to golf in. It's very pithy while still being very readable, but some of the niftier features are really verbose. `(inc x)` is more idiomatic than `(+ x 1)` and "feels" more concise, but doesn't actually save characters. And writing chains of operations is nicer as `(->> x inc (/ 6) (- 4))`, but it's actually longer than just doing it the ugly way.
[Answer]
# Ruby, 30 bytes
```
c=->n{n<1?1:c[n-1]*(4+6.0/~n)}
```
Thanks to xsot, saved few bytes by using complement.
**Ungolfed:**
```
c = -> n {
n < 1 ? 1 : c[n-1]*(4+6.0/~n)
}
```
**Usage:**
```
> c=->n{n<1?1:c[n-1]*(4+6.0/~n)}
> c[10]
=> 16796.0
```
[Answer]
# Prolog, 42 bytes
Using recursion is almost always the way to go with Prolog.
**Code:**
```
0*1.
N*X:-M is N-1,M*Y,X is(4-6/(N+1))*Y.
```
**Example:**
```
19*X.
X = 1767263190.0
```
Try it online [here](http://swish.swi-prolog.org/p/qICyHIzl.pl)
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 months ago.
[Improve this question](/posts/262011/edit)
Suppose you have a grid of cells that is 6 wide and arbitrarily tall. In each cell is a word. Let the bottom row, which is row #1, be the last 6 words of sample.txt in order. Let the second to last row, which is row #2, be the 6 words before those in order. (etc.)
Then consider what happens when you remove some of the words according to the pattern pictured below. When the word in a pink-colored cell is removed, all of the words from previous cells are shifted forward. The new index of the word in cell C\_i,j becomes C\_i,j-1 unless it's originally in the last column where j=1, in which case the new index of the word in the cell C\_i,j becomes C\_i-1,j .
What words are in each of the 36 cells after removing all of the words in the pink cells 3333 times? Write a program that prints them in order, from top to bottom, left to right.
[](https://i.stack.imgur.com/OOeJR.png)
[Download sample.txt](https://gist.githubusercontent.com/mikebolt/6a307f160bb37db4855181bba340172d/raw/fb172fb6e2136025969f7be96564086aec695789/sample.txt)
This file is the [tiny\_shakespeare](https://huggingface.co/datasets/tiny_shakespeare) dataset with all of the punctuation and line breaks removed.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 months ago.
[Improve this question](/posts/261956/edit)
**Problem**
You are given a binary string A of length N.
You can perform the following type of operation on the string A:
* Choose two different indices \$i\$ and \$j\$ (\$1 \le i\$, \$j \le N\$)
* Change \$A\_i\$ and \$A\_j\$ to \$Ai \oplus Aj\$. Here \$\oplus\$ represents the bitwise XOR operation.
**Input**
A binary string consisting of 0's and 1's
**Output**
The minimum number of operations required to make the binary string a palindrome
**Reference**
Here's the [link](https://www.codechef.com/problems/XOR_PAL) of the problem.
**Actual Doubt**
I tried solving it by the logic that the number of operations required would be equal to the number of inequalities of characters in the string when traversing from left and right.
simultaneously.
My code:
```
for(int i=0,j=n-1;i<n/2;i++,j--) {
if(b[i]!=b[j]) count++;
}
```
Where **b** is the binary string and **n** is it's length.
But, it turns out the solution is this:
```
for(int i=0,j=n-1;i<n/2;i++,j--) {
if(b[i]!=b[j]) count++;
}
cout<<(count+1)/2<<endl;
```
And I don't understand why.
Can someone explain this? Thanks.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 8 months ago.
[Improve this question](/posts/261752/edit)
I am working on a code to print all semimagic squares [[1](https://arxiv.org/pdf/1807.02983.pdf)] of a given size. I am working with the following definition:
1. An \$n\times n\$ consists of numbers \$1,2,\cdots, n^2\$.
2. All numbers must be distinct.
3. Sum of each row and each column is equal.
According to Ripatti A. (2018) [[1](https://arxiv.org/pdf/1807.02983.pdf)]:
| \$n\$ | number of semimagic squares |
| --- | --- |
| 1 | 1 |
| 2 | 0 |
| 3 | 9 |
| 4 | 68 688 |
| 5 | 579 043 051 200 |
| 6 | 94 590 660 245 399 996 601 600 |
| \$\cdots\$ | \$\cdots\$ |
If someone knows of any resources that could help me, please let me know.
### References
[1](https://arxiv.org/pdf/1807.02983.pdf). Ripatti A. (2018) On the number of semi-magic squares of order 6. *arXiv*. [10.48550/arXiv.1807.02983](https://doi.org/10.48550/arXiv.1807.02983)
]
|
[Question]
[
The [Quine-McCluskey](https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm) algorithm merges disjunctors in a disjunction like
$$
\lnot x\_0 \land \lnot x\_1 \land \lnot x\_2 \land \lnot x\_3 \lor\\
x\_0 \land \lnot x\_1 \land x\_2 \land \lnot x\_3 \lor\\
\lnot x\_0 \land x\_1 \land x\_2 \land \lnot x\_3 \lor\\
\lnot x\_0 \land \lnot x\_1 \land \lnot x\_2 \land x\_3 \lor\\
\lnot x\_0 \land x\_1 \land \lnot x\_2 \land x\_3 \lor\\
x\_0 \land x\_1 \land \lnot x\_2 \land x\_3 \lor\\
\lnot x\_0 \land x\_1 \land x\_2 \land x\_3 \lor\\
x\_0 \land x\_1 \land x\_2 \land x\_3
$$
into fewer disjunctors in an equivalent disjunction:
$$
x\_1 \land x\_3 \lor\\
\lnot x\_0 \land \lnot x\_1 \land \lnot x\_2 \lor\\
\lnot x\_0 \land x\_1 \land x\_2 \lor\\
x\_0 \land \lnot x\_1 \land \lnot x\_2 \land x\_3
$$
by merging like this:
$$x\_0\land x\_1\lor\lnot x\_0\land x\_1 \iff (x\_0\lor\lnot x\_0)\land x\_1\iff x\_1$$.
[https://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/qmc/](https://www.mathematik.uni-marburg.de/%7Ethormae/lectures/ti1/code/qmc/) will generate test cases to taste.
## Your task
Your task is to write a function transforming any disjunction into an equivalent disjunction of minimal disjunctor count.
The QMC algorithm imperative in the headline is a sloppy summary and a mere recommendation, no hard requirement.
You can encode the data any way fit, that is $$\lnot x\_1 \land \lnot x\_2 \land x\_3$$ can become
* [3,0,0,1]
* [(1,0),(2,0),(3,1)]
* (14,8)
* …
This is `code-golf`. Shortest code wins.
[Answer]
# [Kamilalisp](https://github.com/kspalaiologos/kamilalisp), 139 bytes
```
(defun s m \let-seq(def a \⍸ \= 1 \⌼ $(foldl1 +)@/= m m)(↩ (= 0 \⍴ a) m)(def p m$[⍎ a])\^⍪ p \⍠ m \[tie@* ⍎ $(foldl1 =)] p)
```
"Ungolfed":
```
(⍥← s m \○⊢¨
(○← a \⍸ \= 1 \⌼ $(⌿⊙← +)∘≠ m m) ; Find all possible rows we can join.
(↩ (= 0 \⍴ a) m) ; If we can't join anything, yield.
(○← p m$[⍎ a]) ; Determine the contents of the rows in the matrix to be joined.
\^⍪ p \⍠ m \[⌿⊙⍧∘* ⍎ $(⌿⊙← =)] p) ; Adjoin the new row, remove the merged two.
```
In essence, the algorithm finds two rows in the matrix that represents the expression (where every cell, either -1, 1, or 0 represents that the boolean literal is either negated, taken as given, or not used), that differ at most by one entry. Then, if no such rows are found, the algorithm returns the original matrix. If at least one such pair exists, it is removed from the matrix, the difference between is computed as a mask (e.g. for -1 -1 1 1 and -1 -1 1 -1, the mask is 1 1 1 0), which is then multiplied by the first (or equivalently second) element of the pair to form a new entry in the expression matrix.
Some test cases, etc:
[Attempt This Online!](https://ato.pxeger.com/run?1=m70qOzE3MycxJ7O4YMGCpaUlaboWN7s1UlLTSvMUihVyFWJyUkt0i1MLQUIKiQoxj3p3KMTYKhgCWT17FFQ00vJzUnIMFbQ1HfRtgcpzNTUeta1U0LBVMACp3aKQqAkSA2kuUMhViX7U26eQGKsZE_eodxVQBKhkAciS6JLMVActBZAs3EhbzViFAk2ok86BjShJLS7RNVRQ1-BSUNAAMsBIE8GBs5HFYcIwFZqaXFwI04wQpqEo1IWxUZgw7Zn5VuVFmSWpOXkKGsn5eWWpRempwOCCuA-oAq8CI02or2ABDgA)
[Answer]
# [Haskell](https://www.haskell.org/), 340 bytes
```
import Data.Bits;import Data.List;import Data.List.Ordered
o d[]=d;o _ s=s
p(a:b:c)|a==b=a|0<1=p(b:c)
q(_,b)(c,d)=c.&.b==c.&.d
r t s=and[or[q f e|e<-s]|f<-t]
s(a,b)(c,d)=[(a.&.complement x,b.&.d)|a==c,let x=xor b d,1==popCount x]
t d=nubSort$concatMap(\c->o[c]$concatMap(s c)d)d
u d=head$sortOn length$filter(r d)$subsequences$p$iterate t d
```
Here a disjunctor is represented by `(significantbitmask,setbits)` fiddled by `q` and `s`. `s` combines two disjunctors if they have the same `significantbitmask` and differ in exactly one bit. `o[c]` prevents disjunctors from disappearing if they combine with nobody. `u` computes a minimal disjunction: `t` merges antivalents in `d` until `p` no more merges occur, then it filters for `r` sufficient subsets as the merges can produce superfluous disjunctors.
[Try it online!](https://tio.run/##ZY89a8MwEIZ3/woNokggmwiaUpyoQ9ul0JKho2uCPi6NqC0pkgwZ/N9dJUMJdDp47p73eI8y/cAwLIsdg48Zvcosm2eb0@YWvNuU/4FmFw1EMJVHpuuF2Xi0R0mkKhDZqlbTWQqhhJxXWy4CuZDqRPZMUaKZoUI3d40S12GqiHJxpTOdj90JHRDMsK1TPx@2de6rROSf1xFZFO3HMMAILqMzU5eM6z/NBihEnH1EChnGhQg@vPjpctdXGRnhJvVZimDtnZb5Qwbypesn3@n@BiWkqaGmmopwBGlwKsrOoQHcdz7igx0yRBKRoThNKsFpAqch4YBtWcgMpY9ZRmmdCNG6jCc8lljCKF9T3JFV2765TNmaPbBHxleMc8bvGV/3yy8 "Haskell – Try It Online")
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 10 months ago.
[Improve this question](/posts/260734/edit)
I have the code below working. But there must be a better way.
```
file <- "http://s3.amazonaws.com/assets.datacamp.com/production/course_1127/datasets/tmp_file.csv"
x <- read.csv(file = file)
ts <- xts(x = x, order.by = as.Date(rownames(x), "%m/%d/%Y"))
cd=coredata(ts)
for (j in 1:length(names(ts))) cd[,j]<-cd[,j]/cd[1,j]
for (j in 1:length(names(ts))) ts[,j]<-cd[,j]
```
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/251124/edit).
Closed 1 year ago.
[Improve this question](/posts/251124/edit)
# Solve the Greek Computer Puzzle Toy
There is a small toy of a series of stacked dials -- loosely inspired by the [Antikythera Device](https://en.wikipedia.org/wiki/Antikythera_mechanism). The puzzle, made by [Project Genius](https://www.projectgeniusinc.com/true-genius-collection), has a series of dials that must be arranged in a particular configuration to win. In this challenge, you will write a function/program to find that solution.
[](https://i.stack.imgur.com/KKBwK.jpg)
## The Puzzle
Every dial has 1 or more rings of numbers at 12 radial positions, and they all spin about the same center axis. The top dial has 1 ring, the next dial has 2 rings, then 3 rings, then two dials have 4 rings. Finally, some positions for some rings on some dials are "windows" that let you see the dial below (or the one below that, etc.). The only dial without a window is the very bottom dial.
Once arranged, every radial will have 4 numbers visible (one in each ring), though with the windows, you might be reading any particular number from a higher or a lower dial. You solve the puzzle by arranging the dials so that the numbers in every radial total 42.
There is one solution to the puzzle (see discussion in **Requirements #6**).
## The Code Challenge
### Source Data
[](https://i.stack.imgur.com/DFogB.jpg)
[](https://i.stack.imgur.com/jrd7V.jpg)
[](https://i.stack.imgur.com/Tk7qy.jpg)
[](https://i.stack.imgur.com/tT979.jpg)
[](https://i.stack.imgur.com/zY3MT.jpg)
Here is the same data in a text-accessible rendering:
```
Dial 0 Radials:
0: [3, 0, 0, 0]
1: [0, 0, 0, 0]
2: [6, 0, 0, 0]
3: [0, 0, 0, 0]
4: [10, 0, 0, 0]
5: [0, 0, 0, 0]
6: [7, 0, 0, 0]
7: [0, 0, 0, 0]
8: [15, 0, 0, 0]
9: [0, 0, 0, 0]
10: [8, 0, 0, 0]
11: [0, 0, 0, 0]
Dial 1 Radials:
0: [7, 4, 0, 0]
1: [3, 0, 0, 0]
2: [0, 7, 0, 0]
3: [6, 15, 0, 0]
4: [0, 0, 0, 0]
5: [11, 0, 0, 0]
6: [11, 14, 0, 0]
7: [6, 0, 0, 0]
8: [11, 9, 0, 0]
9: [0, 0, 0, 0]
10: [6, 12, 0, 0]
11: [17, 0, 0, 0]
Dial 2 Radials:
0: [9, 21, 5, 0]
1: [13, 6, 0, 0]
2: [9, 15, 10, 0]
3: [7, 4, 0, 0]
4: [13, 9, 8, 0]
5: [21, 18, 0, 0]
6: [17, 11, 22, 0]
7: [4, 26, 0, 0]
8: [5, 14, 16, 0]
9: [0, 1, 0, 0]
10: [7, 12, 9, 0]
11: [8, 0, 0, 0]
Dial 3 Radials:
0: [7, 9, 3, 1]
1: [0, 20, 26, 0]
2: [9, 12, 6, 9]
3: [0, 3, 0, 0]
4: [7, 6, 2, 12]
5: [14, 0, 13, 0]
6: [11, 14, 9, 6]
7: [0, 12, 0, 0]
8: [8, 3, 17, 10]
9: [0, 8, 19, 0]
10: [16, 9, 3, 10]
11: [2, 0, 12, 0]
Dial 4 Radials:
0: [14, 8, 3, 2]
1: [11, 9, 3, 5]
2: [14, 10, 14, 10]
3: [14, 11, 14, 7]
4: [11, 12, 21, 16]
5: [14, 13, 21, 8]
6: [11, 14, 9, 7]
7: [14, 15, 9, 8]
8: [11, 4, 4, 8]
9: [11, 5, 4, 3]
10: [14, 6, 6, 4]
11: [11, 7, 6, 12]
```
### Requirements
1. Construct the dataset as you see fit.
2. To prevent targeted solutions, your program should suitably randomize the order of the data before traversing it (eg, spin the dials). "Suitably" will obviously have different meanings depending on how you construct your dataset, but the idea is that you randomize the relationship of one dial to the next (do not randomize the order of the radials *within* a dial - who do you think you are... Thanos?).
3. Detect the dial combination that will solve the puzzle
4. No post-hoc fixes; that is, no detecting the orientation of the dials after randomization and then arriving at a known-solution offset from that point. Your solution should, to the view of a reasonable person, mimic the efforts of someone approaching the puzzle for the first time, not knowing the answer beforehand.
5. External libraries are fine, but if you write it for this challenge, count it for this challenge.
6. Output solution as a **pipe-separated list of 12 entries**. These will represent the radial positions of the puzzle, once solved. Each entry should contain a **4-number, comma-separated list** representing the numbers viewable in that radial starting at the center and proceeding outward. An example:
```
#,#,#,#,#|#,#,#,#,#|...etc...
```
Note it will not matter what orientation the puzzle is in (which radial you consider to be "North" or 12 o'clock), as the progression of one radial to the next will be the same once you arrive at a starting point. Therefore, although there is a single solution to the puzzle, it can be stated 12 different ways, each of which would be valid.
>
> **Example:** A list of 12 single-entry items would be as valid if written `0,1,2,3,4,5,6,7,8,9,10,11` or `4,5,6,7,8,9,10,11,0,1,2,3`, or any of the other 10 lists derived from choosing a unique starting index.
>
>
>
## Scoring
This is a `code-golf` challenge, so smallest program by bytes wins. If possible, report your solution as 2 scores... a **Total Size** score that reflects all of your code (your dataset, randomization, and processing code), and a **Logical Size** that reflects just your processing code (what traverses the suitably randomized dataset). Command line input (ie, off-loading your dataset as an input to the function) should still count as the reported **Total Size** byte count, but obviously would not count to the **Logical Size** score. I am asking for this sort of scoring because I don't want to preclude creativity in lambda-izing the dataset, or elegance in logical traversing.
If you cannot adequately separate and determine a Logical Size score, just report a Total Size score.
Winners will be noted for EACH score -- for whomever has the lowest Total Size, and for whomever has the lowest Logical Size.
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/247878/edit).
Closed 1 year ago.
[Improve this question](/posts/247878/edit)
You are given 100 arrays/sets of 5-8 numbers between 1-20. If you combine all the arrays you will always get at least one of each number (1-20), so don't worry about an "unsolvable" case. The goal is to find the combination of arrays that minimizes duplicate numbers while still getting one of each number from 1-20.
Here's an example.
```
[1,5,16,12,9,3,7]
[10,13,6,5,7]
[2,17,8,18,12]
[4,3,11,14,7]
[15,19,20,1]
```
The above sets fill all the numbers from 1-20. The only slight problem is that it has duplicates. There are multiple 5s, 7s, and 1s. Duplicates are fine. In 100 arrays you most likely aren't going to find a perfect match with no duplicates, but the goal is to minimize the number of duplicates you get. The code should work with any random 100 arrays. Good luck! Hopefully, you might find a dynamic, smart technique, but brute force is perfectly fine.
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/239742/edit).
Closed 2 years ago.
[Improve this question](/posts/239742/edit)
The input message consists of ASCII characters
The encoded output message consists of blocks of 0
A block is separated from another block by a space
Two consecutive blocks are used to produce a series of same value bits (only 1s or 0s):
After the ACSII character(s) have been converted to binary, go through the string:
If its a 1: add `0 0` \*The last character multiplied by how many "1"s in the string consecutively after the first 1 found
Else If its a 0: add `00 0` \*The last character multiplied by how many "0"s in the string consecutively after the first 0 found
# Input:
The message consisting of N ASCII characters (without carriage return)
# Output:
The encoded message
# Example
Input
```
C
```
Output
```
0 0 00 0000 0 00
```
More details and a better explanation can be found here: <https://github.com/GlenDC/Codingame/blob/master/descriptions/chuck_norris.md>
**Remember! This is code-golf, shortest code wins!**
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/237262/edit).
Closed 2 years ago.
[Improve this question](/posts/237262/edit)
Assume the result of an exam has been published.
After 5 minutes, First person knows the result.
In next 5 minutes, new 8 persons know the result, and in total 9 know it.
Again after 5 minutes, new 27 people know, and total 36 know.
In similar fashion, total 100, 225..... people keep knowing it on 5 minute interval.
**Challenge**
Given a total number of people knowing (n), and a starting time in hour and minutes, output when total n people will know the result.
Example: If start is 1:02, and n is 225 the output time will be 1:27.
In output colons of time aren't needed, you may input or output as list or seperate variables.
`n` will be always in the sequence of totals, i.e. (1,9,36,100,225....)
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 85 bytes
```
lambda h,m,x:[(h+(y:=(((((x**.5)*8)+1)**.5)-1)*2.5)//60)%24+(m+y%60)//60,(m+y%60)%60]
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPqfZhvzPycxNyklUSFDJ1enwipaI0Nbo9LKVgMEKrS09Ew1tSw0tQ01wUxdIG0EpPX1zQw0VY1MtDVytStVgWyQgA6MA8Sx/wuKMvNKNNI0DHVMDHSMjEw1Nf8DAA "Python 3.8 (pre-release) – Try It Online")
The sequence of totals is just sum of first \$n\$ cubes.
It is a known formula that sum of first \$n\$ cubes is the square of \$n\$th triangular number ([Proof](https://mathschallenge.net/library/number/sum_of_cubes)), i.e.
\$
\{\frac{n(n+1)}{2}\}^2
\$
If we assume given input is \$x\$, then
\$
\{\frac{n(n+1)}{2}\}^2=x
\\
\frac{n(n+1)}{2}=\sqrt{x}
\\
n(n+1)=2\sqrt{x}
\\
n^2+n=2\sqrt{x}
\\
n^2+n-2\sqrt{x}=0
\$
We get a quadratic equation with \$a=1, b=1, c=-2\sqrt{x}\$
The formula for the quadratic equation is
\$
\frac{-b\pm\sqrt{b^2-4ac}}{2a}
\$
We will only take the positive root and plug in
\$
\frac{-b+\sqrt{b^2-4ac}}{2a}
\\
=\frac{-1+\sqrt{(-1)^2-4\times(-2\sqrt{x})\times1}}{2\times1}
\\
=\frac{-1+\sqrt{1+8\sqrt{x}}}{2}
\\
=\frac{(\sqrt{1+8\sqrt{x}})-1}{2}
\$
Which is the formula for the \$n\$, then we just multiply it by 5, divmod by \$60\$ and add with start time.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 103 bytes
```
\d+
$*
(^1|11\1)+
$#1$*
(^1|1\1)+¶(.+)
$2$1$1$1$1$1
+`:1{60}
1:
+`1{24}:
:
(1*):(1*)
$.1:$.2
:(.)$
:0$1
```
[Try it online!](https://tio.run/##NYg9CoNAGET7uUa@YteFxfn8KeYsEiKYIk0KSWe8lgfwYqsWMvB4b@b37/MdSxmmBKsQnvyTA@NZD97H1fsWcoowN95DeolLX6@gTufi7SoIgVXUBVimLDsUcjSoNpbi3sEbtX4A "Retina 0.8.2 – Try It Online") Takes `n` on the first line and the time (including colon) on the second.Explanation:
```
\d+
$*
```
Convert to unary.
```
(^1|11\1)+
$#1$*
```
Take the square root.
```
(^1|1\1)+¶(.+)
$2$1$1$1$1$1
```
Add 5 times the triangular index to the minutes.
```
+`:1{60}
1:
```
Convert 60 minutes to an hour.
```
+`1{24}:
:
```
Ignore days.
```
(1*):(1*)
$.1:$.2
:(.)$
:0$1
```
Convert to decimal.
] |
[Question]
[
This is based on a game one of my math teachers used to play in middle school. He would write 5 random one-digit numbers on the board, and then a random two-digit number. We would try to create an equation that used all 5 of the one-digit numbers to yield the two-digit number.
Here are some examples with solutions to explain this better:
```
Input: Solution:
7 5 4 8 4 34 5*8-7+4/4 = 34
3 1 5 7 6 54 (7+3)*6-5-1 = 54
3 9 2 1 6 87 9*(2+1)*3+6 = 87
2 1 6 9 7 16 (9-7+6*1)*2 = 16
2 4 5 8 6 96 8*(5+6)+2*4 = 96
3 8 4 5 4 49 8*(4+4)-3*5 = 49
```
This challenge is to write a program that can generate such equations for a given input.
The input can be provided either via the command line or via a prompt. The 5 one-digit numbers will always be entered first (in no particular order), followed by the two-digit number. The program will then print out a solution equation it finds; you do not have to handle situations where there is no solution. The function must be capable of using the following operations in the equation: addition, subtraction, multiplication, and division. If you would like to allow additional basic operations, that's fine as long as they remain in the spirit of the challenge (negation, exponentiation, and modulus would be nice additions). Order of operations follows the standard math rules, so parenthesis will be needed for grouping.
The program must take less than a minute to run on a modern computer.
Programs will be scored based on code length (including required whitespace).
Note: division must be exact, not rounded or truncated to nearest integer.
[Answer]
## Python 2.7 (284), Python 3.x (253)
```
from __future__ import division #(Remove for Python 3.x)
from itertools import *
a=raw_input().split()
for i in permutations(a[:-1],5):
for j in product('+-*/',repeat=5):
for k,l in combinations(range(1,12,2),2):
d=''.join(sum(zip(i,j),()))[:-1];d='('+d[:l]+')'+d[l:]
if eval(d)==int(a[-1]):print d;b
```
It gives an error (calling unknown function `b`) on solution.
Basically, it's a gigantic brute force. It takes in the input, splits it by its spaces (`1 2 -> [1,2]`), and then permutes through that list. With every permutation, it will iterate through all possible strings of length 5 using the characters `+-*/`. With each of those iterations, it will generate the combinations of length 2 of the list `[1,3,5,7,9,11]`, interweave the permutation and the string together (`12345 *-/+- -> 1*2-3/4+5-`), and put in the parentheses. Finally, it will evaluate it, and if the answer and equation are true, then it prints the equation and stops.
This is horribly inefficient, about `O(n!/(n-5)!)=O(n^5)`, but it runs in a reasonable time for the test inputs.
[Answer]
### Scala 368:
The 2nd g=-Line is more easy to test, the first is flexible to take command arguments, and both are of equal length, so I only count from the second one - remove it to do args passing:
```
val g=(args.map(_.toDouble))
val g=Array(3,9,2, 1, 6, 87)
val k="+*/-DQ"
val i=(0 to 5)
val f:Seq[(Double,Double)=>Double]=Seq(_+_,_*_,_/_,_-_,(a,b)=>b-a,(a,b)=>b/a)
val h=g.init.permutations;
for(j<-h;o<-i;p<-i;q<-i;r<-i;z=try{f(r)(f(q)(f(p)(f(o)(j(0),j(1)),j(2)),j(3)),j(4))}catch{case _ => 0}
if(z==g(5)))printf("(((%d%c%d)%c%d)%c%d)%c%d=%d\n",j(0),k(o),j(1),k(p),j(2),k(q),j(3),k(r),j(4),g(5))
```
Sample output (you might have a question right now - just a moment):
```
(((5+7)/1)+6)*3=54
(((5-7)D1)*6)*3=54
(((5D7)+1)*6)*3=54
(((5+7)+6)Q1)Q3=54
```
What about this 5D7 thing? D1? Is it hex? There is Q1, Q3 - what's that.
Sir\_Lagsalot allowed new basic operations in the spirit of the challenge, and yes, these are basic operations, Delta and Quotient.
They are different from a/b and a-b in that aQb means b/a and aDb means b-a. Let's call it the Ukrainian notation.
So
```
(((5-7)D1)*6)*3=54
```
means
```
((1-(5-7))*6)*3=54
(1-(-2))*6*3
3*6*3 = 18*3=54
```
To the more interesting question of the how and why: In the beginning I got mad about the possibilities to place the parentheses, and whether (a+b)-c = a+b-c = (a+b-c) = ((a+b)-c) = (b+a)-c and so on. You can get mad over this question, but if you write down the possible parenthesis combinations, you sometimes throw away the scratch sheet and face the fact: You always perform 4 operations between 5 values, and you always start with one of them. If the pattern is always `(((_x_)x_)x_)x_ ?= _` (x being one of the 4 operators) and allow the opposite direction ( x b) and (b x a), you addressed every possibility.
Now for a+b and a\*b we don't need no opposite direction, they are commutative. So I invented the D and Q operator, which just switch the direction. I now have 2 operators more, but don't need to switch direction. Well - it is done in the function Sequence:
```
(a,b)=>b-a,(a,b)=>b/a
```
My for-comprehension takes the values from the Array g, and distributes them on a to e, then I pick 4 indexes to pick the function and later the (only by index) associated operator symbol. I have to catch div/0 errors, since subtraction can lead to zeros, while the sample input data doesn't contain a 0.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/235561/edit).
Closed 2 years ago.
[Improve this question](/posts/235561/edit)
Recently, I created a [binary word search](https://puzzling.stackexchange.com/questions/111576/a-pretty-binary-grid) that got me working with grids. It was fun, so I wanted to create some more similar content. Meet Pythagoras' Golfing grid:
[](https://i.stack.imgur.com/pkIkI.png)
Each of `d`, `e`, `f`, `g`, `h`, `i`, `j`, `k` and `T` represent a numeric value.
Now consider an orthogonal triangle along the lower diagonal of this grid (so the vertical side is `d`, `g`, `i`; the horizontal base is `i`, `j`, `k` and; the hypotenuse is `d`, `T`, `k`).
We'll then assign some value constraints to various different cells/sums of cells, in a manner similar to Pythagoras' theorem:
* Let \$a = d + g + i\$
* Let \$b = i + j + k\$
* Let \$c = f = dk\$
* Let \$T = f - eh\$
You'll be given the value of \$T\$. You should then output the values of \$d,e,f,g,h,i,j,k\$, in that order, such that \$a^2 + b^2 = c^2\$ (equivalently, such that \$(d+g+i)^2 + (i+j+k)^2 = f^2 = (dk)^2\$) and such that \$T = f - eh\$
For example, given a value \$T = 55\$, the output should be:
>
> `4,5,80,22,5,22,22,20`
>
>
>
as \$T = f-eh = 80-5\times5\$ and
$$\begin{align}
(4+22+22)^2 + (22+22+20)^2 & = 48^2 + 64^2 \\
& = 2304 + 4096 = 6400 \\
& = 80^2 = (4\times20)^2
\end{align}$$
The resulting grid would look like this:
[](https://i.stack.imgur.com/ttkMt.png)
#### Input
For clarity, your input will be a numeric value \$T\$:
>
> 55
>
>
>
#### Output
For clarity, your output will be a comma delimited list of the values \$d,e,f,g,h,i,j,k\$:
>
> 4,5,80,22,5,22,22,20
>
>
>
#### Completion of Processing
There can be more than one answer for a given \$T\$, and as such, processing should complete upon discovery of the first valid set of values.
#### Loophole Prevention
Loopholes should not be utilized to achieve an answer. For example, returning hard coded values is prohibited.
#### Final Notes
While their is no official time limit, you can feel free to or not to add a variable cutoff time to your solution and return an answer of ***u*** (representing unsolvable) for the sake of brevity when reviewing answers. So long as this portion of your solution is clearly explained, it can be excluded from your size calculation.
If you *choose* to add a cutoff time, please make it an additional variable for input named *c*.
#### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest code in bytes wins.
]
|
[Question]
[
This question is about moving stacks around in the card game [FreeCell](https://en.wikipedia.org/wiki/FreeCell), but here it will be presented more abstractly.
Given three integers \$0\le n,m<10000,0<k<10000\$.
There are \$m+2\$ columns, \$m\$ of them empty and two of them contain cards (from bottom to top) \$[0,-2,k]\$ and \$[0,-3,k-1,k-2,\cdots,1,0]\$. Besides, \$n\$ empty cells exist.
In each move, you can move the top \$i\$ cards of a column/cell to the top of another preserving order, if:
* After the move, each cell contain at most one card;
* If there are \$a\$ empty columns (not counting destination) and \$b\$ empty cells, then \$i\le (a+1)(b+1)\$. (See revision for more detailed background)
* After the move, all these moved cards are either at the bottom or on a card that is one larger than itself. (For not-bottom moved cards, that mean they are each "on a card that is one larger than itself")
Output the number of moves required to make the two columns contain \$[0,-2,k,k-1,k-2,\cdots,1,0]\$ and \$[0,-3]\$. Output something unambiguous (not a positive integer) and constant (same for every impossible mission) if it's impossible.
Samples:
```
1 1 4 -> 1
2 0 4 -> Impossible
0 2 4 -> 3 (see *)
0 2 3 -> 1 (direct moving allowed)
16 16 88 -> 1
```
\*:
```
[0,-2,4][0,-3,3,2,1,0][][]
[0,-2,4][0,-3,3,2][1,0][]
[0,-2,4,3,2][0,-3][1,0][]
[0,-2,4,3,2,1,0][0,-3][][]
```
Shortest code in each language win.
# Notes
* For those who know FreeCell, suits doesn't matter in this problem, and the 4/6/12 limit also doesn't exist.
* The "0,-2,k" and "0,-3" mean you are not supposed to move k or -3 away, as there's no way to put them back.
]
|
[Question]
[
Your function or program should take a year as input and return (or print) the date (in the Gregorian calendar) of that years Easter (not the Eastern Orthodox Easter). The date returned should be formatted according to ISO 8601, but with support for years greater than 9999 (such as *312013-04-05* or *20010130*), and it only needs to work with years greater than or equal to **1583** (the year of the adoption of the Gregorian calendar), and years less than or equal to **5701583** (as that is when the sequence of Easter dates starts to repeat itself).
Examples:
```
e(5701583) = 5701583-04-10
e(2013) = 2013-03-31
e(1583) = 1583-04-10
e(3029) = 30290322
e(1789) = 17890412
e(1725) = 17250401
```
The use of built-in functions for returning the date of easter is boring and therefore disallowed. Shortest answer (in characters) wins.
*Resources:*
* *<http://en.wikipedia.org/wiki/Computus#Algorithms>*
* *<http://web.archive.org/web/20150227133210/http://www.merlyn.demon.co.uk/estralgs.txt>*
[Answer]
## GolfScript (85 chars)
```
~:^100/.)3*4/.@8*13+25/-^19%.19*15+@+30%.@11/+29/23--.@-^.4/++7%97--^[[email protected]](/cdn-cgi/l/email-protection)/100*\31%)+
```
Sample usage:
```
$ golfscript.rb codegolf11132.gs <<<2013
20130331
```
Note that this uses a different algorithm to most of the current answers. To be specific, I've adapted the algorithm attributed to Lichtenberg in the resource linked by [Sean Cheshire](https://codegolf.stackexchange.com/users/5011/sean-cheshire) in a comment on the question.
The original algorithm, assuming sensible types (i.e. not JavaScript's numbers) and with an adaptation to give month\*31+day (using day offset of 0) is
```
K = Y/100
M = 15 + (3*K+3)/4 - (8*K+13)/25
S = 2 - (3*K+3)/4
A = Y%19
D = (19*A+M) % 30
R = (D + A/11)/29
OG = 21 + D - R
SZ = 7 - (Y + Y/4 + S) % 7
OE = 7 - (OG-SZ) % 7
return OG + OE + 92
```
I extracted a common subexpression and did some other optimisations to reduce to
```
K = y/100
k = (3*K+3)/4
A = y%19
D = (19*A+15+k-(8*K+13)/25)%30
G = 23+D-(D+A/11)/29
return 97+G-(G+y+y/4-k)%7
```
This approach has slightly more arithmetic operations than the other one (Al Petrofsky's 20-op algorithm), but it has smaller constants; GolfScript doesn't need to worry about the extra parentheses because it's stack-based, and since each intermediate value in my optimised layout is used precisely twice it fits nicely with GolfScript's limitation of easy access to the top three items on the stack.
[Answer]
# Python 2 - 125 120 119 chars
This is [Fors's answer](https://codegolf.stackexchange.com/a/11146/2621) shamelessly ported to Python.
```
y=input()
a=y/100*1483-y/400*2225+2613
b=(y%19*3510+a/25*319)/330%29
b=148-b-(y*5/4+a-b)%7
print(y*100+b/31)*100+b%31+1
```
**Edit**: Changed last line from `print"%d-0%d-%02d"%(y,b/31,b%31+1)` to save 5 characters. I would have loved to represent `10000` as `1e4`, but that would produce floating point necessitating a call to `int`.
**Edit2**:
Thanks to Peter Taylor for showing how to get rid of that `10000` and save 1 character.
[Answer]
# PHP 154
**150** chars if I switch to YYYYMMDD instead of YYYY-MM-DD.
```
<?$y=$argv[1];$a=$y/100|0;$b=$a>>2;$c=($y%19*351-~($b+$a*29.32+13.54)*31.9)/33%29|0;$d=56-$c-~($a-$b+$c-24-$y/.8)%7;echo$d>31?"$y-04-".($d-31):"$y-03-$d";
```
With Line Breaks:
```
<?
$y = $argv[1];
$a = $y / 100 |0;
$b = $a >> 2;
$c = ($y % 19 * 351 - ~($b + $a * 29.32 + 13.54) * 31.9) / 33 % 29 |0;
$d = 56 - $c - ~($a - $b + $c - 24 - $y / .8) % 7;
echo $d > 31 ? "$y-04-".($d - 31) : "$y-03-$d";
```
Useage: `php easter.php 1997`
Output: `1997-03-30`
Useage: `php easter.php 2001`
Output: `2001-04-15`
[Answer]
# dc: 106 characters
```
?[0n]smdndsy100/1483*ly400/2225*-2613+dsa25/319*ly19%3510*+330/29%sb148lb-5ly*4/la+lb-7%-d31/0nn31%1+d9>mp
```
Usage:
```
> dc -e "?[0n]smdndsy100/1483*ly400/2225*-2613+dsa25/319*ly19%3510*+330/29%sb148lb-5ly*4/la+lb-7%-d31/0nn31%1+d9>mp"
1725
17250401
>
```
This should be able to be shortened by using 'd' and 'r' instead of all the loads and stores.
[Answer]
# C: 151 148 characters
```
y;a;b;main(){scanf("%d",&y);a=y/100*1483-y/400*2225+2613;b=(y%19*3510+a/25*319)/330%29;b=148-b-(y*5/4+a-b)%7;printf("%d-0%d-%02d\n",y,b/31,b%31+1);}
```
And the same code, but better formatted:
```
#include <stdio.h>
int y, a, b;
int main() {
scanf("%d", &y);
a = y/100*1483 - y/400*2225 + 2613;
b = (y%19*3510 + a/25*319)/330%29;
b = 148 - b - (y*5/4 + a - b)%7;
printf("%d-0%d-%02d\n", y, b/31, b%31 + 1);
}
```
There are frightfully many algorithms for calculating the date of Easter, but only a few of them are well suited for code golfing.
[Answer]
# Javascript 162 156 145
```
function e(y){alert(y+"0"+((d=56-(c=(y%19*351-~((b=(a=y/100|0)>>2)+a*29.32+13.54)*31.9)/33%29|0)-~(a-b+c-24-y/.8)%7)>(f=31)?4:3)+(d-f>0&d-f<10?0:"")+(d>f?d-f:d))}
```
Inspired by @jdstankosky's PHP solution...
Provides YYYYMMDD result...
Now narrowed down to:
```
alert((y=prompt())+0+((d=56-(c=(y%19*351-~((b=(a=y/100|0)>>2)+a*29.32+13.54)*31.9)/33%29|0)-~(a-b+c-24-y/.8)%7)>(f=31)?4:3)+(d-f>0&d-f<10?0:"")+(d>f?d-f:d))
```
Now asks for input... reduced literal string of "0" to 0 and let loose typing work to my advantage! :)
Reduced further to take ES6 into account...
`e=y=>y+"0"+((d=56-(c=(y%19*351-31.9*~((b=(a=y/100|0)>>2)+29.32*a+13.54))/33%29|0)-~(a-b+c-24-y/.8)%7)>(f=31)?4:3)+(d-f>0&d-f<10?0:"")+(d>f?d-f:d)`
[Answer]
## APL 132
This algorithm calculates the number of days Easter lies relative to the beginning of March. The date is returned in the YYYYMMDD format as allowed in the question:
```
E y
(a b)←⌊((3 8×⌊y÷100)+¯5 13)÷4 25
c←7|y+(⌊y÷4)-a-e←⌊d-((19×d←30|(227-(11×c)-a-b))+c←19|y)÷543
+/(10*4 2 0)×y,(3+i>31),(61⍴⍳31)[i←e+28-c]
```
Taking the original test cases:
```
E 2013
20130331
E 1583
15830410
E 3029
30290322
E 1789
17890412
```
[Answer]
# Javascript 134 Characters
Using a slightly modified Al Petrofsky's 20-op algorithm to allow a simpler conversion into the year-month-date format.
This provides additional 14 characters shorter code from the answer provided by [WallyWest](https://codegolf.stackexchange.com/users/8555/wallywest)
## The Original Al Petrofsky's Code:
```
a =Y/100|0,
b =a>>2,
c =(Y%19*351-~(b+a*29.32+13.54)*31.9)/33%29|0,
d =56-c-~(a-b+c-24-Y/.8)%7;
```
Last line changed to:
```
d =148-c-~(a-b+c-24-Y/.8)%7;
```
## 1. 138 Characters With the format YYYY-MM-DD
```
e=y=>(c=(y%19*351-31.9*~((b=(a=y/100|0)>>2)+29.32*a+13.54))/33%29|0,d=148-c-~(a-b+c-24-y/.8)%7,y+'-0'+(d/31|0)+"-"+((o=d%31+1)>9?o:'0'+o))
console.log(e(2021));
console.log(e(2022));
console.log(e(5701583));
console.log(e(2013));
console.log(e(1583));
console.log(e(3029));
console.log(e(1789));
console.log(e(1725));
```
## 2. 134 Characters With the format YYYYMMDD
```
e=y=>(c=(y%19*351-31.9*~((b=(a=y/100|0)>>2)+29.32*a+13.54))/33%29|0,d=148-c-~(a-b+c-24-y/.8)%7,y+'0'+(d/31|0)+((d=d%31+1)>9?d:'0'+d))
console.log(e(2021));
console.log(e(2022));
console.log(e(5701583));
console.log(e(2013));
console.log(e(1583));
console.log(e(3029));
console.log(e(1789));
console.log(e(1725));
```
[Answer]
# [Fortran (GFortran)](https://gcc.gnu.org/fortran/), 179 bytes
```
READ*,I
J=I/100*2967-I/400*8875+7961
K=MOD(MOD(I,19)*6060+(MOD(MOD(J/25,59),30)+23)*319-1,9570)/330
L=K+28-MOD(I*5/4+J+K,7)
WRITE(*,'(I7,I0.2,I0.2)')I,(L-1)/31+3,MOD(L-1,31)+1
END
```
[Try it online!](https://tio.run/##NYvBDoIwEETv/RG67dbutpbSAwcTOBRQE2Li2QveNCH@PwLGw0zeTPKm9/yZHy/znH6wLGN7ahRm0dXZMpFyqYwm2@OKVRWDjqlk0dfnayO3ZOQEqqSStPx/nXUBQwL0BNp5UJ6TYUwhEljvSQx1r11ldl8Fe9Sd7jGCuI/51kqFhcwRMx3cXlBARjkYXmXWHjdtXegZNIv20iyLI66@ "Fortran (GFortran) – Try It Online")
Uses the "Emended Gregorian Easter" algorithm (Al Petrofsky) from the second resource link. Strangely, it fails for year 5701583 (and, apparently, only for this year), predicting the Easter as one week earlier. Prints the date in `YYYYYYYMMDD` format, with some leading spaces if the year has less then seven digits.
] |
[Question]
[
Sona is in her house with her 10 year old daughter. She needs to go to school to bring back another child from school, as school is over at 2 pm. It's hot outside, so she wants to leave her younger child at home.
She gave a bunch of strings to her child to keep her busy while she is gone. She asked her to reverse the words in the string. There are lot of strings, so you need to help her daughter in solving this huge task.
So, given a string that contains words separated by single space, reverse the words in the string. You can assume that no leading or trailing spaces are there.
The string will only contain `[a-zA-z ]`, so you don't need to handle punctuation.
You will be given a string as an input, and you should output a string.
### Sample Test Cases:
```
Input:
Man bites dog
Output:
dog bites Man
Input:
The quick brown fox jumps over the lazy dog
Output:
dog lazy the over jumps fox brown quick The
Input:
Hello world
Output:
world Hello
```
### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins.
[Answer]
## [Retina](https://github.com/m-ender/retina), 7 bytes
```
O$^`\w+
```
[Try it online!](https://tio.run/nexus/retina#@@@vEpcQU679/79vYp5CUmZJarFCSn46AA "Retina – TIO Nexus")
Match all words (`\w+`) sort them with sort key empty string (`O$`) which means they won't get sorted at all, and then reverse their order (`^`).
[Answer]
## Haskell, 21 bytes
```
unwords.reverse.words
```
[Try it online!](https://tio.run/nexus/haskell#@59mW5pXnl@UUqxXlFqWWlScqgfm/c9NzMxTsFUoKMrMK1FQUUhTUPJNzFNIyixJLVZIyU9X@g8A "Haskell – TIO Nexus")
[Answer]
# [Python 3](https://docs.python.org/3/), 29 bytes
```
print(*input().split()[::-1])
```
[Try it online!](https://tio.run/nexus/python3#@19QlJlXoqGVmVdQWqKhqVdckJMJpKOtrHQNYzX///dNzFNIyixJLVZIyU8HAA "Python 3 – TIO Nexus")
[Answer]
# Bash + common Linux utilities, 21
```
printf "$1 "|tac -s\
```
Leaves a trailing space in the output string - not sure if that's OK or not.
[Answer]
# JavaScript (ES6), 31 bytes
```
s=>s.split` `.reverse().join` `
```
---
## Try it
```
f=
s=>s.split` `.reverse().join` `
o.innerText=f(i.value="Man bites dog")
oninput=_=>o.innerText=f(i.value)
```
```
<input id=i><pre id=o>
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 6 bytes
```
ṇ₁↔~ṇ₁
```
[Try it online!](https://tio.run/nexus/brachylog2#@/9wZ/ujpsZHbVPqIKz//5V8E/MUkjJLUosVUvLTlf5HAQA "Brachylog – TIO Nexus")
### Explanation
```
ṇ₁ Split on spaces
↔ Reverse
~ṇ₁ Join with spaces
```
Note that both "split on spaces" and "join wth spaces" use the same built-in, that is `ṇ₁`, just used in different "directions".
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
ḲṚK
```
[Try it online!](https://tio.run/nexus/jelly#@/9wx6aHO2d5////3zcxTyEpsyS1WCElPx0A "Jelly – TIO Nexus")
Explanation:
```
Ḳ Splits the input at spaces
Ṛ Reverses the array
K Joins the array, using spaces
```
[Answer]
# R, 19 bytes
```
cat(rev(scan(,'')))
```
reads the string from stdin. By default, `scan` reads tokens separated by spaces/newlines, so it reads the words in as a vector. `rev` reverses, and `cat` prints the elements with spaces.
[Try it online!](https://tio.run/nexus/r#@5@cWKJRlFqmUZycmKeho66uqan53zcxTyEpsyS1WCElP/0/AA)
[Answer]
# C#, 58 bytes
```
using System.Linq;s=>string.Join(" ",s.Split().Reverse());
```
[Answer]
# C, ~~54~~ 48 bytes
**Using arguments as input, 48 bytes**
```
main(c,v)char**v;{while(--c)printf("%s ",v[c]);}
```
[*Try Online*](https://tio.run/nexus/c-gcc#@5@bmJmnkaxTppmckVikpVVmXV2ekZmTqqGrm6xZUJSZV5KmoaRarKCkUxadHKtpXfv////cxLz/qYklxf9T8tMB)
```
> ./a.out man bites dog
```
**Using pointers, 84 bytes**
```
f(char*s){char*t=s;while(*t)t++;while(t-s){while(*t>32)t--;*t=0;printf("%s ",t+1);}}
```
*Use*
```
main(){ f("man bites dog"); }
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
#Rðý
```
Note: Will only work for 2 or more words. +1 byte if this is not OK.
[Try it online!](https://tio.run/nexus/05ab1e#@68cdHjD4b3///sm5ikkZZakFiuk5KcDAA "05AB1E – TIO Nexus")
[Answer]
# [GNU Make](https://www.gnu.org/software/make/), 62 bytes
```
$(if $1,$(call $0,$(wordlist 2,$(words $1),$1)) $(word 1,$1),)
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 74 bytes
```
,[>++++[<-------->-],]<[>++++[->--------<]+>[[<]>[+>]<]<-[<]>[.>]<[[-]<]<]
```
[Try it online!](https://tio.run/nexus/brainfuck#@68TbacNBNE2ulBgpxurE2sDFQXyoMAmVtsuOtom1i5a2y7WJtZGF8zWA7Kjo3VBArH//7vkpyskZZakFivkJuYBAA "brainfuck – TIO Nexus")
This code creates the number -32 in two different places, but that seems to be fewer bytes than trying to maintain a single -32.
### Explanation
```
,[ input first character
>++++[<-------->-] subtract 32 from current character (so space becomes zero)
,] repeat for all characters in input
< go to last character of last word
[ while there are more words to display:
>++++[->--------<] create -32 two cells right of last letter
+> increment trailing space cell (1 right of last letter) so the next loop works
[[<]>[+>]<] add 32 to all cells in word and trailing space cell
<- subtract the previously added 1 from the trailing space
[<]> move pointer to beginning of word
[.>]< output word (with trailing space)
[[-]<] erase word
< move to last character of previous word
]
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 48 bytes
Almost gave up on this one, but finally got there.
```
oU_;SW;@?ABu>):tS-?;\0$q^s.$;;<$|1osU!(;;...<#(1
```
[Try it online!](https://tio.run/nexus/cubix#@58fGm8dHG7tYO/oVGqnaVUSrGtvHWOgUhhXrKdibW2jUmOYXxyqqGFtraenZ6OsYfj/f0lRfmlSTqpCRqpCZjEA "Cubix – TIO Nexus")
This maps onto a cube with a side length of three as follows
```
o U _
; S W
; @ ?
A B u > ) : t S - ? ; \
0 $ q ^ s . $ ; ; < $ |
1 o s U ! ( ; ; . . . <
# ( 1
. . .
. . .
```
The general steps are:
* Get all input `A` and reverse `B` stack
* Move the negative `q` to the bottom, add a counter `0` to the stack. bit of jumping around in here.
* Find space/end loop, also puts stack in correct print order.
+ Increment counter `)` and fetch the counter item from the stack `t`
+ Is it a space or EOI `S-?`
+ Repeat if not
* Print word loop
+ Decrement counter `(`
+ Exit loop if counter `!U` is 0
+ Swap `s` counter with character on stack
+ Print `o` character and pop it from the stack `;`
+ Repeat loop
* Get the length of the stack `#` and decrement `(`
* Check `?` if 0 and exit `@` if it is 0
* Otherwise print a space `So` clean up `;;` and go back to the first loop.
I've skipped a number of superfluous steps, but you can see it [Step By Step](https://ethproductions.github.io/cubix/?code=ICAgICAgbyBVIF8KICAgICAgOyBTIFcKICAgICAgOyBAID8KQSBCIHUgPiApIDogdCBTIC0gPyA7IFwKMCAkIHEgXiBzIC4gJCA7IDsgPCAkIHwKMSBvIHMgVSAhICggOyA7IC4gLiAuIDwKICAgICAgIyAoIDEKICAgICAgLiAuIC4KICAgICAgLiAuIC4K&input=aGVyZSB0aGV5IGFyZQ==&speed=10)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~11~~ ~~10~~ ~~7~~ 4 bytes
My first attempt at Japt.
```
¸w ¸
```
[Try it online](http://ethproductions.github.io/japt/?v=1.4.4&code=uHcguA==&input=Ik1hbiBiaXRlcyBkb2ci)
* Saved 3 bytes thanks to [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions)
---
## Explanation
```
:Implicit input of string U
¸ :Split on <space>
w :Reverse
¸ :Join with <space>
```
---
Please share your Japt tips [here](https://codegolf.stackexchange.com/q/121253/58974).
[Answer]
# [Python 2](https://docs.python.org/2/), 34 bytes
```
lambda s:' '.join(s.split()[::-1])
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQbKWuoK6XlZ@Zp1GsV1yQk1mioRltZaVrGKv5v6AoM69EIU1D3TcxTyEpsyS1WCElP11d8z8A "Python 2 – TIO Nexus")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 4 bytes
```
jd_c
```
[Try it online!](http://pyth.herokuapp.com/?code=jd_c&input=%22Man%20bites%20dog%22&test_suite=1&test_suite_input=%22Man%20bites%20dog%22&debug=0)
[Answer]
# PHP, 47 Bytes
```
<?=join(" ",array_reverse(explode(" ",$argn)));
```
[Try it online!](https://tio.run/nexus/php#s7EvyCjgUkksSs@zVfJNzFNIyixJLVZIyU9Xsuayt/tvY2@blZ@Zp6GkoKSTWFSUWBlflFqWWlScqpFaUZCTn5IKlgHr19TUtP7/HwA "PHP – TIO Nexus")
[Answer]
# k, 9 bytes
```
" "/|" "\
```
[Try it in your browser of the web variety!](http://johnearnest.github.io/ok/?run=%22%20%22%2F%7C%22%20%22%5C%22Man%20bites%20dog%22)
```
" "\ /split on spaces
| /reverse
" "/ /join with spaces
```
[Answer]
# [J-uby](http://github.com/cyoce/J-uby), 23 bytes
```
:split|:reverse|~:*&' '
```
### Explanation
```
:split # split by spaces
| # then
:reverse # reverse
| # then
~:*&' ' # join with spaces
```
[Answer]
## Mathematica, 35 bytes
```
StringRiffle@Reverse@StringSplit@#&
```
[Try it online!](https://tio.run/nexus/mathics#S7P9H1xSlJmXHpSZlpaT6hCUWpZaVJzqABEMLsjJLIlW1lFSUIpV@x8AFCpRcEhzUPJNzFNIyixJLVZIyU9X@g8A "Mathics – TIO Nexus")
[Answer]
# Vim, 20 bytes
```
:s/ /\r/g|g/^/m0<cr>vGJ
```
This is shorter than the other vim answer.
[Try it online!](https://tio.run/nexus/v#@29VrK@gH1Okn16Trh@nn2vAVebu9f@/b2KeQlJmSWqxQkp@OgA "V – TIO Nexus")
[Answer]
# [Röda](https://github.com/fergusq/roda), ~~27~~ 25 bytes
*2 bytes saved thanks to @fergusq*
```
{[[split()|reverse]&" "]}
```
[Try it online!](https://tio.run/nexus/roda#S4v5Xx0dXVyQk1mioVlTlFqWWlScGqumpKAUW/s/NzEzr5orWslRIclZIcU1TcE9wzNLKbYmjav2PwA "Röda – TIO Nexus")
This function takes input from the input stream.
### Explanation (outdated)
```
{[[(_/" ")()|reverse]&" "]} /* Anonymous function */
(_/" ") /* Pull a value from the stream and split it on spaces */
() /* Push all the values in the resulting array to the stream */
|reverse /* And reverse it */
[ ] /* Wrap the result into an array*/
&" " /* Concatenate each of the strings in the array with a space */
[ ] /* And push this result to the output stream */
```
[Answer]
# Pyth, 3 bytes
```
_cw
```
My first Pyth answer, one byte shorter than @notjagan's answer!
Explained:
```
cw # Split the input by space (same as Python's string.split())
_ # Reverses the array
# Pyth prints implicitly.
```
[Answer]
# [Zsh](https://www.zsh.org/), 13 bytes
```
echo ${(Oa)@}
```
[Try it online!](https://tio.run/##qyrO@J@moVn9PzU5I19BpVrDP1HTofZ/LVeaQkhGqkJhaWZytkJSUX55nkJafoVCVmluQbFCfllqkUIJUDonsapSISU//T8A "Zsh – Try It Online")
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 4 bytes
```
z]Qù
```
[Try it online!](https://tio.run/nexus/ohm#@18VG3h45///vol5CkmZJanFCin56QA "Ohm – TIO Nexus")
**Explanation**
```
z Split the input on spaces.
] Dump it onto the stack.
Q Reverse the stack.
ù Join the stack with spaces. Implicit output.
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 7 bytes
```
qS/W%S*
```
[Try it online!](https://tio.run/nexus/cjam#@18YrB@uGqz1/79vYp5CUmZJarFCSn46AA "CJam – TIO Nexus")
**Explanation**
```
q e# Read input
S/ e# Split on spaces
W% e# Reverse
S* e# Join with spaces
```
[Answer]
# [TAESGL](https://github.com/tomdevs/taesgl), 7 bytes
```
ĴS)Ř)ĴS
```
[**Interpreter**](https://tomdevs.github.io/TAESGL/v/1.3.1/index.html?code=XHUwMTM0UylcdTAxNTgpXHUwMTM0Uw==&input=Ik1hbiBiaXRlcyBkb2ci)
**Explanation**
```
ĴS)Ř)ĴS
AĴS) implicit input "A" split at " "
Ř) reversed
ĴS joined with " "
```
[Answer]
# [J](http://jsoftware.com/), 6 bytes
```
|.&.;:
```
[Try it online!](https://tio.run/nexus/j#HYyxCsIwFEX3fsXFwVqoQddGRRHFQRdxlzZ9bQIxD5tXuvjvtTocuAcuZ6bSBtsCKXKsUEwsFY73/HoeP2qudDFmSSLmd9lo9Vwj1bcyoHJCETW3@oAKBjWh0RfynjFw52utH5Y6gosIjLKK7HshePdyAg4QOwmFViy4QYmhcyIUcAqtd9EiUpjUUJokZCxjh8W756lApbH7hUaTZf8NMeMX "J – TIO Nexus") This is reverse (`|.`) under (`&.`) words (`;:`). That is, split sentence into words, reverse it, and join the sentence again.
[Answer]
# Gema, 29 characters
```
<W><s>=@set{o;$1 ${o;}}
\Z=$o
```
Sample run:
```
bash-4.4$ gema '<W><s>=@set{o;$1 ${o;}};\Z=$o' <<< 'Man bites dog'
dog bites Man
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 2 years ago.
[Improve this question](/posts/226485/edit)
Several Mathematica functions have system-defined short forms, e.g., /@ for Map. Many of them are listed here: <https://reference.wolfram.com/language/tutorial/OperatorInputForms.html>
However, there also exist some system-defined short forms for function-option combinations. E.g., `Log2@n`instead of `Log[2, n]` and `Log10@n`instead of `Log[10, n]`. Is there a comprehensive list of these?
]
|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/223153/edit).
Closed 2 years ago.
[Improve this question](/posts/223153/edit)
There are \$a\$ honest man(always tell the truth), \$b\$ dishonest man(always tell lie), and \$c\$ random man(tell random Y/N). How many times at least should you ask one of them a yes/no question about who they are, to guarantee you get knowledge of who they are? You may assume that it's possible.
Test cases:
```
(a,b,c) -> ans
(1,1,0) -> 1
(1,1,1) -> 3
(0,0,2) -> 0
```
Notes:
* I don't know if there's clever way, but anyway brute-force work
* It's same if you can ask any expression without referring current or future ask. If you ask them "what will A answer if I ask B" the answer is just "(A is liar) xor B". "Did A tell lie when answering B" is just "(A's answer) xor B".
* Actually it's possible to identify them iff there are less than half of random answerer, or an edge case that all are random answerers. Only considering honest and random, if there are more honest than random, ask them same question and do a majority vote gets answer to the question. If there are same honest and random, and random tell as if they are honest and real honest are random, you can't tell the difference.
[Sandbox](https://codegolf.meta.stackexchange.com/a/18940/)
]
|
[Question]
[
**This question already has answers here**:
[Check if input is permutation of source [duplicate]](/questions/90154/check-if-input-is-permutation-of-source)
(1 answer)
[Determine whether strings are anagrams](/questions/1294/determine-whether-strings-are-anagrams)
(162 answers)
Closed 2 years ago.
I like anagrams. I like programs that reference their own source code. So this challenge combines them!
**Input.**
The input to the program could be anything, including letters, numbers, symbols, you name it.
**Output.**
A truthy value if the input's characters can be rearranged to give the source code, and a falsy value if the input's characters cannot. This does include spaces: the input must have the same number of spaces as the source code.
**Scoring.**
Lowest amount of characters wins, with one exception: the program must use at least three distinct characters.
]
|
[Question]
[
So... uh... this is a bit embarrassing. But we don't have a plain "Hello, World!" challenge yet (despite having 35 variants tagged with [hello-world](/questions/tagged/hello-world "show questions tagged 'hello-world'"), and counting). While this is not the most interesting code golf in the common languages, finding the shortest solution in certain esolangs can be a serious challenge. For instance, to my knowledge it is not known whether the shortest possible Brainfuck solution has been found yet.
Furthermore, while all of ~~[Wikipedia](https://en.wikipedia.org/wiki/List_of_Hello_world_program_examples)~~ (the Wikipedia entry [has been deleted](https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/List_of_Hello_world_program_examples) but there is a [copy at archive.org](https://web.archive.org/web/20150411170140/https://en.wikipedia.org/wiki/List_of_Hello_world_program_examples)
), [esolangs](https://esolangs.org/wiki/Hello_world_program_in_esoteric_languages) and [Rosetta Code](https://rosettacode.org/wiki/Hello_world/Text) have lists of "Hello, World!" programs, none of these are interested in having the shortest for each language (there is also [this GitHub repository](https://github.com/leachim6/hello-world)). If we want to be a significant site in the code golf community, I think we should try and create the ultimate catalogue of shortest "Hello, World!" programs (similar to how our [basic quine challenge](https://codegolf.stackexchange.com/q/69/8478) contains some of the shortest known quines in various languages). So let's do this!
## The Rules
* Each submission must be a full program.
* The program must take no input, and print `Hello, World!` to STDOUT (this exact byte stream, including capitalization and punctuation) plus an optional trailing newline, and nothing else.
* The program must not write anything to STDERR.
* If anyone wants to abuse this by creating a language where the empty program prints `Hello, World!`, then congrats, they just paved the way for a very boring answer.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
* Submissions are scored in *bytes*, in an appropriate (pre-existing) encoding, usually (but not necessarily) UTF-8. Some languages, like [Folders](https://esolangs.org/wiki/Folders), are a bit tricky to score - if in doubt, please ask on [Meta](https://meta.codegolf.stackexchange.com/).
* This is not about finding *the* language with the shortest "Hello, World!" program. This is about finding the shortest "Hello, World!" program in every language. Therefore, I will not mark any answer as "accepted".
* If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck-derivatives like Alphuck), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
As a side note, please *don't* downvote boring (but valid) answers in languages where there is not much to golf - these are still useful to this question as it tries to compile a catalogue as complete as possible. However, *do* primarily upvote answers in languages where the authors actually had to put effort into golfing the code.
For inspiration, check [the Hello World Collection](https://helloworldcollection.github.io/).
## The Catalogue
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
## [><>](https://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
jQuery.ajax({
url: answersUrl(answer_page++),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
answers.push.apply(answers, data.items);
answers_hash = [];
answer_ids = [];
data.items.forEach(function(a) {
a.comments = [];
var id = +a.share_link.match(/\d+/);
answer_ids.push(id);
answers_hash[id] = a;
});
if (!data.has_more) more_answers = false;
comment_page = 1;
getComments();
}
});
}
function getComments() {
jQuery.ajax({
url: commentUrl(comment_page++, answer_ids),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c);
});
if (data.has_more) getComments();
else if (more_answers) getAnswers();
else process();
}
});
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
return a.owner.display_name;
}
function process() {
var valid = [];
answers.forEach(function(a) {
var body = a.body;
a.comments.forEach(function(c) {
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});
var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
link: a.share_link,
});
else console.log(body);
});
valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});
var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;
var answer = jQuery("#answer-template").html();
answer = answer.replace("{{PLACE}}", lastPlace + ".")
.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)
.replace("{{LINK}}", a.link);
answer = jQuery(answer);
jQuery("#answers").append(answer);
var lang = a.language;
lang = jQuery('<a>'+lang+'</a>').text();
languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
});
var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);
langs.sort(function (a, b) {
if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
return 0;
});
for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
.replace("{{LINK}}", lang.link);
language = jQuery(language);
jQuery("#languages").append(language);
}
}
```
```
body {
text-align: left !important;
display: block !important;
}
#answer-list {
padding: 10px;
width: 290px;
float: left;
}
#language-list {
padding: 10px;
width: 500px;
float: left;
}
table thead {
font-weight: bold;
}
table td {
padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<thead>
<tr><td>Language</td><td>User</td><td>Score</td></tr>
</thead>
<tbody id="languages">
</tbody>
</table>
</div>
<div id="answer-list">
<h2>Leaderboard</h2>
<table class="answer-list">
<thead>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
</thead>
<tbody id="answers">
</tbody>
</table>
</div>
<table style="display: none">
<tbody id="answer-template">
<tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
<tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
```
[Answer]
# Stuck, 0 bytes
Well, can't get shorter than that...
An empty program will output `Hello, World!` in [Stuck](http://esolangs.org/wiki/Stuck).
[Answer]
# [PHP](https://php.net), 13 bytes
```
Hello, World!
```
Yes. It works.
[Try it online!](https://tio.run/##K8go@P/fIzUnJ19HITy/KCdF8f9/AA "PHP – Try It Online")
[Answer]
# Brainfuck, 78 bytes
~~***Open-ended bounty:** If anyone can improve this score, I will pass the bounty (+500) on to them.*~~
[@KSab](https://codegolf.stackexchange.com/users/15858/ksab) has found a [~~76~~ 72 byte solution](https://codegolf.stackexchange.com/a/163590/4098)!
```
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
```
[Try it online!](https://tio.run/nexus/brainfuck#HYqBCQBACAIHEp1AXCR@/zH6SkU4tEnTRqGMkMzZ9suzSRknDWhqWMlmPtrhiItQ9wc)
The first 28 bytes `--<-<<+[+[<+>--->->->-<<<]>]` initialize the tape with the following recurrence relation (mod 256):
\$f\_n=171(-f\_{n-1}-f\_{n-2}-f\_{n-3}+1)\$, with \$f\_0=57, f\_1=123,f\_2=167\$
The factor of \$171\$ arises because \$3^{-1}=171 \pmod{256}\$. When the current value is translated one cell back (via `<+>---`) subtracting \$3\$ each time effectively multiplies the value by \$171\$.
At \$n=220\$ the value to be translated is zero, and the iteration stops. The ten bytes preceding the stop point are the following:
\$[130, 7, 43, 111, 32, 109, 87, 95, 74, 0]\$
This contains all of the components necessary to produce `Hello, World!`, in hunt-and-peck fashion, with minor adjustments.
I've also found an alternative 78 byte solution:
```
-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.
```
[Try it online!](https://tio.run/nexus/brainfuck#HUqBCQAwCDpI7ALxkdj/ZzRLTDQdNtACTCOakx4D4ymoFZYqBhfKDr2/rC/xivQzHw)
I consider this one to be better than the first for several reasons: it uses less cells left of home, it modifies less cells in total, and terminates more quickly.
---
### More Detail
Recurrence relations have surprisingly terse representations in Brainfuck. The general layout is the following:
```
{...s3}<{s2}<{s1}[[<+>->{c1}>{c2}>{c3...}<<<]>{k}]
```
which represents:
\$f\_n=c\_1f\_{n-1}+c\_2f\_{n-2}+c\_3f\_{n-3}+\cdots+k\$
with
\$f\_0=s\_1, f\_1=s\_2+c\_1f\_0+k,f\_2=s\_3+c\_2f\_0+c\_1f\_1+k,\text{etc.}\$
Additionally, the `<+>` may be changed to multiply the range by a constant without affecting the stop point, and a term may be added before the `>{k}` to shift the range by a constant, again without affecting the stop point.
---
### Other Examples
**Fibonacci Sequence**
```
+[[<+>->+>+<<]>]
```
***N*-gonal Numbers**
*Triangular Numbers*
```
+[[<+>->++>-<<]>+]
```
Defined as \$f\_n=2f\_{n-1}-f\_{n-2}+1\$, with \$f\_0=0,f\_1=1\$.
*Square Numbers*
```
+[[<+>->++>-<<]>++]
```
*Pentagonal Numbers*
```
+[[<+>->++>-<<]>+++]
```
etc.
---
### BF Crunch
I've published the code I used to find some of this solutions on [github](https://github.com/primo-ppcg/BF-Crunch). Requires .NET 4.0 or higher.
```
Usage: bfcrunch [--options] text [limit]
Arguments
------------------------------------------------------------
text The text to produce.
limit The maximum BF program length to search for. If zero, the length of the
shortest program found so far will be used (-r). Default = 0
Options
------------------------------------------------------------
-i, --max-init=# The maximum length of the initialization segment. If excluded, the
program will run indefinitely.
-I, --min-init=# The minimum length of the initialization segment. Default = 14
-t, --max-tape=# The maximum tape size to consider. Programs that utilize more tape than
this will be ignored. Default = 1250
-T, --min-tape=# The minimum tape size to consider. Programs that utilize less tape than
this will be ignored. Default = 1
-r, --rolling-limit
If set, the limit will be adjusted whenever a shorter program is found.
-?, --help Display this help text.
```
Output is given in three lines:
1. Total length of the program found, and the initialization segment.
2. Path taken, starting with the current tape pointer. Each node corresponds to one character of output, represented as (pointer, cost).
3. Utilized tape segment.
For example, the final result for `bfcrunch "hello world" 70 -r -i23` is:
```
64: ++++[[<+>->+++++>+<<]>]
49, (45, 5), (44, 3), (45, 6), (45, 1), (45, 4), (42, 4), (43, 5), (45, 3), (45, 4), (46, 2), (44, 4)
32, 116, 100, 104, 108, 132, 0, 0, 132, 0
```
This corresponds to the full program:
```
++++[[<+>->+++++>+<<]>]<<<<.<+.>++++..+++.<<<.>+++.>>.+++.>.<<-.
```
---
### Other Records
**Hello, World!**
*Wrapping, ~~**78 bytes**:~~*
*[Surpassed by @KSab (72)](https://codegolf.stackexchange.com/a/163590/4098)*
```
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
```
or
```
-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.
```
*Non-wrapping, ~~**80 bytes** (previously [92 bytes (mitchs)](http://codegolf.stackexchange.com/a/55506)):~~*
*[Surpassed by @KSab (76)](https://codegolf.stackexchange.com/a/163590/4098)*
```
-[[<]->+>>>>+>+>+>+>+>+]>>>>+.>>>++.<++..<.<<--.<+.>>>>>>--.<<<.+++.>.>-.<<<<<+.
```
**Hello, world!**
*Wrapping, ~~**80 bytes**:~~*
*[Surpassed by @KSab (77)](https://codegolf.stackexchange.com/a/163590/4098)*
```
++<-[[<+>->+>--->-<<<]>+++]>+.<<<<<<<++.>>>..>.<<--.<<<--.>>+.>>>.+++.<.<<<-.<+.
```
*Non-wrapping, **81 bytes** (previously [92 bytes (hirose)](http://golf.shinh.org/reveal.rb?Helloworldless+Hello+world/hirose_1313505002&bf)):*
```
+>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.>++>.>..+>>.+>-->--[>-.<<]
```
**hello, world!**
*Wrapping, ~~**74 bytes**:~~*
*[Surpassed by @KSab (70)](https://codegolf.stackexchange.com/a/163590/4098)*
```
-<++[[<+>->->+++>+<<<]->]<<.---.<..<<.<<<---.<<<<-.>>-.>>>>>.+++.>>.>-.<<.
```
*Non-wrapping, **84 bytes**:*
```
---->+++>++>->->++[+++++++[>+++++[>++>>+<<<-]<-]++<]>>>>.---.>---..+>->.+>-->+>[-.<]
```
---
### [Esolangs](http://esolangs.org/wiki/Brainfuck) Version
**Hello World!\n**
*Wrapping, **76 bytes**:*
```
+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.[<]>+.
```
This uses one cell left of home, and thus would be considered 77.
*Non-wrapping, **83 bytes**:*
```
->+>>>+>>---[++++++++++[>++++++>+++>+<<<-]-<+]>+>+.>.->--..>->-.>[>.<<]>[+>]<<.>++.
```
[Rdebath approved](https://esolangs.org/wiki/Talk:Brainfuck#Shortest_known_.22hello_world.22_program.). profilebf output:
```
Hello World!
Program size 83
Final tape contents:
: 0 0 73 101 109 115 112 88 33 10 0
^
Tape pointer maximum 10
Hard wrapping would occur for unsigned cells.
Counts: +: 720 -: 79 >: 221 <: 212
Counts: [: 9 ]: 84 .: 13 ,: 0
Total: 1338
```
---
### [inversed.ru](http://inversed.ru/InvMem.htm#InvMem_7) (Peter Karpov)
**Hello World!**
*Wrapping, **70 bytes** (previously 781):*
```
+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.
```
*Non-wrapping, **77 bytes** (previously 89?):*
```
->+>>>+>>-[++++++[>+++++++++>+++++>+<<<-]<+]>>.>--.->++..>>+.>-[>.<<]>[>]<<+.
```
The author claims that the shortest hand-coded "Hello World!" is 89 bytes, but provides no reference. I hereby claim the record for this, too.
**hello world!**
*Wrapping, **65 bytes** (previously 66 bytes):*
```
+++[>--[>]----[----<]>---]>>.---.->..>++>-----.<<<<--.+>>>>>-[.<]
```
This is actually hand-coded as well (the best I could find by crunching is [68 bytes](https://tio.run/nexus/brainfuck#HYiBCQBACAIHkpxAXCTaf4w@X1C8W1y6BZdzYUjj0YUCvyQzMUHan32mruDuAw)). The first cell is initialized to 259 (3), and decremented by 7 each iteration, looping 37 times. The next cell is decremented by 6, resulting in 256 − 6·37 = 34. The rest of the cells are decremented by 4 each time, adding one cell each iteration, with each new cell inialized to 252 (-4). The result is the following:
```
[ 3, 0, 0, 0, 0, 0, 0, ...]
[252, 250, 248, 0, 0, 0, 0, ...]
[245, 244, 244, 248, 0, 0, 0, ...]
[238, 238, 240, 244, 248, 0, 0, ...]
[231, 232, 236, 240, 244, 248, 0, ...]
[224, 226, 232, 236, 240, 244, 248, ...]
...
[ 35, 64, 124, 128, 132, 136, 140, ...]
[ 28, 58, 120, 124, 128, 132, 136, ...]
[ 21, 52, 116, 120, 124, 128, 132, ...]
[ 14, 46, 112, 116, 120, 124, 128, ...]
[ 7, 40, 108, 112, 116, 120, 124, ...]
[ 0, 34, 104, 108, 112, 116, 120, ...]
```
1 The solution given (79 bytes) can be trivially reduced by one:
```
-[>>+>+[++>-<<]-<+<+]>---.<<<<++.<<----..+++.>------.<<++.>.+++.------.>>-.<+.
```
[Answer]
# [ArnoldC](http://lhartikk.github.io/ArnoldC/), 71 bytes
```
IT'S SHOWTIME
TALK TO THE HAND "Hello, World!"
YOU HAVE BEEN TERMINATED
```
Just for lols...
[Try it online!](https://tio.run/##DcmxCoAgEADQ3a@4XFr6CcMDpVTIK2mMbDsS/H@4euu7@tu43iKexgzZpUI@oCKzLkAJyCE4Ey1o9zC3CUrrXAetzrT/cSDMiBEIt@CjIbQiHw "ArnoldC – Try It Online")
[Answer]
# [Seed](https://esolangs.org/wiki/Seed), ~~6016~~ ~~4234~~ 4203 bytes
```
20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793
```
[Try it online!](https://tio.run/##JdfZdR05DATQVBwCSXDNZxyB8z@aWy3/WHpPTQK1Af3v79//fn5G@3PXvGfMVa3VPPvMtt8bo689a4x96lR/c91x15pvnnX3OLv1dkZv9/UzTvfdnLPfevvsdbtP51qeG2fe1d6cb61Wbaz7Vq96t80xdx/rdF/d29fq@ZPx@lbIue3sV@XM0/ZajlecYvpzf7uKUV3tptDmQ6WX0@85t7p21pjXoy8lnPeaa56afDa2vnzf2qrv0/vGfu7YtZ2prDbavPqfo7oL9@zpo415pr738N3e3S1zDGVWP04ET9eQ464WSl27r6Ayrgvg@QLZGaVwnQ2VrAfCWfdVm/M@tfTeW87USm@9w3LduhM4IJjnKe@Wc08g2@Uj9Z@xR81aqoLh9cXcbVdpvp8cUgpZ62jvNhCVE3cbpYzbrz76KX1Nt882OirPTUs1tNHHu2uce1NRc6sey4kD4qeXrkB8w8TGOO5QNagkBekjTURSrftlXyjtRRI@HYCp2VtBYSjmqQkIBbvXgnyr21w8iWG@sYZeAE9y66W8d33qFnStHSk6bIzZ@h5k@N4mEuStWYeAKtCq8LS3IzykjLp3p@t32gDYUZLLHP9ppANnRJCuXRTggnCOgI6QszvNnGrBbVMd7tfaG5@r9SieKkcUVUcZq931iNZHqQolHxrHBaw0p5@hC@cWdnsjawTRV8F3H5ZpPbLu/fh7xev55QlC0UF6BCu5@4K7FMRYM32CRj3Tbzgj21DR5@rRxVI53rSYC8lYb1zW5gmacXvbE0kVaHMLStbRJoKoF46QUCffbpZmZpqqV3oO9265kiSqjv546T0qxMDjTioMBaTWb5A4fK1Gn23Q3ZjMVThb6/NUEwC912SBM/xrAgSfSDpPTH1koR0b4XE3AmohmOmdISUSQedDlxNWjSC61aVKFvTcpBBgY2JwewQKJLp78E8mOHKuZB2LTa3Ebuwc4xG9om6iKaJr8IUe0vw8IU4ILojLkCgPAjbyFY5C7TOSwxM05xx@uUFjF2zYQS0YOUJDAwBFgAtfArGvSnCD9SY6YhLRByeJ@4FBF8KNuhPDQidF3L7F4XXqEBDCw5WQ8eze8KU@AmpcWTGhPOoMhy9dXZxInBaU6OMATgmqciAhjD0Vz/gzWc6eyIrDaKxCiOFxb/QjpF9ELY/oZCZFu2gArONQT5cj@COSNGRESQUIQRo7i9RudLtl7k4SYtooWJICCKZT1EGjwlxPgFK2/ivC2gnXFclVGo5kZ4Mq9vk3U4wrRP2aIZVeoseO5C5/62MxqaW9kxHRJFAPfWrT1mmB9Pn9wztXnZLTxov2t/nhyBav8DatH/y6YX2DL5BMYFGBwEJ7Ojzx9f00K4ijnNjVqWAQ8E8LTxWQm5lyIWh@kQ5BKeFaYs1UddC77AfW5qGZNJEnLaPSD4E4o7u@uMNklLKS3TvhuJPRmThSFwUJXzNE8awNCxQ@utB9FPm@P@hY@LQFC9AVkFky8jkJdNZIdScsZM6dfFnpIqMACr@qS4RJFTqUBGoWW1LjfWHOBxIcGV9ASXFSVeXJZxTWEkhIstSoaqJFdDBWNFPf0nGDg4rYXkKe8@0e4Q8Vijf08klihD5XNgDzQXYRq5bfb7i/iF7KglFQrSTW@IJBRhhf5wsTE8Hgga20ObW6bmRnz4PJquCNTaKKdkhP3H6TLI7cyYFvmNEBV/ugGc7A0psdJtFk6ajzGWyFrvbNKv9ncjzJbAjE5c5O9UqmQVCNjHm562KHudC5vkoMDOm9EjoriLTsHFx2g4Beo8wEi/TVYzYIUbEyJUhVdGcUCQKLHuhXKHQXCcyEj6bqN1lAZQXZWRdmgicu5GOTyffc2IKA5oybGRMiFmR50DZ3E7BuWVkflahukgeLG0/mhRiBLIVbkpw8shOaXSs18CvcQQ16nPRv6WPLSI9qTjRNWdazLuXwkciIniFVGZBZII3r@uZpTlc5HbPQJ@iTofTtunJofCtYxZc9o8EWrBTJczJDM5or@7JrODQRCCqHQspqkIGckRNkRG0SP5sF5JKDOSlBLA0M9Bc@aFnoBWLNkCzQsiHKNxPe/ja@eWvbkAa4Eh0mzic4Psk@ZETQtyekC7xpGHacI@Bf5mzW4Di0vtWwZdd1Tw/JmXuYswRm/xMyWZYy9r9lKkvuimiS0nhJ4HHat0xYpdRrv8LuTgkYsMrK0Cfi@IZ3MOb/nmwXJj1GIvE46304PgPhZaXj3uyq2QWysZy8uGT2e3qEhRV0yDrb/A3apJOl6obx@jYkRovVBT7HyQMBZ2Al8Mgo@@kLyeMXJLncMipmgsPxBu5MNr1v117ZWikMuPjO6vg9blSzoADYGd9Rdl6bsh@7CpeCZ0UhVlEP7LwboN0TIwcAy6uJGDMTCZrEowPc4yM7UtwrU825kwhDRV6gKAAJlczzK5yz8rACSeFgZ0fM1FifXAWORULtN@vRyzSRhTYmu3@0G@lFNZYAM2rl@B1Lmf@yAi8jgyFLpTTodGANbhkhiWvEewHDZN57pJ5FE5Xf2Zju33dZ6Nv3jvW9QuWl7WTx5SRNnXQoM5zp@yyT2KEvgyObdlYTa5PG4jJ448KpeQGwFo5MhU@WJwM270teXpCY1RbNish7aOIHCjdTtezurGnbX9/ufbLxnm8vXjH@@3b0lUXx22p@@xCaI6M7RrJxiWrY0MkKle7M0LCbMKNJ4sKE5sjQGFn9E8ote9@nSa2Zy7AMgOCg3WixZUt0LC5w8k0fYZaJ@mWuFJnfdEPey9tSfDZ/I7VlHO8vOLlUeQKLGHe278rEWzPZ8JXFHXpJbvOo15CYXvs3mYBZyWg/yGbZAzkgE7z1jRNT/tXPz/8 "Seed – Try It Online")
The resulting Befunge-98 program (based on [this](https://codegolf.stackexchange.com/a/55486/30688)) is
```
"9!dlroW ,olleH"ck,@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9XslRMySnKD1fQyc/JSfVQSs7Wcfj/HwA "Befunge-98 (PyFunge) – Try It Online")
[Answer]
## [Mornington Crescent](https://github.com/padarom/esoterpret), ~~3614~~ 3568 bytes
*Thanks to NieDzejkob for saving 46 bytes by using shorter line names.*
```
Take Northern Line to Hendon Central
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Gunnersbury
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Holloway Road
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Mile End
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Barking
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Wood Lane
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Mile End
Take Central Line to Fairlop
Take Central Line to Mile End
Take District Line to Barking
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Richmond
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Richmond
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Stepney Green
Take District Line to Hammersmith
Take District Line to Stepney Green
Take District Line to Upney
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent
```
[Try it online!](https://tio.run/##xVdLbsJADN33FHMAumh7gpK2sACE@LRrk1jNiMRGzlDE6akRn4pAGJIS2CBFz3ie7Wd7JmUhS9@O6TEUzEIkt1qNYIqmx@JiFDIdS2gcmzZSxGQCNRFIHk4bNYGmGyiwEiZ4AnizmRMbuj3UmhOhZJO5LAssPvWDxcIG3n3t4SH@IJmh/kvdFNgcusiROwsWhtSGNNUDU@vik3gARJqwoRNEV5OHy8kdJXU8Sy2tU1aA/9@Dv7B9iKKN/AoMXrUwZEa82Br0bRhCZJNk@ceTk4QXsDQDhqjQKu/Ie1KFaHzl7LFzGq1pKzPTAocV83otP7dtqxrk07V62jtFd66HD/fQzDdBjuVVegTBxcILM0JRrpBk5qlhnhvm5VxbTXQ5bClthv5loCfc@udOE2SqGbvjXDvPoPxc9EgiB38xR6YDhOWXnadlK8zAG2yNsg1zKNC8fD/ASsKzSto@X/f/zpFbzTNPkHXL1y8hD8GBDeOUC@Gax7Hn9BpvbEOHM8Klael1kSr35yVexmuLcreTy7Ra24Yu5uvfJt4nzdEzKIhB1rwD4Wx7dWrqj84VLmXj0WIVat39i09P3r34fgE "Mornington Crescent – Try It Online")
This is most certainly suboptimal, but it's half the size of the solution on esolangs.
`Hello, World` is constructed via slicing the following station names and concatenating the results:
```
Hendon Central
▀▀
Holloway Road
▀▀▀
Heathrow Terminals 1, 2, 3
▀▀
Wood Lane
▀▀
Fairlop
▀▀
Richmond
▀
```
Finally, I'm computing the character code of `!` as `(2<<4)+1 == 33`. All these parts are concatenated in Paddington and finally printed in Mornington Crescent.
**Note:** The language doesn't specify whether it's possible to travel to same station twice in a row, but the interpreter does allow it, so I've made use of it.
[Answer]
# brainfuck, 72 bytes
```
+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
```
[Try it online!](https://tio.run/##HYpBCoBADAMfVJoXhHyk7EEFQQQPgu@v2Z3DEMLs73Y953fc3VGZypJCOSEHba@hhPxbQEQUNGjmxmoT5Gocdf8)
And the original non-wrapping **76 byte** solution:
```
+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--.
```
[Try it online!](https://tio.run/##HYhRCoBAEEIPJOMJZC6y7EcFQQR9BJ1/ckeRp@7vdj3nd9xVGBiSkNaEwvYSMCUaHWKVXhHBTGZf0WKuy6z6AQ "brainfuck – Try It Online")
### Other shortest known (to my knowledge) solutions I've found
**'Hello, world!' 77 bytes:**
```
+[+++<+<<->>>[+>]>+<<++]>>>>--.>.>>>..+++.>>++.<<<.>>--.<.+++.------.<<<-.<<.
```
[Try it online!](https://tio.run/##HUrJCYBAECsoTCoIaWTZhwqCCD4E6x9nJ4/c@7tdz/kddyYGAEEK2wOeLg/MSo6gWUrWp0yRJPag7qKx2kXM/AE)
**'hello, world!' 70 bytes:**
```
+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.
```
[Try it online!](https://tio.run/##HYpBCoAwEAMftGxeEPKR0oMWCiJ4EHz/mnYOQ0hyvsf1zG/cVdEkpbItGZJd6oIzFEBEQAKtVXnfVW5An/yq@gE)
---
These were found using a c++ program I wrote here: <https://github.com/ksabry/bfbrute>
Note: I originally wanted to clean up this code before I posted it to make it actually somewhat readable and usable, but since I haven't gotten around to it in over a year I figure I'll just post it as is. It makes heavy use of templates and compile time constants for any potential optimizations and it has a bunch of commented out code from my testing but no helpful comments so sorry but it's a bit horrible.
There is nothing terribly clever about the code, it's brute forcer at it's core, however it is quite optimized. The major optimization is that it first iterates through all programs without loops (no `[` or `]`) up to a specified length (16 currently) and caches an array of all the changes it will make on the data array. It will only store a single program per unique array of changes so for example only one of `>+<<->` and `<->>+<` will be stored. It then iterates through all possible programs which are composed of any program in this cache with any combination of loops between them. After executing each program it does a simple greedy hunt and peck for the characters and appends this to the end of the program.
After running this through the space of all programs I noticed that almost all the shortest programs (up to length ~19) were of the form `*[*[*]*]`. Restricting the search to programs of this form sped up the search considerably. The current record holder was found at length 27. This one was actually computed to be length 74, but I noticed a particular sequence `.>.>.>.` which was lucky enough to have a 0 in the data cell to it's right allowing it to be simplified to `[.>]<` bringing it down to 72.
I let it run for quite awhile and completed the search with the current parameters up to length 29, I suspect it will be difficult to beat the current one by simply going higher, I think the most promising approach would probably be increasing the search space in some intelligent way.
[Answer]
# [evil](http://esolangs.org/wiki/Evil), 70 bytes
```
aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw
```
[Try it online!](https://tio.run/##JYs5CsBADAPfOsUUgbSOnu9dOyAJdPk9bzfqMGWV0RokQATD1Wzz71jrJkx6j@k@ "evil – Try It Online")
It uses the following four commands:
```
a - increment the register
u - decrement the register
e - interweave the register's bits (01234567 -> 20416375)
w - write the value of the register as an ASCII character
```
[Answer]
# Piet, 90 codels
[](https://i.stack.imgur.com/TZNsF.png)
This is a 30 by 3 image. Alternatively, at codel size 10:
[](https://i.stack.imgur.com/TnaHd.png)
The uses a 3-high layout so that I only need to pointer once. If this is still golfable I could probably shave at most another column, since there's a push-pop no-op in there.
Edit: [@primo's 84 codel solution](https://codegolf.stackexchange.com/a/67601/21487).
[Answer]
# [Haystack](https://github.com/kade-robertson/haystack), 17 Bytes
Haystack is a 2D programming language that executes until it finds the needle in the haystack `|`, all while performing stack-based operations. All programs start from the top left corner, and can use the directional characters `><^v` to move around the program. Direction is inherited, so you do not need to keep using `>` to go right, direction will only change when it hits a different directional character.
By default, the interpreter reads from the top left going right, so we can just put "Hello, World!" onto the stack, use `o` to print it, then place the needle to finish executing.
```
"Hello, World!"o|
```
[Try it online!](https://tio.run/##y0isLC5JTM7@/1/JIzUnJ19HITy/KCdFUSm/5v9/AA "Haystack – Try It Online")
Bonus: A more exciting version:
```
v >;+o|
v "
v !
v d
v l
v r
>>"Hello, ">>>v
W v
" v
^<<<<<<<
```
[Answer]
# [Help, WarDoq!](http://esolangs.org/wiki/Help,_WarDoq%21), 1 byte
```
H
```
Not only does [Help, WarDoq!](http://esolangs.org/wiki/Help,_WarDoq%21) have a built-in for most common spellings of the phrase, it even satisfies our usual definition of programming language.
Try it in the [official online interpreter](http://cjam.aditsu.net/#code=l%3AQ%7B%22HhEeLlOoWwRrDd%2C!AaPpQq%22Q%7C%5B%22Hh%22%22ello%22a%5B'%2CL%5DSa%22Ww%22%22orld%22a%5B'!L%5D%5D%3Am*%3A%60%5B%7Briri%2B%7D%7Briri%5E%7D%7Brimp%7D%7Brizmp%7DQ%60Q%7B%5C%2B%7D*%60L%5D%2Ber%3A~N*%7D%3AH~&input=H) (code goes in *Input*).
[Answer]
# [MarioLANG](https://esolangs.org/wiki/MarioLANG), ~~259~~ ~~249~~ ~~242~~ ~~240~~ 235 bytes
```
+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
!+======================---
=#>++++++++++++++.).+++.-!>!
=======================#=#
```
[Try it online!](https://tio.run/##bY6xDsIwDET3fEXiLLFOvi9o/CNMnRAStBL/LwUXyoDIsywP5zv7sT5v@33drmPA4Yqj8G60wC5F3ZwJAun/VAhFU2yX1vBFz7HQzBBqrxOvaKiRHIdojaoMD3lmcAk15YI@5RB7dfzAT4QVLynnuTFeqWO8AA "MarioLANG – Try It Online")
This has been tested [in the Ruby implementation](https://github.com/mynery/mariolang.rb).
[After obfuscating "Hello, World!"](https://codegolf.stackexchange.com/a/54928/8478) in MarioLANG I looked into golfing it a bit. The above is the shortest I have found so far.
As before I started from a Brainfuck solution which sets four cells to the nearest multiple of 10 to the characters `He,` and space [and converted it to MarioLANG](https://codegolf.stackexchange.com/q/55380/8478). You can then shorten the code a bit by making use of the auxiliary floor in the loop which almost halves the width of the loop. Note that the bottom is only executed one time less than the top, so you don't get exact multiples of the initial counter in all 4 cells any more.
Finally, I wanted to make use of the wasted space in front of the loop, so I added a bunch of elevators to make use of the vertical space there. And then I realised that I could fold the code *after* the loop (see previous revision) below the loop to make use of some more vertical space, which saved five more bytes.
This is likely still far from perfect, but it's a decent improvement over the naive solution, I think.
## Metagolf
Time for some automation...
I have started setting up a solver in Mathematica to find an optimal solution. It currently assumes that the structure of the code is fixed: counter set to 12, 4 cells for printing, with the fixed assignment to `He,<space>` and the same order of those cells. What it varies is the number of `+`s in the loop as well as the necessary corrections afterwards:
```
n = 12;
Minimize[
{
3(*lines*)+
12(*initialiser base*)+
Ceiling[(n - 6)/2] 3(*additional initialiser*)+
8(*loop ends*)+
18(*cell moves*)+
26(*printing*)+
43*2(*steps between letters in one cell*)+
-2(*edge golf*)+
4 Max[4 + a + d + g + j + 2 Sign[Sign@g + Sign@j] + 2 Sign@j + 2,
4 + b + e + h + k + 2 Sign[Sign@h + Sign@k] + 2 Sign@k] +
2 (Abs@c + Abs@f + Abs@i + Abs@l),
a >= 0 && d >= 0 && g >= 0 && j >= 0 &&
b >= 0 && e >= 0 && h >= 0 && k >= 0 &&
n*a + (n - 1) b + c == 72 &&
n*d + (n - 1) e + f == 101 &&
n*g + (n - 1) h + i == 44 &&
n*j + (n - 1) k + l == 32
},
{a, b, c, d, e, f, g, h, i, j, k, l},
Integers
]
```
It turns out, that for an initial counter of 12 my handcrafted solution is already optimal. However, using 11 instead saves two bytes. I tried all counter values from 6 to 20 (inclusive) with the following results:
```
6: {277,{a->7,b->6,c->0,d->16,e->1,f->0,g->0,h->9,i->-1,j->0,k->6,l->2}}
7: {266,{a->6,b->5,c->0,d->11,e->4,f->0,g->2,h->5,i->0,j->0,k->5,l->2}}
8: {258,{a->2,b->8,c->0,d->3,e->11,f->0,g->5,h->0,i->4,j->4,k->0,l->0}}
9: {253,{a->8,b->0,c->0,d->5,e->7,f->0,g->2,h->3,i->2,j->0,k->4,l->0}}
10: {251,{a->0,b->8,c->0,d->3,e->8,f->-1,g->4,h->0,i->4,j->3,k->0,l->2}}
11: {240,{a->1,b->6,c->1,d->1,e->9,f->0,g->4,h->0,i->0,j->3,k->0,l->-1}}
12: {242,{a->6,b->0,c->0,d->6,e->3,f->-4,g->0,h->4,i->0,j->0,k->3,l->-1}}
13: {257,{a->1,b->5,c->-1,d->6,e->2,f->-1,g->3,h->0,i->5,j->0,k->3,l->-4}}
14: {257,{a->1,b->4,c->6,d->0,e->8,f->-3,g->3,h->0,i->2,j->2,k->0,l->4}}
15: {242,{a->1,b->4,c->1,d->3,e->4,f->0,g->1,h->2,i->1,j->2,k->0,l->2}}
16: {252,{a->0,b->5,c->-3,d->4,e->2,f->7,g->0,h->3,i->-1,j->2,k->0,l->0}}
17: {245,{a->4,b->0,c->4,d->5,e->1,f->0,g->0,h->3,i->-4,j->0,k->2,l->0}}
18: {253,{a->4,b->0,c->0,d->1,e->5,f->-2,g->2,h->0,i->8,j->0,k->2,l->-2}}
19: {264,{a->0,b->4,c->0,d->5,e->0,f->6,g->2,h->0,i->6,j->0,k->2,l->-4}}
20: {262,{a->0,b->4,c->-4,d->5,e->0,f->1,g->2,h->0,i->4,j->0,k->2,l->-6}}
```
**Note:** This solver assumes that the linear code after the loop is all on the top line, and the above code is that solution folded up. There might be a shorter overall solution by making the solver aware of the folding, because now I get 3 more `+`s in the first part for free, and the next 4 instructions would cost only 1 byte instead of 2.
[Answer]
# [Dark](https://esolangs.org/wiki/Dark), 106 bytes
```
+h hell
h$twist sign s
s$scrawl " Hello, World!
s$read
h$twist stalker o
o$stalk
o$personal
o$echo
h$empty
```
I'll just let some quotes from the language specification speak for the brilliance of this esolang:
>
> Dark is a language based on manipulating entire worlds and dimensions to achieve goals and to build the best torturous reality possible.
>
>
>
>
> Whenever a syntax error occurs, the program's sanity decreases by 1. [...] If the program's sanity reaches zero, the interpreter goes insane.
>
>
>
>
> Corruption flips a single bit in the variable when it occurs.
>
>
>
>
> When the master dies, all servant variables attached to that master also die. This is useful for grouping and mass killing variables.
>
>
>
>
> Forces a variable to kill itself, freeing it (remember though that it will leave decay).
>
>
>
>
> Sets a variable to a random value. Uses the Global Chaos Generator.
>
>
>
>
> If a stalker is not initialized, any attempts to perform IO will result in depressing error messages to be written to the console.
>
>
>
[Answer]
# [Homespring](https://esolangs.org/wiki/Homespring), 58 bytes
```
Universe net hatchery Hello,. World! powers a b snowmelt
```
[Try it online!](https://tio.run/##DcrBCYAwDAXQVb53cQ4XEM9Vgy2kSUmDxemj7/yyVurNitwRm5SHrBOEHDn5mclerMSs84Jdja8JaDr@hIQDXXRUYkfEBw "Homespring – Try It Online")
The trailing space is significant.
Let me tell you a story. There was once a power plant which powered a nearby salmon hatchery. The salmon hatchery hatched a young homeless salmon which embarked on a journey upriver to find a spring. It did find such a spring, with the poetic name "Hello, World!", where it matured and spawned a new young salmon. Both fish now swam downstream, in search of the wide ocean. But just short of the mouth of the river, there was a net in the river - the mature fish was caught and only the young one managed to slip through and reached the ocean and the rest of the universe. In the meantime, the hatchery had hatched more salmon which had travelled upstream as well and spawned and so on and so on.
However, vast amounts of melting snow had been travelling down a different arm of the river. And just after our first young salmon from the springs of "Hello, World!" has reached the ocean, the snowmelt hit the universe and... uh... destroyed it. And they lived happily ever after... or I guess they didn't.
Those were actually the semantics of the above program. Homespring is weird.
[Answer]
# [Chef](https://esolangs.org/wiki/Chef), 465 bytes
```
H.
Ingredients.
72 l h
101 l e
108 l l
111 l o
44 l C
32 l S
87 l w
114 l r
100 l d
33 l X
Method.
Put X into mixing bowl.Put d into mixing bowl.Put l into mixing bowl.Put r into mixing bowl.Put o into mixing bowl.Put w into mixing bowl.Put S into mixing bowl.Put C into mixing bowl.Put o into mixing bowl.Put l into mixing bowl.Put l into mixing bowl.Put e into mixing bowl.Put h into mixing bowl.Pour contents of the mixing bowl into the baking dish.
Serves 1.
```
[Try it online!](https://tio.run/##ldGxDoMgEIDh/Z7inoBINdHdpR2aNHFxrXIWUgoJYu3b0yNdOrA4/eHjYLlZ05LSWQBc3COQMuTiKqA9oUUNspJc4nZcC1Lms4em4fRQ56kBupaz82XWwMMVV0Fdc0aAK0XtlYDbFnFE46LHl/kY98DJ71ZkVmW2ZQ5l9mXeyzyUuT/0tz3EVGZdYL8FnL2LeRvoF4ya/gd@LzJO92dGZVbNOxwovGlFKVL6Ag "Chef – Try It Online")
Tested with the Ruby interpreter. Makes alphabet soup.
I tried to be as compliant to the [original spec](http://www.dangermouse.net/esoteric/chef.html) as I could, so even though the interpreter I used lets you drop the `the`s in the `Pour contents` instruction, I haven't done so.
The mixing bowl is pretty expensive, so there might be a better approach. I tried using base conversion to encode the message, but unfortunately the spec doesn't clarify whether `Divide` uses integer or floating point division, and the interpreter I have uses the latter. There's also no modulo operator, which doesn't help either.
[Answer]
# Piet, 84 codels
*28x3, here shown with codel width 10.*
Created with [PietDev](https://www.rapapaing.com/blog/pietdev) ([zip](https://web.archive.org/web/20190408184542/http://www.rapapaing.com/piet/pietdev.zip)), tested with [npiet](http://www.bertnase.de/npiet/). The layout of the program is the following:
Yellow fill indicates codels where the path overlaps, orange fill indicates codels which must be the same color, for purposes of control flow.
To aid in the creation of this, I wrote a rudimentary interpreter for a stack-based language with piet-like commands, which I have dubbed "pasm" ([source](https://gist.github.com/primo-ppcg/d6ccb34016235d2e5841a38941c4f7c3#file-pasm-py)). The output from this interpreter (with [this input](https://gist.github.com/primo-ppcg/d6ccb34016235d2e5841a38941c4f7c3#file-hello-pasm)) is the following:
```
1 nop blu1 []
4 push 3 blu2 [3]
5 dup grn2 [3, 3]
6 add cyn2 [6]
7 dup ylw2 [6, 6]
8 mul grn1 [36]
9 dup red1 [36, 36]
10 dup blu1 [36, 36, 36]
11 add mgn1 [36, 72]
H 12 putc blu0 [36]
15 push 3 blu1 [36, 3]
16 sub mgn2 [33]
17 dup cyn2 [33, 33]
20 push 3 cyn0 [33, 33, 3]
21 mul blu2 [33, 99]
22 push 1 blu0 [33, 99, 1]
23 add mgn0 [33, 100]
24 dup cyn0 [33, 100, 100]
25 push 1 cyn1 [33, 100, 100, 1]
26 add blu1 [33, 100, 101]
e 27 putc cyn0 [33, 100]
28 dup ylw0 [33, 100, 100]
32 push 4 ylw1 [33, 100, 100, 4]
33 dup mgn1 [33, 100, 100, 4, 4]
34 add red1 [33, 100, 100, 8]
35 add ylw1 [33, 100, 108]
36 dup mgn1 [33, 100, 108, 108]
l 37 putc blu0 [33, 100, 108]
38 dup grn0 [33, 100, 108, 108]
l 39 putc ylw2 [33, 100, 108]
40 dup mgn2 [33, 100, 108, 108]
43 push 3 mgn0 [33, 100, 108, 108, 3]
44 add red0 [33, 100, 108, 111]
45 dup blu0 [33, 100, 108, 111, 111]
o 46 putc cyn2 [33, 100, 108, 111]
47 dup ylw2 [33, 100, 108, 111, 111]
48 dup mgn2 [33, 100, 108, 111, 111, 111]
53 push 5 mgn0 [33, 100, 108, 111, 111, 111, 5]
54 div ylw0 [33, 100, 108, 111, 111, 22]
55 dup mgn0 [33, 100, 108, 111, 111, 22, 22]
56 add red0 [33, 100, 108, 111, 111, 44]
57 dup blu0 [33, 100, 108, 111, 111, 44, 44]
, 58 putc cyn2 [33, 100, 108, 111, 111, 44]
59 dup ylw2 [33, 100, 108, 111, 111, 44, 44]
60 add grn2 [33, 100, 108, 111, 111, 88]
64 push 4 grn0 [33, 100, 108, 111, 111, 88, 4]
65 dup red0 [33, 100, 108, 111, 111, 88, 4, 4]
66 mul ylw2 [33, 100, 108, 111, 111, 88, 16]
67 dup mgn2 [33, 100, 108, 111, 111, 88, 16, 16]
68 add red2 [33, 100, 108, 111, 111, 88, 32]
69 putc mgn1 [33, 100, 108, 111, 111, 88]
70 push 1 mgn2 [33, 100, 108, 111, 111, 88, 1]
71 sub red0 [33, 100, 108, 111, 111, 87]
W 72 putc mgn2 [33, 100, 108, 111, 111]
o 73 putc blu1 [33, 100, 108, 111]
76 push 3 blu2 [33, 100, 108, 111, 3]
77 add mgn2 [33, 100, 108, 114]
r 78 putc blu1 [33, 100, 108]
l 79 putc cyn0 [33, 100]
d 80 putc grn2 [33]
! 81 putc ylw1 []
```
No pointer, switch, or roll commands are used. No codels are wasted either; in fact two are reused.
[Answer]
# HTML, 13 bytes
```
Hello, World!
```
The text is automatically inserted into the `<body>`, and is displayed.
[Answer]
# CSS, 30 bytes
```
:after{content:"Hello, World!"
```
Cascading Style Sheets (CSS) isn't a typical programming language, but it can do fixed output fairly well. This is done by creating a [pseudo-element](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements) after every element with the content `Hello, World!`. So only one element (`<html>`) is selected, this assumes that we're using the most basic HTML document, i.e.
```
<html><style>:after{content:"Hello, World!"</style></html>
```
This works in most major browsers, with the notable exception of Firefox, which applies the selector to the `<html>` and `<body>` elements. This is also why Stack snippets don't work, because there is always a body element that gets styled as well. Below is a slightly modified version to test.
```
* :after{content:"Hello, World!"
```
[Answer]
# Java, 79
```
class H{public static void main(String[]a){System.out.print("Hello, World!");}}
```
[Try it online!](https://tio.run/##y0osS9TNSsn@/z85J7G4WMGjuqA0KSczWaG4JLEESJXlZ6Yo5CZm5mkElxRl5qVHxyZqVgdXFpek5urll5boFQAFSzSUPFJzcvJ1FMLzi3JSFJU0rWtr//8HAA "Java (JDK) – Try It Online")
Earlier versions of Java may allow you to use a static block (51 bytes), but currently I don't know of a way to bypass the `main` method.
[Answer]
# [Whitespace](http://esolangs.org/wiki/whitespace), ~~192~~ ~~150~~ 146 bytes
Whitespace only needs spaces, tabs and linefeeds while other characters are ignored.
Which can be troublesome to display on here.
So in the code below the spaces & tabs were replaced.
And a ';' was put in front of the linefeeds for clarity.
To run the code, first replace . and > by spaces and tabs.
```
...;
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
.;
.;
>.>;
...>>.>.>>;
>...>;
..;
.;
;
;
..>;
;
;
;
```
[Try it online!](https://tio.run/##VY1RCsAwCEO/4ylytVEK299ghR7fxVWhQ9RAnnGe1@jPfbTuTtJIQK36JKDFNVIXhJ1G0j8o7vKy0CAtTBUqdwUgH8kJRJyZ@ws "Whitespace – Try It Online")
### Hexdump of code
```
00000000: 2020 200a 2020 0909 2020 0920 0920 0a20
00000010: 2009 0909 090a 2020 2009 0a20 2020 0909
00000020: 090a 2020 2009 2020 0a20 2009 0920 0920
00000030: 200a 2020 0909 2020 0920 0909 0a20 2009
00000040: 0909 0909 0909 0a20 2020 0920 200a 2020
00000050: 2009 0a20 0a20 2020 0909 0920 0a20 2009
00000060: 0920 2020 0909 0a0a 2020 0a20 0a20 0a09
00000070: 2009 0a20 2020 0909 2009 2009 090a 0920
00000080: 2020 090a 2020 0a20 0a0a 0a20 2009 0a0a
00000090: 0a0a
```
### Whitespace assembly code:
```
push 0 ;null
push -74 ;! chr(33)
push -7 ;d chr(100)
push 1 ;l chr(108)
push 7 ;r chr(114)
push 4 ;o chr(111)
push -20 ;W chr(87)
push -75 ; chr(32)
push -63 ;, chr(44)
push 4 ;o
push 1 ;l
dup ;l
push -6 ;e chr(101)
push -35 ;H chr(72)
p:
dup jumpz e
push 107 add printc
jump p
e:
exit
```
### Remarks:
I had to write a program just to calculate that adding 107 gives the optimal golf for the sentence. Since the bytesize that an integer takes in the code changes. : 4+int(abs(log2($n)))
The code will still run without the "e:" label & exit part on [whitespace.kauaveel.ee](http://whitespace.kauaveel.ee/). But that could make the whitespace code invalid on other whitespace compilers. So those bytes weren't golfed out from the solution.
**It Should Be Noted That**
As Kevin Cruijssen pointed out in the comments, by allowing an "exit by error" as per meta, the Whitespace can be golfcoded more to **126** characters.
```
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
...>>.>.>>;
>...>;
..;
.;
;
```
[Try it online!](https://tio.run/##K8/ILEktLkhMTv3/X0GBkxOIgZALxOTkBFIKEALKVoDIIBgg1ZxQ1SiKQPqgOmFKQSq5oJKcEI2cUAuAarn@/wcA "Whitespace – Try It Online")
**Assembly:**
```
push -74
push -7
push 1
push 7
push 4
push -20
push -75
push -63
push 4
push 1
dup
push -6
push -35
label_0:
push 107
add
printc
jmp label_0
```
[Answer]
# [Seed](https://github.com/TryItOnline/seed), ~~4154~~ ~~4135~~ ~~4117~~ 4078 bytes
Explanation, quite long, along with the description of the generation algorithm on my home page (as per request in comments): [link](https://palaiologos.rocks/posts/mersenne-twister/)
Possibly smallest one can create in finite amount of time.
**Feersum's generator has been outscored by 125 digits.**
```
18 1999111369209307333809858526699771101145468560828234645250681099656696029279480812880779443148152835266354745917034724622145903651417563371730237765283326056988244774110441802133624468817714160177386022056512108401823787027806425684398448067970193332644167536135089961308323052217690818659345826221618714547471817786824952177760705661213021136861627615564344797191592895410701640622192392412826316893318666484043376230339929937013414786228802341109250367744273459627437423609306999946689714086908789713031946200584966850579209651689981508129953665360591585003323062426849065928803791631705897655870676902001410564547259097078231664817435753967511921076054045034302323796976905054512737624542497156263914722954936458789312271946701667519720841308380062811251340113402138536813062807047486584549696366881131076129644333426157514410757991556230404583924322168740934746079177400690540383270574734570453863131129670312070568678426587468145691141064452504683450565188718043501125177371576228281599163415914580472091806809959254536307112226422637068036069837636348250796013947548859219492684001888592443619271863264913733271796439829896342322684180478385639971904415730730155249230972472713598001454701479081682503703435292522488015910406951417625194589254609756805750713606175216991897729604817653297756338264018378339186646236428245791304007449872675676823828828025054891324604572924113135541994460293993994930010757779465315482913805320566037487246911578188713647298779820394853314711728701462997760060773720597833413054385989484972761510228922232188763499675904892361201334056531237561182096332707820332381472154893517831468669407424867949853884550905603295504680929068346527584718316837786318710085149722173684889784734888358566137013072868037395888296895408992035862679921478330680631465096402120764369879221964359613565641652779510635224788673321444028128955312660697375763703507924497355056468329176678508797277505818080245055083627993568557883893217501909841992899324584338401263402065617507377073719573642373296064002058833488593469308722954567388945161866200094063588423591356962865924188962743278147095803148276100759174767606637848987740320689762075562393521992008413240632519860537097220403160035470139899869535541445941688033346042941342229305392639867768112643798588915164061012851035069872578424685533430920913310727097269791325370108354115267003538502506307401037702631576755065238836157990287620373910423088628131973441805618500402407032751005850768445522318425479521483938945040598642922742796671148454685792926662105094734939468210307429214048710552195412807154088634170043145174020299723624868716804740205833308025010299791473201989330179511900752421521748244324520372384555472905196933204791343923384985673930225356512632819977168423365518584516873151142795940198973519372718229122661025988052451376835210066645728260048500257088773609522352231828810506243886764860621803233068079848240668323783996022507908005888468315483796728648978952610219628600082949325089555677853995177602958596492703349550377871982505777660804519503438416790609328789548538308170189581940118961959513239411467871900221985235702327603132341245854941342838886675363828149587290416073764877392438738417021129652498464495269870868163299830870636019233313974206364225614175115905798645888824666280593535350493547833757379214088677125769505793280646751090271497879000895725329057103702349349795211071357094147037863458426851391499872003703049553149335378055054176480977774050198041879243243264959205957441742983643583697591926138999543475339555662645088503078864968452030049140027407987267835123806661736568594687416676322591834962173789578844522343172160526435025531896189408441645468352864002987706103448393710107805248652709736711528349633758515438315407447026188178510124322920110858766628704828773265703683997486487094455425009292414948853993709223752434073750917088611480305840639869649933404702780843770306859066070919534638022435125602050780767420448917941603557783974740312706609928585387278690009349321957381507513875981113699582062422293555869483805964659436085153933836036107786
```
[Try it online!](https://tio.run/##JdeJcdxIDAXQVDaEvhudzzqCzb@873PKtiyNSDbwL4D//fnz79@/vf7p773e@zxvtDfbnXNWe7Vrj3Peu7f31vva69Q@rUaNuc7aY7dTvb13tstOG2/ct6pVH1Xt@n7NvqrvUTNPmnvdtV@/ba471hnDM1@bZ/fV7z5z3n5nG/Pek3vmOG2fVzXWuncpYq1ebfQ5j49OVVfa6qf5f5YChut3H73Val2Vt24bt9pZY59a89VS37nvtv5mDvDEc/c8fe5WOumz1RyzbcXd8/RSZ7@5do3Ue3rdAHHX7Tm9juLedq2a23X8cbwegmadfsY9fe@zphbe7a/vN@rt1V3cz2p56BvzjQW0cWY/pTCHnrM0sWBylDPne@O96aa5@nLuCMZ4gMpDxDwQWuOq9Dl0zbvGPGETge@t47kqb5Webr730O7z0dqu9fx@t30jAAi6@OEtTL4HneNfwxxFNLUoCAEDoq@dNFRt3tdVDwHPPnsD/gQ/j8cQXALawDboL2Z6@uvq3NB/KOhgAIpjdK2fFSFg8J2X5yhuYfYGDo8C@u37AOxBYwyIvumMtDb7GDetBeE8@d1BEB@z1VRevY8NR5r2BV2lveppimwbcnFeTnH20Tyd9ZnaoEEwdKP3rvC@wiPUXjiGSkqvkDmjlboLAR5HGVTvp5ZOVpskBikiQpcDN/FOR@T5zNHHp6Q6txykJ1InusOjzlNBnOczN396L5osUtnta4wXYHOjEK3uF2KW/z3CVbB4rj4M/lAH1XlY3p2DG/yjMb/EN@dB229XOQ8RtPfW3avKjQB@UQB@6/sAMAeHSjnx1etTjvjRjTHeeAVMohy5K/VedDD9iy3i7H0TPQ2U2AUm2lRLqPtVVERAvt548qSimRwRLJoYQ1EtPaLgvC9PDiieltMjI8iXArlGenqTNxiCDblesLeokcyHH5NEvJgIkSCsFztyCoGBFGN6c05juFd3kBip0zS4/W0jWi3XiDjcejpzY3dutmfFlaTUtr9Eq7NIKGnp@O7O4ValzoTZ0eWqhCXy962Pa3V4aLmlRkMJ@cpZFN5RgeiMZPahthYteM5LG3HAXjDHhGwBb7KpS00YDcTk4Sh6sSNGfIrRgXUu2SmOHffpglVIhNs4@YuDiglT@5v0V6qh3vMWiDAjbwFF5Dy1GwfoimM/DQsvGULKEv8yHfkkA2eidSZsWyt0KlbGcimeNRPjUN2URwL3S8Wm@ej2zrf9CqWJ2WS6Ere8VAXVRnUzAj8pUjUnCcBwRErwApCyfb8zCjR9zAeVXZpyS4R2S0OaZn63ZtZpBTYnjgE350WZcQxP@GTHpbErYq9AkqHOgT4xbow2komTfWyuqdK5tZHNH885LmMQo4t4HOYjqpZCmXHsqgghHEFzz7350h8vESswIm0tugYqc37eBTbd1S82aRcxjJLZdjIOGt60iq0BhqBgomQKkrErv@liqIKygbplxEdJ/JDZvi4zNMMeSxWRijsFZipA@YtJDY700r5UHjktXjXAN@RCNXdRgVHzeV56GEds/TlI/D2kZOboh8OGHwWLbuhb@IoUDHGkTMPkzSLDjvsbtxaZQVDhJ3SPnYzNXsNDRk7mH72z5PgqwWiMnLosFcrhQkpKZYwUqyc8EdECfeY3@nWJEa7AZ890IJN0H20KKNFGQpRj/tJxshB9mayoZBl4GS0ZyxileKbhzq5OaGTXWEbMDGVuYGZEUy2nSdojBVb9NjX6AwZKjV@cOkrk@IWfU/OIG7icxXb42NlApGNMU5kYusz@xtCRWDJlZO/isgv@jMlPVVhoX@j175rMY4Sj0x5jMXuZ7NGGhaFnUVpZ56LhAAIk7WU1EAuM5x7kB3MzY0Tj2KNQ1A4sfNsdtVT/ttITiVofjcDM60xcBEAAFETyFcF/Vr3MkaIQU05gqNZWacdzjxGX7RTeWbmkteTXeOggDlCIUOMjFPxoEPIBFBIzSWCNIXfZibZfshBcevS8bJLy5mU3/kYooOLDShokLrPeJLdWQs0ZKa1/bmNDGYaxkb0URBQtQs3snmjnXEY2ZcmUcBOmiUzOz2TMOBFHONL7t0tV1lxBax8Z2ZF2hkYhDstGoBgKXL4zwrczFM5VEvJ7JiiU5W3AtpatTAEzl1CMKLInfQYUVwD5tumMQqFtdcFrFvTsbStQZjfCUkVe41t4Mu0BsrJGx5JWVANecL3UZxkBf1ZkrpyPbPMBt7NMXhr48WVvrSx/yf0VxeNWyORPA@H@Ql8wgzuaD23XpmSv/HZekMjIbIqGE6EIbQEdBuToyE7gqjg8@7b0fJ8LezYJeLzs434Zz@wsbOIlW@lLvLRvS2nrGxHuVZLXkUyEbCjeRcg4EZmIR1fPAIo5vg1K4urDmuhadpUm5pKvL0HL2tYEq72RbimzpUQkxpxYEPKxuD6tsPU5jaTVhEiH3d/WQvYmekX3Ga0ZOokHL1pIRACTGMaekMkbzXhgdk8gWPRtTwyUivhEc5GOTBLp7v8CiF/qGz2ZAkleWZfkAiXsPvtVZisMZnIrr3wri4U9YPdsKvFItqwka8/bXpK7f9s1aDDA9vfj2xJNcvRlXwb4iemyxtMcgkSM8GzZNcwwcq3PShk2IzuNJ65IVEz2WP4kRGGGzvZNkzjtZQ1av/dJ4/eG10AGP5mNkG0agdOKEGAtOdhLnwYC1a6shDeTy@xg0IqYMxy91OQRme07phRVeUlreXXI@M8sz7sYefql4Pq9qTPX@N7CMvdQ756V95ukglltm8nipE0h6nuTqGWn@vv3fw "Seed – Try It Online")
## Original, 4154 byte version
Added per request of @JoKing, because the 1st program doesn't *quite* run on TIO, albeit being valid.
```
20 77698190481213510983405846204529755428212736563278528088055816123655499433757607718113585773285686740433752335768949721107461077652705328567448384490378909463204984642622585570301449419608763821501335954761638946551568252142160714228369356054944595121742743720935369219143086698092657062614382519069928478344861416117079283276656675368390764675728501797178208908097054412833019383889935034413095990596139618411133857423995278221670378808372393943846302426674985203826030563290800228881174929701934609803807325868775242909948272754141956168876233403760199007405891058308908050926690654387065882097924294620229833663324754801060691573338185912369627367088050915813931912943122729210762147280440619571047157836177316082899933374851699282897590433145623725705072835054748369992455883804733164985993447304652512229557984322495162682327137071900307763332392727562988633724175094951314863886096190608268953115914497741446723188169519334729165647294618083444761551231012944903572063441813639201051793052623561949314826491616145873848990439549320951496534538450810083853945092224500179417650727351532486362656533602860500906935826231374501097567347929533018944533000919137863885267937690665655625569011036163950983389810112758403211861147501289650757555111271813737813381172074709337306647481507917983021055643749698971365256395367215437223669891280521155247529741719633106765965869860677198632388808752014013939448563313855130972968670015202479226496876067874099463222366536167126653600056389712632892652810365218798697007191747287017174284819764736012653205048166550645507761123345279502597627995423826537299795220169894222867163817508592362092945387317777666016102146798532337718546431888424995701016828542559577710937459975677354300708252448630110787487122698124054544454425586794841157136743408274159313823745226919626156949004386804874236325506583268311452185182143521552429596087556634158778951670223004413763782647825362665491934988477225698133609360969370513836064317152213804169538880632390908441210809806024082600637872813704781431414342781727628446451808751293046212690472851527294326981763969926510021099532791692362104324026231160941956411410511639925420026544463125250979130259151326444714248961523031316570018708849878676230362246913063109584502143502908906243190007062857721367402065760878808920961082444422470813023453274563914735545463757909757689866565064353853099958949763412521666109346825939993377745919874506439752272141853783745051726268592621080457687000431023453539135927140364910898906534604541224314820195082362228787083990333757268808864746297304451768935814651205074884015268982492445996542040655715230139673520569765431617018824427859214902954216246257690105154030408059145566852643855789351907818461502260430297487602982850090037405732117988720732457199005151517240766953718440639691354185802798689950155164379549518496065038927905828230066053603755553745353618846804435103593395141938947781375633374976924393453162350331593801284839409264892975739791751842620029351535320807733966984270102067017902086335370470815153908942490581427972998999752666174807935897314584088695849094389002316139005810918748032068307783088481430339303809949409414892479892121893571274086727250767713365523021125610242269894861374297866741571608166536165735922984579027986499758294460652554897534526492251140681138244025665400003029337114012766773010641359450599171473565675885966777145500248501370644599274741842644014722083732709145488157998306684831419559774212264003518406013032514468522158218837161285401631773099549510145156007147884565387852623860047153609138110997222297132678660783411624002400927435687937355446057878202312894093195453248164648271580944753933355967626542678764854079218206499479071658357103085513937246462858404881973219571392564909528645166637501279457604649906515968389831094896970731573714836150178126997674563415266672131632765794599548356902607125568792417432226125654028873443580337866760487651905138461301986816386866811155111486155341154153322710638921116465132825486519667178335471102213200521032618562169530188826434060179505699797068436325168526618824444305122475837890944742004331675952611756641739756206337285946
```
[Try it online!](https://tio.run/##LdeJcSU5DAPQVDYEHdSVz04Em395H9ozVfZ891dLJAiA1H9//vz78zPaP@fsd/trdfvoc/X27qy2bu3Rao131qpxRx9n7rXnOHeN2@5ta92@@/B01Xs151lnt3P67fa565w57tp3n2rft2NOK@6rd0bv7dT26@w1Tlvf0lN15616bZ772ivHtXpCqbHHsOc6bbZuRfW32z17imy1bue36uzugdfW6g4ea/QaXUz@G3fuN9dugq2yWranxql5RvOFb0d/vWa7GyDtje2wPbZHdgLQfm/cOtCp66nc@2nHM5hs0OxjkztfO7t8PjJq/bzTzx1NOvaUaFX3hiTelOt9jm527LO99V5bb/fp51aH4oRijfkejO6Qygky0Bf0fBPosJltgAd4T2WaYDeMUqkc2SR@FcS3SplTa6uwZU151t33KExZq4R3nHFWye0tUF74qlk5c3vzNSVDjNf9mr8ZreC0YbOEAq515fqAYscQaAxsmnvPOcrOt/W2AdnXmZLrd70Q6O2Q63ykar68IJiKYY/Zh6CUBqqqCdRW1bYAT291bKSuHdWU@Q5wPhufuqt/5fLkrBf69VqSOUNRV7MN2BGmwgoLC5mVw45W7iBpo/JXQybVHxJBPlScYxTyIMYdCt8nDiAHyFHZ2eryobhlfj04o/qRVV4ShEceNxUGmojJYc3e4YDU58Aed8bsara9IRs5v45e@Z9iUvyqUB3JLWxBKYpBuLbDJOhtQYB6oR8q0A7idyEkgCE93MXgdQ/@wAw@1POIzZH19pq1fLPa7c1xd2FaKi311cJpKe2gePgF6SYrgCwvzt2G/CyLYNhADgeSFzkLWI6EUHFFAjdK9MFi1cbsgCNcUZ@QKjsC0s9rDGNG3m/FoKhcbJ0pMao22QlJoodTlDyxLb61elYEkGPzyIkQBhYfivfMCaEAAzlPVkiNZ07jCVB4uANK5c@p@Mlp4hYIm@8cBFqlW6E2cQGFKeFP29ARxLUM2zmi/xHjRrmWMrDWP/niaV6A8IoBqHDsEsQWjeCUYpFodrnE9z5L/CJYQeP08X2C4Irz5W9OGu8aN4AJ8Epsk35oygZQnw2ceJ/a98esaA9s9hnq5pktV9skEUpDEAf5D@DHstwnZBnxmQWNR@1ryCmYsFnVP3HhkJ6KhIpVKIpQRHr829txrJ@cVRq5HJCusdh8iH@LwugbYXgQFy0M8Lc1yoZJ7@MR7jHrxjX4fCx5hiOB6YJhpKkNdlUcNz/2EBmPY6wrdeX85V1lWy8lGNk67yki18c5qqIMFgmU2DBoAwzzI1uiraC7ug5U08f1@ej6@hIS0SInOxrZim8rmt34PJc4EaFfK6phnS@2zC7qYNdK5NHRyw8NMSzh@SPwcDx9IE4Vf/goFWqx73bTWnrajGfoE3dpLaepeXzKkSLl7jLXT0hBNb2l1P1jJiuJ4en1BBemUHfcl@klKJG/uOo2JEQpisQBmclXZXbMCdqnd2b8viYC7IoPRbhvqKQXdyqyGTtlpVdgPmJ1SUKFs2nWTEkFIKYwPX2YV6Q9AIlJpCvhNjfaedlWfCt29RWipe8xjyFVBWxp4hlGxlfzxiQzptyvjXJJBwHKubjLF26iif0hRnTPU@YKiXbGmxcLywhzP29KRVbsERQiyGCTqmfuQPKwtTKFUHraEgLjLi@IGXrTVultALKDNpbHHHuktRDO/mpZOU7@wO2/gTFj45Umw0VmvFwayXelswsU9@vzeS2bBFMaojzBTxxtfnOaIzLDxf40qrQ5HEhiHJssMSFdsiAeL0rCNDkyN/E1VdSCtcOvRBlXYOQFLpM5gLZp9wbUDIt6NyGNeIau6bgVbw8plgTsxEbBHMXE@ytmeBKI6iGpAYc/0yUEWlw2bqi3Zrpq6buZSU46AC@5cXcsFFrGFUf0IFqGh6iFyWR4CItBGNxvG7FHPVDnYMKx/rRCgmC8kjQogdpc5sAomHfFb2e6y0rJMjlKtuISlfFZbeZMH82E90g62ovNp6lIXXVe6tjTlZUj9nPTtswirzJPYX/G7jMjjpNQkIFw3tdtY9OGN4PKSx@CMTCxOq4O55ahY31qR@a8EDnEUltKK5d4dgYl9AtLIar9qTsaZCao8CJ6ygAuAwenpDN46imvx2G13MYDhZFJMI1EdUQ0M1jqUkmEz0hEF/ObMaWkjFm5KBjv8Sutceb@MNJ56SZdoT7vfpmxIQaIm9k2nk21/W/jAw5ioUFFlF8NKxndDEOpG6euzH5pXb5iq5xIyD1OjwTOwlW6amGV2uTrnkEesplSKyKLIp8afC5A8Q5A6Kw5YSxoKkM@tPenDdkJNfVyRKbVkVGdl7QwnJyk8TJn4Lpyf4P2ytg30rGEM1Nt7s2FNJsMgzd@Ly8cE6T7ln6oL6aVxnY@rjoqF560eB4Pk51ue7/BzwTyzclpJj0DkJfEBbsTww26LXeaHnEmIarKrcj9KWNYzA@gFJlbDCaYLtSWta76Jj@S2bk4iFHJTUIzE7isYtPxikwuVojaPKNZtlQKKwSbVpo5HoUyAL0My7aTIhCC1ouwM@qbZzUTjDTXpF0h7vyGPR09dl7ZVNmJCS3ZVXpCuojBB63RBTS5KeRKdtPfSPFz@OqfDNIeem63qPVSStWamTtHro8ZQW9uNdSS@WuHqzJytzLPAosg5kfUnVlhx7vStHlXbnoMJiOR2S4E7N9cGn5zkEwjQnBvAGHLDEcIwTTtUO@wzGY2FjZYVZJExMoPdBkkYT5G5G8YiOlmspgfgzKwreQJAmz7ppf@Wez@NWdxt9xs1Oz@vW9j72jfbQnVYZ0rLqFIO91q54IxMxYYQ39@/gc "Seed – Try It Online")
[Answer]
# [Hexagony](https://github.com/mbuettner/hexagony), ~~37~~ 32 bytes
>
> **Notice:** I'll be giving a bounty of 500 rep to the first person who finds a valid solution in a hexagon of side-length 3 or a provably optimal solution of side-length 4. If you can't find such a solution but manage to beat my score in a side-length 4 hexagon (by getting more no-ops at the end of the program, which can be omitted from the source code), I'm willing to give out a smaller bounty for that as well.
>
>
>
```
H;e;P1;@/;W;o;/l;;o;Q/r;l;d;2;P0
```
[Try it online!](http://hexagony.tryitonline.net/#code=SDtlO1AxO0AvO1c7bzsvbDs7bztRL3I7bDtkOzI7UDA&input=)
I proudly present my second 2D programming language, *and* (to my knowledge) the first ever 2D language on a hexagonal grid.
The source code doesn't look very 2D, does it? Well, whitespace is optional in Hexagony. First, the source code is padded to the next [centred hexagonal number](https://oeis.org/A003215) with no-ops (`.`). The next such number is 37, so we insert five no-ops at the end. Then the source code is rearranged into regular hexagon:
```
H ; e ;
P 1 ; @ /
; W ; o ; /
l ; ; o ; Q /
r ; l ; d ;
2 ; P 0 .
. . . .
```
This is also runnable. [Try it online!](http://hexagony.tryitonline.net/#code=ICAgSCA7IGUgOwogIFAgMSA7IEAgLwogOyBXIDsgbyA7IC8KbCA7IDsgbyA7IFEgLwogciA7IGwgOyBkIDsKICAyIDsgUCAwIC4KICAgLiAuIC4gLg&input=)
Hexagony has a bunch of pretty funky features, including 6 different instruction pointers and a memory layout which is the line graph of a hexagonal grid, but this code uses only one IP and one memory edge, so let's not worry about that for now.
Here is an overview over the relevant commands:
* Letters just set the current memory edge to their ASCII value
* `;` prints the current value, modulo 256, as a byte to STDOUT.
* `/` is a mirror which behaves as you'd expect (causing the IP to take a 120 degree turn).
* Digits work as they do in [Labyrinth](https://github.com/mbuettner/labyrinth): they multiply the current cell by 10 and then add themselves.
* `@` terminates the program.
Now the final catch is that the source wraps around all 3 pairs of edges. Furthermore, if the IP leaves the grid through one of the six corners, there are two possible rows to jump to. Which one is chosen depends on whether the current value is positive or non-positive. The following annotated version shows where the IP re-enters each time it leaves the grid:
```
H ; e ; -> 1
5 -> P 1 ; @ / -> 4
3 -> ; W ; o ; / -> 2
1 -> l ; ; o ; Q /
4 -> r ; l ; d ; -> 5
2 -> 2 ; P 0 . -> 3
. . . .
```
So if we remove all the direction changes, this program boils down to the following linear code:
```
H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@
```
What's with `Q2`, `P0` and `P1`? Letters are printed easily because we can just set the edge to the corresponding value. For the comma, the space and the exclamation mark, that doesn't work. We also can't just set their value with `44`, `32`, `33`, respectively, because the memory edge is non-zero to begin with, and due to the semantics of individual digits that would wreak all sorts of havoc. If we wanted to do that, we'd have to reset the edge value to zero with something like `*`, `+`, `-`, `&` or `^` first. However, since the value is taken modulo 256 before being printed we don't have to set the values exactly to 44, 32, or 33. For instance, `Q2` will set the edge value to `81*10 + 2 = 812`, which is `44` when taken modulo `256`. This way we can save a byte on each of those three characters. (Unfortunately, it's never possible to get there with a single digit from the value the cell already has. Amusingly, where it *does* work is the `o` in `World`, because that can also be obtained from `W9`.)
[You can use this CJam script](http://cjam.aditsu.net/#code=q%3AC%3B'%5B%2C_el%5EA%2Cm*%7B_Ab256%25c%5C%2B%7D%25%7B0%3DC%26%7D%2C1f%3EN*&input=%2C) to find all letter-digit combinations that result in a given character.
I'm not sure whether this is optimal. I doubt it's possible to do it in a hexagon of side-length 3 (where you'd only have 19 characters available), but it might be possible to solve it in a hexagon with side-length 4 with less than 32 commands, such that there are more no-ops at the end of the grid.
[Answer]
# x86\_64 machine code for Linux, 32 bytes
When Linux starts a new process, all the registers (except RSP) are zero, so we can get RAX=1 by only modifying the low byte. The x86-64 System V ABI doesn't guarantee this, but it's what Linux actually does. This code only works as `_start` in a static executable.
```
0000000000000000 <_start>:
0: e8 0d 00 00 00 call 12 <hello>
5: 48 65 6c 6c 6f
a: 2c 20 57 6f 72
f: 6c 64 21 5e 40
0000000000000012 <hello>:
12: 5e pop rsi
13: 40 b7 01 mov dil,0x1
16: b2 0d mov dl,0xd
18: b0 01 mov al,0x1
1a: 0f 05 syscall
1c: b0 3c mov al,0x3c
1e: 0f 05 syscall
```
The call instruction pushes the next address, which contains the hello world string, onto the stack. We pop the address of the string into `rsi`.
Then the other arguments are set up for a `syscall` to `sys_write`, which prints the string.
The program terminates with a `syscall` to `sys_exit`. `sys_write` returns the number of bytes written, so the upper bytes of RAX are zero after the first `syscall` (unless it returned an error), so `mov al, 60` gives us RAX = `__NR_exit` in only 2 bytes.
You can make this program segfault by closing its stdout (`./a.out >&-`), so `sys_write()` will return `-EBADF`, the second `syscall` will return `-ENOSYS`, and then execution will fall off the end. But we don't need to handle `write()` errors gracefully.
[Answer]
# C, 30 Bytes
```
main(){puts("Hello, World!");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oLSkWEPJIzUnJ19HITy/KCdFUUnTuvb/fwA "C (gcc) – Try It Online")
Fairly vanilla, but I can't think of a commonly compilable way to do it any shorter (unless maybe some kind of raw asm trick might work?). Still, beats most esolangs!
[Answer]
# [Fourier](https://github.com/beta-decay/Fourier), 15 bytes
***[BIG CHANGES to Fourier!](https://github.com/beta-decay/beta-decay.github.io/commit/f56ae30caea38dd8a9c36afe7a399b6be4b4d818)***
```
`Hello, World!`
```
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=YEhlbGxvLCBXb3JsZCFg)
Yes, the days of typing out the ASCII code of each character are gone forever: Fourier now *kind of* supports strings. When you enclose a string in backticks, that string will be outputted.
Note that you can't do anything other than output that string: you cannot store it in a variable, it is not stored in the accumulator and there are no string manipulation tools.
---
Here, you can find the train wreck that was *old* Fourier. ;)
```
72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a
```
[**Try it online!**](https://tio.run/nexus/fourier#FcfBCQAwCATBgkTIqUTb2f6LMGR@sx3oCGuwpIoMppH07xcfMtl9)
Now, some of you will probably have [met Fourier before](https://codegolf.stackexchange.com/questions/55384/golfing-strings-in-fourier) and may be fairly familiar with the language. The whole language is based upon an accumulator: a global variable which pretty much all operators use.
The most important part of the code is the `a` operator. This takes the numerical value of the accumulator and converts it to a character using the Python code `chr(accumulator)`. This is then printed to STDOUT.
Unfortunately, I haven't had the chance to use Fourier yet (*nudge nudge*, *wink wink*), mainly because of its lack of strings and string operators. Even so, it's still usuable for many other challenges (see the examples section of its EsoLangs page).
Note that this is shorter than my entry into the [Esolangs list](http://esolangs.org/wiki/Hello_world_program_in_esoteric_languages#Fourier) because I didn't actually think that I could golf it any more. And then, when writing the Fourier string golfing challenge, I realised I could go quite a bit shorter.
## Note
If you were wondering about variable syntax, Geobits wrote a program which uses variables *and* is the same length:
```
72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a
```
[**Try it online!**](https://tio.run/nexus/fourier#DcfBDQAgCACxgQxRwAjr3Bo8XB3trx2GLmUEDL/F3riRQf0jB0mm0/0A)
[Answer]
# [C--](http://www.cs.tufts.edu/%7Enr/c--/index.html), 155 bytes
```
target byteorder little;import puts;export main;section"data"{s:bits8[]"Hello, World!\0";}foreign"C"main(){foreign"C"puts("address"s);foreign"C"return(0);}
```
Unfortunately, the only known C-- compiler, [Quick C--](https://github.com/nrnrnr/qc--) is no longer maintained. It's a pain in a neck to build, but it *is* possible...
[Answer]
# Java 5, 61 bytes
```
enum H{H;{System.out.print("Hello, World!");System.exit(0);}}
```
This is valid in both Java 5 and Java 6. This won't work in Java 4 or earlier (because `enum` didn't exist) and will not work in Java 7 or after (because this solution uses a bypass[1] that was "fixed").
```
enum H { // An enum is basically a class.
H; // Static initialization of the mandatory instance, invoking the default constructor.
// Happens before the existence check of "main"-method.
// No constructor means default constructor in Java.
{ // Instance initialization block.
// Executed in each constructor call.
System.out.print("Hello, World!"); // duh!
System.exit(0); // Exit before the JVM complains that no main method is found.
// (and before it writes on stderr)
}
}
```
## Rough equivalence in Java as usually written
The above code is roughly equivalent to the following one.
```
class HelloWorld {
public final static HelloWorld INSTANCE;
static {
INSTANCE = new HelloWorld();
}
public HelloWorld() {
System.out.print("Hello, World!");
System.exit(0);
}
}
```
## Proof of correctness
```
$ java -version
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)
$ javac H.java
$ java H
Hello, World!
$
```
---
1. The bypass consists of the static execution of code when the class is being linked. Before Java 7, the `main`-method-containing class was no exception to the static initialization code. Afterwards, static initialization was delayed until the `main` method would actually be found.
[Answer]
## Malbolge, 112 bytes
```
('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9&7Y#VV2TSn.Oe*c;(I&%$#"mCBA?zxxv*Pb8`qo42mZF.{Iy*@dD'<;_?!\}}|z2VxSSQ
```
I'm going to see if there's a shorter one. Got a better computer since last time, so I can generate quite a bit faster.
For show, here's "Hello World!" without the comma.
```
(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc
```
[Answer]
# [Unreadable](https://esolangs.org/wiki/Unreadable), ~~843~~ ~~755~~ ~~732~~ ~~666~~ ~~645~~ ~~629~~ 577 bytes
>
> '"'""'""'""'"'"'""""""'""'"""'""'""'""'""'""'""'""'"'""'""""""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""'"'"""""""'""""""""'"""'"'"""""""'"""'"'"""""""'""'""'"""'"'""'""'""'"'""'""'""'"""""""'""'"""'"'"""""""'""'"""'"'"""""""'""'""'""'"""'"'""'"""""""'"""
>
>
>
Unreadable programs are supposed to be displayed with a variable-width font, so they honor the language's name. I'm slightly disappointed that my more sophisticated approaches turned out to be a lot longer. Loops are insanely expensive in Unreadable...
[Try it online!](https://tio.run/nexus/unreadable#@6@upK4ER2AOCEAEkKVQlaGqw68aC0LRSoI@JNupjqBuQjBI1KdOY4SIHHRnquPiIWvEFnqoUU1AAM0wuI3//wMA "Unreadable – TIO Nexus")
### How it works
Unreadable has only ten functions; six of these are used in this code:
```
'" p Print.
'"" + Increment.
'""" 1 Return 1.
'"""""" : Set.
'""""""" = Get.
'"""""""" - Decrement.
```
After using my single-character notation and adding some whitespace and comments, the above code looks like the following. Multi-line statements are executed from bottom to top.
```
p+++ Print 3 + variable 2 (o).
pp Print variable 2 two times (l).
:+1+++++++ Save 8 + variable 3 in variable 2.
p+ Print 1 + variable 3 (e).
:++1+++++++++++++ Save 13 + variable 4 in variable 3.
:+++1+++++++++++++++ Save 43 + variable 0 in variable 4.
p++++++++++++++++++++++++++++ Print 28 + variable 0 (H).
:-1++++++++++++ Save 44 in variable 0.
:1+++++++++++++++++++++++++++++++1 Save 32 in variable 1.
p=-1 Print variable 0 (,).
p=1 Print variable 1 ( ).
p=+++1 Print variable 4 (W).
p+++ Print 6 + variable 2 (r).
p+++=+1 Print 3 + variable 2 (o).
p=+1 Print variable 2 (l).
p=++1 Print variable 3 (d).
p+=1 Print 1 + variable 1 (!).
```
I've generated the actual source code by running the uncommented version of the above pseudocode through [this CJam program](https://tio.run/nexus/cjam#fY89CsAwCIX3nELSIdCHg2vBK3TpHTLb@w@p@WkhHfLA588ngiWl@zrBkQxCdCjHvKWY94xSDEAgMnNzBkFXa33@FpV9cFoZ7AcnXO8sNG36MZYFdS5YS4IpV6vR@/GlJ224WyMqDw "CJam – TIO Nexus").
[Answer]
# [JSFuck](https://esolangs.org/wiki/JSFuck), ~~6293~~ ~~6289~~ 6277 bytes
This may get a mention as one of the longest "shortest *Hello, World!* programs" (actually I do not know if this is optimal, but it's the shortest I managed to get).
**Warning: only works in Firefox and Safari**
```
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()
```
There is also a slightly longer version (+4 bytes) that also works in Chrome and Microsoft Edge:
```
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]]((![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()
```
For those unfamiliar with JSFuck, it's about writing JavaScript as if there were only six characters, and it can get pretty crazy at times.
This table shows how the characters used in the *Hello, World!* program are encoded in JSFuck. The plain text code is just `alert("Hello, World!")`.
```
+----------+--------------------------------------+---------------------------+
|JavaScript| write as | JSFuck |
+----------+--------------------------------------+---------------------------+
| a | (false+[])[1] | (![]+[])[+!![]] |
| l | (false+[])[2] | (![]+[])[!![]+!![]] |
| e | (true+[])[3] | (!![]+[])[!![]+!![]+!![]] |
| r | (true+[])[1] | (!![]+[])[+!![]] |
| t | (true+[])[0] | (!![]+[])[+[]] |
| ( | ([]+[]["fill"])[13] | 114 bytes |
| " | ([]+[])["fontcolor"]()[12] | 539 bytes |
| H | btoa(true)[1] | 1187 bytes |
| o | (true+[]["fill"])[10] | 105 bytes |
| space | ([]["fill"]+[])[20] | 107 bytes |
| W | (NaN+self())[11] | 968 bytes |
| d | (undefined+[])[2] | ([][[]]+[])[!![]+!![]] |
| ! | atob((Infinity+[])[0]+false)[0] | 1255 bytes |
| ) | (0+[false]+[]["fill"])[20] | 114 bytes |
+----------+--------------------------------------+---------------------------+
```
Here the strings `"fill"`, `"fontcolor"`, etc. must be written as `"f"+"i"+"l"+"l"`, `"f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"` to be encoded.
The global identifiers `self`, `atob` and `btoa` get written like `Function("return self")()`.
`Function` itself should be `[]["fill"]["constructor"]`.
The comma `","` is tricky, I'm not 100% sure how it works but it uses the `[]["concat"]` function to create an array.
I'll post an update when I have time to do more tests.
---
I encoded this using JScrewIt - credits to [GOTO 0](https://codegolf.stackexchange.com/users/12474/goto-0) for creating such a sophisticated tool:
* Open Firefox *(You can choose any other browser(s), but Firefox only code is the shortest.)*
* Navigate to **JScrewIt**: <http://jscrew.it>
* **Input:** `alert("Hello, World!")`
* **Executable code:** checked
* **Compatibility:** Only this browser
This differs from my answer to [this question](https://codegolf.stackexchange.com/questions/17950/jsfuck-golf-hello-world) for the presence of the comma after "Hello".
Interestingly, the ES6 syntax
```
alert`Hello, World!`
```
takes even more bytes to encode (+1500 or so) because of the higher complexity of encoding two backticks rather than `("` and `")`.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/209242/edit).
Closed 3 years ago.
[Improve this question](/posts/209242/edit)
## The challenge.
Make a program that produces a random series of 8 notes in the scale of E minor, and then harmonizes them.
## Details.
* Notes must be represented in output as a 1-2 char string, which designates the note and if it is sharped or not, followed by a number, which designates the octave. Examples would be `C3`, `D#7`, or `A#1`. No notes can be flatted, only sharped.
* No notes can have an octave lower than `1`.
* The scale starts at `E4` and ends at `D5`. No notes that are randomly generated can be outside of these bounds, but the chords can be below it.
* Each note that the program randomly makes must have a chord of three notes an octave below it.
* The three notes of a chord are as followed:
+ Root note: The note originally randomly generated, but an octave lower.
+ Middle note: Depending on what note fits within the scale, this is `3` to `4` semitones above the root note and is what makes a chord major or minor.
+ Top note: The fifth of the root note, or raised `7` semitones. If the fifth of the root note isn't in the scale, then the top note is `6` semitones above the root.
* Output is simply just a print to the console of a string.
## Output.
What a note and its harmony look like:
`({E4}, {E3}, {G3}, {B3})`
Output format:
`[ (*note and harmony*), x8 ]`
All space padding is optional.
# Conclusion.
Any languages are allowed, and the shortest response, in bytes, after a week is the winner.
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 3 years ago.
[Improve this question](/posts/201410/edit)
A directed graph **G** is given with Vertices **V** and Edges **E**, representing train stations and unidirectional train routes respectively.
Trains of different train numbers move in between pairs of Vertices in a single direction.
Vertices of **G** are connected with one another through trains with allotted train numbers.
A hop is defined when a passenger needs to shift trains while moving through the graph. The passenger needs to shift trains only if the train-number changes.
Given two Vertices **V1** and **V2**, how would one go about calculating the minimum number of hops needed to reach **V2** starting from **V1**?
---
[](https://i.stack.imgur.com/ROyLs.jpg)
In the above example, the minimum number of hops between Vertices **0** and **3** is 1.
There are two paths from 0 to 3, these are
`0 -> 1 -> 2 -> 7-> 3`
`Hop Count 4`
Hop Count is 4 as the passenger has to shift from Train A to B then C and B again.
and
`0 -> 5 -> 6 -> 8 -> 7 -> 3`
`Hop Count 1`
Hop Count is 1 as the passenger needs only one train route, B to get from Vertices **0** to **3**
Thus the minimum hop count is 1.
---
**Input Examples**
Input Graph Creation
[](https://i.stack.imgur.com/0tMgt.png)
Input To be solved
[](https://i.stack.imgur.com/VvLUa.png)
---
**Output Example**
Output - Solved with Hop Counts
[](https://i.stack.imgur.com/LLB9A.png)
0 in the `Hop Count` column implies that the destination can't be reached
]
|
[Question]
[
You must write a program or function that takes a string of brackets and outputs whether or not that string is fully matched. Your program should print a [truthy or falsy](http://meta.codegolf.stackexchange.com/questions/2190/interpretation-of-truthy-falsey) value, and IO can be in any [reasonable format](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
# Rules and definitions:
* For the purpose of this challenge, a "bracket" is any of these characters: `()[]{}<>`.
* A pair of brackets is considered "matched" if the opening and closing brackets are in the right order and have no characters inside of them, such as
```
()
[]{}
```
Or if every subelement inside of it is also matched.
```
[()()()()]
{<[]>}
(()())
```
Subelements can also be nested several layers deep.
```
[(){<><>[()]}<>()]
<[{((()))}]>
```
* A string is considered "Fully matched" if and only if:
1. Every single character is a bracket,
2. Each pair of brackets has the correct opening and closing bracket and in the right order, and
3. Each bracket is matched.
* You may assume the input will only contain [printable ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters).
# Test IO
Here are some inputs that should return a truthy value:
```
()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]
```
And here are some outputs that should return a falsy value:
```
( Has no closing ')'
}{ Wrong order
(<)> Each pair contains only half of a matched element
(()()foobar) Contains invalid characters
[({}<>)> The last bracket should be ']' instead of '>'
(((())) Has 4 opening brackets, but only 3 closing brackets.
```
As usual, this is code-golf, so standard loopholes apply, and shortest answer in bytes wins.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~1101, 1085~~, 981 bytes
```
{(<(({}))((((()()()()()){}){}){})({}[{}]<(())>){((<{}{}>))}{}>{({}<>)(<>)}{}<(({
}))((((()()()()()){}){}){}())({}[{}]<(())>){((<{}{}>))}{}>{({}<>)({}[{}](<()>)){
{}{}(<(())>)}{}{<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))(((((()()()()()){}){})){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()(<>)}{}<(({}))(((((()()()()()){}){})(
)){}{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((()()()){}){}()){({}[()])}{})({}[{}]<(()
)>){((<{}{}>))}{}>{<({}()()<>)>()(<>)}{}<(({}))((((((()()()()()){})){}{}())){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{<>{{
}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((((()()()()()){}){}){}())){}{})({}[{}]<(())>
){((<{}{}>))}{}>{<({}()()()<>)>()(<>)}{}<(({}))((((((()()()()()){}){}){}())()){}
{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<{}>[()]){<>{{}}(<()>)<>{{}}(<()>)}{}}<>([]<>)({}<
(())>){((<{}{}>))}{}
```
[Try it online!](https://tio.run/##rZNBDsIgFESvM7PoDQgXaVjgwsRoXLj94ew4QDU11Uq1pYVfGCZvUnq4xdN1OF7iOWeDAyyRKBcfjZpqtxZHS0Eq0tMAZ8mSJ0tvWnWe0KPXdSeVXV5NIyxJaEWAaYNKc15TqfWYRFWyIFggsHh9YXAooDLzYI8ntrvulW@GUcbiCwb20qylfI1ZE6rsT7p71g/naQtRf97naf3N/6/McqxfcdI1wbxOdTfG0H6Vt1A5o7I7P4aYh3gH "Brain-Flak – Try It Online")
This is 980 bytes of source code, and `+1` for the `-a` flag allowing ASCII input (but decimal output)
This is an answer I've been wanting to write for a *very very* long time. At least 6 months. I waited to post this because I knew that answering this challenge would be extra hard in brain-flak. But it's worth it for one very important reason: The source code itself is a truthy input, which is the entire point of this language itself.
And as I wrote about [here](http://meta.codegolf.stackexchange.com/a/9957/31716), this question was what inspired me to write brain-flak.
>
> Shortly after I wrote Are the brackets fully matched?, it made me wonder how much information you can store with only matched brackets. One thing that stood out to me, was that even though you only have 4 "atoms" of sorts:
>
>
>
> ```
> (){}[]<>
>
> ```
>
> you really have 8 units of information to convey, since each of these bracket types can be empty, or have other brackets in between, which are fundamentally different pieces of information. So, I decided to write a language that only allowed for matched brackets, and where empty brackets convey something different than brackets with other brackets inside of them.
>
>
>
This answer took roughly two hours to write. I'll admit it's pretty poorly golfed, mostly because a lot of the code is repeated for each bracket type. But I'm mostly amazed that I was able to write an answer at all, especially given that Brain-Flak is
>
> A minimalist esolang designed to be painful to use
>
>
>
I'm going to attempt to golf it down later, but I wanted to get this out there anyway.
I have a detailed explanation, but it's about 6 thousand characters long, so I think it would not be wise to paste the entire thing into this answer. You can read through it [here](https://gist.github.com/DJMcMayhem/52453a771830a0dcd42323d39396ce54) if you want. I'll add a shorter explanation here.
The basic idea, is that we repeat the following steps for every character on the stack:
* We check each character to see if it matches any bracket. If it is an opening bracket, we push a number onto the other stack according to the following mapping:
```
( = 1
< = 2
[ = 3
{ = 4
```
* Then we check to see if it matches any closing bracket. If it does, we push the equivalent number onto the alternate stack, just like for opening brackets. *Then*, we check if the top two numbers are equal. If they are, the both get popped and the program continues as normal. If they are not, we clear both stacks (to stop the looping) and push a one onto the alternate stack. This is essentially a "break" statement.
* After checking the 8 bracket types, we push the value of this run through the loop. Since we zero out most of it, the only snippets that have any value are the conditionals when we compare against brackets. So if any bracket is matched, the whole loop has a value of 1. If none of them did, the whole loop has a value of 0. In this case, we will clear both stacks and push a 0 onto the alternate stack. Again, this is like a "break" statement.
After this main loop is running, the rest is fairly simple. We are on the (empty) main stack, and the alternate stack is empty (if the brackets were matched) or non-empty if they were not. So we run this:
```
#Toggle to the alternate stack
<>
#Push this stack-height onto main-stack
([]<>)
#Logical not
({}<(())>){((<{}{}>))}{}
```
This will push a 0 or a 1 onto the main-stack, and when the program ends it is implicitly printed.
---
* *Thanks to [@WheatWizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard) for coming up with a good stack-clean "equals" and "logical not" snippet, and for regularly updating the [github wiki](https://github.com/DJMcMayhem/Brain-Flak/wiki) with useful examples.*
* *Thanks to [@ASCII-only](https://codegolf.stackexchange.com/users/39244/ascii-only) for writing an online [integer metagolfer](https://brain-flak.github.io/integer/) which helped immensely in writing this program*
---
*revisions*
* *Removed some push pop redundancy*
* *Changed my zero counter logic*
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~204~~ ~~196~~ 190 bytes
```
{({}<>)<>((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())(({<({}<>[({})])>[()]{()(<{}>)}{}<>}{}()<({}<>[({})]){(<{}({}())>)}{}<>>)){(<({}{}<>[{}]{}<>)>)}{}{<>{{}}}{}}<>((){[()]<>})
```
[Try it online!](https://tio.run/##1Y5BCsMwDAS/oz3kB0IfKT64h0Bo6KHXRW9PVyIp5AmVwZI1y3qfn7m9l3Wfr@OgMT3gYVW4Dpgwoe6Apn7Zb@eGgKqg0dvlUXBAHYNycWYgi@gy3EQsWrbAqZGdllq1ijk6WEN6kJmasoKC9YNc8ff5l/kF "Brain-Flak – Try It Online")
-8 bytes thanks to Wheat Wizard. -6 bytes thanks to Jo King.
### Explanation
This program stores the character codes of all current unclosed brackets on the second stack. The bracket pairs `<>`, `[]`, and `{}` each have character codes that differ by exactly 2, so there is no need to check for them specifically. The pair `()` only differs by 1, so we check for `(` specifically, and effectively decrement that byte (actually increment every other byte) before continuing.
```
# While there are bytes left to process
{
# Move byte to second stack
({}<>)<>
# Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())
((
# For each opening bracket type:
{
# Evaluate as zero
<
# Compute difference between bracket type and input byte
({}<>[({})])
>
# Evaluate loop iteration as -1 if equal, 0 otherwise
[()]{()(<{}>)}{}<>
}
# Remove the 0 that was inserted to terminate that loop
{}
# Add 1 to result
()
# Evaluate rest of this expression as zero
<
# Determine whether the byte is open parenthesis
({}<>[({})])
# If not:
{
# Add 1 to byte and break if
(<{}({}())>)
}{}
# Return to main stack
<>
>
# Push result twice (0 if matched an opening bracket, 1 otherwise)
))
# If byte was not an opening bracket:
{
# Push zero to break out of if
(<
# Push (open bracket + 2 - byte) below that zero
({}{}<>[{}]{}<>)
>)
}{}
# If byte was neither an opening bracket nor the appropriate closing bracket:
{
# Clear alternate stack and stay there to break out of main loop early
<>{{}}
}{}
# End of main loop
}
# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket. If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.
# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 19 bytes
Input is given in *quotes*. Code:
```
"[](){}<>"2÷)"":g2Q
```
Well crap, a *lot* of bugs and unimplemented features were found. Explanation:
```
"[](){}<>" # Push this string
2÷ # Split into pieces of two
) # Wrap it into an array (which should not be needed)
"" # Push an empty string
: # Infinite replacement
```
This is actually a tricky part. What this looks like in pseudocode is:
```
input().replace(['[]', '()', '{}', '<>'], "")
```
This is covered by this part from the [05AB1E code](https://github.com/Adriandmen/05AB1E/blob/master/05AB1E.py#L1498):
```
if type(b) is list:
temp_string = temp_string_2 = str(a)
while True:
for R in b:
temp_string = temp_string.replace(R, c)
if temp_string == temp_string_2:
break
else:
temp_string_2 = temp_string
stack.append(temp_string)
```
As you can see, this is **infinite replacement** (done until the string doesn't change anymore). So, I don't have to worry about setting the replacement into a loop, since this is already builtin. After that:
```
g # Take the length of the final string
2Q # Check if equal with 2 (which are the quotes at the end)
```
Uses **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=IltdKCl7fTw-IjLDtCIiOmcyUQ&input=J1soW117fSk8e1soKTwoKT5dfSgpPnt9XSc) (slightly modified because the above version is deprecated).
[Answer]
## JavaScript (ES6), ~~52~~ 50 bytes
```
f=s=>(t=s.replace(/\(\)|\[]|{}|<>/,''))==s?!s:f(t)
```
Repeatedly remove brackets until the result is the same as the original, then return false unless the string is now empty.
Edit: Saved 2 bytes thanks to @edc65.
[Answer]
## Python, 67 bytes
```
lambda s:eval("s"+".replace('%s','')"*4%([],(),{},'<>')*len(s))==''
```
Generates and evals an expression that looks like
```
s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')
```
and checks if the result is empty.
Sp3000 saved 8 bytes by pointing out that `[],(),{}` can be subbed in without quotes because they're Python objects, and that two parens were unneeded.
[Answer]
# Retina, 20 bytes
```
+`\(\)|\[]|{}|<>
^$
```
[Try it online](http://retina.tryitonline.net/#code=K2BcKFwpfFxbXXx7fXw8PgoKTWBeJA&input=WygpKCkoKSgpXQ)
[Answer]
## CJam, ~~25~~ ~~24~~ ~~23~~ 21 bytes
*Thanks to Sp3000 for saving 2 bytes.*
*Thanks to jimmy23013 for saving 2 bytes.*
```
q_,{()<>}a`$2/*{/s}/!
```
[Test suite.](http://cjam.aditsu.net/#code=qN%2F%7B%3AQ%7B%0A%0AQ_%2C%7B()%3C%3E%7Da%60%242%2F*%7B%2Fs%7D%2F!%0A%0A%7D%26%5DoNo%7D%2F&input=()%0A%5B%5D()%7B%7D%3C%3E%0A(((())))%0A(%7B%5B%3C%3E%5D%7D)%0A%5B%7B()%3C%3E()%7D%5B%5D%5D%0A%5B(%5B%5D%7B%7D)%3C%7B%5B()%3C()%3E%5D%7D()%3E%7B%7D%5D%0A%0A(%0A%7D%7B%0A(%3C)%3E%0A(()()foobar)%0A%5B(%7B%7D%3C%3E)%3E%0A(((())))
Works essentially the same as the other answers: we repeatedly remove `()`, `[]`, `<>` and `{}` from the string and check if we end up with the empty string. To avoid having to check when we're done, we remove the pairs `N` times where `N` is the length of the string, which is always sufficient (since each iteration will remove at least two characters, unless we're done). I'm glad to see that this doesn't beat Retina. :) (Although Pyth or Jelly might...)
There's one fun golfing trick here: to get the string `()<>[]{}` we use the following:
```
{()<>}a`$
```
The, `{()<>}` is just a block (i.e. a function), which contains the other brackets as code. With `a` we wrap the block in an array. The ``` stringifies that array, which gives `"[{()<>}]"`. Finally, we sort the string with `$`, which rearranges the brackets to `()<>[]{}`.
[Answer]
# Yacc, 119 bytes
Does not use regex/replace.
```
%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}
```
## Ungolfed
```
%% # Grammar in BNF
input:
r;
r:
%empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%% # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}
```
## Compilation
```
yacc -o bracket.c bracket.y
cc -o bracket bracket.c
```
## Usage
```
~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 % :(
```
[Answer]
## Pyth, ~~31~~ ~~25~~ 24 bytes
Golfed down to 25 bytes thanks to FryAmTheEggMan
Removed 1 byte
```
VQ=:Q"<>|\[]|{}|\(\)"k;!
```
Try it here: [Test suite](https://pyth.herokuapp.com/?code=Vz%3D%3Az%22%3C%3E%7C%5C%5B%5D%7C%7B%7D%7C%5C%28%5C%29%22k%3B%21z&test_suite=1&test_suite_input=%28%29%0A%5B%5D%28%29%7B%7D%3C%3E%0A%28%28%28%28%29%29%29%29%0A%28%7B%5B%3C%3E%5D%7D%29%0A%5B%7B%28%29%3C%3E%28%29%7D%5B%5D%5D%0A%5B%28%5B%5D%7B%7D%29%3C%7B%5B%28%29%3C%28%29%3E%5D%7D%28%29%3E%7B%7D%5D%0A%28%0A%7D%7B%0A%28%3C%29%3E%0A%28%28%29%28%29foobar%29%0A%5B%28%7B%7D%3C%3E%29%3E%0A%28%28%28%28%29%29%29&debug=0) !
I'm still a Pyth newbie, any help is appreciated.
## Explanation
```
VQ For N in range(0, len(z)), with Q being the evaluated input.
Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
=:Q"<>|\[]|{}|\(\)"k assign Q without {}, [], <> nor () (regex replacement) to Q
; End of For loop
! Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise
```
BTW, congrats to the other Pyth answer (which is currently 20 bytes)
[Answer]
# Pyth, 20 bytes
```
!uuscNTc"[](){}<>"2G
```
Try it online: [Test Suite](http://pyth.herokuapp.com/?code=!uuscNTc%22[]%28%29%7B%7D%3C%3E%222G&input=%22%28[%29]%22&test_suite=1&test_suite_input=%22%28%29%22%0A%22[]%28%29%7B%7D%3C%3E%22%0A%22%28%28%28%28%29%29%29%29%22%0A%22%28%7B[%3C%3E]%7D%29%22%0A%22[%7B%28%29%3C%3E%28%29%7D[]]%22%0A%22[%28[]%7B%7D%29%3C%7B[%28%29%3C%28%29%3E]%7D%28%29%3E%7B%7D]%22%0A%22%28%22%0A%22%7D%7B%22%0A%22%28%3C%29%3E%22%0A%22%28%28%29%28%29foobar%29%22%0A%22[%28%7B%7D%3C%3E%29%3E%22%0A%22%28%28%28%28%29%29%29%22&debug=0)
Repeatedly removes occurrences of `[]`, `()`, `<>` and `{}` by splitting and re-merging. Checks if the resulting string is empty or not.
[Answer]
# Javascript ES6, 54 bytes
```
f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_
```
Uses a recursive replace implementation. Simple enough.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 204 bytes
```
(()){{}{({}<>)<>}<>({<(<(({})<>)>)(((((((([(())()()()]){}){}){}())(()))(((())()){}()){})){})(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))<>{}<>{{}({}[({})]<>({})){(<>)(<>)}{}{}(<>)}{}>{}<>}<>)}{}((){<>[()]})
```
[Try it online!](https://tio.run/##3U9BDsMgDPuOfegPonyk6oEdKlWbdtg1yts7G/aKAUbBdgw8PuN6b@drPO8bIKu6UB3JSO2oQECEjkziN3ZbMedBiXOZEqbJ6qIkGXDSDK7e3cUEyxWiOtmW2mY7BDXbKebwM5wCvcGQTeoqprlXrWsr0pnNP/vNNr4 "Brain-Flak – Try It Online")
Not quite as short as [Nitroden's answer](https://codegolf.stackexchange.com/a/142224/76162), but uses a very different approach. This one runs through the input repeatedly, removing neighbouring matching pairs of brackets each time until there are none left. At that point if there is anything left on the stack, then the string was not fully matched.
### Explanation:
```
(()) Push 1 to simulate the check at the start of the loop
{ While check
{} Pop check
{({}<>)<>}<> Reverse input
({ Loop over input
< Don't push the values of these calculations
(<(({})<>)>) Create a copy of the top of the input and push to the other stack
(((((
((([(())()()()]){}){}){}())
(()))
(((())()){}()){})
){}) Push the differences in values of the end brackets
(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{})) If the copy is the same as any of these, push the difference between the other bracket twice
<>{}<> Pop copy
{ If this character is a start bracket
{}({}[({})]<>({})) Check if the next character is the end bracket
{(<>)(<>)}{} If not, push a 0 to each stack as buffer
{} Pop the top of the input stack, either the start bracket if they matched or the buffer 0
(<>) Push 0 to other stack to end check
}{}>
{} Pop the top of the other stack
If the character was not an end bracket, pop the copy of check, which is 0
If it was, but didn't match the next character, pop the buffer 0
If the brackets matched, pop the end bracket and add it to the loop total
<>} Repeat with the rest of the input
<>) Push the loop total
If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1
```
[Answer]
# Regex (PCRE flavor), ~~41~~ 37 bytes
```
^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$
```
Just a standard solution with recursive regex.
*Thanks jimmy23013 for shaving off 4 bytes*
[Answer]
## Brainfuck, 132 bytes
```
+>,[[<->>+>[-]<<-]<[>+>[<+<+>>>+<-]+++++[>--------<-]>[<<+>++++[>-----<-]>[<++++
+[>------<-]>-[<++++[>--------<-]>[,>]]]]<],]<<[>]>.
```
Formatted:
```
+>,
[
[<-> >+>[-]<<-]
<
[
not matching closing bracket
>+>[<+<+>> >+<-]
+++++[>--------<-]
>
[
not open paren
<<+>
++++[>-----<-]>
[
not open angle bracket
<+++++[>------<-]>-
[
not open square bracket
<++++[>--------<-]>
[
not open brace
,>
]
]
]
]
<
]
,
]
<<[>]
>.
```
Expects input without a trailing newline. Prints `\x00` for false and `\x01` for true.
[Try it online.](http://brainfuck.tryitonline.net/#code=Kz4sW1s8LT4-KzwtXTxbPis-PlstXTxbPCs8Kz4-Pis8LV0rKysrK1s-LS0tLS0tLS08LV0-Wzw8Kz4rKysrWz4tLS0tLTwtXT5bPCsrKysrWz4tLS0tLS08LV0-LVs8KysrK1s-LS0tLS0tLS08LV0-Wyw-XV1dXTxdLF08PFs-XT4u&input=WyhbXXt9KTx7WygpPCgpPl19KCk-e31d)
Approach: Maintain a stack starting with `\x01`, and push the corresponding closing bracket whenever an opening bracket is encountered. Before checking whether the current character is an opening bracket, first check whether it's equal to the closing bracket at the top of the stack, and if so pop it. If it's neither the proper closing bracket nor an opening bracket, consume the rest of the input while moving the pointer to the right. At the end, check whether the pointer is next to the initial `\x01`.
[Answer]
# Perl, ~~34~~ 33 bytes
Includes +2 for `-lp`
Run with input on STDIN:
```
./brackets.pl <<< "{<>()}"
```
`brackets.pl`:
```
#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_
```
Finds the first bracket pair without anything between them and removes it as long as there are any. Then checks if the final string is empty.
[Answer]
# Java 7, ~~156~~ 151 bytes
```
class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}
```
I'm not expecting this to win any awards but I didn't see a Java answer yet. Additionally, I like to lurk around PPCG and I would enjoy being able to vote/comment on other answers.
Input is given as program parameters. This follows the same format as many other answers here in that it preforms a regex replacement in a loop. Originally I had it loop N times where N is the length of the original string but looping to `Integer.MAX_VALUE` is shorter :]. This should be ok because `Integer.MAX_VALUE` is the maximum length of a `String` in Java so there's an implicit assumption that the length of input is something that is handle-able by Java. The runtime is pretty bad (took about 20 minutes on my lappytop) on account of the loop but I didn't see any restriction on that.
[Answer]
# [Haskell](https://www.haskell.org/), 151 bytes
```
infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0
```
[Try it online!](https://tio.run/##PcuxCsMgFIXh3acoWlDHrkEd@wTd5BIcLJXaUJIWDHKf3ZoLdTnwHfgfYXvGnFtLyz2V00UwqeRUxG6LkFpOO5Nm2JH9MJDrMJL1YWr71@3IbhjIMIxk/Jtzwbm9rd/IZjHba8hbZO0V0mLfa1o@Z@6Vh4raVK@0UdoB9qkIR9h@ "Haskell – Try It Online")
[Answer]
## [Grime](https://github.com/iatorm/grime/tree/v0.1) v0.1, 34 bytes
```
M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M
```
Prints `1` for a match and `0` for no match.
[Try it online!](http://grime.tryitonline.net/#code=TT1cKE1cKXxcW01cXXxce01cfXxcPE1cPnxNTXxfCmVgTQ&input=WyhbXXt9KTx7WygpPCgpPl19KCk-e31d)
## Explanation
Grime is my 2D pattern-matching language designed for [this challenge](https://codegolf.stackexchange.com/questions/47311/language-design-2-d-pattern-matching); it can also be used to match 1D strings.
This is my first answer with it.
I did modify Grime today, but only to change the character of one syntax element (``` instead of `,`), so it doesn't affect my score.
```
M= Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\> a smaller M inside matched brackets,
|MM or two smaller Ms concatenated,
|_ or the empty pattern.
e`M Match the entire input against M.
```
[Answer]
# Reng v.3.3, 137 bytes, noncompeting
[Try it here!](https://jsfiddle.net/Conor_OBrien/avnLdwtq/)
```
aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2< < < +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
\$2+)1z+#z/ ~n1/
```
There's a bit more golfing to be done, but at least it works. I added a command `ð` to keep track of stacks after this challenge in order for this to be remotely possible/easily. I'll explain this in a bit, but it generally keeps track of all strings iterated over and looks for repeats; if there is a repeat, then the string is irreducible. Otherwise, the string will be reduced to the empty string/stack, and will output `1`. Otherwise, no output will be produced.
[Answer]
## PowerShell v2+, ~~63~~ 62 bytes
```
param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a
```
Can't quite catch JavaScript, but is currently edging out the other non-esolangs.
Similar approach as other answers: a simple loop that continues so long as we can remove one of `[]`, `()`, or `<>` (with several extraneous characters because we need to escape the regex specials). We use `$b` as a helper along the way to remember what our previous loop's `$a` was set as. An uninitialized variable is `$null`, so the first time the loop is encountered, `$a` is obviously not equal to `$null`.
At the end of the loop, `$a` is either empty or not, and the Boolean-not of that string is either `True` or `False`.
### Example
```
PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True
PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False
```
[Answer]
# C, ~~121~~ ~~122~~ 114 bytes
Shaved of 8 bytes thanks to @xsot!
```
a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}
```
Uses a stack.
[Answer]
### Python 2.7, 96 bytes
```
def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])
```
[Answer]
# Julia, 51 bytes
```
~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n
```
The least insane of several options. Unsurprisingly, leveraging the power of regex is the shortest path to string matching, but this really only applies if the pattern to match is regular. Trying to do PCRE recursive patterns ends up ballooning the size of the code, either by seeing if the whole string is the match or by anchoring the ends and then creating a construct to specify the inner body for regex recursion. Neither of which are pretty or conducive to code golf.
## Explanation:
```
~z= # Define ~z to be the following:
z==( # If z is equal to
n=replace(z, # z with the replacement of
r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
"" # with empty strings
) # (which is assigned to n)
)?z=="" # whether z is an empty string
:~n # else ~ applied to the substituted string
```
The function repeatedly removes adjacent pairs of parentheses from its only argument, and returns true if it can derive an empty string this way.
[Answer]
# R, 298
```
function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}
```
The approach here is to convert the sequence into R code, and then try to parse and evaluate it. If that gives an error, then return `FALSE`.
But there is a minor problem ... R's rules for brackets are different, so `<` and `>` are not brackets at all, and the other types have rules of their own. This is solved by a revolutionary approach -- a squeaking function, whose only function is to signal an error if its head and tail squeak in different ways.
For example, `[]` is transformed into `S('[', {}, ']')`, where S is defined as ...
```
S=function(H,B,T)if(H!=T)stop()
```
Because the head squeak and tail squeak match, no error is thrown.
A few other examples (the left part is a sequence of brackets and right part is its transformation into valid R code that can be evaluated):
```
[} --> S('[', {}, '}') # squeaks an error
[()] --> S('[', {S('(',{},'(')}, "[")
({[]}) --> S('(',{S('{',{S('[',{},'[');},'{');},'(');
```
Some other sequences of brackets will result in parse errors:
```
[[) --> S('[',{S('[',{},'(');
```
So the remaining part just catches the errors and returns FALSE if there are any, and TRUE if there are none.
The human-readble code:
```
sqk <- function(.){
s=strsplit;u=paste0
.=s(.,"")[[1]] # break the argument up into 1-character pieces
p=s("><)(}{][","")[[1]] # vector of brackets
.[!.%in%p]="§" # replace anything besides brackets by § (--> error)
for(i in 1:4*2){
.[.==p[i]]=sprintf("S('%s',{",p[i]) # '<' --> S('<',{ ... etc
.[.==p[i-1]]=sprintf("},'%s');",p[i]) # '>' --> },'<'); ... etc
}
S=function(H,B,T)if(H!=T)stop() # define the working horse
r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
if(inherits(r,"try-error"))FALSE else TRUE # any errors?
}
```
Applying it on sample cases:
```
truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
() [](){}<> (((())))
TRUE TRUE TRUE
({[<>]}) [{()<>()}[]] [([]{})<{[()<()>]}()>{}]
TRUE TRUE TRUE
> sapply(falsy,sqk)
( } (<2)> (()()foobar) [({}<>)> (((()))
FALSE FALSE FALSE FALSE FALSE FALSE
```
[Answer]
# Lua (92 bytes)
The older Lua answer is everything but golfing code. There's my proposal instead:
```
function x(s)m=""return s:gsub("%b<>",m):gsub("%b[]",m):gsub("%b{}",m):gsub("%b()",m)==m end
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~11~~ 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
é:råvm∟&1Γ
```
[Run and debug it](https://staxlang.xyz/#p=823a7286766d1c2631e2&i=%28%29%0A%5B%5D%28%29%7B%7D%3C%3E%0A%28%28%28%28%29%29%29%29%0A%28%7B%5B%3C%3E%5D%7D%29%0A%5B%7B%28%29%3C%3E%28%29%7D%5B%5D%5D%0A%5B%28%5B%5D%7B%7D%29%3C%7B%5B%28%29%3C%28%29%3E%5D%7D%28%29%3E%7B%7D%5D%0A%28%0A%7D%7B%0A%28%3C%29%3E%0A%28%28%29%28%29foobar%29%0A%5B%28%7B%7D%3C%3E%29%3E%0A%28%28%28%28%29%29%29&a=1&m=2)
Got lucky, as stax has a literal constant in it with matched pairs of brackets.
[Answer]
# Curry, ~~64~~ 56 bytes
*Tested to work in both [PAKCS](https://www.informatik.uni-kiel.de/%7Epakcs/) and [KiCS2](https://www-ps.informatik.uni-kiel.de/kics2/)*
```
f(x:a++y:b)|elem[x,y]["{}","<>","[]","()"]=f a*f b
f""=1
```
[Try it on Smap!](https://smap.informatik.uni-kiel.de/smap.cgi?browser/80)
[Try it online!](https://tio.run/##HcixCoMwEADQ3a84jg5JtYWuIcneSfeQIdocSFUkVjCk@fZUurzhDXsI8ba697CVQuwQrq6j6PnXT342RxOtwZSxQalPjD1hHK0icFeCviJE9SizGxcQArrgp/3l788WGK/@q2AN4/KBCxAgM9akLLWVmqXMOZYf)
This returns `1` if string is balanced and nothing otherwise.
## Explanation
Our definition of `f` then matches the empty string as balanced for a base case:
```
f""=1
```
Then we have the main logic:
```
f(x:a++y:b)|[x,y]=:=anyOf["{}","<>","[]","()"]=f a*f b
```
Here `*` is used like a logical and. Since the only value we can get back is `1`, this always gives back `1` when it finds results. But when it doesn't this doesn't give any result.
With that this pattern matches strings with a pair of matching brackets so that they divide the input into two balanced strings.
[Answer]
# C, 258 bytes
```
#define E else if(a==
#define D(v) {if (b[--p]!=v)z=1;}
#define F b[p++]=
main(a, v) char* v[]; {char b[99],p=0,z=0;for(;*v[1];v[1]++) {a=*v[1];if(a=='(')F 0;E '[')F 1;E '{')F 2;E '<')F 3;E '>')D(3)E '}')D(2)E ']')D(1)E ')')D(0)else z=1;}puts(z|p?"0":"1");}
```
## Degolfed, macro-substituted, commented
```
int main(int a, char* v[]) {
// ^ this variable is used as a general purpose int variable and not as its intended purpose (argc)
char b[99], // create a 99 byte array for storing bracket types
p = 0, // pointer within the array
z = 0; // error flag
// loop through every byte of input (argv[1])
for(;*v[1];v[1]++) {
a=*v[1];// a is the current byte
if(a=='(') b[p++] = 0; // record bracket type
else if(a== '[') b[p++] = 1;
else if(a== '{') b[p++] = 2;
else if(a== '<') b[p++] = 3;
else if(a== '>') {
if (b[--p] != 3) z = 1; // error: bracket type mismatch
} else if(a== '}') {
if (b[--p] != 2) z = 1;
} else if(a== ']') {
if (b[--p] != 1) z = 1;
}else if(a== ')') {
if (b[--p] != 0)z = 1;
}else z = 1; // error: invalid character
}
// if either z or p is not 0 print a '0', otherwise print a '1'
// if p is not zero that means not all brackets were closed
// if z is not zero that indicates an erro
puts(z|p ? "0":"1");
}
```
```
[Answer]
# [Kotlin](https://kotlinlang.org), ~~100~~ ~~89~~ 86 bytes
-11 bytes: Use `any` instead of `firstOrNull`
-3 bytes: Use `chunked` instead of `split` (thanks to @leo848)
```
fun f(s:String):Boolean="()<>[]{}".chunked(2).any{it in s&&f(s.replace(it,""))}||s==""
```
[Try it online!](https://tio.run/##bVG7bsMwDNz9FQIRBCTQeOhoyB76Cx0VDWpqt0JcybDlIWD07a4cd6jVchDA4x0fp6sPvXVLNzvxZaxDElyIFMNoXUAA@p0h7XOlkTjKJmOloBQZyko2OuYdGEk2SFFpnVVQaY4kWSUGUpKmh@PK2rXdqyJnUyX92Y6QOu/fzJjvgust9P81CYxFsdq04dYNc6jEa0jZB4l6g3uHcIbDo3gGcWrEgbuNSxHoYXOHU/Ujq16871vjalhdWO@F8vI5u2v7js9UGndjG4R1Yjoek6wc26E3lxZteEo/Q/F@n@oaYFm@AQ "Kotlin – Try It Online")
[Answer]
# Python 2, 80 bytes
```
def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/199118/edit).
Closed 4 years ago.
[Improve this question](/posts/199118/edit)
After seeing some impossibly short solutions in this SE, I began to wonder what code someone could come up with to build a pseudo-random number generator. Now given that I am new to programming, I have absolutely no idea what such generator should look like, or what language to write them in. But that did not stop me from trying some goofy things like writing PRNG, listing primes or prime tests.
So here's the deal, the challenge is to write a pseudo-random number generator that does the following things:
1.Accept a seed in the form of string, number, bits, or whatever, and generate a pseudo-random sequence based on that string. The initial seed should default to 0 if nothing is provided.
2.Accept some input N and generate a pseudo random sequence of length N. Straight forward enough. You can choose to name this whatever you want, or not at all.
3.Be deterministic, the same seed should generate the same sequence each time.
4.I have absolutely no idea how this is tested but the results should be reasonably random. So the results from your generator should be close to uniform distribution within your arbitrary sample space.
5.You can choose any mathematical formula/operation for your pseudo random generation, but it should update its internal state in a deterministic way and use that new internal state for the generation of another number.
**You may not outsource your random number generation to any source, be it built in or online.** Every variable update/ operation should be explicitly ordered. (things like random.randint() is banned, sorry I only know python)
I can't come up with some inventive way of scoring, so shortest program wins.
]
|
[Question]
[
I thought this would be a fun challenge for everyone and I'm curious to see the solutions people come up with.
Print the "12 Days Of Christmas" lyrics
```
On the first day of Christmas,
my true love gave to me,
A partridge in a pear tree.
On the second day of Christmas,
my true love gave to me,
Two turtle doves,
And a partridge in a pear tree.
...
On the twelfth day of Christmas,
My true love gave to me,
Twelve drummers drumming,
Eleven pipers piping,
Ten lords-a-leaping,
Nine ladies dancing,
Eight maids-a-milking,
Seven swans-a-swimming,
Six geese-a-laying,
Five golden rings,
Four calling birds,
Three french hens,
Two turtle doves,
And a partridge in a pear tree.
```
### Rules
* You don't have to worry about capitalization; the entire text can be case insensitive
* You can sensibly ignore any punctuation: hyphens can be spaces, and commas and periods can be ignored
* There should be a blank line between each verse
* You must ordinalize your numbers: "**first** day of Christmas", "**Four** calling birds", etc
[Answer]
## Brainfuck - 2,974
I am rather proud of this one. That sounds like a pretty big number, but keep in mind, I did not use any external compression libraries, and none of the original text is in my program anywhere. None of the other submissions can say that. This is all hand coded. More naive text generators give over 39k for this text, so I would say this is a significant improvement.
```
>--[<->+++++]<---[>+>+>+>+>+<<<<<-]++++++++++>>[+++++>]<<<[+++++>]<<[+
++++>]<+++++>>++++[<++++++++>-]++++++++++++>+>+>>>>>>>>>>>>>+<<<<<<<<<
<<<<<<[<<<<++.-.->>>.<<++.--<<.<++.-->>>>>.>>>>>>>>>>>>>>[<<<<<<<<<<<<
<<<<++.>.<<<<++.-->>-.+<--.++>>.--<<.>>>>.>>>>>>>>>>>>>>-]<[<<<<<<<<<<
<<<<<<<<++.>>-.<<.>>>>-.+<<<<.-->>++.>++.--<<.>->>>.>>>>>>>>>>>>>>+<-]
<[<<<<<<<<<<<<<<++.<<<++.-->>+.->.--<<.>>>>.>>>>>>>>>>>>>+<-]<[<<<<<<<
<<<<<<<+.<+.>.->++.--<<-.>>>>.>>>>>>>>>>>>+<-]<[<<<<<<<<<<<<<<<++.-->+
.--.+.>>++.--<<.>>>>.>>>>>>>>>>>+<-]<[<<<<<<<<<<<+.<<<++.>>>>-.+<<<<.-
->>+.->+.--<<.>>>>.>>>>>>>>>>+<-]<[<<<<<<<<<<+.<<+.>>>+.-<+.--<<-.>>>>
.>>>>>>>>>+<-]<[<<<<<<<<<<<--.+++.---.>>++.--<<++.>>>>.>>>>>>>>+<-]<[<
<<<<<<<<<--.>++.-->>--.++<.++.--<<++.>>>>.>>>>>>>+<-]<[<<<<<<<++.<<.+.
->>--.<<<+.->>>>>.>>>>>>+<-]<[<<<<<<+.-<<<++.--.>>++.-.-<<+.->>>>>.>>>
>>+<-]<[<<<<<<<--.+++.->>.+.+.-->>.>>>>+<-]<<<<<<<<+.---.>>>>++.>.<<<+
+.<--.>>>>.<<<<<++.>++.>>.<<+.>>+.+.<--.<<--.>>>-.>>.<<<.>>.>.<<+.--.>
----.<<<<++++.>>>>>.<<<-.+++.>>+.<<<<.>>>>>.<<<<--.<----.>>>>.<<<<++++
.>>>>>.<<++.<.>>>.<<<--.<<.>>>>>.<<<<<-->+>>-->+>>>>>>>>>>>>>>>>>>>>>>
>>>>>>[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<++.>.<<<<++.>>-.>>-.<<<<.->>>>>.<<
<<<.>>>--.>-.<<+..<<+.>>>.+.>>.<<<<<-.->>>-.>.<<..<+.>+.-<--.+>>>++>.>
>>>>>>>>>>>>>>>>>>>>>>>>>>-]<[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<++.>>-.<<
.>>>>-.+<<<<.>>++.>>>.<<--.<<+.>>.<<<.-->>>++.+.>>.<<---.<<.>>.++<<.>.
-<--.+>>>>.>>>>>>>>>>>>>>>>>>>>>>>>>>-]<[<<<<<<<<<<<<<<<<<<<<<<<<<<<++
.<<<++.>>+.>>>.<<<--.+++.>--.<<<-.>>>+.>>.<<<<<---.>>>>>.<<<---.<<++++
.----.++>>>---.++<<+.>++.-<--.+>>>>.>>>>>>>>>>>>>>>>>>>>>>>>>-]<[<<<<<
<<<<<<<<<<<<<<<<<<<<<<+.<+.>.<<++.>>>>>.<<<--.<<----.+++.>.<+.>>>+.->>
.<<<<<-.---.>>++.<<++.>.>.-<--.+>>>>.>>>>>>>>>>>>>>>>>>>>>>>>-]<[<<<<<
<<<<<<<<<<<<<<<<<<<<<<<++.>+.--.+.>>++.>>.<<<.<<----.>+.<+++.>>>-.->>.
<<<<<---.++>>>>>.<<<.<.>-.-.<.>+++.-<--.+>>>>.>>>>>>>>>>>>>>>>>>>>>>>-
]<[<<<<<<<<<<<<<<<<<<<<<<<<+.<<<++.>>>>-.<<<<.>>+.>>>.<<.>+.<<<<----.>
>.>.>>.<<<<<.++>>>>>.<<.->.<<<+.>-..<.>+.-<--.+>>>>.>>>>>>>>>>>>>>>>>>
>>>>-]<[<<<<<<<<<<<<<<<<<<<<<<<+.<<+.>>>+.>.<<<<--.<++..>>>.-<<<.>>>>>
.<<<<<----.>>>>>.<<<-.<<.++>>>>+.--<<<++.>++.-<--.+>>>>.>>>>>>>>>>>>>>
>>>>>>>-]<[<<<<<<<<<<<<<<<<<<<<<<<<--.+++.>>>-.+<<<<++.>>>>>.<<<<--.>+
+.---.<<-.+.-->>++.>>>.<<.<<++.>.-<--.+>>+.->>.>>>>>>>>>>>>>>>>>>>>-]<
[<<<<<<<<<<<<<<<<<<<<<<<--.>++.>>--.++<.>>.<<<<<.--.>>---..<+++.>++.-<
--.>>>>.<<<<<+.>++.->>.<<<++.->>>+.->>.>>>>>>>>>>>>>>>>>>>-]<[<<<<<<<<
<<<<<<<<<<<<++.<<.>>--.<<<++..>>>>>.<<<<--.>>.<<<.>>+.<<--.>++.>>>>.<<
<<.<++.-->>.->+.->>.>>>>>>>>>>>>>>>>>>-]<[<<<<<<<<<<<<<<<<<<<++.>.<<++
.>>>.<<.>--.<--.++.<---.<<++.>>>>>.<<<<<-.>>+++.>>+.<<<<+.>>>-.>>.<<<<
<----.>>-.-<<+++.->>>->+>.>>>>>>>>>>>>>>>>>-]<[<<<<<<<<<<<<<<<<<<<<<--
.>>>>>.<<--.<<<.>>>++.++.--.<<+.<+++.>--.<+.>>>>>.<<<<++.>+.>>>.<<<<<-
---.>>>>>.<<<++.<<++++.----.>>>.>>.<<++.--.<<<++++..>>>>>.<<<<<-->->--
->>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<<<<<..>>>>>>>->+[>+>>>>>>>>>>>
>>[>]+[<]<<<<<<<<<<<<<-]>[<+>-]<<]
```
Unfortunately, this is about 600 characters longer than its own output, but whatever.
It keeps the characters c,h,m,r,w in an array, and uses that to print all text. Two arrays to the right of twelve spaces each keep track of which day we are on for the count, and for which items we can output.
I may be able to optimize it a bit by reorganizing the memory map to bring the printing characters in between the two counting arrays to avoid such long chains of `<<<<<<<` and `>>>>>>`, but that would be a lot of work at this point. I could also probably choose some better seed characters with frequency analysis to minimize incrementing / decrementing, but whatever.
This does depend on 8-bit wrapping cells to work properly.
Ungolfed:
```
>--[<->+++++]<---
[>+>+>+>+>+<<<<<-]++++++++++
>>[+++++>]<<<[+++++>]<<[+++++>]<+++++>>
++++[<++++++++>-]
++++++++++++>+>+>>>>>>>>>>>>>+<<<<<<<<<<<<<<<
[
<<<<++o.-n.->>>.<<++t.--<<h.<++e.-->>>>>.
>>>>>>>>>>>>>>
12[<<<<<<<<<<<<<<<<++t.>w.<<<<++e.-->>-l.+<--f.++>>t.--<<h.>>>>.>>>>>>>>>>>>>>-]
11<[<<<<<<<<<<<<<<<<<<++e.>>-l.<<e.>>>>-v.+<<<<e.-->>++n.>++t.--<<h.>->>>.>>>>>>>>>>>>>>+<-]
10<[<<<<<<<<<<<<<<++t.<<<++e.-->>+n.->t.--<<h.>>>>.>>>>>>>>>>>>>+<-]
9<[<<<<<<<<<<<< <<+n.<+i.>n.->++t.--<<-h.>>>> . >>>>>>>>>>>>+<-]
8<[<<<<<<<<<<< <<<<++e.-->+i.--g.+h.>>++t.--<<h.>>>> . >>>>>>>>>>>+<-]
7<[<<<<<<<<<< <+s.<<<++e.>>>>-v.+<<<<e.-->>+n.->+t.--<<h.>>>> . >>>>>>>>>>+<-]
6<[<<<<<<<<< <+s.<<+i.>>>+x.-<+t.--<<-h.>>>> . >>>>>>>>>+<-]
5<[<<<<<<<< <<<--f.+++i.---f.>>++t.--<<++h.>>>>. >>>>>>>>+<-]
4<[<<<<<<< <<<--f.>++o.-->>--u.++<r.++t.--<<++h.>>>> . >>>>>>>+<-]
3<[<<<<<< <++t.<<h.+i.->>--r.<<<+d.->>>>>.>>>>>>+<-]
2<[<<<<<<+s.-<<<++e.--c.>>++o.-n.-<<+d.->>>>>.>>>>>+<-]
1<[<<<<<<<--f.+++i.->>r.+s.+t.-->>.>>>>+<-]
<<<<<<<<+d.---a.>>>>++y.>_.<<<++o.<--f.>>>>_.<<<<<++c.>++h.>>r.<<+i.>>+s.+t.
<--m.<<--a.>>>-s.>>_.<<<m.>>y.>_.<<+t.--r.>----u.<<<<++++e.>>>>>_.
<<<-l.+++o.>>+v.<<<<e.>>>>>_.
<<<<--g.<----a.>>>>v.<<<<++++e.>>>>>.
<<++t.<o.>>>.
<<<--m.<<e.>>>>>.
<<<<<-->+>>-->+
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
12[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<++t.>w.<<<<++e.>>-l.>>-v.<<<<e.->>>>>.
<<<<<d.>>>--r.>-u.<<+m.m.<<+e.>>>r.+s.>>.<<<<<-d.->>>-r.>u.<<m.m.<+i.>+n.-<--g.+>>>++>.
>>>>>>>>>>>>>>>>>>>>>>>>>>>-]
11<[<<<<<<<<<<<<<<<<<<<<<<<<<<< <<<<++e.>>-l.<<e.>>>>-v.+<<<<e.>>++n.>>>.
<<--p.<<+i.>>p.<<<e.-->>>++r.+s.>>.<<---p.<<i.>>p.++<<i.>n.-<--g.+>>>>.>>>>>>>>>>>>>>>>>>>>>>>>>>-]
10<[<<<<<<<<<<<<<<<<<<<<<<<<<< <++t.<<<++e.>>+n.>>> .<<<--
.+++o.>--r.<<<-d.>>>+s.>>.<<<<<---a.>>>>>.<<<---l.<<++++e.----a.++>>>---p.++<<+
i.>++n.-<--g.+>>>> . >>>>>>>>>>>>>>>>>>>>>>>>>-]
9< [<<<<<<<<<<<<<<<<<<<<<<<<< <<+n.<+i.>n.<<++e.>>>>> .<<<--l.<<----a.+++d.>
i.<+e.>>>+s.->> .<<<<<-d.---a.>>++n.<<++c.>i.>n.-<--g.+>>>> . >>>>>>>>>>>>>>>>>>>>>>>>-]
8< [<<<<<<<<<<<<<<<<<<<<<<<< <<<<++e.>+i.--g.+h.>>++t.>> .<<<m.<<----a.>+
i.<+++d.>>>-s.->> .<<<<<---a.++>>>>> .<<<m.<i.>-l.-k.<i.>+++n.-<--g.+>>>> . >>>>>>>>>>>>>>>>>>>>>>>-]
7< [<<<<<<<<<<<<<<<<<<<<<<< <+s.<<<++e.>>>>-v.<<<<e.>>+n.>>> .<<s.>+w.<<<<
----a.>>n.>s.>> .<<<<<a.++>>>>> .<<s.->w.<<<+i.>-m.m.<i.>+n.-<--g.+>>>>. >>>>>>>>>>>>>>>>>>>>>>-]
6< [<<<<<<<<<<<<<<<<<<<<<< <+s.<<+i.>>>+x.> .<<<<--g.<++e.e.>>>s.-<<<e.>>>>>
.<<<<<----a.>>>>> .<<<-l.<<a.++>>>>+y.--<<<++i.>++n.-<--g.+>>>> . >>>>>>>>>>>>>>>>>>>>>-]
5< [<<<<<<<<<<<<<<<<<<<<< <<<--f.+++i.>>>-v.+<<<<++e.>>>>> .<<<<--g.>++o.---
l.<<-d.+e.-->>++n.>>> .<<r.<<++i.>n.-<--g.+>>+s.->> . >>>>>>>>>>>>>>>>>>>>-]
4< [<<<<<<<<<<<<<<<<<<<< <<<--f.>++o.>>--u.++<r.>> .<<<<<c.--a.>>---l.l.<+++
i.>++n.-<--g.>>>> .<<<<<+b.>++i.->>r.<<<++d.->>>+s.->> . >>>>>>>>>>>>>>>>>>>-]
3< [<<<<<<<<<<<<<<<<<<< <++t.<<h.>>--r.<<<++e.e.>>>>> .<<<<--f.>>r.<<<e.>>+
n.<<--c.>++h.>>>> .<<<<h.<++e.-->>n.->+s.->> . >>>>>>>>>>>>>>>>>>-]
2< [<<<<<<<<<<<<<<<<<<<++t.>w.<<++o.>>>.<<t.>--u.<--r.++t.<---l.<<++e.>>>>>.
<<<<<-d.>>+++0.>>+v.<<<<+e.>>>-s.>>.<<<<<----a.>>-n.-<<+++d.->>>->+>.
>>>>>>>>>>>>>>>>>-]
1<[<<<<<<<<<<<<<<<<<<<<<--a.>>>>>.<<p--.<<<a.>>>++r.++t.--r.<<+i.<+++d.>--g.<+
e.>>>>>.<<<<++i.>+n.>>>.<<<<<----a.>>>>>.<<<++p.<<++++e.----a.>>>r.>>.<<++
t.--r.<<<++++e..>>>>>.<<<<<-->->--->>>>>>>>>>>>>>>>>>>-]
<<<<<<<<<<<<<<<<<<<<<<..>>>>>>>->+
[>+>>>>>>>>>>>>>[>]+[<]<<<<<<<<<<<<<-]>[<+>-]<<
]
```
[Answer]
# Common Lisp, 333 ~~363~~
```
(dotimes(n 12)(format t"on-the-~:R-day-of-christmas
my-true-love-gave-to-me
~v*~@{~R-~A
~#[and-~]~}a-PARTRIDGE-IN-A-PEAR-TREE
"(1+ n)(- 22 n n)12'drummers-drumming 11'pipers-piping 10'lords-a-leaping 9'ladies-dancing 8'maids-a-milking 7'swans-a-swimming 6'geese-a-laying 5'golden-rings 4'calling-birds 3'french-hens 2'turtle-doves))
```
The builtin facilities to format ordinals are helpful, but most of the compression comes from being able to use the same argument list over and over, skipping over fewer and fewer arguments at each run.
As proven by [coredump](https://codegolf.stackexchange.com/users/903/coredump) in the comments, the builtin facilities can still be put to good use for the cardinals.
[Answer]
## Perl, ~~438~~ 291 chars
Inspired by [Jeff Burdges's use of DEFLATE compression](https://codegolf.stackexchange.com/a/4197/3191), [Ventero's compressed Ruby code](https://codegolf.stackexchange.com/a/4213/3191) and [J B's use of Lingua::EN::Numbers](https://codegolf.stackexchange.com/a/4209/3191), I managed to compress my entry down to 291 chars (well, bytes) including decompression code. Since the program contains some non-printable characters, I've provided it in [MIME Base64 format](http://en.wikipedia.org/wiki/Base64):
```
dXNlIENvbXByZXNzOjpabGliO2V2YWwgdW5jb21wcmVzcyAneNolkMFqAkEMhu8+RVgELdaIXmXB
S2/FFyhF4k7cHTqTsclMZd++M3pJvo+QH5JiDJ9exkKrj/PqXOKV1bod77qj9b2UeGBZ7w/bpd9s
3rCDruf3uWtwS3qS/vfROy0xsho+oWbB3d+b19YsJHWGhIHp5eQ8GzqSoWkk/xxHH36a24OkuT38
K21kNm77ND81BceCWtlgoBAq4NWrM7gpyzDhxGKQi+bA6NIfG5K4/mg0d0kgTwwdvi67JHVeKKyX
l3acoxnSDYZJveVIBnGGrIUh1BQYqZacIDKc5Gvpt1vEk3wT3EmzejcyeIGqTApZmRftR7BH3B8W
/5Aze7In
```
To unencode the program, you can use the following helper Perl script:
```
use MIME::Base64;
print decode_base64 $_ while <>;
```
Save the output in a file named `12days.pl` and run it with `perl -M5.01 12days.pl`. As noted, you need to have the [Lingua::EN::Numbers](http://search.cpan.org/dist/Lingua-EN-Numbers/) module installed for the code to work.
In case you're wondering, the readable part of the code simply looks like this:
```
use Compress::Zlib;eval uncompress '...'
```
where the `...` stands for 254 bytes of [RFC 1950](https://www.rfc-editor.org/rfc/rfc1950) compressed Perl code. Uncompressed, the code is 361 chars long and looks like this:
```
use Lingua'EN'Numbers"/e/";s==num2en(12-$i++)." "=e,y"." "for@n=qw=drummers.drumming pipers.piping lords.a.leaping ladies.dancing maids.a.milking swans.a.swimming geese.a.laying golden.rings calling.birds french.hens turtle.doves.and=;say"on the ".num2en_ordinal($_)." day of christmas my true love gave to me @n[$i--..@n]a partridge in a pear tree
"for 1..12
```
Writing this code was a weird kind of golfing exercise: it turns out the maximizing repetition and minimizing the number of distinct characters used are much more important than minimizing raw character count when the relevant metric is size *after compression*.
To squeeze out the last few chars, I wrote a simple program to try small variations of this code to find the one that compresses best. For compression, I used Ken Silverman's [KZIP](http://advsys.net/ken/utils.htm) utility, which usually yield better compression rations (at the cost of speed) than standard Zlib even at the maximum compression settings. Of course, since KZIP only creates ZIP archives, I then had to extract the raw DEFLATE stream from the archive and wrap it in a RFC 1950 header and checksum. Here's the code I used for that:
```
use Compress::Zlib;
use 5.010;
@c = qw(e i n s);
@q = qw( " );
@p = qw( = @ ; , );
@n = ('\n',"\n");
$best = 999;
for$A(qw(e n .)){ for$B(@q){ for$C(@q,@p){ for$D(@p){ for$E(@q,@p){ for$F(qw(- _ . N E)){ for$G("-","-"eq$F?():$F){ for$H(@c){ for$I(@c,@p){ for$N(@n){ for$X(11,"\@$I"){ for$Y('$"','" "',$F=~/\w/?$F:()){ for$Z('".num2en_ordinal($_)."'){
$M="Lingua'EN'Numbers";
$code = q!use MB/A/B;sDDnum2en(12-$H++).YDe,yCFC Cfor@I=qwEdrummersFdrumming pipersFpiping lordsGaGleaping ladiesFdancing maidsGaGmilking swansGaGswimming geeseGaGlaying goldenFrings callingFbirds frenchFhens turtleFdovesFandE;say"on the Z day of christmas my true love gave to me @I[$H--..X]a partridge in a pear treeN"for 1..12!.$/;
$code =~ s/[A-Z]/${$&}/g;
open PL, ">12days.pl" and print PL $code and close PL or die $!;
$output = `kzipmix-20091108-linux/kzip -b0 -y 12days.pl.zip 12days.pl`;
($len) = ($output =~ /KSflating\s+(\d\d\d)/) or die $output;
open ZIP, "<12days.pl.zip" and $zip = join("", <ZIP>) and close ZIP or die $!;
($dfl) = ($zip =~ /12days\.pl(.{$len})/s) or die "Z $len: $code";
$dfl = "x\xDA$dfl" . pack N, adler32($code);
$dfl =~ s/\\(?=[\\'])|'/\\$&/g;
next if $best <= length $dfl;
$best = length $dfl;
$bestcode = $code;
warn "$A$B$C$D$E$F$G$H$I $X $Y $best: $bestcode\n";
open PL, ">12days_best.pl" and print PL "use Compress::Zlib;eval uncompress '$dfl'" and close PL or die $!;
}}}}}}
print STDERR "$A$B$C$D$E$F\r";
}}}}}}}
```
If this looks like a horrible kluge, it's because that's exactly what it is.
---
For historical interest, here's my original 438-char solution, which generates nicer output, including line breaks and punctuation:
```
y/_/ /,s/G/ing/for@l=qw(twelve_drummers_drummG eleven_pipers_pipG ten_lords-a-leapG nine_ladies_dancG eight_maids-a-milkG seven_swans-a-swimmG six_geese-a-layG five_golden_rGs four_callG_birds three_french_hens two_turtle_doves);s/e?t? .*/th/,s/vt/ft/for@n=@l;@n[9..11]=qw(third second first);say map("\u$_,\n","\nOn the $n[11-$_] day of Christmas,\nMy true love gave to me",@l[-$_..-1]),$_?"And a":A," partridge in a pear tree."for 0..11
```
Highlights of this version the pair of regexps `s/e?t? .*/th/,s/vt/ft/`, which construct the ordinals for 4 to 12 from the cardinals at the beginning of the gift lines.
This code can, of course, also be compressed using the Zlib trick described above, but it turns out that simply compressing the *output* is more efficient, yielding the following 338-byte program (in Base64 format, again):
```
dXNlIENvbXByZXNzOjpabGliO3NheSB1bmNvbXByZXNzICd42uWTwU7DMAyG730KP8DGOyA0bsCB
vYBp3MYicSo7W9e3xx3ijCIQDHZIUjn683+/k3ZPAjUSDKxWIeACZYC7qGw1o226hwWqHghSORKM
6FMtkGnT3cKEWpXDSMACCBOhQlWim+7jUKO+SGg5dT8XqAetiSD4nrmPBMDPvXywtllF18OgJH2E
SGJfcR+Ky2KL/b0roMeUWEZ4cXb7biQeGol4LZQUSECdyn4A0vjUBvnMXCcYiYy2uE24ONcvgdOR
pBF9lYDNKObwNnPOTnc5kYjH2JZotyogI4c1Ueb06myXH1S48eYeWbyKgclcJr2D/dnwtfXZ7km8
qOeUiXBysP/VEUrt//LurIGJXCdSWxeHu4JW1ZnS0Ph8XOKloIecSe39w/murYdvbRU+Qyc=
```
I also have a 312-byte gzip archive of the lyrics, constructed from the same DEFLATE stream. I suppose you could call it a "zcat script". :)
[Answer]
## Python 2.7 (465)
```
for k in range(12):
print'On the %s day of Christmas\nMy true love gave to me'%'first^second^third^fourth^fifth^sixth^seventh^eighth^ninth^tenth^eleventh^twelfth'.split('^')[k]
print'\n'.join('Twelve drummers drumm*Eleven pipers pip*Ten lords-a-leap*Nine ladies danc*Eight maids-a-milk*Seven swans-a-swimm*Six geese-a-lay*Five golden rings^Four calling birds^Three french hens^Two turtle doves and^a partridge in a pear tree^'.replace('*','ing^').split('^')[11-k:])
```
However, I put the 'and' on the same line as the doves instead of the partridge.
[Answer]
# JavaScript 570
This is my first time golfing. JavaScript 570
```
var l=["first","second","third","fourth","fifth","sixth","seventh","eigth","nineth","tenth","eleventh","twelth","Two turtle doves","Three french hens","Four calling birds","Five golden rings","Six geese-a-laying","Seven swans-a-swimming","Eight maids-a-milking","Nine ladies dancing","Ten lords-a-leaping","Eleven pipers piping","Twelve drummers drumming"];var b = "<br/>";for(var i=0;i<12;i++){var p="On the "+l[i]+"day of Christmas"+b+"My true love gave to me"+b;for(var x=i;x>0;x--)p+=l[13+x]+b;if(i>0)p+="and ";p+="a partridge in a pear tree"+b+b;document.write(p);}
```
[Answer]
# Vim – 578 keystrokes
I decided to try and vim-golf this, since this is the kind of thing that can be vim-golfed.
Start by inserting the framework - the "X day of Christmas" line a total of 12 times (89 keystrokes):
```
KS TL GT
12iOn the X day of Christmas,<Enter> 30 30 30
my true love gave to me,<Enter> 25 55 55
and a partridge in a pear tree.<Enter> 32 87 87
<Enter><Esc> 2 89 89
```
Then, perform a series of macros that will insert the numbers 2 through 12 in the respective places they need to be for the lyrics (172 keystrokes):
```
KS TL GT
42kqmO2<Esc>9/a<Enter>q10@m 17 17 106
dw 2 19 108
6jqm/2<Enter>O3<Esc>jq9@m 14 33 122
/3<Enter>qm/3<Enter>O4<Esc>jq8@m 16 49 138
/4<Enter>qm/4<Enter>O5<Esc>jq7@m 16 65 154
/5<Enter>qm/5<Enter>O6<Esc>jq6@m 16 81 170
/6<Enter>qm/6<Enter>O7<Esc>jq5@m 16 97 186
/7<Enter>qm/7<Enter>O8<Esc>jq4@m 16 113 202
/8<Enter>qm/8<Enter>O9<Esc>jq3@m 16 129 218
/9<Enter>qm/9<Enter>O10<Esc>jq2@m 17 146 235
/10<Enter>qm/10<Enter>O11<Esc>jq@m 18 164 253
?11<Enter>O12<Esc> 8 172 261
```
The "dw" on the second line is to get rid of the first "and", because it doesn't go there.
Then, perform a series of substitutions for the number of things the true love gave (319 keystrokes):
```
KS TL GT
:%s/12/twelve drummers drumming,/g 34 34 295
:%s/11/eleven pipers piping,/g 30 64 325
:%s/10/ten lords-a-leaping,/g 29 93 354
:%s/9/nine ladies dancing,/g 28 117 382
:%s/8/eight maids-a-milking,/g 30 147 412
:%s/7/seven swans-a-swimming,/g 31 178 443
:%s/6/six geese-a-laying,/g 27 205 366
:%s/5/five golden rings,/g 26 231 392
:%s/4/four calling birds,/g 27 268 419
:%s/3/three french hens,/g 26 294 445
:%s/2/two turtle doves,/g 25 319 470
```
And finally, replacing each occurrence of `X` with an ordinal number:
```
KS TL GT
/X<Enter>sfirst<Esc> 10 10 480
nssecond<Esc> 9 18 488
nsthird<Esc> 8 27 497
nsfourth<Esc> 9 36 506
nsfifth<Esc> 8 44 514
nssixth<Esc> 8 52 522
nsseventh<Esc> 10 62 532
nseighth<Esc> 9 71 541
nsninth<Esc> 8 79 549
nstenth<Esc> 8 87 557
nseleventh<Esc> 11 98 568
nstwelfth<Esc> 10 108 578
```
And we're done!
---
I'm sure there are other optimizations I missed, but I think that's pretty good myself.
[Answer]
## Ruby (474)
```
(0..11).each{|i|puts "On the #{"first^second^third^fourth^fifth^sixth^seventh^eighth^ninth^tenth^eleventh^twelfth".split("^")[i]} day of Christmas\nMy true love gave to me";puts "a partridge in a pear tree\n\n^two turtle doves and^three french hens^four calling birds^five golden rings^six geese-a-lay*Seven swans-a-swimm*Eight maids-a-milk*Nine ladies danc*Ten lords-a-leap*Eleven pipers pip*Twelve drummers drumming".gsub('*','ing^').split('^')[0..i].reverse.join("\n")}
```
or in a more readable form (486):
```
(0..11).each do |i|
puts "On the #{"first^second^third^fourth^fifth^sixth^seventh^eighth^ninth^tenth^eleventh^twelfth".split("^")[i]} day of Christmas\nMy true love gave to me"
puts "a partridge in a pear tree\n\n^two turtle doves and^three french hens^four calling birds^five golden rings^six geese-a-lay*Seven swans-a-swimm*Eight maids-a-milk*Nine ladies danc*Ten lords-a-leap*Eleven pipers pip*Twelve drummers drumming".gsub('*','ing^').split('^')[0..i].reverse.join("\n")
end
```
anybody got an idea how to circumvent the .reverse? i could't come up with a solution
[Answer]
## PowerShell, 440
```
-join('On the 1 day of Christmas
my true love gave to me
1a partridge in a pear tree
1first1second1third1fourth1fifth1sixth1seventh1eighth1ninth1tenth1eleventh1twelfth1Twelve drummers drumm7Eleven pipers pip7Ten lords-a-leap7Nine ladies danc7Eight maids-a-milk7Seven swans-a-swimm7Six geese-a-lay7Five golden rings
1Four calling birds
1Three french hens
1Two turtle doves
And '-replace7,'ing
1'-split1)[(26..15|%{0
29-$_
1
$_..26-le25
2})]
```
This prints the lyrics as given in the question with multiple lines per verse. We can save a few characters if that requirement isn't there.
[Answer]
## Perl, 500 485
```
@s=(first,second,third,fourth,fifth,sixth,seventh,eighth,ninth,tenth,eleventh,twelfth);
$;=ing;
@a=(
"Twelve drummers drumm$;",
"Eleven pipers pip$;",
"Ten lords-a-leap$;",
"Nine ladies danc$;",
"Eight maids-a-milk$;",
"Seven swans-a-swimm$;",
"Six geese-a-lay$;",
"Five golden r$;s",
"Four call$; birds",
"Three french hens",
"Two turtle doves\nAnd "
);
for(0..11){
print"\n\nOn the $s[$_] day of Christmas\nMy true love gave to me\n";
$"=$/;
print"@b";
unshift@b,pop@a;
print"A partridge in a pear tree"
}
```
This is my first attempt, and I am sure it could be made a lot shorter. The line breaks are for readability. It has three important arrays, one of which holds the name for each day `@s`, one of which lists off all of the gifts (except for the first one) `@a`, and one that lists off what gifts have already been given `@b`. The main mechanism is that each day, it prints `@b` and then transfers one additional gift from `@a` to `@b`.
Thanks to Andrew for 500->485
[Answer]
# C (644)
Count does not include whitespace used for presentation.
```
#include <stdio.h>
void main() {
char *e = "On the \0 day of Christmas my true love gave to me\0 Twelve drummers drumming Eleven pipers piping Ten lords-a-leaping Nine ladies dancing Eight maids-a-milking Seven swans-a-swimming Six geese-a-laying Five golden rings Four calling birds Three french hens Two turtle doves and A partridge in a pear tree\n\n";
printf("%sfirst%s%s%ssecond%s%s%sthird%s%s%sfourth%s%s%sfifth%s%s%ssixth%s%s%sseventh%s%s%seighth%s%s%sninth%s%s%stenth%s%s%seleventh%s%s%stwelfth%s%s",
e, e+8, e+276, e, e+8, e+255, e, e+8, e+237, e, e+8, e+218, e, e+8, e+200, e, e+8, e+181, e, e+8, e+158, e, e+8, e+136, e, e+8, e+116, e, e+8, e+96, e, e+8, e+75, e, e+8, e+50);
}
```
Output is like:
```
On the first day of Christmas my true love gave to me A partridge in a pear tree
...
On the twelfth day of Christmas my true love gave to me Twelve drummers drumming Eleven pipers piping Ten lords-a-leaping Nine ladies dancing Eight maids-a-milking Seven swans-a-swimming Six geese-a-laying Five golden rings Four calling birds Three french hens Two turtle doves and A partridge in a pear tree
```
[Answer]
## Powershell, 487 453
```
0..11 | % {
'On the {0} day of christmas my true love gave to me {1}`n'-f
(
'first^second^third^fourth^fifth^sixth^seventh^eighth^ninth^tenth^eleventh^twelfth'.Split('^')[$_],
(
'a partridge in a pear tree^two turtle doves and^three french hens^four calling birds^five golden rings^six geese-a-laying^Seven swans-a-swimming^Eight maids-a-milking^Nine ladies dancing^Ten lords-a-leaping^Eleven pipers piping^Twelve drummers drumming'.Split('^')[$_..0]-join' '
)
)
}
```
Thank you to [Daan](https://codegolf.stackexchange.com/a/4205/880) for the idea of splitting a concatenated string.
I had originally included a switching statement to get the "and" on the partridge for all but the first verse. But, because the question absolves us of punctuation, we can just append the "and" to the doves.
This results in line feeds as follows:
```
On the first day of christmas my true love gave to me a partridge in a pear tree
On the second day of christmas my true love gave to me two turtle doves and a partridge in a pear tree
On the third day of christmas my true love gave to me three french hens two turtle doves and a partridge in a pear tree
```
[Answer]
# Perl, 368 ~~389~~ (no unicode/compression)
```
use Lingua::EN::Numbers"/n/";@s=qw(A-partridge-in-a-pear-tree turtle-doves french-hens calling-birds golden-rings geese-a-laying swans-a-swimming maids-a-milking ladies-dancing lords-a-leaping pipers-piping drummers-drumming);$_=$s[0];for$m(1..12){$n=num2en_ordinal$m;say"On the $n day of christmas
my true love gave to me
$_
";s/A/and a/;$_=num2en($m+1)." $s[$m]
$_"}
```
Harnesses [Lingua::EN::Numbers](https://metacpan.org/module/Lingua%3a%3aEN%3a%3aNumbers), though I'm not 100% convinced it's a good idea when I see the module and its identifier names' lengths. Needs Perl 5.10 or later, run from the command line with a `-E` switch.
**Edit:** minor improvements: stop using an array, better use of `$_`, unneeded whitespace.
[Answer]
## C# (528)
```
class P{static void Main(){for(int i=1;i<12;i++){Console.WriteLine("On the "+"^first^second^third^fourth^fifth^sixth^seventh^eighth^ninth^tenth^eleventh^twelfth".Split('^')[i]+" day of christmas my true love gave to me "+"a partridge in a pear tree^two turtle doves and^three french hens^four calling birds^five golden rings^six geese-a-laying^Seven swans-a-swimming^Eight maids-a-milking^Nine ladies dancing^Ten lords-a-leaping^Eleven pipers piping^Twelve drummers drumming".Split('^').Take(i).Aggregate("",(t,s)=>s+' '+t));}}}
```
[Answer]
PHP, 548
```
$n=explode('|','first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|eleventh|twelfth');$w=explode('|','and a partridge in a pear tree.|two turtle doves|three french hens|four calling birds|five golden rings|six geese a-laying|seven swans a-swimming|eight maids a-milking|nine ladies dancing|ten lords a-leaping|eleven pipers piping|twelve drummers drumming');foreach($n as $i=>$j)echo "on the $n[$i] day of christmas,\nmy true love sent to me\n".str_replace($i?'':'and ','',implode(",\n",array_reverse(array_slice($w,0,$i+1))))."\n\n";
```
Reduced length with compression, 502
```
eval(gzuncompress(base64_decode('eNpVkE1u3DAMhfc+BWEI8AzqDtJtg7QHCYKCsWiLrX4MUjPOAD58KE829UIyP5Hge8/lF/pYY/F0GvZhHGYWrbvSVLLfa2Dx+1yuUsM+82yn8kc76UbZbuIl2JW5FfWB4tdb3SjaxHB+dtv/OzB7QFhRqrBfCDi3klCgCtHFJgtU2xkJfLmRmg7jMAvlKUCgrIcmmDBGzgu8m0pDfCNYSvSUQQxr0woLkRLg94h3Yw/hoBtmNagbp9Tw4QMSsm84cfzXqNkiiOiZFDzmqTEzCbHI0RcJ12P6sAwrryTarqPR7JsgL9eUGj5+7MHymIsQTuHkzLeC45df7u+ZplCgLxlqIHD51fGbLb1DmWEKwloT6tilu2V0NVWWC6jlDLVAoq6/aJU/QmvEiU6Ofw/DzyNni3sYOT3S78euH1EE79Z6M1V0elQauY1t49Po+NuPs32Xvuv650+BSMT/')));
```
[Answer]
# Java, 2062
I know this was posted a while ago, but I thought I would try. I'm a student and still new to this but its seems to work.
```
public class TwelveDaysOfChristmas
{
public static void main(String[] args)
{
String[] days = new String[12];
days[0] = "and a partriage in a pear tree.";
days[1] = "Two turtle doves, ";
days[2] = "Three french hens, ";
days[3] = "Four callings birds, ";
days[4] = "Five diamond rings, ";
days[5] = "Six geese a-laying, ";
days[6] = "Seven swans a-swimming, ";
days[7] = "Eight maids a-milking, ";
days[8] = "Nine ladies dancing, ";
days[9] = "Ten lords a-leaping, ";
days[10] = "Eleven pipers piping, ";
days[11] = "Twelve twelve drummers drumming, ";
System.out.println(chorus(0));
System.out.println("a partriage in a pear tree");
for(int i = 1; i<days.length; i++)
{
System.out.println(chorus(i));
for(int x = i; x>=0; x--)
{
System.out.println(days[x]);
}
System.out.println();
}
}
public static String chorus(int line)
{
String chorus = "On the " + getLine(line) + " day of Christmas my true " +
"love gave to me, ";
return chorus;
}
public static String getLine(int line)
{
int num = line;
String result = "first";
switch (num)
{
case 1: result = "second";
break;
case 2: result = "third";
break;
case 3: result = "fourth";
break;
case 4: result = "fifth";
break;
case 5: result = "sixth";
break;
case 6: result = "seventh";
break;
case 7: result = "eighth";
break;
case 8: result = "ninth";
break;
case 9: result = "tenth";
break;
case 10: result = "eleventh";
break;
case 11: result = "twelfth";
break;
}
return result;
}
}
```
[Answer]
## Swift, 577
```
import UIKit
let f=NSNumberFormatter()
f.numberStyle = .SpellOutStyle
for i in 0...11{
let w = split("first-second-third-four-fif-six-seven-eigh-nin-ten-eleven-twelf"){$0=="-"}[i]+(i<3 ?"":"th")
println("On the \(w) day of Christmas\nmy true love gave to me")
for m in reverse(0...i){
if m==0{break}
let v = split("turtle doves and*french hens*calling birds*golden rings*geese-a-lay*swans-a-swimm*maids-a-milk*ladies danc*lords-a-leap*pipers pip*drummers drumm"){$0=="*"}[m-1]+(m<5 ?"":"ing")
println("\(f.stringFromNumber(m+1)!) \(v)")}
println("a partridge in a pear tree.")}
```
You can paste this in a playground.
I tried moving the `v` into the print command and got:
```
Playground execution failed: <EXPR>:20:1: error: expression was too complex to be solved in reasonable time; consider breaking up the expression into distinct sub-expressions
```
[Answer]
# [///](https://esolangs.org/wiki////), 439 bytes
```
/|/\/\///^/on the |%/ day of christmas
my true love gave to me
|=/-a-|&/ing|*/even|+/th%|:/
^|A/el* pipers pip&
B|B/ten lords=leap&
C|C/nine ladies danc&
D|D/eight maids=milk&
E|E/s* swans=swimm&
F|F/six geese=lay&
G|G/five golden r&s
H|H/four call& birds
I|I/three french hens
J|J/two turtle doves
and K|K/a partridge in a pear tree/^first%K:second%J:+ird%I:four+H:fif+G:six+F:s*+E:eigh+D:nin+C:ten+B:el*+A:twelf+twelve drummers drumm&
A
```
[Try it online!](https://tio.run/##HVDJiiMxDL37K3QpH2Ia3Q05ZN9@oQl4yqoqM7YrWE5nAv73tGoQaEPoLRwdT8SfDzb8lkC845yhTgStQ/DuDfMA/VQC1@RYpTfU8iSI8w/B6CTVGRKptsYv99U0hjy2FdIP5WawTl2zqNS9bZDiCh7hQYWXotW2bbFSlk/F8zqSk92u7TCHLO@dD8QCn3ut9m2PFMapQnJBblOIf7U6tAPyCvjlMq/5FVLS6tiOyOEfjERM6@jeWp3aCYewkJ2jF7iiWZ3bGYf5WaB3MWr4E4SBurSL8C1EMBTK/QQTZVbXdsX6mqE@S40EXmSzctnDrd3QwcOVWoIfCUIGGckV8YcI70MoXLubZern7LurNYLSXeyCa852CIM5WeFqjpZX5mAXgWZvRb3ZWfHFbK04Zja2vigOZskiwpdnSouF/xutNp/PLw "/// – Try It Online")
If trailing newlines are allowed, you can save four bytes:
```
/|/\/\///^/on the |%/ day of christmas
my true love gave to me
|=/-a-|&/ing|*/even|+/th%|A/el* pipers pip&
B|B/ten lords=leap&
C|C/nine ladies danc&
D|D/eight maids=milk&
E|E/s* swans=swimm&
F|F/six geese=lay&
G|G/five golden r&s
H|H/four call& birds
I|I/three french hens
J|J/two turtle doves
and K|K/a partridge in a pear tree
/^first%K^second%J^+ird%I^four+H^fif+G^six+F^s*+E^eigh+D^nin+C^ten+B^el*+A^twelf+twelve drummers drumm&
A
```
[Try it online!](https://tio.run/##HVDJbgMhDL3zFb4Mh6DKX5BD9u0XKiQ6eGZQgYkwaRqJf089FZLxJr@Fo@OJ@P3Ghp/yEC3OGepE0DoE714wD9BPJXBNjlV6QS0Pgjj/EIxOQp0hkWpr/HAfTWPIY1sh/VBuBuvUtQ1SXME93Knw8mm1bVuslOVG8byO5KS3azvMIcth5wOxAOdeq33bI4VxqpBckN0U4rdWh3ZAXgE/XeY1P0NKWh3bETn8wkjEtI7updWpnXAIC805eoErmtW5nXGYHwV6F6OGryAM1KVdhGkhgqFQ7ieYKLO6tivW5wz1UWok8CKYlcsebu2GDu6u1BL8SBAySEmuiDNESqEdQuHa3SxTP2ffXa0RnO5iF2RzlvFgTlbYmqPllTnYRaLZW9FvdlacMVsrnpmNrU@Kg1miyPDlkdJi4n@i1eb9/gM "/// – Try It Online")
### Explanation
/// is a language where the only operation is a self-modifying substitution. In particular, the instruction `/abc/xyz/` replaces all instances of `abc` with `xyz` in the rest of the source code, including other substitutions.. Any other characters are simply output to STDOUT.
While this is enough for Turing-completeness, golfing in /// generally consists of starting with the intended output and identifying repeated substrings that can be replaced with single-character shortcuts.
`\` can be used as an escape character in patterns, replacements, and literal characters to mean a literal `/` or `\`.
---
The first instruction encountered is `/|/\/\//`. This means "replace all `|` with `//` in the rest of the program." This saves a byte for every subsequent substitution in the program.
---
After this, a set of replacements are made to compress the text itself:
* `on the` becomes `^`.
* `day of christmas \n my true love gave to me \n` becomes `%`.
* `-a-` becomes `=`.
* `ing` becomes `&`.
* `even` becomes `*`.
* `th%` becomes `+`.
* `^` preceded by two newlines (which appears in every verse but the first) becomes `:`.
---
Following this, we write the lyrics themselves. This is done using replacements `A` through `K`. Each letter replacement adds a line to the replacement after it. For example, `K` represents `a partridge in a pear tree` and `J` represents `two turtle doves \n and K`.
In this way, each verse of the song is composed of:
* `^` or `:`
* A string representing the correct ordinal (say, `el*th`)
* `%`
* A letter `A` through `K` that represents the correct lyrics.
However, because most of the ordinals end in `th`, we use the substitution `th%` → `+` to save some bytes.
[Answer]
## Ruby 1.9.3, compressed, 321 characters
Since the code contains non-printable characters, I'll post a hexdump of the code instead:
```
0000000: 2363 6f64 696e 673a 6269 6e61 7279 0a72 #coding:binary.r
0000010: 6571 7569 7265 277a 6c69 6227 3b65 7661 equire'zlib';eva
0000020: 6c20 5a6c 6962 2e69 6e66 6c61 7465 2778 l Zlib.inflate'x
0000030: da2d 90db 6ac3 300c 86ef f714 a163 b042 .-..j.0......c.B
0000040: 15e8 5ea7 f442 8be5 58cc 8720 39cd 42db ..^..B..X.. 9.B.
0000050: 3dfb e4a4 3792 f559 c7ff fcd5 574e a4f7 =...7..Y....WN..
0000060: 073f a6b9 eaa1 64a8 81e0 fdfe b17c 7a16 .?....d......|z.
0000070: ad9d d250 b2eb 6a60 719d 2fb3 d4d0 79f6 ...P..j`q./...y.
0000080: 6695 7f9b a51b 65f3 c463 3097 b905 7547 f.....e..c0...uG
0000090: f1f5 5717 8a56 71bc f0f5 090e 5728 1e86 ..W..Vq.....W(..
00000a0: 20ac 35a1 bea5 15aa cc04 b1dc 0846 3453 .5..........F4S
00000b0: 0b24 3a9c 6c87 5669 c0c9 9c12 89ee 0fce .$:.l.Vi........
00000c0: e3ab 374c 3c35 6cae 411b 6b5d c429 2044 ..7L<5l.A.k].) D
00000d0: c28d d942 d61a 1d93 5563 1eb6 e2b6 2b24 ...B....Uc....+$
00000e0: e42d 3371 fc69 74bb 0474 c1dc a82e bc4f .-3q.it..t.....O
00000f0: b233 6124 526a 4d71 6dc8 73db b444 67f9 .3a$RjMqm.s..Dg.
0000100: 6240 3761 60c0 182d 826f 934a 4d31 2102 b@7a`..-.o.JM1!.
0000110: 2f94 8700 81b2 91a5 4035 01a3 1d64 b7da /[[email protected]](/cdn-cgi/l/email-protection)..
0000120: 1413 1661 42a9 c26e 24e0 6c33 2642 3141 ...aB..n$.l3&B1A
0000130: 888e 973f ee7b 385f 4fd3 f31f be35 9d6f ...?.{8_O....5.o
0000140: 27 '
```
To create the actual code from the hexdump, put it in a file and run `xxd -r hexdump > 12days.rb`. Then executing `ruby1.9.3 12.days.rb` will run the code and print the lyrics.
Note that this code requires Ruby 1.9.3 (because it uses `Zlib.inflate`) , so it won't work with Ruby 1.8.x, 1.9.1 and 1.9.2.
The uncompressed code is 425 characters long:
```
12.times{|i|puts"on-the-#{%w(first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth)[i]}-day-of-christmas
my-true-love-gave-to-me",%w(twelve-drummers-drumming eleven-pipers-piping ten-lords-a-leaping nine-ladies-dancing eight-maids-a-milking seven-swans-a-swimming six-geese-a-laying five-golden-rings four-calling-birds three-french-hens two-turtle-doves-and a-partridge-in-a-pear-tree)[~i..-1],p}
```
[Answer]
# Perl, 319/313
Idea : Uncompress and evaluate J B's Lingua::EN::Numbers solution.
First, paste this text block into the command `perl -e 'use MIME::Base64; print decode_base64 $_ while <>;' >12days.pl`. Next, run the command `perl -M5.01 12days.pl`.
```
dXNlIENvbXByZXNzOjpabGliOyRfPSd4nCWOwW7CMAyG730K
q8oBNIUOjq2QxmG3iT3AhJBpTBsRu12cgqpp776UXWx/v63/96QEH166Cev6/VjXx4kvFLWspCqb
N91/P1YHO2JM0buOrBeLdiSMNkUiSFNMgawb7qRwjSRtb3sShRZDyK724qNT6IbgSGzMSgYipewS
cM4M+kDRjPrwzIvA6N0isA+3hQM6T2odSvvEIT7XgXBcePRj/tfmtpCLE/PCzyEr68ac90a/Xk/N
dYiGV9vNZrtb/xjZy8Q7knP284LBcKM4l58CqVwnMAIOZxiu0PbRa2LUgmdIcaL8wZ2gw1zSAEyF
ORdlo9WhQnGA1RL4b70y/LJdb0rI+YZP+bD8Lf4A5ut+sic7ZXZhbCB1bmNvbXByZXNzJF87Cg==
```
The script itself takes the form `use Compress::Zlib;$_='...';eval uncompress$_;` where `...` is J B's 368 char solution after being compressed with this command and escaping a `'`.
```
perl -M5.01 -e 'use Compress::Zlib; $_ .= <> while !eof; say compress($_);' <12days_JB.pl
```
Ilmari's script complains about modifying a read only value without the extra `$_=...;` characters, but presumably he'd make this **313**. You could save several more bytes by tweaking the compression manually like Ilmari did before, maybe achieving **310 or so**, but I didn't bother.
---
**Perl, 376 (cheating off another submission)** [my original submission]
First, create a perl script called `12days.pl` containing :
```
use IO::Uncompress::Inflate qw(inflate);inflate\*DATA=>'-';
__DATA__
```
Next, pipe the output from any other submission into `12days.txt` and execute the command :
```
perl -e 'use IO::Compress::Deflate qw(deflate); deflate "-" => "-";' <12days.txt >>12days.pl
```
Vola `12days.pl` is around 376 bytes and prints the song. ;) Amusingly using rawinflate moves precisely six bytes from the data doc into the code starting from Ilmari's output.
I'd originally set about looking for a Huffman coding module directly, which isn't nearly so dishonest. Yet, sadly CPAN has no modules with English's letter entropy table, which is what you really want when compressing very short strings.
I found that `fortune -m Days\ of\ Christmas` does not work either, regrettably.
[Answer]
# VALA, 584, 574
```
void main(){int i=0;string[] d={"first","second","thrid","fourth","fifth","sixth","seventh","eighth","ninth","tenth","eleventh","twelfth"};string[] p={"Twelve drummers drumming","Eleven pipers piping","Ten lords-a-leaping","Nine ladies dancing","Eight maids-a-milking","Seven swans-a-swimming","Six geese-a-laying","Five golden rings","Four calling birds","Three french hens","Two turtle doves","A"};while(i<12){stdout.printf("On the %s day of Christmas,\nmy true love gave to me,\n%s partridge in a pear tree.\n\n",d[i],string.joinv(",\n",p[11-i:12]));p[11]="And a";i++;}}
```
No more warning at compilation.
[Answer]
# Java, 608
First post on Stack Exchange, second attempt at this problem.
```
class T{public static void main(String[]args){String Z=" partridge in a pear tree.\n";String[] B=(" day of Christmas,\nMy true love gave to me0first0second0third0fourth0fifth0sixth0seventh0eighth0ninth0tenth0eleventh0twelfth0A"+Z+"0Two turtle doves,0Three french hens,0Four calling birds,0Five golden rings,0Six geese-a-laying,0Seven swans-a-swimming,0Eight maids-a-milking,0Nine ladies dancing,0Ten lords-a-leaping,0Eleven pipers piping,0Twelve drummers drumming,").split("0");for(int i=1;i<13;i++){System.out.println("On the "+B[i]+B[0]);for(int j=i+12;j>12;j--)System.out.println(B[j]);B[13]="And a"+Z;}}}
```
Java is a little cumbersome for tasks like this, but using split helped reduce the String overhead.
[Answer]
## Java, 630 bytes
```
public class code{public static void main(String[]a){int x=0;String[]l={"A Partridge in a Pear Tree.\n","Two Turtle Doves, and","Three French Hens,","Four Calling Birds,","Five Gold Rings,","Six Geese-a-Laying,","Seven Swans-a-Swimming,","Eight Maids-a-Milking,","Nine Ladies Dancing,","Ten Lords-a-Leaping,","Eleven Pipers Piping,","Twelve Drummers Drumming,"};for(String d:new String[]{"First","Second","Third","Fourth","Fifth","Sixth","Seventh","Eighth","Ninth","Tenth","Eleventh","Twelfth"}){System.out.println("On the "+d+" day of Christmas\nMy true love sent to me");for(int i=0;i<=x;i++){System.out.println(l[x-i]);}x++;}}}
```
or as clean(ish) code:
```
public class code {
public static void main(String[] a) {
int x = 0;
String[] l = new String[]{"A Partridge in a Pear Tree.\n", "Two Turtle Doves, and", "Three French Hens,", "Four Calling Birds,", "Five Gold Rings,", "Six Geese-a-Laying,", "Seven Swans-a-Swimming,", "Eight Maids-a-Milking,", "Nine Ladies Dancing,", "Ten Lords-a-Leaping,", "Eleven Pipers Piping,", "Twelve Drummers Drumming,"};
for (String d : new String[]{"First", "Second", "Third", "Fourth", "Fifth", "Sixth", "Seventh", "Eighth", "Ninth", "Tenth", "Eleventh", "Twelfth"}) {
System.out.println("On the " + d + " day of Christmas\nMy true love sent to me");
for (int i = 0; i <= x; i++) {
System.out.println(l[x - i]);
}
x++;
}
}
}
```
Example, including validation website: <https://code.golf/12-days-of-christmas#java>
I even got rank #13, I'd really love to get some feedback here. I'm pretty new to this, so would like to know some quick wins here for the Java edition!
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 566 bytes
```
for(d=["First","Second","Third","Fourth","Fifth","Sixth","Seventh","Eighth","Ninth","Tenth","Eleventh","Twelfth"],g=["A Partridge in a Pear Tree.","Two Turtle Doves, and","Three French Hens,","Four Calling Birds,","Five Gold Rings,","Six Geese-a-Laying,","Seven Swans-a-Swimming,","Eight Maids-a-Milking,","Nine Ladies Dancing,","Ten Lords-a-Leaping,","Eleven Pipers Piping,","Twelve Drummers Drumming,"],v=[],i=0;i<12;i++){for(l=["On the "+d[i]+" day of Christmas\nMy true love sent to me"],j=i+1,k=0;j-->0;)l[++k]=g[j];v[i]=l.join("\n")}console.log(v.join("\n\n"))
```
[Try it online!](https://tio.run/##PVLBbsIwDP0VqyeqtmjblXXSNsZ2gA2N3koPETGtS5qgpJShad/O3FA4@em9F8d@SS064TaW9m2ijcTzeWvsSKZ5MCPr2iAOVrgxWjLIKrJ9nZmDbase0NbXFf1cKnaoPXqjsvLgky5EdhXUzZMdUfXni7jk255hKWxrSZYIpEHAEoWFzCKOvddAxrcqhKnp0MUghpHYADOLelPBB2oXD/PBq1CKdAkvPPOFpQ7h3SgJ38x7iueGd0SHiUjm4sR0fN0CVkehHfOrIzXNoPitYCFI9sqC1G4QeEuEuZCEDqZCbwaal4a5sd49R7G/tvEZwJL2aF1frnYOhGec2kPT9IoHXiviLs2LmNK7CT3eP0woisLf/p0UJ/eloa0QgkjmVEQBSHECs4XXypJrG@HWenGC1h4QFEcHjuOH1kCD3LZOKbqPd9y3TpKnu0mo8ijaFWmZ18Wk436pGteG9ChY6yD844/gjMKxMuWouwm9FJ7P/w "JavaScript (Node.js) – Try It Online")
[Answer]
# [Zsh](https://www.zsh.org/) `-y`, 383 bytes
```
for x y (first
two-turtle-doves second
three-french-hens third
`for a b (four call\ -birds
five golden-r\ s
six geese-a-lay
seven swans-a-swimm
eight maids-a-milk
nine ladies-danc
ten lords-a-leap
eleven pipers-pip
twelve drummers-drumm)()(<<<$a-$1ing$2\ ${${a%[et]}/%v/f}th) $b`)<<<"On the $x day of Christmas
my true love gave to me
$1a partridge in a pear tree
"&&1="$y
${1-and }"
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LVFLbsIwEFW3PsUoMogsLJSuuqCrHqAHACSGeJJY9SfyOIEUoR6kG6SqPVRPU0PZzBs9vzf283x-vXP3sy7UVGwv30Nq1NPvw0cTIhxhgkVjIieRDkGlISZLSoeRGJjq4LVIXSRSTSRfd6ojz5A6E7XYXf0I--wPQ4Qard2A2ucjFo0ZCdpgNXkVN8CCzRFaIiaFyuIkmEbywAf0nBk-GOcEmbZL4NDoK-eMfRPeeAKL2hArjb4WKbtsiDeFJewF2duk3vQUWWXIOcjm23UcnLtyt6ZclIvVaiVRycr4Vj5uQJ7kCWdrStvzcjYum3PqSpD7XZl1xavPKQnkETROEBp46aLh5JCFmyDFIT8rXDNiLimAIyErhB5jika3BMbnv-kJYxYTiWI-r54LOQl5qhR6Defifw_3dVzu-Ac)
This may be the first time I've used Zsh's anonymous functions in golf. By combining it with the `-y` option, I can conveniently split `$b` into `$1` and `$2`.
Makes use of some interesting symmetries:
* all the gifts (starting with the fourth) contain `ing`
* fi**ve** -> fi**f**th; twel**ve** -> twel**f**th (that's a mini-etymology lesson for you)
* nin**e** -> ninth; eigh**t** -> eighth
[Answer]
# Java - 1329 chars
```
class x{public static void main(String[] args){for(int i=1;i<=12;i++){System.out.print("On the ");switch(i){case 1:System.out.print("first");break;case 2:System.out.print("second");break;case 3:System.out.print("third");break;case 4:System.out.print("fourth");break;case 5:System.out.print("fifth");break;case 6:System.out.print("sixth");break;case 7:System.out.print("seventh");break;case 8:System.out.print("eighth");break;case 9:System.out.print("ninth");break;case 10:System.out.print("tenth");break;case 11:System.out.print("eleventh");break;case 12:System.out.print("twelfth");break;}System.out.println(" day of Christmas\nmy true love gave to me");switch(i){case 12:System.out.println("Twelve drummers drumming");case 11:System.out.println("Eleven pipers piping");case 10:System.out.println("Ten lords-a-leaping");case 9:System.out.println("Nine ladies dancing");case 8:System.out.println("Eight maids-a-milking");case 7:System.out.println("Seven swans-a-swimming");case 6:System.out.println("Six geese-a-laying");case 5:System.out.println("Five golden rings");case 4:System.out.println("Four calling birds");case 3:System.out.println("Three french hens");default:if(i>=2)System.out.print("Two turtle doves\nAnd a");else System.out.print("A");System.out.println(" partridge in a pear tree");break;}System.out.println();}}}
```
I'm too lazy to ungolf it, but it is here: <http://ideone.com/MU9IcP>.
[Answer]
# Rust 525 chars
Messy:
```
fn main(){for i in 1..13{println!("On the {} day of Christmas,\nmy true love gave to me\n{}\n",["first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth"][i-1],["Twelve Drummers Drumming","Eleven Pipers Piping","Ten Lords a Leaping","Nine Ladies Dancing","Eight Maids a Milking","Seven Swans a Swimming","Six Geese a Laying","Five Golden Rings","Four Calling Birds","Three French Hens","Two Turtle Doves and","a Partridge in a Pear Tree."][(12-i)..12].join("\n"));}}
```
Formatted (haha rustfmt go brrr):
```
fn main() {
for i in 1..13 {
println!(
"On the {} day of Christmas,\nmy true love gave to me\n{}\n",
[
"first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth",
"ninth", "tenth", "eleventh", "twelfth"
][i - 1],
[
"Twelve Drummers Drumming",
"Eleven Pipers Piping",
"Ten Lords a Leaping",
"Nine Ladies Dancing",
"Eight Maids a Milking",
"Seven Swans a Swimming",
"Six Geese a Laying",
"Five Golden Rings",
"Four Calling Birds",
"Three French Hens",
"Two Turtle Doves and",
"a Partridge in a Pear Tree."
][(12 - i)..12]
.join("\n")
);
}
}
```
I love how much this looks like the Python 2 and Ruby solutions (thanks for the inspiration). However, because the string split gives an iterator, I think the `.split('^').collect::<Vec<str>>()` I'd have to write would actually remove all the benefits of having `^`-delimited strings instead of literal lists/arrays. (For the first substitution, I guess there's also `.split('^').nth(i-1).unwrap()`, but that's also a mouthful.)
] |
[Question]
[
This isn't very widely known, but what we call the Fibonacci sequence, AKA
```
1, 1, 2, 3, 5, 8, 13, 21, 34...
```
is actually called the *Duonacci* sequence. This is because to get the next number, you sum the previous 2 numbers. There is also the *Tribonacci* sequence,
```
1, 1, 1, 3, 5, 9, 17, 31, 57, 105, 193, 355, 653, 1201...
```
because the next number is the sum of the previous 3 numbers. And the *Quadronacci* sequence
```
1, 1, 1, 1, 4, 7, 13, 25, 49, 94, 181, 349, 673...
```
And everybody's favorite, the *Pentanacci* sequence:
```
1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129...
```
And the *Hexanacci* sequence, the *Septanacci* sequence, the *Octonacci* sequence, and so on and so forth up to the N-Bonacci sequence.
The N-bonacci sequence will always start with **N** 1s in a row.
# The Challenge
You must write a function or program that takes two numbers *N* and *X*, and prints out the first *X* N-Bonacci numbers. N will be a whole number larger than 0, and you can safely assume no N-Bonacci numbers will exceed the default number type in your language. The output can be in any human readable format, and you can take input in any reasonable manner. (Command line arguments, function arguments, STDIN, etc.)
As usual, this is Code-golf, so standard loopholes apply and the shortest answer in bytes wins!
# Sample IO
```
#n, x, output
3, 8 --> 1, 1, 1, 3, 5, 9, 17, 31
7, 13 --> 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
1, 20 --> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
30, 4 --> 1, 1, 1, 1 //Since the first 30 are all 1's
5, 11 --> 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129
```
[Answer]
## Boolfuck, 6 bytes
```
,,[;+]
```
>
> You can safely assume no N-Bonacci numbers will exceed the default number type in your language.
>
>
>
The default number type in Boolfuck is a bit. Assuming this also extends to the input numbers N and X, and given that N>0, there are only two possible inputs - 10 (which outputs nothing) and 11 (which outputs 1).
`,` reads a bit into the current memory location. N is ignored as it must be 1. If X is 0, the loop body (surrounded by `[]`) is skipped. If X is 1, it is output and then flipped to 0 so the loop does not repeat.
[Answer]
## Python 2, 79 bytes
```
n,x=input()
i,f=0,[]
while i<x:v=[sum(f[i-n:]),1][i<n];f.append(v);print v;i+=1
```
[Try it online](http://ideone.com/fork/fHjGyW)
[Answer]
## Haskell, 56 bytes
```
g l=sum l:g(sum l:init l)
n#x|i<-1<$[1..n]=take x$i++g i
```
Usage example: `3 # 8`-> `[1,1,1,3,5,9,17,31]`.
How it works
```
i<-1<$[1..n] -- bind i to n copies of 1
take x -- take the first x elements of
i++g i -- the list starting with i followed by (g i), which is
sum l: -- the sum of it's argument followed by
g(sum l:init l) -- a recursive call to itself with the the first element
-- of the argument list replaced by the sum
```
[Answer]
# Pyth, 13
```
<Qu+Gs>QGEm1Q
```
[Test Suite](http://pyth.herokuapp.com/?code=%3CQu%2BGs%3EQGEm1Q&input=3%0A8&test_suite=1&test_suite_input=3%0A8%0A7%0A13%0A1%0A20%0A30%0A4%0A5%0A11&debug=0&input_size=2)
Takes input newline separated, with `n` first.
### Explanation:
```
<Qu+Gs>QGEm1Q ## implicit: Q = eval(input)
u Em1Q ## read a line of input, and reduce that many times starting with
## Q 1s in a list, with a lambda G,H
## where G is the old value and H is the new one
+G ## append to the old value
s>QG ## the sum of the last Q values of the old value
<Q ## discard the last Q values of this list
```
[Answer]
# Javascript ES6/ES2015, ~~107~~ ~~97~~ ~~85~~ 80 Bytes
Thanks to @user81655, @Neil and @ETHproductions for save some bytes
---
```
(i,n)=>eval("for(l=Array(i).fill(1);n-->i;)l.push(eval(l.slice(-i).join`+`));l")
```
[try it online](https://jsfiddle.net/n83n11ej/12/)
---
Test cases:
```
console.log(f(3, 8))// 1, 1, 1, 3, 5, 9, 17, 31
console.log(f(7, 13))// 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
console.log(f(5, 11))// 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129
```
[Answer]
## ES6, 66 bytes
```
(i,n)=>[...Array(n)].map((_,j,a)=>a[j]=j<i?1:j-i?s+=s-a[j+~i]:s=i)
```
Sadly `map` won't let you access the result array in the callback.
[Answer]
# Jelly, 12 bytes
```
ḣ³S;
b1Ç⁴¡Uḣ
```
[Try it online!](http://jelly.tryitonline.net/#code=4bijwrNTOwpiMcOH4oG0wqFV4bij&input=&args=Nw+MTM)
### How it works
```
b1Ç⁴¡Uḣ Main link. Left input: n. Right input: x.
b1 Convert n to base 1.
¡ Call...
Ç the helper link...
⁴ x times.
U Reverse the resulting array.
ḣ Take its first x elements.
ḣ³S; Helper link. Argument: A (list)
ḣ³ Take the first n elements of A.
S Compute their sum.
; Prepend the sum to A.
```
[Answer]
## Python 2, 55 bytes
```
def f(x,n):l=[1]*n;exec"print l[0];l=l[1:]+[sum(l)];"*x
```
Tracks a length-`n` window of the sequence in the list `l`, updated by appending the sum and removing the first element. Prints the first element each iteration for `x` iterations.
A different approach of storing all the elements and summing the last `n` values gave the same length (55).
```
def f(x,n):l=[1]*n;exec"l+=sum(l[-n:]),;"*x;print l[:x]
```
[Answer]
# [Haskell](https://www.haskell.org/), 47 bytes
```
q(h:t)=h:q(t++[h+sum t])
n?x=take x$q$1<$[1..n]
```
[Try it online!](https://tio.run/##BcFBCoMwEAXQfU/xF1koCeI0LRVpmBP0BCGLLISIJpg6BW@fvpfiuS373lrt0iy9S3PtRGuf9PnLkNDfCl9O4rbgUlXRW3kahhJajmuBQ47HB8d3LQIFb3kyeDFZA@L7aGBHfhg8mSi0Pw "Haskell – Try It Online")
`<$` might have been introduced into Prelude after this challenge was posted.
---
**[Haskell](https://www.haskell.org/), 53 bytes**
```
n%i|i>n=sum$map(n%)[i-n..i-1]|0<1=1
n?x=map(n%)[1..x]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P081sybTLs@2uDRXJTexQCNPVTM6UzdPTy9T1zC2xsDG0NaQK8@@whYmZ6inVxH7PzcxM0/BVgEo6KtQUJSZV6KgohBtbG@ho2Bub2iso2Bob2Sgo2BsYG@io2Bqb2gY@x8A "Haskell – Try It Online")
Defines the binary function `?`, used like `3?8 == [1,1,1,3,5,9,17,31]`.
The auxiliary function `%` recursively finds the `i`th element of the `n`-bonacci sequence by summing the previous `n` values. Then, the function `?` tabulates the first `x` values of `%`.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
↑§¡ȯΣ↑_B1
```
[Try it online!](https://tio.run/##yygtzv7//1HbxEPLDy08sf7cYiAz3snw////5v8NjQE "Husk – Try It Online")
Starts from the `B`ase-`1` representation of *N* (simply a list of *N* ones) and `¡`teratively sums (`Σ`) the last (`↑_`) *N* elements and appends the result to the list. Finally, takes (`↑`) the first *X* numbers in this list and returns them.
[Answer]
# C#, 109 bytes
```
(n,x)=>{int i,j,k;var y=new int[x];for(i=-1;++i<x;y[i]=i<n?1:k){k=0;for(j=i-n;j>-1&j<i;)k+=y[j++];}return y;}
```
[Try it online!](https://tio.run/##fU/RSsMwFH3vV1z6MFp6O5ZlddY080HwQRQEH3wYfahdHGm3VJN2rox9e02HA4duHMK9yT3n5J7chHmlRdcYqZbw0pparJnz@zZ8lOqTOfkqMwaedbXU2XrnAHw0byuZg6mz2pZNJRfwlEnl@f0Q4L5ReSJVjT9nns5gAbzzFG59PtvZJ5BYYMk2mYaWK/EFPW2bsvdKe5KHhAWBTLasncuUy0TdkpvS35V8dCAUXIaKFbOQDIpEMr8MeDsvgiBley3qRito2b5jjnNXKVOtxPBVy1rYLMI77GdqbTMOHyq7sosuwsKjCNe@D5yDS7AHxQhjJFOkxIXB4JxuikDoifCIKRKK4wgnMca2j@klG4IwHv1rcxaX7OgIYXJqd4ke2RDkz@/H/BSvIiTj2HV85uwtum8 "C# (.NET Core) – Try It Online")
---
```
(n, x) => {
int i, j, total;
var result = new int[x];
for (i = -1; ++i < x; ) { //calculate each term one at a time
total = 0; //value of the current term
for (j = i - n; j > -1 & j < i;) //sum the last n terms
{
total += result[j++];
}
result[i] = i < n ? 1 : total; //first n terms are always 1 so ignore the total if i < n
}
return result;
}
```
[Answer]
# [Haskell](https://www.haskell.org), 46 bytes
```
g _ 0=[]
g(h:t)n=h:g(t++[sum$h:t])(n-1)
```
```
g.g[1]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8GCpaUlaboWNw3SFeIVDGyjY7nSNTKsSjTzbDOs0jVKtLWji0tzVYAisZoaebqGmlxptul66dGGsVB9YbmJmXkKtgop-VwKCrmJBb4KBUWZeSVAjkK0QpqCsYIFiKkDZJorGBrD2IYKRgYwtrGBggmMbapgaAhiQ02HuQ4A)
This is based on [xnor's answer](https://codegolf.stackexchange.com/a/70522/) but it employs 1 clever trick.
The \$n\$-bonacci sequence always start with \$n\$ `1`s. A more general version of this might start with just any \$n\$ values. And this more general version is what we implement with `g`. `g` takes a list of \$n\$ integers and a value \$m\$ and gives us a list of the first \$m\$ terms of this generalized \$n\$-bonacci sequence.
The trick is then that `g[1]` is a cheap way to generate \$n\$ `1`s. Since the sequence starting with `[1]` is just an endless stream of `1`s. So we use `g` in two ways, and even though `g` might be slightly longer because it implements something a little more general, it saves bytes because it serves two purposes.
[Answer]
# Java, 82 + 58 = 140 bytes
Function to find the *ith* **n**-bonacci number (**82 bytes**):
```
int f(int i,int n){if(i<=n)return 1;int s=0,q=0;while(q++<n)s+=f(i-q,n);return s;}
```
Function to print first *k* **n**-bonacci number (**58 bytes**):
```
(k,n)->{for(int i=0;i<k;i++){System.out.println(f(i,n));}}
```
[Answer]
# C++11, 360 bytes
Hi I just like this question. I know c++ is a very hard language to win this competition. But I'll thrown a dime any way.
```
#include<vector>
#include<numeric>
#include<iostream>
using namespace std;typedef vector<int>v;void p(v& i) {for(auto&v:i)cout<<v<<" ";cout<<endl;}v b(int s,int n){v r(n<s?n:s,1);r.reserve(n);for(auto i=r.begin();r.size()<n;i++){r.push_back(accumulate(i,i+s,0));}return r;}int main(int c, char** a){if(c<3)return 1;v s=b(atoi(a[1]),atoi(a[2]));p(s);return 0;}
```
I'll leave this as the readable explanation of the code above.
```
#include <vector>
#include <numeric>
#include <iostream>
using namespace std;
typedef vector<int> vi;
void p(const vi& in) {
for (auto& v : in )
cout << v << " ";
cout << endl;
}
vi bonacci(int se, int n) {
vi s(n < se? n : se, 1);
s.reserve(n);
for (auto it = s.begin(); s.size() < n; it++){
s.push_back(accumulate(it, it + se, 0));
}
return s;
}
int main (int c, char** v) {
if (c < 3) return 1;
vi s = bonacci(atoi(v[1]), atoi(v[2]));
p(s);
return 0;
}
```
[Answer]
[Uiua](https://www.uiua.org/) (version 0.0.7), 34 bytes
```
→(;;)⍥(⊂∶/+↙∶→,⇌.)∶→(-,,)[⍥.-1∶1].
```
[Answer]
# APL, 21
```
{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}
```
This is a function that takes *n* as its left argument and *x* as its right argument.
Explanation:
```
{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}
⍺/1 ⍝ begin state: X ones
+ ⍝ identity function (to separate it from the ⍵)
⍺{ }⍣⍵ ⍝ apply this function N times to it with X as left argument
⍵, ⍝ result of the previous iteration, followed by...
+/ ⍝ the sum of
⍺↑ ⍝ the first X of
⌽ ⍝ the reverse of
⍵ ⍝ the previous iteration
⍵↑ ⍝ take the first X numbers of the result
```
Test cases:
```
↑⍕¨ {⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1} /¨ (3 8)(7 13)(1 20)(30 4)(5 11)
1 1 1 3 5 9 17 31
1 1 1 1 1 1 1 7 13 25 49 97 193
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1
1 1 1 1 1 5 9 17 33 65 129
```
[Answer]
# Python 3, 59
Saved 20 bytes thanks to FryAmTheEggman.
Not a great solution, but it'll work for now.
```
def r(n,x):f=[1]*n;exec('f+=[sum(f[-n:])];'*x);return f[:x]
```
Also, here are test cases:
```
assert r(3, 8) == [1, 1, 1, 3, 5, 9, 17, 31]
assert r(7, 13) == [1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193]
assert r(30, 4) == [1, 1, 1, 1]
```
[Answer]
# C, 132 bytes
The recursive approach is shorter by a couple of bytes.
```
k,n;f(i,s,j){for(j=s=0;j<i&j++<n;)s+=f(i-j);return i<n?1:s;}main(_,v)int**v;{for(n=atoi(v[1]);k++<atoi(v[2]);)printf("%d ",f(k-1));}
```
## Ungolfed
```
k,n; /* loop index, n */
f(i,s,j) /* recursive function */
{
for(j=s=0;j<i && j++<n;) /* sum previous n n-bonacci values */
s+=f(i-j);
return i<n?1:s; /* return either sum or n, depending on what index we're at */
}
main(_,v) int **v;
{
for(n=atoi(v[1]);k++<atoi(v[2]);) /* print out n-bonacci numbers */
printf("%d ", f(k-1));
}
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~144~~ ~~124~~ 122 bytes
-20 bytes thanks to [Nitroden](https://codegolf.stackexchange.com/users/69059/nitrodon)
This is my first Brain-Flak answer, and I'm sure it can be improved. Any help is appreciated.
```
(([{}]<>)<{({}(()))}{}>)<>{({}[()]<<>({<({}<({}<>)<>>())>[()]}{})({}<><({({}<>)<>}<>)>)<>>)}{}<>{({}<{}>())}{}{({}<>)<>}<>
```
[Try it online!](https://tio.run/##TYwxCoAwDEV3T/IzOIiDS8hFSoc6CKI4uIacPSYVwaGFn/d46932a9zOdrgDRa2yECvUACIytZiSu4Aqs0A5Rn9JJCxJFCb1Y6AP5t@l7LwVjiB692@5L8M0Pw "Brain-Flak – Try It Online")
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 46 bytes
The generating function of the sequence is:
$$\frac{(n-1)x^n}{x^{n+1}-2x+1}-\frac{1}{x-1}$$
```
(n,m)->Vec(n--/(x-(2-1/x)/x^n)-1/(x-1)+O(x^m))
```
[Try it online!](https://tio.run/##FckxCsMwDIXhq4hMEpVwHLc0S3OFbl2CAyY0JeAYETq4p3ft7fvf03Du8tGywaNg4oNker1XTCIGs@Ag1mQyeUlUVRdLlyfm5SAqQTX@MIBMoOeevpVdiw7WECNuDIGIYZ4dw@gr7gzWNViGoW9wPcO14VYv6z2VPw "Pari/GP – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 60 bytes
```
function(n,m){for(i in 1:m)T[i]=`if`(i>n,sum(T[i-1:n]),1);T}
```
[Try it online!](https://tio.run/##Lcw9CoAwDEDh3VM4JhDBWEVR9BRuIohCIUNT8GcSz15Fun284e1BV699sJdup3gFJYe39TtIKppy63CcZO4XsQvIoHRcDr6ScaszEmM3Pv8CDDWY/KqJTSRTkUeanMrIipgxvA "R – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) , 8 bytes
```
1ẋ?‡W∑*Ḟ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyI1IiwiIiwiMeG6iz/igKFX4oiRKuG4niIsIiIsIjIiXQ==)
```
1ẋ # [1] * input
‡W∑ # Function summing its inputs
? * # Set the arity to the input
Ḟ # Generate an infinite list from the function and the vector of 1s.
```
[Answer]
# Julia, 78 bytes
```
f(n,x)=(z=ones(Int,n);while endof(z)<x push!(z,sum(z[end-n+1:end]))end;z[1:x])
```
This is a function that accepts two integers and returns an integer array. The approach is simple: Generate an array of ones of length `n`, then grow the array by adding the sum of the previous `n` elements until the array has length `x`.
Ungolfed:
```
function f(n, x)
z = ones(Int, n)
while endof(z) < x
push!(z, sum(z[end-n+1:end]))
end
return z[1:x]
end
```
[Answer]
## Perl 6, ~~52~72~~ 47~67 bytes
```
sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}
```
Requires the module `MONKEY-SEE-NO-EVAL`, because of the following error:
>
> ===SORRY!=== Error while compiling -e
>
> EVAL is a very dangerous function!!! (use MONKEY-SEE-NO-EVAL to override,
>
> but only if you're VERY sure your data contains no injection attacks)
>
> at -e:1
>
>
>
```
$ perl6 -MMONKEY-SEE-NO-EVAL -e'a(3,8).say;sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}'
(1 1 1 3 5 9 17 31)
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 22 ~~26~~ bytes
```
1tiXIX"i:XK"tPI:)sh]K)
```
This uses [current release (10.2.1)](https://github.com/lmendo/MATL/releases/tag/10.2.1) of the language/compiler.
[**Try it online!**](http://matl.tryitonline.net/#code=MXRpWElYImk6WEsidFBJOilzaF1LKQ&input=NwoxMwo)
A few extra bytes :-( due to a bug in the `G` function (paste input; now corrected for next release)
### Explanation
```
1tiXIX" % input N. Copy to clipboard I. Build row array of N ones
i:XK % input X. Build row array [1,2,...X]. Copy to clipboard I
" % for loop: repeat X times. Consumes array [1,2,...X]
t % duplicate (initially array of N ones)
PI:) % flip array and take first N elements
sh % compute sum and append to array
] % end
K) % take the first X elements of array. Implicitly display
```
[Answer]
# [Perl 6](http://perl6.org), 38 bytes
```
->\N,\X{({@_[*-N..*].sum||1}...*)[^X]} # 38 bytes
```
```
-> \N, \X {
(
{
@_[
*-N .. * # previous N values
].sum # added together
|| # if that produces 0 or an error
1 # return 1
} ... * # produce an infinite list of such values
)[^X] # return the first X values produced
}
```
### Usage:
```
# give it a lexical name
my &n-bonacci = >\N,\X{…}
for ( (3,8), (7,13), (1,20), (30,4), (5,11), ) {
say n-bonacci |@_
}
```
```
(1 1 1 3 5 9 17 31)
(1 1 1 1 1 1 1 7 13 25 49 97 193)
(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
(1 1 1 1)
(1 1 1 1 1 5 9 17 33 65 129)
```
[Answer]
# J, 31 bytes
```
]{.(],[:+/[{.])^:(-@[`]`(1#~[))
```
Ungolfed:
```
] {. (] , [: +/ [ {. ])^:(-@[`]`(1 #~ [))
```
## explanation
Fun times with [the power verb in its gerund form](http://code.jsoftware.com/wiki/Vocabulary/hatco#Gerund_n):
```
(-@[`]`(1 #~ [)) NB. gerund pre-processing
```
Breakdown in detail:
* `] {. ...` Take the first `<right arg>` elements from all this stuff to the right that does the work...
* `<left> ^: <right>` apply the verb `<left>` repeatedly `<right>` times... where `<right>` is specified by the middle gerund in `(-@[`]`(1 #~ [)`, ie, `]`, ie, the right arg passed into the function itself. So what is `<left>`? ...
* `(] , [: +/ [ {. ])` The left argument to this entire phrase is first transformed by the first gerund, ie, `-@[`. That means the left argument to this phrase is the *negative* of the left argument to the overall function. This is needed so that the phrase `[ {. ]` takes the *last* elements from the return list we're building up. Those are then summed: `+/`. And finally appended to that same return list: `] ,`.
* So how is the return list initialized? That's what the third pre-processing gerund accomplishes: `(1 #~ [)` -- repeat 1 "left arg" number of times.
[Try it online!](https://tio.run/##jY/BasMwEETv@oqhPdimsq214iYWpIR8QC89GoeEYJGU0EKcW0h@3R1bOaSlhYoVvJFmlt333neYOxjw9s05ixtdu6e8PmdNsnJxuqjXzTqWx2udJH2iHjJEfu4iaFwcfKfU6zKD1cAMSNMXiL4V30qNijylkNFHgtjvvvvivzBXMDhhshp0Zccof1GYv6P/qjCsYfcfwwrCyfO3/ce2xWnXwu@P3YlubI4tNocDJOrGBuWwhfw2yt3CXOOZUopKqXa7@4SFxyzglCg2sJALc7MYikngcvBI/wU "J – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 41 bytes
```
->a,b{r=[1]*a;b.times{z,*r=r<<r.sum;p z}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ6m6yDbaMFYr0TpJryQzN7W4ukpHq8i2yMamSK@4NNe6QKGqtvZ/WrSxjkUsV0FpSbGCuq6urjpXWrS5jqExmpChjpEBmpCxgY4JmpCpjqFh7H8A "Ruby – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 68 bytes
```
function(n,x){a=1+!1:n;for(i in n+1:x){a[i]=sum(a[(i-n:1)])};a[1:x]}
```
[Try it online!](https://tio.run/##FcnBCoMwDADQ@76iuyUYwdgNR9UvKT2UQSCHRdAJg@G3V3t6h7cWcVNbZLf3VxcDox/@88zNnYONsqygTs1Zw6FG1DRv@wdyBG0tMCY8xhyvTEcR8PTCm8BA7KtMfVf1HT2qT2LGcgI "R – Try It Online")
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~26~~ 24 bytes
```
{(y-x){y,+/x#y}[-x]/x#1}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqlqjUrdCs7pSR1u/QrmyNlq3IhbIMKz9nxZtbm1oFPsfAA "K (ngn/k) – Try It Online")
] |
[Question]
[
Using your language of choice, golf a [quine](http://en.wikipedia.org/wiki/Quine_%28computing%29).
>
> A **quine** is a non-empty computer program which takes no input and produces a copy of its own source code as its only output.
>
>
>
No cheating -- that means that you can't just read the source file and print it. Also, in many languages, an empty file is also a quine: that isn't considered a legit quine either.
No error quines -- there is already a [separate challenge](https://codegolf.stackexchange.com/questions/36260/make-an-error-quine) for error quines.
Points for:
* Smallest code (in bytes)
* Most obfuscated/obscure solution
* Using esoteric/obscure languages
* Successfully using languages that are difficult to golf in
The following Stack Snippet can be used to get a quick view of the current score in each language, and thus to know which languages have existing answers and what sort of target you have to beat:
```
var QUESTION_ID=69;
var OVERRIDE_USER=98;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}
function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}
function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=!1;comment_page=1;getComments()}})}
function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}
getAnswers();var SCORE_REG=(function(){var headerTag=String.raw `h\d`
var score=String.raw `\-?\d+\.?\d*`
var normalText=String.raw `[^\n<>]*`
var strikethrough=String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>`
var noDigitText=String.raw `[^\n\d<>]*`
var htmlTag=String.raw `<[^\n<>]+>`
return new RegExp(String.raw `<${headerTag}>`+String.raw `\s*([^\n,]*[^\s,]),.*?`+String.raw `(${score})`+String.raw `(?=`+String.raw `${noDigitText}`+String.raw `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+String.raw `</${headerTag}>`+String.raw `)`)})();var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}
function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))
body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)
valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,})});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)
lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<i>'+a.language+'</i>').text().toLowerCase();languages[lang]=languages[lang]||{lang:a.language,user:a.user,size:a.size,link:a.link,uniq:lang}});var langs=[];for(var lang in languages)
if(languages.hasOwnProperty(lang))
langs.push(languages[lang]);langs.sort(function(a,b){if(a.uniq>b.uniq)return 1;if(a.uniq<b.uniq)return-1;return 0});for(var i=0;i<langs.length;++i)
{var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
```
```
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>
```
[Answer]
## [Hexagony](https://github.com/mbuettner/hexagony), side-length ~~17~~ 16, ~~816~~ 705 bytes
```
180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.
```
[Try it online!](http://hexagony.tryitonline.net/#code=MTgwOTYzMTA5MTY4ODQzODgwNTU4MjQ0NDkxNjczOTUzMzI3NTc3MjMzOTM4MTI5MzM5MTczMDU4NzIwNTA0MDgxNDg0MDIyNTQ5ODExNDAyMDU4MjcxMzAzODg3NjcwNzEwMjc0OTY5NDU1MDY1NTU3ODgzNzAyMzY5ODA3MTQ4OTYwNjA4NTUzMjIzODc5NTAzODkyMDE3MTU3MzM3Njg1NTc2MDU2NTEyNTQ2OTMyMjQzNTk0MzE2NjM4MjQ3NTk3MDc1NDIzNTA3OTM3OTQzODE5ODEyNjY0NDU0MTkwNTMwMjE0ODA3MDMyNjAwMDgzMjg3MTI5NDY1NzUxMTk1ODM5NDY5Nzc3ODQ5NzQwMDU1NTg0MDQzMzc0NzExMzYzNTcxNzExMDc4NzgxMjk3MjMxNTkwNjA2MDE5MzEzMDY1MDQyNjY3NDA2Nzg0NzUzNDIyODQ0Ii4iLj4uQC4jLiMuIy4jLiMuIy4jLj4uKC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLjwuIi4uLi4uLi4iLiIuPi4vLjQuUS47LisuPC4jLj4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi48LiIuLi4uLiIuIi4-LiMuIy4-Lk4uMi4nLlwuPi4uLi4uLi4uLi4uLi49Lj0uLi4uLi4uXy48LiIuLi4uLiIuIi4-Lj4uOy4nLj0uOi5cLj4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLjwuIi4uLiIuIi4-LlwuJy4lLicuPC4jLj4uLi4uLi4uLi4uLi4uLi5fLi4uLi48LiIuLi4iLiIuPi4jLiMuPi48LiMuPi4uLi4uLi4uLi4uLi4uLj0uPS48LiIuIi4iLj4uIy5cLicuUi4vLj4uLi4uLi4uLi4uLi4uLi4uLjwuIi4hLi4uLi4uLi4uLi4vLj4u&input=)
This is what it looks like unfolded:
```
1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
" . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
. . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
. " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
. . . . . . . . . . . . . . . . . . . . < . " . . . . .
" . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
. . . . . . . = . = . . . . . . . _ . < . " . . . .
. " . " . > . > . ; . ' . = . : . \ . > . . . . .
. . . . . . . . . . . . . . . . . . < . " . . .
" . " . > . \ . ' . % . ' . < . # . > . . . .
. . . . . . . . . . . _ . . . . . < . " . .
. " . " . > . # . # . > . < . # . > . . .
. . . . . . . . . . . . = . = . < . " .
" . " . > . # . \ . ' . R . / . > . .
. . . . . . . . . . . . . . . < . "
. ! . . . . . . . . . . . / . > .
. . . . . . . . . . . . . . . .
```
Ah well, this was quite the emotional rollercoaster... I stopped counting the number of times I switched between "haha, this is madness" and "wait, if I do *this* it should actually be fairly doable". The constraints imposed on the code by Hexagony's layout rules were... severe.
It might be possible to reduce the side-length by 1 or 2 without changing the general approach, but it's going to be tough (only the cells with `#` are currently unused *and* available for the decoder). At the moment I also have absolutely no ideas left for how a more efficient approach, but I'm sure one exists. I'll give this some thought over the next few days and maybe try to golf off one side-length, before I add an explanation and everything.
Well at least, I've proven it's possible...
Some CJam scripts for my own future reference:
* [Encoder](http://cjam.aditsu.net/#code=qS-N-Y%2514f-W%2582b)
* [Literal-shortcut finder](http://cjam.aditsu.net/#code='%5B%2C_el%5EA%2Cm*%7B_N%2B%5CAb256%2546%3D*%7D%2F)
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), side length 11, 314 bytes
```
164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q
```
[Try it online!](https://tio.run/##jYy7CsJQEAW/RUgINnF37z7z0l@wvyApRCtt9evjtRAbUadZZg7s@XibT9fLfVlQmdg9OALFURDVEphpsoggRJJQsnIUIIG6eIQYiRCwSyAEgQuKhklYJAU0ouAShDSKMBMSk5sbg0nZLAlQKj/ZU/tkten69sW6bsa56XL7gfxfy79L/u5Fq93bqmmYmi2NTd0OuesPPe@X5QE "Hexagony – Try It Online")
---
Note: Currently [the shortest program](https://codegolf.stackexchange.com/questions/69/golf-you-a-quine-for-great-good/193220#193220) is only **261** bytes long, using a similar technique.
Older version:
# [Hexagony](https://github.com/m-ender/hexagony), side length 11, 330 bytes
```
362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/
```
[Try it online!](https://tio.run/##jY29CsJAEISfRVBSCHH/bzfR6CNof00K0UpbJQ8fL2ChIOpUO98yM@fjrT9dL/dxZCMAVkRVFoIwFOJkRtNhpKQcIG5sShwaYk4GUSSiEj6lWR0lOblIQkH1UpMSBAIYu5QUA4mWqcTixJoCsDRF4YYp6qJVM7TLaoP7alH1Q1PXuf6k/B/Lv0n@7t9tns279ctr1w1bqhZP1LStHFbj@AA "Hexagony – Try It Online")
Encoder: [Try it online!](https://tio.run/##jZHNTsMwEITvfoohApoQ6v4hIdKmIMGFG6hHysEkTmyRJpVj0Up9@LJxCuKEnMiyvfPtatarRPspq@p41JttYyyehBX8UQnDmKyzJpdIEqys0XWJ4RLPtZWlND9aa5GiwDkKXVlpENaN5bpdbUUmI1IZdkoayYgJAvRfinF3Dwd8kHTLRq6GxdUU8cRJmQJcnAG6wHiR5rrUFpeXcIfFh2ipKKySNUKXiy6EuNcjuk9JlxXFpDENOQu6pkTWuQwQx3jL1Hu3B9AtyDa@RKXzIKI057mvRNZsc2oaYWNyZCrCEE1RtNIythG6JkYT0RWnl2hVs@Phej9chvtrVLIurTqFsY8i3r8cY85virtb1tei82x2PHLOyQHHCAkOmFNHA1ImeKH9gpagaEI6xxpEcs9/7Yr6kv6gN@eLeVJ@kBeDMxrPEov/EHd/IOqAe0zdKBz/h/hNS2hqc9zgFaNv "Haskell – Try It Online")
The program is roughly equivalent to this Python code: [Try it online!](https://tio.run/##ZZDbbsMgDIbv8xSWpimJJrWAzWnS9i5JR9RITakCVZW@fGbSXuzABdgf/u0fLks@xjOu6zDHCdKSYJwucc6Q8le85qqawgQfgEYJgVpKrZGU8EaSQmuMKoFRWmn0gpxBoxV67ck4ZYTnRaTJu6JG7SRZpxyRlSS14zbWCi@FMOiIVSgUaR5lkZxCbb2Q3MkzN9L6qnp42t3mMYcm5blhc21b3Y7jKUAx@gnivQLo2LHis@ez4FfoOBsHBs8KgF@96t2ubjf8eG7Z9/tNBXCI5zyer4GTcErhIe//VvVdCszi/NXUXd3CC3i7XSxMe7ZQCjYQhyGFXD4Vt/zO4QJvT/7f3OE4N/f2p72@jC391vUb "Python 3 – Try It Online")
Unfolded code:
```
3 6 2 0 0 3 5 1 1 5 5
3 4 2 0 9 6 1 4 2 3 7 6
6 2 6 1 4 2 6 2 5 2 5 3 9
0 4 8 6 3 6 5 2 3 9 5 9 4 6
8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
. / : { ; + ' = 1 P ' % ' a { : . . \ .
. . . . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . \
. . . . . . . . . . . . . \
! $ > < . . . . . . . . \
. . @ > { ? 2 ' % < . .
. . . . : ; ; 4 Q / .
```
Two `.`s takes 1 bit. Any other characters take 1 bit and a base-97 digit.
# Explanation
Click at the images for larger size. Each explanation part has corresponding Python code to help understanding.
### Data part
Instead of the complex structure used in some other answers (with `<`, `"` and some other things), I just let the IP pass through the lower half.
[](https://i.stack.imgur.com/qNCdC.png)
First, the IP runs through a lot of numbers and no-op's (`.`) and mirrors (`\`). Each digit appends to the number in the memory, so in the end the memory value is equal to the number at the start of the program.
```
mem = 362003511...99306179
```
`!` prints it,
```
stdout.write(str(mem))
```
and `$` jumps through the next `>`.
Starting from the `<`. If the memory value `mem` is falsy (`<= 0`, i.e., the condition `mem > 0` is not satisfied), we have done printing the program, and should exit. The IP would follow the upper path.
[](https://i.stack.imgur.com/JbSX5.png)
(let the IP runs ~~around the world~~ for about 33 commands before hitting the `@` (which terminates the program) because putting it anywhere else incurs some additional bytes)
If it's true, we follow the lower path, get redirected a few times and execute some more commands before hitting another conditional.
[](https://i.stack.imgur.com/cDsec.png)
```
# Python # Hexagony
# go to memory cell (a) # {
a = 2 # ?2
# go to memory cell (b) # '
b = mem % a # %
```
Now the memory looks like this:
[](https://i.stack.imgur.com/LXFfU.png)
If the value is truthy:
```
if b > 0:
```
the following code is executed:
[](https://i.stack.imgur.com/ykMH1.png)
```
# Python # Hexagony
b = ord('Q') # Q
b = b*10+4 # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256)) # ;
stdout.write(chr(b%256)) # ;
```
See detailed explanation of the `Q4` at [MartinEnder's HelloWorld Hexagony answer](https://codegolf.stackexchange.com/a/57600/69850). In short, this code prints `.` twice.
Originally I planned for this to print `.` once. When I came up with this (print `.` twice) and implement it, about 10 digits were saved.
Then,
```
b = mem // a # :
```
Here is a important fact I realized that saved me about 14 digits: You don't need to be at where you started.
---
To understand what I'm saying, let's have a BF analogy. (skip this if you already understood)
Given the code
```
while a != 0:
b, a = a * 2, 0
a, b = b, 0
print(a)
```
Assuming we let `a` be the value of the current cell and `b` be the value of the right cell, a straightforward translation of this to BF is:
```
[ # while a != 0:
[->++<] # b, a = a * 2, 0
>[-<+>] # a, b = b, 0
<. # print(a)
]
```
However, note that we don't need to be at the same position all the time during the program. We can let the value of `a` be whatever we are at the start of each iteration, then we have this code:
```
[ # while a != 0:
[->++<] # b, a = a * 2, 0
# implicitly let (a) be at the position of (b) now
. # print(a)
]
```
which is several bytes shorter.
---
Also, the corner wrapping behavior also saves me from having a `\` mirror there - without it I would not be able to fit the digits (+2 digits for the `\` itself and +2 digits for an unpaired `.` to the right of it, not to mention the flags)
(details:
* The IP enters the lower-left corner, heading left
* It get warped to the right corner, still heads left
* It encounters a `\` which reflects it, now it heads right-up
* It goes into the corner and get warped again to the lower-left corner
)
---
If the value (of the mod 2 operation above) is falsy (zero), then we follow this path:
[](https://i.stack.imgur.com/NCG9k.png)
```
# Python # Hexagony # Memory visualization after execution
b = mem // a # : # [click here](https://i.stack.imgur.com/s53S3.png)
base = ord('a') # 97 # a
y = b % base # '%
offset = 33 # P1
z = y + offset # ='+
stdout.write(chr(z)) # ; # [click here](https://i.stack.imgur.com/Dfalo.png)
mem = b // base # {: # [click here](https://i.stack.imgur.com/bdRHf.png)
```
I won't explain too detailed here, but the offset is actually not exactly `33`, but is congruent to `33` mod `256`. And `chr` has an implicit `% 256`.
[Answer]
# MySQL, 167 characters
```
SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));
```
That's right. :-)
I really did write this one myself. It was originally [posted at my site](https://joshduff.com/2008-11-29-my-accomplishment-for-the-day-a-mysql-quine.html).
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~9.8e580~~ ~~1.3e562~~ ~~9.3e516~~ ~~12818~~ ~~11024~~ ~~4452~~ ~~4332~~ ~~4240~~ ~~4200~~ ~~4180~~ ~~3852~~ ~~3656~~ ~~3616~~ ~~3540~~ 2485 + 3 = 2488 bytes
*Now fits in the observable universe!*
```
(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>
```
[Try it online!](https://tio.run/nexus/brain-flak#zVVBEoMgDLz3JcmhP2CY6TsYXsLwdhpIEaoE0KrTKgjrmmRhtQEAkVo8EErrzfPB4zXSY69b6949mQunjYzzfnO38ca1ztTSXo85bM9ovr9@3@r5lTnxdO/3FG390os662U5i@Tlnp@liO2q73Do2H8z@zTymlRlb9XPft/mdO39xoz2QVZ4TOteXVfp7Lv/376vv6iXn2u/B2f/e0nxjbEWHTgPqACM85ZQxQAqDelXojrPJw0NoCXGQqULnZnNHOqJXpFqSg6YSBzC@TVlyYigNPp4nwgxOaf3Pj@jADUBqXYVR9RrLLNI0Z9aFgQkgRgnqMvS0DUpZjhlrSNtIKUfIYTn6w0 "Brain-Flak – TIO Nexus")
---
## Explanation
This Quine works like most Quines in esoteric languages; it has two parts an encoder and a decoder. The encoder is all of the parentheses at the beginning and the decoder is the more complex part at the very end.
A naive way of encoding the program would be to put the ASCII value of every character in the decoder to the stack. This is not a very good idea because Brain-Flak only uses 8 characters (`()<>[]{}`) so you end up paying quite a few bytes to encode very little information. A smarter idea, and the one used up until now is to assign each of the 8 braces to an much smaller number (1-8) and convert these to the ASCII values with our decoder. This is nice because it costs no more than 18 bytes to encode a character as opposed to the prior 252.
However this program does neither. It relies on the fact that Brain-Flak programs are all balanced to encode the 8 braces with the numbers up to 5. It encodes them as follows.
```
( -> 2
< -> 3
[ -> 4
{ -> 5
),>,],} -> 1
```
All the close braces are assigned 1 because we can use context to determine which of them we need to use in a particular scenario. This may sound like a daunting task for a Brain-Flak program, but it really is not. Take for example the following encodings with the open braces decoded and the close braces replaced with a `.`:
```
(.
((..
<([.{...
```
Hopefully you can see that the algorithm is pretty simple, we read left to right, each time we encounter a open brace we push its close brace to an imaginary stack and when we encounter a `.` we pop the top value and put it in place of the `.`. This new encoding saves us an enormous number of bytes in the encoder while only losing us a handful of bytes on the decoder.
### Low level explanation
*Work in progress*
[Answer]
## GolfScript, 2 bytes
```
1
```
(note trailing newline) This pushes the number 1 onto the stack. At the end of the program, GolfScript prints out all items in the stack (with no spaces in between), then prints a newline.
This is a true quine (as listed in the question), because it actually executes the code; it doesn't just "read the source file and print it" (unlike the PHP submission).
---
For another example, here's a GolfScript program to print `12345678`:
```
9,(;
```
1. `9`: push 9 to the stack
2. [`,`](http://www.golfscript.com/golfscript/builtin.html#%2C): consume the 9 as an argument, push the array `[0 1 2 3 4 5 6 7 8]` to the stack
3. [`(`](http://www.golfscript.com/golfscript/builtin.html#%28): consume the array as an argument, push the array `[1 2 3 4 5 6 7 8]` and the item `0` to the stack
4. [`;`](http://www.golfscript.com/golfscript/builtin.html#%3B): discard the top item of the stack
The stack now contains the array `[1 2 3 4 5 6 7 8]`. This gets written to standard output with no spaces between the elements, followed by a newline.
[Answer]
# [Prelude](http://esolangs.org/wiki/Prelude), ~~5157~~ ~~4514~~ ~~2348~~ ~~1761~~ ~~1537~~ ~~664~~ ~~569~~ ~~535~~ ~~423~~ ~~241~~ ~~214~~ ~~184~~ ~~178~~ ~~175~~ ~~169~~ ~~148~~ ~~142~~ ~~136~~ 133 bytes
*Thanks to Sp3000 for saving 3 bytes.*
~~This is rather long...~~ (okay, it's still long ... at least it's beating the shortest ~~known Brainfuck~~ C# quine on this challenge now) *but* it's the first quine I discovered myself (my Lua and Julia submissions are really just translations of standard quine techniques into other languages) *and* as far as I'm aware no one has written a quine in Prelude so far, so I'm actually quite proud of this. :)
```
7( -^^^2+8+2-!( 6+ !
((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)
```
That large number of digits is just an encoding of the core code, which is why the quine is so long.
The digits encoding the quine have been generated with [this CJam script](http://cjam.aditsu.net/#code=qW%25%7Bi2%2BAb%7D%2F&input=7(%20-%5E%5E%5E2%2B8%2B2-!(%206%2B%20!%0A%20%20((%23%5E%23(1-%20)%23)8(1-)8)%23)).
This requires a standard-compliant interpreter, which prints characters (using the values as character codes). So if you're using [the Python interpreter](http://web.archive.org/web/20060504072747/http://z3.ca/~lament/prelude.py) you'll need to set `NUMERIC_OUTPUT = False`.
## Explanation
First, a few words about Prelude: each line in Prelude is a separate "voice" which manipulates its own stack. These stacks are initialised to an infinite number of 0s. The program is executed column by column, where all commands in the column are executed "simultaneously" based on the previous stack states. Digits are pushed onto the stack individually, so `42` will push a `4`, then a `2`. There's no way to push larger numbers directly, you'll have to add them up. Values can be copied from adjacent stacks with `v` and `^`. Brainfuck-style loops can be introduced with parentheses. See the link in the headline for more information.
Here is the basic idea of the quine: first we push loads of digits onto the stack which encode the core of the quine. Said core then takes those digits,decodes them to print itself and then prints the digits as they appear in the code (and the trailing `)`).
This is slightly complicated by the fact that I had to split the core over multiple lines. Originally I had the encoding at the start, but then needed to pad the other lines with the same number of spaces. This is why the initial scores were all so large. Now I've put the encoding at the end, but this means that I first need to skip the core, then push the digits, and jump back to the start and do the printing.
### The Encoding
Since the code only has two voices, and and adjacency is cyclic, `^` and `v` are synonymous. That's good because `v` has by far the largest character code, so avoiding it by always using `^` makes encoding simpler. Now all character codes are in the range 10 to 94, inclusive. This means I can encode each character with exactly two decimal digits. There is one problem though: some characters, notably the linefeed, have a zero in their decimal representation. That's a problem because zeroes aren't easily distinguishable from the bottom of the stack. Luckily there's a simple fix to that: we offset the character codes by `2`, so we have a range from 12 to 96, inclusive, that still comfortably fits in two decimal digits. Now of all the characters that can appear in the Prelude program, only `0` has a 0 in its representation (50), but we really don't need `0` at all. So that's the encoding I'm using, pushing each digit individually.
However, since we're working with a stack, the representations are pushed in reverse. So if you look at the end of the encoding:
```
...9647344257
```
Split into pairs and reverse, then subtract two, and then look up the character codes:
```
57 42 34 47 96
55 40 32 45 94
7 ( - ^
```
where `32` is corresponds to spaces. The core does exactly this transformation, and then prints the characters.
### The Core
So let's look at how these numbers are actually processed. First, it's important to note that matching parentheses don't have to be on the same line in Prelude. There can only be one parenthesis per column, so there is no ambiguity in which parentheses belong together. In particular, the vertical position of the closing parenthesis is always irrelevant - the stack which is checked to determine whether the loop terminates (or is skipped entirely) will always be the one which has the `(`.
We want to run the code exactly twice - the first time, we skip the core and push all the numbers at the end, the second time we run the core. In fact, after we've run the core, we'll push all those numbers again, but since the loop terminates afterwards, this is irrelevant. This gives the following skeleton:
```
7(
( )43... encoding ...57)
```
First, we push a `7` onto the first voice - if we don't do this, we'd never enter the loop (for the skeleton it's only important that this is non-zero... why it's specifically `7` we'll see later). Then we enter the main loop. Now, the second voice contains another loop. On the first pass, this loop will be skipped because the second stack is empty/contains only 0s. So we jump straight to the encoding and push all those digits onto the stack. The `7` we pushed onto the first stack is still there, so the loop repeats.
This time, there is also a `7` on the second stack, so we do enter loop on the second voice. The loop on the second voice is designed such that the stack is empty again at the end, so it only runs once. It will *also* deplete the first stack... So when we leave the loop on the second voice, we push all the digits again, but now the `7` on the first stack has been discarded, so the main loop ends and the program terminates.
Next, let's look at the first loop in the actual core. Doing things simultaneously with a `(` or `)` is quite interesting. I've marked the loop body here with `=`:
```
-^^^2+8+2-!
(#^#(1- )#)
==========
```
That means the column containing `(` is not considered part of the loop (the characters there are only executed once, and even if the loop is skipped). But the column containing the `)` *is* part of the loop and is ran once on each iteration.
So we start with a single `-`, which turns the `7` on the first stack into a `-7`... again, more on that later. As for the actual loop...
The loop continues while the stack of digits hasn't been emptied. It processes two digits at a time,. The purpose of this loop is to decode the encoding, print the character, and at the same time shift the stack of digits to the first voice. So this part first:
```
^^^
#^#
```
The first column moves the 1-digit over to the first voice. The second column copies the 10-digit to the first voice while also copying the 1-digit back to the second voice. The third column moves that copy back to the first voice. That means the first voice now has the 1-digit twice and the 10-digit in between. The second voice has only another copy of the 10-digit. That means we can work with the values on the tops of the stacks and be sure there's two copies left on the first stack for later.
Now we recover the character code from the two digits:
```
2+8+2-!
(1- )#
```
The bottom is a small loop that just decrements the 10-digit to zero. For each iteration we want to add 10 to the top. Remember that the first `2` is not part of the loop, so the loop body is actually `+8+2` which adds 10 (using the `2` pushed previously) and the pushes another 2. So when we're done with the loop, the first stack actually has the base-10 value and another 2. We subtract that 2 with `-` to account for the offset in the encoding and print the character with `!`. The `#` just discards the zero at the end of the bottom loop.
Once this loop completes, the second stack is empty and the first stack holds all the digits in reverse order (and a `-7` at the bottom). The rest is fairly simple:
```
( 6+ !
8(1-)8)#
```
This is the second loop of the core, which now prints back all the digits. To do so we need to 48 to each digit to get its correct character code. We do this with a simple loop that runs `8` times and adds `6` each time. The result is printed with `!` and the `8` at the end is for the next iteration.
So what about the `-7`? Yeah, `48 - 7 = 41` which is the character code of `)`. Magic!
Finally, when we're done with that loop we discard the `8` we just pushed with `#` in order to ensure that we leave the outer loop on the second voice. We push all the digits again and the program terminates.
[Answer]
# Javascript ES6 - 21 bytes
```
$=_=>`$=${$};$()`;$()
```
I call this quine "The Bling Quine."
Sometimes, you gotta golf in style.
[Answer]
# Vim, 11 bytes
```
q"iq"qP<Esc>hqP
```
* `iq"qP<Esc>`: Manually insert a duplicate of the text that *has to be* outside the recording.
* `q"` and `hqP`: Record the inside directly into the unnamed `""` register, so it can be pasted in the middle. The `h` is the only repositioning required; if you put it inside the macro, it will be pasted into the result.
**Edit**
A note about recording with `q"`: The unnamed register `""` is a funny thing. It's not really a true register like the others, since text isn't stored there. It's actually a pointer to some other register (usually `"-` for deletes with no newline, `"0` for yanks, or `"1` for deletes with a newline). `q"` breaks the rules; it actually writes to `"0`. If your `""` was already pointing to some register other than `"0`, `q"` will overwrite `"0` but leave `""` unchanged. When you start a fresh Vim, `""` automatically points to `"0`, so you're fine in that case.
Basically, Vim is weird and buggy.
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), side length ~~15 14 13~~ 12, ~~616 533 456~~ 383 bytes
After several days of careful golfing, rearranging loops and starting over, I've *finally* managed to get it down to a side 12 hexagon.
```
1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>
```
[Try it online!](https://tio.run/##bcxNSsRAEAXgsxhGGnFM6r@qne7gEXSfjQvRlW719LEyGIXBBw3V1Ffv7eXz@fXj/WtdMUQd0UkApFYBdDNwUSYJAA9WoUBQCVdV5lAFYHFgAgZiwoSGis4gCNWjqknyyLXUUHYMk3xIlVggCOrWAMrBwu4UTObu6lxNzY2rK4krikXeBdVAs/wxVctrq6yhMQzzOLXD6a6NW@bjuKf337ENP0Pqcma3ZRnnf@guE97PN@3Qs/bPnXPYVZqlPMmpD9PDhdl7kjz2ct0uOrbtVWnj0u1YpnldvwE "Hexagony – Try It Online")
Unfolded:
```
1 8 4 5 7 1 1 7 2 4 0 0
4 9 9 4 0 1 7 6 6 0 7 4 5
3 2 4 8 0 0 7 8 3 5 4 2 8 1
0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
" " > . / < $ ; - < . . . . . > , . . . . . .
. . . = = . . . . . . . . . < " . . . . . .
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
. . . . . . . . . $ . . < " . . . .
" " > \ ' Q 4 ; = " / @ > . . . .
. . . . . . . . . . . < " . . .
. . " " > P = ' % < . > . . .
. . . . . . . . . . < " . .
! ' < . \ = 6 , ' / > . .
. . . . . . . . . . . .
```
While it doesn't look like the most golfed of Hexagony code, the type of encoding I used is optimised for longer runs of no-ops, which is something you would otherwise avoid.
### Explanation
This beats the [previous Hexagony answer](https://codegolf.stackexchange.com/a/74294/76162) by encoding the no-ops (`.`) in a different way. While that answer saves space by making every other character a `.`, mine encodes the *number* of no-ops. It also means the source doesn't have to be so restricted.
Here I use a base 80 encoding, where numbers below 16 indicate runs of no-ops, and numbers between 16 and 79 represent the range 32 (`!`) to 95 (`_`) (I'm just now realising I golfed all the `_`s out of my code lol). Some Pythonic pseudocode:
```
i = absurdly long number
print(i)
base = 80
n = i%base
while n:
if n < 16:
print("."*(16-n))
else:
print(ASCII(n+16))
i = i//base
n = i%base
```
The number is encoded in the first half of the hexagon, with all the
```
" " >
" " >
... etc
```
on the left side and the
```
> ,
< "
>
< "
... etc
```
on the right side redirecting the pointer to encode the number into one cell. This is taken from [Martin Ender's answer](https://codegolf.stackexchange.com/a/74294/76162) (thanks), because I couldn't figure out a more efficient way.
It then enters the bottom section through the `->`:
```
" " > \ ' Q 4 ; = " / @ > . . . .
. . . . . . . . . . . < " . . .
. . " " > P = ' % < . > . . .
. . . . . . . . . . < " . .
-> ! ' < . \ = 6 , ' / > . .
```
`!` prints the number and `'` navigates to the right memory cell before starting the loop. `P='%` mods the current number by 80. If the result is 0, go up to the terminating `@`, else go down and create a cell next to the mod result with the value `-16`.
```
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
. . . . . . . . . $ . . < " . . . .
" " > \ ' Q 4 ; = " / @ > . . . .
/
/
```
Set the cell to (mod value + -16). If that value is negative, go up at the branching `>+'\`, otherwise go down.
If the value is positive:
```
" " > . / < $ ; - < . . . . . > , . . . . . .
. . . = = . . . . . . . . . < " . . . . . .
. " " > ' . . . . > + ' \ . > . . . . . .
```
The pointer ends up at the `;-<` which sets the cell to (mod value - -16) and print it.
The the value is negative:
```
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
```
Go down to the `> ) <` section which starts the loop. Here it is isolated:
```
. . > ) < $ = < . .
. . . . . . . . .
\ ' Q 4 ; = " /
```
Which executes the code `'Q4;="=` which prints a `.` (thanks again to Martin Ender, who wrote a [program](http://cjam.aditsu.net/#code=q%3AC%3B%27%5B%2C_el%5EA%2Cm*%7B_Ab256%25c%5C%2B%7D%25%7B0%3DC%26%7D%2C1f%3EN*&input=.) to find the letter-number combinations for characters) and moves back to the starting cell. It then increments (`)`) the mod value cell and loops again, until the mod value is positive.
When that is done, it moves up and joins with the other section at:
```
" " > . / < $ ; - < . . .
\
\
```
The pointer then travels back to the start of the larger loop again
```
" " > . / <--
. . . = =
. " " > '
. . . = =
. " " > :
. . . . .
" " > \ ' . .
. . . . . . .
. . " " > P = ' % < . > . . .
```
This executes `='=:'` which divides the current number by 80 and navigates to the correct cell.
### Old version (Side length 13)
```
343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""
```
[Try it online!](https://tio.run/##fY/NSgUxDIWfxaKMV7DT/DS38bbFV3A/GxHRlW716cekM4jixUJ/wvnOSfr6/PH48v72ua7ExIqIfCQVYGT1ShIpEYKg7USbBqpWozsQiCWl4rWwuwUyZM1YQFE2Jg1GxFR7q9ee6Bqoa2AuATAeE2fvyqaD7kwZflc902exlG/1OFTgZI7i82YlkWRzFFKbZ1Ah9Hm6a/XyNNXoq1/Hs6uG7TaDX5OjbbHjP3qH@6HG2/ibbe0nOcCw5879fJ5BywOfqM3x/k9fJ0KI/enQpqs6el3Ylxa4adMclxDW9Qs)
~~I can most definitely golf another side length off this, but I'll have to leave it til' tomorrow because it's getting late.~~ Turns out I'm impatient and can't wait until tomorrow. ~~Maybe another side can be golfed?~~ ~~:(~~ *ahhhhhhhhh* i did it!
I even golfed off a [couple of extra digits](https://tio.run/##fZPLTsMwEEX3@YoBFUUIMH7FcWhr8QMs2GfTBYIVbOHrw52x86S0o4ztyfHN9ST9ePs@vX99/gwDLX4tBfJkKCJbcpjxqq0WSAeoQbYYc@ZVoLiAAmpWqg0i4vKICEE9Ux7lFtnhCqQF1zJqChNmWBpiBtHgjhE5hwqHqyZXTopaJFtgTrZ68YfDFFBjO1e1uNbyaGa0PMbw/kw68efLITLgC@ow56N3gjZYtaVXnWSuWLEThDRsilkrXbHiIjc5Yh1xO8rRcj@zsBbRWI6bpceus7Sao0KqEYke6UA72tMDxhlIdL/Gy@yIUH/iAKU1Xab14kaiO6x6mW3gC@Ir6dzn0fkTrltxfyze0xY943W3lR2/hyzaI7@id3uIXqM5z7Po9IGpszFJzt@rmry@QK6mG/GZttglueX/6AolFughFvCCavhLW@gfd2oYfgE) with a base 77 encoding, but it doesn't really matter, since it has the same bytecount.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 20 bytes
```
3434Qu$v@!<"OOw\o;/"
```
*Almost got the* `\o/`...
**Net**:
```
3 4
3 4
Q u $ v @ ! < "
O O w \ o ; / "
. .
. .
```
# Try it online
Try it [here](https://ethproductions.github.io/cubix/?code=MzQzNFF1JC9AITwiT093XG87LyI=)!
# Additional notes
## Background story
After being impressed by reading [this great answer](https://codegolf.stackexchange.com/a/103532/63774) by @ais523, I started thinking about further golfing the quine. After all, there were quite a few no-ops in there, and that didn't feel very compressed. However, as the technique his answer (and mine as well) uses, requires the code to span full lines, a saving of at least 12 bytes was needed. There was one remark in his explanation that really got me thinking:
>
> On the subject of golfing down this quine further, [...] it'd need [...] some other way to represent the top face of the cube [...]
>
>
>
Then, suddenly, as I stood up and walked away to get something to drink, it struck me: What if the program didn't use character codes, but rather numbers to represent the top face? This is especially short if the number we're printing has 2 digits. Cubix has 3 one-byte instructions for pushing double-digit numbers: `N`, `S` and `Q`, which push `10`, `32` and `34` respectively, so this should be pretty golfy, I thought.
The first complication with this idea is that the top face is now filled with useless numbers, so we can't use that anymore. The second complication is that the top face has a size which is the cube size squared, and it needed to have an even size, otherwise one number would also end up on the starting position of the instruction pointer, leading to a polluted stack. Because of these complications, my code needed to fit on a cube of size 2 (which can contain 'only' 24 bytes, so I had to golf off at least 21 bytes). Also, because the top and bottom faces are unusable, I only had 16 effective bytes.
So I started by choosing the number that would become half of the top face. I started out with `N` (10), but that didn't quite work out because of the approach I was taking to print everything. Either way, I started anew and used `S` (32) for some reason. That did result in a proper quine, or so I thought. It all worked very well, but the quotes were missing. Then, it occured to me that the `Q` (34) would be really useful. After all, 34 is the character code of the double quote, which enables us to keep it on the stack, saving (2, in the layout I used then) precious bytes. After I changed the IP route a bit, all that was left was an excercise to fill in the blanks.
## How it works
The code can be split up into 5 parts. I'll go over them one by one. Note that we are encoding the middle faces in reverse order because the stack model is first-in-last-out.
### Step 1: Printing the top face
The irrelevant instructions have been replaced by no-ops (`.`). The IP starts the the third line, on the very left, pointing east. The stack is (obviously) empty.
```
. .
. .
Q u . . . . . .
O O . . . . . .
. .
. .
```
The IP ends at the leftmost position on the fourth line, pointing west, about to wrap around to the rightmost position on that same line. The instructions executed are (without the control flow character):
```
QOO
Q # Push 34 (double quotes) to the stack
OO # Output twice as number (the top face)
```
The stack contains just 34, representlng the last character of the source.
### Step 2: Encode the fourth line
This bit pretty much does what you expect it to do: encode the fourth line. The IP starts on the double quote at the end of that line, and goes west while pushing the character codes of every character it lands on until it finds a matching double quote. This matching double quote is also the last character on the fourth line, because the IP wraps again when it reaches the left edge.
Effectively, the IP has moved one position to the left, and the stack now contains the representation of the fourth line in character codes and reverse order.
### Step 3: Push another quote
We need to push another quote, and what better way than to recycle the `Q` at the start of the program by approaching it from the right? This has the added bonus that the IP directly runs into the quote that encodes the third line.
Here's the net version for this step. Irrelevant intructions have been replaced by no-ops again, the no-ops that are executed have been replaced by hashtags (`#`) for illustration purposes and the IP starts at the last character on the fourth line.
```
. .
. .
Q u $ . . . . .
. . w \ . . / .
. #
. #
```
The IP ends on the third line at the first instruction, about to wrap to the end of that line because it's pointing west. The following instructions (excluding control flow) are excecuted:
```
$uQ
$u # Don't do anthing
Q # Push the double quote
```
This double quote represents the one at the end of the third line.
### Step 4: Encoding the third line
This works exactly the same as step 2, so please look there for an explanation.
### Step 5: Print the stack
The stack now contains the fourth and third lines, in reverse order, so all we need to do now, it print it. The IP starts at the penultimate instruction on the third line, moving west. Here's the relevant part of the cube (again, irrelevant parts have been replaced by no-ops).
```
. .
. .
. . . v @ ! < .
. . . \ o ; / .
. .
. .
```
This is a loop, as you might have seen/expected. The main body is:
```
o;
o # Print top of stack as character
; # Delete top of stack
```
The loop ends if the top item is 0, which only happens when the stack is empty. If the loop ends, the `@` is executed, ending the program.
[Answer]
## Brainf\*ck (755 characters)
This is based off of a technique developed by Erik Bosman (ejbosman at cs.vu.nl). Note that the "ESultanik's Quine!" text is actually necessary for it to be a quine!
```
->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
```
[Answer]
# Vim, ~~17~~, 14 keystrokes
Someone randomly upvoted this, so I remembered that it exists. When I re-read it, I thought "Hey, I can do better than that!", so I golfed two bytes off. It's still not the shortest, but at least it's an improvement.
---
For a long time, I've been wondering if a vim quine is possible. On one hand, it must be possible, since vim is turing complete. But after looking for a vim quine for a really long time, I was unable to find one. I *did* find [this PPCG challenge](https://codegolf.stackexchange.com/questions/2985/compose-a-vim-quine), but it's closed and not exactly about literal quines. So I decided to make one, since I couldn't find one.
I'm really proud of this answer, because of two *firsts*:
1. This is the first quine I have ever made, and
2. As far as I know, this is the worlds first *vim-quine* to ever be published! I could be wrong about this, so if you know of one, please let me know.
So, after that long introduction, here it is:
```
qqX"qpAq@q<esc>q@q
```
[Try it online!](https://tio.run/nexus/v#@19YGKFUWOBY6FAoDcT//wMA "V – TIO Nexus")
Note that when you type this out, it will display the `<esc>` keystroke as `^[`. This is still accurate, since `^[` represents `0x1B`, which is escape [in ASCII](http://www.asciitable.com/), and the way vim internally represents the `<esc>` key.
*Also* note, that testing this might fail if you load an existing vim session. I wrote a [tips](/questions/tagged/tips "show questions tagged 'tips'") answer explaining that [here](https://codegolf.stackexchange.com/a/74663/31716), if you want more information, but basically you need to launch vim with
```
vim -u NONE -N -i NONE
```
*or* type `qqq` before running this.
Explanation:
```
qq " Start recording into register 'q'
X " Delete one character before the cursor (Once we play this back, it will delete the '@')
"qp " Paste register 'q'
Aq@q<esc> " Append 'q@q' to this line
q " Stop recording
@q " Playback register 'q'
```
On a side note, this answer is probably a world record for most 'q's in a PPCG answer, or something.
[Answer]
# PostScript, 20 chars
Short and legit. 20 chars including trailing newline.
```
(dup == =)
dup == =
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 45 bytes
```
.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"
```
You can test this code [here](https://ethproductions.github.io/cubix/?code=Li4uLi4+Li4uUiRSLi4uLlcuLl4iLjxSLiEnLlwpISciUkA+Pm87Py9vJ3Ui&input=&speed=20).
This program is fairly hard to follow, but to have any chance to do so, we need to start by expanding it into a cube, like the Cubix interpreter does:
```
. . .
. . >
. . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
. . .
. . .
. . .
```
This is a Befunge-style quine, which works via exploiting wrapping to make string literals "wrap around" executable code (with only one `"` mark, the code is both inside and outside the quote at the same time, something that becomes possible when you have programs that are nonlinear and nonplanar). Note that this fits our definition of a proper quine, because two of the double quotes don't encode themselves, but rather are calculated later via use of arithmetic.
Unlike Befunge, though, we're using four strings here, rather than one. Here's how they get pushed onto the stack;
1. The program starts at the top of the left edge, going rightwards; it turns right twice (`R`), making it go leftwards along the third and last of the lines that wrap around the whole cube. The double quote matches itself, so we push the entire third line onto the stack backwards. Then execution continues after the double quote.
2. The `u` command does a U-turn to the right, so the next thing we're running is from `'"` onwards on the middle line. That pushes a `"` onto the stack. Continuing to wrap around, we hit the `<` near the left hand side of the cube and bounce back. When approaching from this direction, we see a plain `"` command, not `'"`, so the entire second line is pushed onto the stack backwards above the third line and the double quote.
3. We start by pushing a `!` onto the stack (`'!`) and incrementing it (`)`); this produces a double quote without needing a double quote in our source code (which would terminate the string). A mirror (`\`) reflects the execution direction up northwards; then the `W` command sidesteps to the left. This leaves us going upwards on the seventh column, which because this is a cube, wraps to leftwards on the third row, then downwards on the third column. We hit an `R`, to turn right and go leftwards along the top row; then the `$` skips the `R` via which we entered the program, so execution wraps round to the `"` at the end of the line, and we capture the first line in a string the same way that we did for the second and third.
4. The `^` command sends us northwards up the eleventh column, which is (allowing for cube wrapping) southwards on the fifth. The only thing we encounter there is `!` (skip if nonzero; the top of the stack is indeed nonzero), which skips over the `o` command, effectively making the fifth column entirely empty. So we wrap back to the `u` command, which once again U-turns, but this time we're left on the final column southwards, which wraps to the fourth column northwards. We hit a double quote during the U-turn, though, so we capture the entire fourth column in a string, from bottom to top. Unlike most double quotes in the program, this one doesn't close itself; rather, it's closed by the `"` in the top-right corner, meaning that we capture the nine-character string `...>.....`.
So the stack layout is now, from top to bottom: fourth column; top row; `"`; middle row; `"`; bottom row. Each of these are represented on the stack with the first character nearest the top of the stack (Cubix pushes strings in the reverse of this order, like Befunge does, but each time the IP was moving in the opposite direction to the natural reading direction, so it effectively got reversed twice). It can be noted that the stack contents are almost identical to the original program (because the fourth column, and the north/top face of the cube, contain the same characters in the same order; obviously, it was designed like that intentionally).
The next step is to print the contents of the stack. After all the pushes, the IP is going northwards on the fourth column, so it hits the `>` there and enters a tight loop `>>o;?` (i.e. "turn east, turn east, output as character, pop, turn right if positive"). Because the seventh line is full of NOPs, the `?` is going to wrap back to the first `>`, so this effectively pushes the entire contents of the stack (`?` is a no-op on an empty stack). We almost printed the entire program! Unfortunately, it's not quite done yet; we're missing the double-quote at the end.
Once the loop ends, we reflect onto the central line, moving west, via a pair of mirrors. (We used the "other side" of the `\` mirror earlier; now we're using the southwest side. The `/` mirror hasn't been used before.) We encounter `'!`, so we push an exclamation mark (i.e. 33; we're using ASCII and Cubix doesn't distinguish between integers and characters) onto the stack. (Conveniently, this is the same `!` which was used to skip over the `o` command earlier.) We encounter a pair of `R` commands and use them to make a "manual" U-turn (the second `R` command here was used earlier in order to reach the first row, so it seemed most natural to fit another `R` command alongside it.) The execution continues along a series of NOPs until it reaches the `W` command, to sidestep to the left. The sidestep crashes right into the `>` command on the second line, bouncing execution back exactly where it was. So we sidestep to the left again, but this time we're going southwards, so the next command to execute is the `)` (incrementing the exclamation mark into a double quote), followed by an `o` (to output it). Finally, execution wraps along the eighth line to the second column, where it finds a `@` to exit the program.
I apologise for the stray apostrophe on the third line. It doesn't do anything in this version of the program; it was part of an earlier idea I had but which turned out not to be necessary. However, once I'd got a working quine, I just wanted to submit it rather than mess around with it further, especially as removing it wouldn't change the byte count. On the subject of golfing down this quine further, it wouldn't surprise me if this were possible at 3×3 by only using the first five lines, but I can't see an obvious way to do that, and it'd need even tighter packing of all the control flow together with some other way to represent the top face of the cube (or else modifying the algorithm so that it can continue to use the fourth column even though it'd now be ten or eleven characters long).
[Answer]
# Python 2, 30 bytes
```
_='_=%r;print _%%_';print _%_
```
[Taken from here](https://web.archive.org/web/20130701215340/http://en.literateprograms.org/Quine_(Python))
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 261 bytes, side length 10
```
113009344778658560261693601386118648881408495353228771273368412312382314076924170567897137624629445942109467..../....%'=g':..\..................\.................\................\...............\..............\.............\............\!$/'?))='%<\..>:;/$;4Q/
```
[Try it online!](https://tio.run/##hYk7DsIwEETPgpTISmPvz7vrhMAZ6N1QoFBBC6c3pkbAaPSkN3O9PM7b/fZsDZEBCouYuWbPCqSohRWQXRFdxd1RwKVkzkzkZkjGrC5I3OudAqaFBA2ymhdDNiVRKiK5CCEUUYs96Y0xrFuYY6zxI/X/Un97/W51N6RwnKY1jPt@HOYlDYucUmsv "Hexagony – Try It Online")
Uses the same encoding [user202729's answer](https://codegolf.stackexchange.com/a/156271/76162), but terminates in a divide by zero error.
Formatted, this looks like:
```
1 1 3 0 0 9 3 4 4 7
7 8 6 5 8 5 6 0 2 6 1
6 9 3 6 0 1 3 8 6 1 1 8
6 4 8 8 8 1 4 0 8 4 9 5 3
5 3 2 2 8 7 7 1 2 7 3 3 6 8
4 1 2 3 1 2 3 8 2 3 1 4 0 7 6
9 2 4 1 7 0 5 6 7 8 9 7 1 3 7 6
2 4 6 2 9 4 4 5 9 4 2 1 0 9 4 6 7
. . . . / . . . . % ' = g ' : . . \
. . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . \
. . . . . . . . . . . . . \
. . . . . . . . . . . . \
! $ / ' ? ) ) = ' % < \
. . > : ; / $ ; 4 Q /
. . . . . . . . . .
```
[Try it online!](https://tio.run/##hZC9DsIwDIT3PsUhtapY6F@atEDhGdi7MKAywQpPH84mBAbU9iTbtb@cnFwvj/N0vz29R/wqqkFJ9cyGckkcOnSwaBlb5hI1YxXHVo9IXyyEFLMuiWPDpqhiVTIbHmjRBIAVDWv2HVWxcuyIYbAw2mxC7EItVg5WkZ49oRx7sqHs26tZ82EEsIy93q3VXBMotbJ6201QEasMOQZMjFv9H5M4mtP4YzZPLUOAXnGRemOLVMCW1ppDIoAVUj5WjiPW1MAqw/5nrviBb7cjljIanFB8x//svX8B "Hexagony – Try It Online")
Some python-like psuedo-code to explain:
```
n = ridiculously long number
base = 103
print(n)
while n > 0:
b = 2
if n%b == 1:
c = '.'
print(c)
else:
n = n//b
b = base
c = chr(n%b + 1)
print(c)
n = n//b
```
I'm using base 103 rather than the optimal base 97 just to make sure the number fully fits the top half of the hexagon and doesn't leave an extra `.` to encode.
Here's a [link](https://tio.run/##jZJPU4MwEMXv@RRPploilv7RE5Z60ItHp0frIUIgGSl0Qsb22@MmYMdTMZmE7L5fdl52UKL9klXVdXp/aIzFi7AiflbCMCbrrMklkgRba3RdYrbBa21lKc2v1lqkKDBBoSsrDcK6sbFutweRSU4qw1FJIxkxQYB@pFi4OJzG08Qty30Ni9sVoqWXMgX4PAN0gcU6zXWpLW5u4A/rT9FSUVgla4T@LlwKUa9zileky4py0piGnAXuUSJzLgNEEd4z9eG@AXQLso1vUek84HTNe@4rkTXbDI9G2JgcmeKYoSmKVlrG9kLXxGgiXHHqRKuaYxzuTrNNeLpDJevSqiGNE@dx3znGvN8Uy8U964u5oOuAeJjz8@kaUxJL2hMf79hZujQJ@yc1DgEOG6d6bJQasDFbl5AzgCtq75ya8wQO9y9NqWHrP7rHN9S7R8ImtD/gDfMf) to user202729's encoder that I used to get the large number and check that the number actually fit in the hexagon.
[Answer]
# C, ~~64~~ 60 bytes
```
main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
```
This may segfault on 64-bit systems with some compilers, such as newest Clang, due to the type of `s` being interpreted as 32-bit `int` instead of a pointer.
So far, this is the shortest known C quine. There's an [extended bounty](https://codegolf.meta.stackexchange.com/a/12581/61563) if you find a shorter one.
This works in [GCC](https://tio.run/##S9ZNT07@/z83MTNPo1izuqAoM68kTaPYVglDRDVZtVjVUCVZx9hEp1jTulYJxvj/HwA), [Clang](https://tio.run/##S9ZNzknMS///PzcxM0@jWLO6oCgzryRNo9hWCUNENVm1WNVQJVnH2ESnWNO6VgnG@P8fAA), and [TCC](https://tio.run/##S9YtSU7@/z83MTNPo1izuqAoM68kTaPYVglDRDVZtVjVUCVZx9hEp1jTulYJxvj/HwA) in a [POSIX](https://en.wikipedia.org/wiki/POSIX) environment. It invokes an excessive amount of undefined behavior with all of them.
Just for fun, here's a [repo](https://github.com/aaronryank/quines/tree/master/c) that contains all the C quines I know of. Feel free to fork/PR if you find or write a different one that adds something new and creative over the existing ones.
Note that it only works in an [ASCII](https://en.wikipedia.org/wiki/ASCII) environment. [This](https://pastebin.com/raw/MESjTMQt) works for [EBCDIC](https://en.wikipedia.org/wiki/EBCDIC), but still requires [POSIX](https://en.wikipedia.org/wiki/POSIX). Good luck finding a POSIX/EBCDIC environment anyway :P
---
How it works:
1. `main(s)` abuses `main`'s arguments, declaring a virtually untyped variable `s`. (Note that `s` is not actually untyped, but since listed compilers auto-cast it as necessary, it might as well be\*.)
2. `printf(s="..."` sets `s` to the provided string and passes the first argument to `printf`.
3. `s` is set to `main(s){printf(s=%c%s%1$c,34,s);}`.
4. The `%c` is set to ASCII `34`, `"`. This makes the quine possible. Now `s` looks like this:
`main(s){printf(s="%s%1$c,34,s);}`.
5. The `%s` is set to `s` itself, which is possible due to #2. Now `s` looks like this:
`main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}`.
6. The `%1$c` is set to ASCII 34 `"`, `printf`'s first\*\* argument. Now `s` looks like this:
`main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}`
... which just so happens to be the original source code.
\* [Example](https://tio.run/##S9ZNT07@/185My85pzQlVcGmuCQlM18vw46LKzOvRCE3MTNPoyw/M0WTq5pLAQhAghkKtgpKHqk5Ofk6CuH5RTkpikrWYMmC0pJijQxNa67a//8B) thanks to @Pavel
\*\* first argument after the format specifier - in this case, `s`. It's impossible to reference the format specifier.
---
I think it's impossible that this will get any shorter with the same approach. If `printf`'s format specifier was accessible via `$`, this would work for 52 bytes:
```
main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
```
---
Also here's a longer 64-byte version that will work on all combinations of compilers and ASCII environments that support the POSIX printf `$` extension:
```
*s;main(){printf(s="*s;main(){printf(s=%c%s%1$c,34,s);}",34,s);}
```
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), ~~120 116 98 96 76 70~~ 66 bytes
Edit: yay, under 100
Edit: Saved a bunch o' bytes by switching to all `/`s on the bottom line
```
:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////
```
[Try it online!](https://tio.run/##y8kvLvn/38pI29RIy9JUy0jbzsrK0N4q2ioaCBziVO3tNKIVlLj0CQCu////6zoCAA) + [verification it's deterministic for all possible states](https://tio.run/##y8kvLvn/38pI29RIy9JUy0jbzsrK0N4q2ioaCBziVO3tNKIVlLj0CQCu////6zoGAgA)
Lost is a 2D language in which the starting position and direction are completely random. This means there has to be a lot of error-checking at every stage to make sure you've got the correct instruction pointer, and it isn't one that has just wandered in randomly.
### Explanation:
All the `/`s on the bottom line are there to make sure that all the pointers that spawn in a vertical direction or on the bottom line get funneled in the right direction. From there, they end up at several different places, but all of them end up going right into the
```
^%?>
////
```
Which clears out all the non-zero numbers in the stack. The `([` after that clears out any extra 0s as well.
In the middle of the clear, it hits the `%`, which turns the 'safety' off, which allows the program to end when it hits the `@` (without this, the program could end immediately if a pointer started at the `@`).
From there it does a pretty simple 2D language quine, by wrapping a string literal (`"`) around the first line, pushing a `"` character by duping a space (`:2+`) and then a newline (`52*`). For the second line, it creates a `/` character (`95*2+`) and duplicates it a bunch (`>::1?:[:[[[[`), before finally ending at the `@` and printing the stack implicitly. The `?1` is to stop the process from creating too many 0s if the pointer enters early, saving on having to clear them later.
I saved 20 bytes here by making the last line all the same character, meaning I could go straight from the duping process into the ending `@`.
### Explanation about the duping process:
`[` is a character known as a 'Door'. If the pointer hits the flat side of a `[` or a `]` , it reflects, else it passes through it. Each time the pointer interacts with a Door, it switches to the opposite type. Using this knowledge we can construct a simple formula for how many times an instruction will execute in a `>:[` block.
Add the initial amount of instructions. For each `[`, add 2 times the amount of instructions to the left of it. For the example `>::::[:[[[`, we start with 5 as the initial amount. The first Door has 4 dupe instructions, so we add 4\*2=8 to 5 to get 13. The other three Doors have 5 dupes to their left, so we add 3\*(5\*2)=30 to 13 to get 43 dupe instructions executed, and have 44 `>`s on the stack. The same process can be applied to other instructions, such as `(` to push a large amount of items from the stack to the scope, or as used here, to clear items from the stack.
A trick I've used here to avoid duping too many 0s is the `1?`. If the character is 0, the `?` doesn't skip the 1, which means it duplicates 1 for the remainder of the dupe. This makes it *much* easier to clear the stack later on.
[Answer]
# [Chicken](http://esolangs.org/wiki/Chicken), 7
```
chicken
```
No, this is not directly echoed :)
[Answer]
## Cross-browser JavaScript (41 characters)
It works in the top 5 web browsers (IE >= 8, Mozilla Firefox, Google Chrome, Safari, Opera). Enter it into the developer's console in any one of those:
```
eval(I="'eval(I='+JSON.stringify(I)+')'")
```
It's not "cheating" — unlike Chris Jester-Young's single-byte quine, as it could easily be modified to use the `alert()` function (costing 14 characters):
```
alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))
```
Or converted to a bookmarklet (costing 22 characters):
```
javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
```
[Answer]
# [Fission](http://esolangs.org/wiki/Fission), 6 bytes
It appears this is now the shortest "proper" quine among these answers.
```
'!+OR"
```
## Explanation
Control flow starts at `R` with a single right-going `(1,0)` atom. It hits `"` toggling print mode and then wraps around the line, printing `'!+OR` before hitting the same `"` again and exiting print mode.
That leaves the `"` itself to be printed. The shortest way is `'"O` (where `'"` sets the atom's mass to the character code of `"` and `O` prints the character and destroys the atom), but if we did this the `"` would interfere with print mode. So instead we set the atom's value to `'!` (one less than `"`), then increment with `+` and *then* print the result with `O`.
## Alternatives
Here are a couple of alternatives, which are longer, but maybe their techniques inspire someone to find a shorter version using them (or maybe they'll be more useful in certain generalised quines).
### 8 bytes using `J`ump
```
' |R@JO"
```
Again, the code starts at `R`. The `@` swaps mass and energy to give `(0,1)`. Therefore the `J` makes the atom jump over the `O` straight onto the `"`. Then, as before, all but the `"` are printed in string mode. Afterwards, the atom hits `|` to reverse its direction, and then passes through `'"O` printing `"`. The space is a bit annoying, but it seems necessary, because otherwise the `'` would make the atom treat the `|` as a character instead of a mirror.
### 8 bytes using two atoms
```
"'L;R@JO
```
This has two atoms, starting left-going from `L` and right-going from `R`. The left-going atom gets its value set by `'"` which is then immediately printed with `O` (and the atom destroyed). For the right-going atom, we swap mass and energy again, jump over the `O` to print the rest of the code in print mode. Afterwards its value is set by `'L` but that doesn't matter because the atom is then discarded with `;`.
[Answer]
## Java, 528 bytes:
A Java solution with an original approach:
```
import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}
```
in readable form:
```
import java.math.*;
class a
{
public static void main (String [] a)
{
BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36);
int i=0;
for (byte c:b.toByteArray ())
{
if (++i==92)
System.out.print (b.toString (36));
System.out.print ((char) c);
}
}
}
```
[Answer]
These are the two shortest **Ruby** quines [from SO](https://stackoverflow.com/questions/2474861/shortest-ruby-quine/2475931#2475931):
```
_="_=%p;puts _%%_";puts _%_
```
and
```
puts <<2*2,2
puts <<2*2,2
2
```
Don't ask me how the second works...
[Answer]
## [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~20~~ ~~14~~ ~~9~~ 7 bytes
Before we get started, I'd like to mention the trivial solution of a file which contains a single `0`. In that case Retina will try to count the `0`s in the empty input, the result of which is also `0`. I wouldn't consider that a proper quine though.
So here is a proper one:
```
>\`
>\`
```
[Try it online!](https://tio.run/##K0otycxLNPz/3y4mgQuI//8HAA "Retina – Try It Online")
Alternatively, we could use `;` instead of `>`.
### Explanation
The program consists of a single replacement which we print twice.
In the first line, the ``` separates the configuration from the regex, so the regex is empty. Therefore the empty string (i.e. the non-existent input) is replaced with the second line, verbatim.
To print the result twice, we wrap it in two output stages. The inner one, `\` prints the result with a trailing linefeed, and the outer one, `>`, prints it without one.
If you're a bit familiar with Retina, you might be wondering what happened to Retina's implicit output. Retina's implicit output works by wrapping the final stage of a program in an output stage. However, Retina doesn't do this, if the final stage is already an output stage. The reason for that is that in a normal program it's more useful to be able to replace the implicit output stage with special one like `\` or `;` for a single byte (instead of having to get rid of the implicit one with the `.` flag as well). Unfortunately, this behaviour ends up costing us two bytes for the quine.
[Answer]
## GolfScript, 8 bytes
I always thought the shortest (true) GolfScript quine was 9 bytes:
```
{'.~'}.~
```
Where the trailing linefeed is necessary because GolfScript prints a trailing linefeed by default.
But I just found an 8-byte quine, which works exactly around that linefeed restriction:
```
":n`":n`
```
[Try it online!](http://golfscript.tryitonline.net/#code=IjpuYCI6bmA&input=)
So the catch is that GolfScript doesn't print a trailing linefeed, but it prints the contents of `n` at the end of the program. It's just that `n` contains a linefeed to begin with. So the idea is to replace that with the string `":n`"`, and then stringifying it, such that the copy on the stack prints with quotes and copy stored in `n` prints without.
As pointed out by Thomas Kwa, the 7-byte CJam quine can also be adapted to an 8-byte solution:
```
".p"
.p
```
Again, we need the trailing linefeed.
[Answer]
# [Fueue](https://github.com/TryItOnline/fueue), 423 bytes
Fueue is a queue-based esolang in which the running program *is* the queue.
```
)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
```
[Try it online!](https://tio.run/##TU9bjsQgDLtMKzVTVRvzSAH1AHsHxOfsDeY3V@8mzKy0VFAnJrb5eT1fz/umZUkh53XFptS6lSGtK7erayOloX0BlPTqfV/ScaRa9sfR9AATtUGXjk5EOq4xtu@DmppIt18nbapbb0qPWS/Y9lSGwX2YgJIpqI6vsbdsStrGBpYYShU/geBnlIhTYpUqAAoq4NiYbEycCHZfQkAEo7IIPl2TwMSG@D3lKv94297zCjkF95cY2f0wl8Bx5OlRZssz5HcC03fn07wzcggsltdmIvu87fqXx7J6Pd2ct@nCJ9tkYBaWd5J5x9/gTLSPXdPZ@/4F "Fueue – Try It Online")
# How it works
This explanation ~~may or may not have~~ got way out of hand. On the other hand I don't know how to explain it *much* shorter in a way I hope people can follow.
## Fueue cheat sheet
See [esolang wiki article](https://esolangs.org/wiki/Fueue) for details, including the few features not used in this program.
* The initial program is the initial state of the queue, which can contain the following elements:
+ Integer literals (only non-negative in the source, but negative ones can be calculated), executing them prints a character.
+ Square-bracket delimited nested blocks, inert (preserved intact unless some function acts upon them).
+ Functions, their arguments are the elements following them immediately in the queue:
- `+*/-%`: integer arithmetic (`-` is unary, `%` logical negation). Inert if not given number arguments.
- `()<`: put element in brackets, remove brackets from block, add final element to block. The latter two are inert unless followed by a block.
- `~:`: swap, duplicate.
- `$`: copy (takes number + element). Inert before non-number.
- `H`: halt program.Note that while `[]` nest, `()` don't - the latter are simply separate functions.
## Execution trace syntax
Whitespace is optional in Fueue, except between numerals. In the following execution traces it will be used to suggest program structure, in particular:
* When a function executes, it and its arguments will be set off from the surrounding elements with spaces. If some of the arguments are complicated, there may be a space between them as well.
* Many execution traces are divided into a "delay blob" on the left, separated from a part to the right that does the substantial data manipulation. See next section.
Curly brackets `{}` (not used in Fueue) are used in the traces to represent the integer result of mathematical expressions. This includes negative numbers, as Fueue has only non-negative literals – `-` is the negation function.
Various metavariable names and `...` are used to denote values and abbreviations.
## Delaying tactics
Intuitively, execution cycles around the queue, partially modifying what it passes through. The results of a function cannot be acted on again until the next cycle. Different parts of the program effectively evolve in parallel as long as they don't interact.
As a result, a lot of the code is devoted to synchronization, in particular to delaying execution of parts of the program until the right time. There are a lot of options for golfing this, which tends to turn those parts into unreadable blobs that can only be understood by tracing their execution cycle by cycle.
These tactics won't always be individually mentioned in the below:
* `)[A]` delays `A` for a cycle. (Probably the easiest and most readable method.)
* `~ef` swaps the elements `e` and `f` which also delays their execution. (Probably the least readable, but often shortest for minor delays.)
* `$1e` delays a single element `e`.
* `-` and `%` are useful for delaying numbers (the latter for `0` and `1`.)
* When delaying several equal elements in a row, `:` or `$` can be used to create them from a single one.
* `(n` wraps `n` in brackets, which may later be removed at convenience. This is particularly vital for numeric calculations, since numbers are too unstable to even be copied without first putting them in a block.
## Overall structure
The rest of the explanation is divided into seven parts, each for a section of the running program. The larger cycles after which most of them repeat themselves will be called "iterations" to distinguish them from the "cycles" of single passes through the entire queue.
Here is how the initial program is divided between them:
```
A: )$$4255%%1(~
B: ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:
D: (H-
E:
F:
G: ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
```
The big numeral at the end of the program encodes the rest in reverse, two digits per character, with 30 subtracted from each ASCII value (so e.g. `10` encodes a `(`.)
On a higher level you can think of the data in this program (starting with the bignum) as flowing from right to left, but control flowing from left to right. However, at a lower level Fueue muddles the distinction between code and data all the time.
* Section G decodes the bignum into ASCII digits (e.g. digit `0` as the integer `48`), splitting off the least significant digits first. It produces one digit every 15 cycles.
* Section F contains the produced digit ASCII values (each inside a block) until section E can consume them.
* Section E handles the produced digits two at a time, pairing them up into blocks of the form `[x[y]]`, also printing the encoded character of each pair.
* Section D consists of a deeply nested block gradually constructed from the `[x[y]]` blocks in such a way that once it contains all digits, it can be run to print all of them, then halt the entire program.
* Section C handles the construction of section D, and also recreates section E.
* Section B recreates section C as well as itself every 30 cycles.
* Section A counts down cycles until the last iteration of the other sections. Then it aborts section B and runs section D.
## Section A
Section A handles scheduling the end of the program.
It takes 4258 cycles to reduce to a single swap function `~`, which then makes an adjustment to section B that stops its main loop and starts running section D instead.
```
)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
```
* A `$` function creates 4255 copies of the following `%` while the `(` wraps the `~` in brackets.
* Each cycle the last `%` is used up to toggle the following number between `0` and `1`.
* When all `%`s are used up, the `$1` creates 1 copy of the `[~]` (effectively a NOP), and on the next cycle the `)` removes the brackets.
## Section B
Section B handles regenerating itself as well as a new iteration of section C every 30 cycles.
```
) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] [BkB]
)$ $24% %0 :< [~:)~)] ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1 < < [~:)~)] [BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0 < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
~:) ~)[BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB] ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] (2)
) [BkB] [BkB] $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
```
* A `:` duplicates the big block following (one copy abbreviated as `[BkB]`), then `)` removes the brackets from the first copy.
* `$$24%%0` sets up a countdown similar to the one in section A.
* While this counts down, `:<` turns into `<<`, and a `~` swaps two of the blocks, placing the code for a new section C last.
* The two `<` functions pack the two final blocks into the first one - this is redundant in normal iterations, but will allow the `~` from section A to do its job at the end.
* (1) When the countdown is finished, the `)` removes the outer brackets. Next `~:)` turns into `):` and `~)` swaps a `)` to the beginning of the section C code.
* (2) Section B is now back at its initial cycle, while a `)` is just about to remove the brackets to start running a new iteration of section C.
In the final iteration, the `~` from section A appears at point (1) above:
```
~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] )
```
The `~` swaps the `)` across the block and into section C, preventing section B from being run again.
## Section C
Section C handles merging new digit character pairs into section D's block, and also creating new iterations of section E.
The below shows a typical iteration with `x` and `y` representing the digits' ASCII codes. In the very first iteration, the incoming "D" and "E" elements are the initial `[H]` and `-` instead, as no previous section E has run to produce any digit character pairs.
```
C D E
$11~ ) ~<[[+$4--498+*-:~-10)):])<~] [)))~] < [)))~[...]] [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~] < [)))~] [)))~[...][x[y]]]
~~~ ~~~ ) ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~ ~ ) [)))~[....]] [[+$4--498+*-:~-10)):])<~]
~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
[)))~[....]] ~[+$4--498+*-:~-10)):])<~
```
* This uses a different method of synchronization which I discovered for this answer. When you have several swap functions `~` in a row, the row will shrink to approximately 2/3 each cycle (because one `~` swaps two following), but occasionally with a remainder of `~`s that ~~wreaks havoc on~~ carefully manipulates what follows.
* `$11~` produces such a row. The next `~` swaps a `<` across the following block. Another `<` at the end appends a new digit pair block (digits x and y as ASCII codes) into the section D block.
* Next cycle, the `~` row has a `~~` remainder, which swaps a `~` over the following `)`. The other `<` appends section D to a `[)))~]` block.
* Next the swapped `~` itself swaps the following block with new section E code across the section D block. Then a new leftover `~` swaps a `)` across, and finally the last `~~` in the `~` row swap one of them across to section E just as the `)` has removed its brackets.
In the final iteration, section A's `~` has swapped a `)` across section B and into section C. However, section C is so short-lived that it already has disappeared, and the `)` ends up at the beginning of section D.
## Section D
Section D handles printing the final big numeral and halting the program. During most of the program run, it is an inert block that sections B–G cooperate on building.
```
(H -
[H]-
⋮
[)))~[H-]] After one iteration of section C
⋮
[)))~[)))~[H-][49[49]]]] Second iteration, after E has also run
⋮
) [)))~[...]] [49[48]] Final printing starts as ) is swapped in
))) ~[...][49[48]]
)) )[49[48]] [...]
)) 49 [48][...] Print first 1
) )[48] [...]
) 48 [...] Print 0
)[...] Recurse to inner block
...
⋮
)[H-] Innermost block reached
H - Program halts
```
* In the first cycle of the program, a `(` wraps the halting function `H` in brackets. A `-` follows, it will be used as a dummy element for the first iteration instead of a digit pair.
* The first real digit pair incorporated is `[49[49]]`, corresponding to the final `11` in the numeral.
* The very last digit pair `[49[48]]` (corresponding to the `10` at the beginning of the numeral) is not actually incorporated into the block, but this makes no difference as `)[A[B]]` and `)[A][B]` are equivalent, both turning into `A[B]`.
After the final iteration, the `)` swapped rightwards from section B arrives and the section D block is deblocked. The `)))~` at the beginning of each sub-block makes sure that all parts are executed in the right order. Finally the innermost block contains an `H` halting the program.
## Section E
Section E handles combining pairs of ASCII digits produced by section G, and both prints the corresponding encoded character and sends a block with the combined pair leftwards to sections C and D.
Again the below shows a typical iteration with `x` and `y` representing the digits' ASCII codes.
```
E F
~ [+$4--498+*-:~-10)):] ) < ~ [y] [x]
) [+$4--498+*-:~-10)):] < [x] [y]
+ $4- - 498 +*- :~ -10 ) ) : [x[y]]
+--- -{-498} +*- ~~{-10} ) ) [x[y]] [x[y]]
+-- - 498 +* -{-10} ~ ) x [y] [x[y]]
+- -{-498} + * 10 x )[y] [x[y]]
+ - 498 + {10*x} y [x[y]]
+ {-498} {10*x+y} [x[y]]
{10*x+y-498} [x[y]]
[x[y]]
```
* The incoming digit blocks are swapped, then the y block is appended to the x block, and the whole pair block is copied. One copy will be left until the end for sections C and D.
* The other copy is deblocked again, then a sequence of arithmetic functions are applied to calculate `10*x+y-498`, the ASCII value of the encoded character. `498 = 10*48+48-30`, the `48`s undo the ASCII encoding of `x` and `y` while the `30` shifts the encoding from `00–99` to `30–129`, which includes all printable ASCII.
* The resulting number is then left to execute, which prints its character.
## Section F
Section F consists of inert blocks containing ASCII codes of digits. For most of the program run there will be at most two here, since section E consumes them at the same speed that G produces them with. However, in the final printing phase some redundant `0` digits will collect here.
```
[y] [x] ...
```
## Section G
Section G handles splitting up the big number at the end of the program, least significant digits first, and sending blocks with their ASCII codes leftward to the other sections.
As it has no halting check, it will actually continue producing `0` digits when the number has whittled down to 0, until section D halts the entire program with the `H` function.
`[BkG]` abbreviates a copy of the big starting code block, which is used for self-replication to start new iterations.
Initialization in the first cycles:
```
) :~ : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
) ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [10...11] [BkG]
```
Typical iteration, `N` denotes the number to split:
```
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [N] [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 ) : [N] : [BkG]
) ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] +5 5 ) [N] [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] ~ 10 N [N] [BkG] [BkG]
) ~:~ ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~] / N 10 [N] [BkG] [BkG]
) ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~] ( {N/10} [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~] : [{N/10}] [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 ) ~ ~ [{N/10}] [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 ) ) [{N/10}] ~ [{N/10}] [N] [BkG] [BkG]
) ~ * [):~[$1(+48]):~+] -10 ~ ) {N/10} [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+] * {-10} {N/10} ) [N] [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~ + {-10*(N/10)} N [{N/10}] [BkG] [BkG]
) ~ ~ [$1(+48] ) ~ ~ {N%10} [{N/10}] [BkG] [BkG]
) [$1(+48] ~ ) {N%10} ~ [{N/10}] [BkG] [BkG]
$1( + 48 {N%10} ) [BkG] [{N/10}] [BkG]
( {48+N%10} BkG [{N/10}] [BkG] New iteration starts
[{48+N%10}] ....
```
* The delay blob here is particularly hairy. However, the only new delaying trick is to use `+:5` instead of `--10` to delay a `10` two cycles. Alas only one of the `10`s in the program was helped by this.
* The `[N]` and `[BkG]` blocks are duplicated, then one copy of `N` is divided by `10`.
* `[{N/10}]` is duplicated, then more arithmetic functions are used to calculate the ASCII code of the last digit of `N` as `48+((-10)*(N/10)+N)`. The block with this ASCII code is left for section F.
* The other copy of `[{N/10}]` gets swapped between the `[BkG]` blocks to set up the start of a new iteration.
# Bonus quine (540 bytes)
```
)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63
```
[Try it online!](https://tio.run/##VVBbjsMwCDxLpESCjaoFO2/lAL2D5c/2Bv3l6lnwo/FaIwsPzIB5f16f13Vh33u/8jBwkE6kwy7iEZR1NAwU8IiCIkawM@Ls@3UQITwkjA890zb@PESYEOMZT@mOJJhIgkYoWocCIr9WPm1myBRHTxE1jjFgeMYIzECLwXHCDLwDrQYNFoZds97uHFi9hyUFbrOC24GAt6qtKatJcuZi0kq0hapaiafqNhuZJZrKVkWu3ecbzoFbEunsWSR7USl0ALXNd/5FtmpHUhOu/t9sLrj7pidTbbH@G6aM0X45zWC78rbbEjdrKchDMkwuM9f1Bw "Fueue – Try It Online")
Since I wasn't sure which method would be shortest, I first tried encoding characters as two-digit numbers separated by `(`s. The core code is a bit shorter, but the 50% larger data representation makes up for it. Not as golfed as the other one, as I stopped when I realized it wouldn't beat it. It has one advantage: It doesn't require an implementation with bignum support.
Its overall structure is somewhat similar to the main one. Section G is missing since the data representation fills in section F directly. However, section E must do a similar divmod calculation to reconstruct the digits of the two-digit numbers.
[Answer]
# [Amazon Alexa](https://en.wikipedia.org/wiki/Amazon_Alexa), 31 words
```
Alexa, Simon Says Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says Alexa, Repeat That Alexa, Simon Says, Alexa, Repeat That Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says quiet
```
(each command is on a newline)
When said out loud to a device with the Amazon Alexa digital assistant enabled (I've only tested this on the Echo Dot though), it should say the same words back to you. There will be some different lengths of pauses between words, as you wait for Alexa to reply, and it says everything without breaks, but the sequence of words are the same.
### Explanation:
Each line is a new Alexa command, one of either:
* `Alexa, Simon Says ...`, which will prompt Alexa to say everything afterward the command
* `Alexa, Repeat That`, which repeats the last thing Alexa said
(neither of these appear on most lists of Alexa commands, so I hope someone has actually learned something from this)
We can simplify this to the commands `S` and `R` respectively, separated by spaces. For example, `SR` will represent `Alexa, Simon Says Alexa, Repeat That`. The translation of our program would be:
```
SS R SRSRS R SQ
```
Where `Q` is `quiet` (but can be anything. I chose `quiet` because that's what Alexa produced when I tried to give it `quine`, and it fit, so I kept it). Step by step, we can map each command to the output of each command:
```
Commands: SS
Output: S
Commands: SS R
Output: S S
Commands: SS R SRSRS
Output: S S RSRS
Commands: SS R SRSRS R
Output: S S RSRS RSRS
Commands: SS R SRSRS R SQ
Output: S S RSRS RSRS Q
Total Commands: SSRSRSRSRSQ
Total Output: SSRSRSRSRSQ
```
The general approach for this was to get the output *ahead* of the input commands. This happens on the second to last command, which gets an extra `S` command. First we have to get behind on output though. The first two commands `SS R` only produce `SS`, leaving us to make up the `R`. However, this allows us to start a `S` command with an `R`, which means we can repeat a section (`RSRS`) multiple times, which allows us to get the spare `S` leftover. After that, all we had to do was use it to say whatever we wanted.
[Answer]
## Javascript (36 char)
```
(function a(){alert("("+a+")()")})()
```
This is, AFAICT, the shortest javascript quine posted so far.
[Answer]
# [Labyrinth](https://github.com/mbuettner/labyrinth), ~~124~~ ~~110~~ 53 bytes
*Thanks to Sp3000 for golfing off 9 bytes, which allowed me to golf off another 7.*
```
44660535853919556129637653276602333!
1
:_98
/8 %
@9_.
```
[Try it online!](http://labyrinth.tryitonline.net/#code=NDQ2NjA1MzU4NTM5MTk1NTYxMjk2Mzc2NTMyNzY2MDIzMzMhCjEKOl85OAovOCAlCkA5Xy4&input=)
## Explanation
Labyrinth 101:
* Labyrinth is a stack-based 2D language. The stack is bottomless and filled with zeroes, so popping from an empty stack is not an error.
* Execution starts from the first valid character (here the top left). At each junction, where there are two or more possible paths for the instruction pointer (IP) to take, the top of the stack is checked to determine where to go next. Negative is turn left, zero is go forward and positive is turn right.
* Digits in the source code don't push the corresponding number – instead, they pop the top of the stack and push `n*10 + <digit>`. This allows the easy building up of large numbers. To start a new number, use `_`, which pushes zero.
* `"` are no-ops.
First, I'll explain a slightly simpler version that is a byte longer, but a bit less magical:
```
395852936437949826992796242020587432!
"
:_96
/6 %
@9_.
```
[Try it online!](http://labyrinth.tryitonline.net/#code=Mzk1ODUyOTM2NDM3OTQ5ODI2OTkyNzk2MjQyMDIwNTg3NDMyIQoiCjpfOTYKLzYgJQpAOV8u&input=)
The main idea is to encode the main body of the source in a single number, using some large base. That number can then itself easily be printed back before it's decoded to print the remainder of the source code. The decoding is simply the repeated application of `divmod base`, where print the `mod` and continue working with the `div` until its zero.
By avoiding `{}`, the highest character code we'll need is `_` (95) such that base 96 is sufficient (by keeping the base low, the number at the beginning is shorter). So what we want to encode is this:
```
!
"
:_96
/6 %
@9_.
```
Turning those characters into their code points and treating the result as a base-96 number (with the least-significant digit corresponding to `!` and the most-significant one to `.`, because that's the order in which we'll disassemble the number), we get
```
234785020242697299628949734639258593
```
Now the code starts with a pretty cool trick (if I may say so) that allows us to print back the encoding and keep another copy for decoding with very little overhead: we put the number into the code in reverse. I computed the result [with this CJam script](http://cjam.aditsu.net/#code=qW%2596bsW%25&input=!%0A%22%0A%3A_96%0A%2F6%20%25%0A%409_.) So let's move on to the actual code. Here's the start:
```
395852936437949826992796242020587432!
"
```
The IP starts in the top left corner, going east. While it runs over those digits, it simply builds up that number on top of the stack. The number itself is entirely meaningless, because it's the reverse of what we want. When the IP hits the `!`, that pops this number from the stack and prints it. That's all there is to reproducing the encoding in the output.
But now the IP has hit a dead end. That means it turns around and now moves back west (without executing `!` again). This time, conveniently, the IP reads the number from back to front, so that now the number on top of the stack *does* encode the remainder of the source.
When the IP now hits the top left corner again, this is not a dead end because the IP can take a left turn, so it does and now moves south. The `"` is a no-op, that we need here to separate the number from the code's main loop. Speaking of which:
```
...
"
:_96
/6 %
@9_.
```
As long as the top of the stack is not zero yet, the IP will run through this rather dense code in the following loop:
```
"
>>>v
^< v
^<<
```
Or laid out linearly:
```
:_96%._96/
```
The reason it takes those turns is because of Labyrinth's control flow semantics. When there are at least three neighbours to the current cell, the IP will turn left on a negative stack value, go ahead on a zero and turn right on a positive stack value. If the chosen direction is not possible because there's a wall, the IP will take the opposite direction instead (which is why there are two left turns in the code although the top of the stack is never negative).
The loop code itself is actually pretty straightforward (compressing it this tightly wasn't and is where Sp3000's main contribution is):
```
: # Duplicate the remaining encoding number N.
_96 # Push 96, the base.
%. # Take modulo and print as a character.
_96 # Push 96 again.
/ # Divide N by 96 to move to the next digit.
```
Once `N` hits zero, control flow changes. Now the IP would like to move straight ahead after the `/` (i.e. west), but there's a wall there. So instead if turns around (east), executes the `6` again. That makes the top of the stack positive, so the IP turns right (south) and executes the `9`. The top of the stack is now `69`, but all we care about is that it's positive. The IP takes another right turn (west) and moves onto the `@` which terminates the code.
All in all, pretty simple actually.
Okay, now how do we shave off that additional byte. Clearly, that no-op seems wasteful, but we need that additional row: if the loop was adjacent to the number, the IP would already move there immediately instead of traversing the entire number. So can we do something useful with that no-op.
Well, in principle we can use that to add the last digit onto the encoding. The encoding doesn't really need to be all on the first line... the `!` just ensures that whatever *is* there also gets printed there.
There is a catch though, we can't just do this:
```
95852936437949826992796242020587432!
3
:_96
/6 %
@9_.
```
The problem is that now we've changed the `"` to a `3`, which also changes the actual number we want to have. And sure enough that number doesn't end in `3`. Since the number is completely determined by the code starting from `!` we can't do a lot about that.
*But* maybe we can choose another digit? We don't really care whether there's a `3` in that spot as long as we end up with a number that correctly encodes the source. Well, unfortunately, none of the 10 digits yields an encoding whose least-significant digit matches the chosen one. Luckily, there's some leeway in the remainder of the code such that we can try a few more encodings without increasing the byte count. I've found three options:
1. We can change `@` to `/`. In that case we can use any digit from `1357` and get a matching encoding. However, this would mean that the program then terminates with an error, which is allowed but doesn't seem very clean.
2. Spaces aren't the only "wall" characters. Every unused character is, notably all letters. If we use an upper case letter, then we don't even need to increase the base to accommodate it (since those code points are below `_`). 26 choices gives plenty of possibilities. E.g. for `A` any odd digit works. This is a bit nicer, but it still doesn't seem all that elegant, since you'd never use a letter there in real code.
3. We can use a greater base. As long as we don't increase the base significantly, the number of decimal digits in the encoding will remain the same (specifically, any base up to 104 is fine, although bases beyond 99 would actually require additional characters in the code itself). Luckily, base 98 gives a single matching solution: when we use the digit `1`, the encoding also ends in `1`. This is the only solution among bases 96, 97, 98, 99, so this is indeed very lucky. And that's how we end up with the code at the top of this answer.
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), ~~293~~ ~~262~~ 249 bytes
```
>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\
```
[Try it online!](https://tio.run/##y8kvLvn/387KSNvUSMvKTMtKw8JES9vcVEvTys4KBKIhwCpaA6hA0w4hZBUNUulgp2qvaKOBANEoQEGJK0bZhlaAi0L9MVz////XdQQA "Lost – Try It Online")
## Explanation
This entire project has been an up and down. I kept thinking it was impossible and then coming up with a crazy idea that just might work.
Why is a Lost Quine so hard?
As you may know Lost is a 2D programming language where the start location and direction are entirely random. This makes writing any lost program about as difficult as writing radiation hardened code. You have to consider every possible location and direction.
That being said there are some standard ways to do things. For example here is the standard way of printing a string.
```
>%?"Stringv"(@
^<<<<<<<<<<<<<
```
This has a collection stream at the bottom that grabs the most of the ips and pulls them to the start location. Once they reach are start location (upper left) we sanitize them with a loop getting rid of all the values on the stack then turn the safety of push the string and exit. (safety is a concept unique to Lost every program must hit a `%` before exiting, this prevents the possibility of the program terminating upon start). Now my idea would be to extend this form into a full fledged quine.
The first thing that had to be done was to rework the loop a bit, the existing loop was specific to the String format.
```
>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<
```
We need to add a second stream to avoid the possibility of the `!` jumping over the stream and creating a loop.
Now we want to mix this with the standard Quine format. Since Lost is based very much on Klein I've ~~basically stolen~~ borrowed the Klien Quine for [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender).
```
:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<
```
This quite conveniently prints the first line of the quine. Now all we need to do is hard-code the streams. Well this is easier said than done. I tried approximately four different methods of doing this. I'll just describe the one that worked.
The idea here is to use doors to get the desired number of arrows. A Door is a special type of mirror that changes every time it is hit. `[` reflects ips coming from the left and `]` from the right. When they are hit by an ip from either of these sides the switch orientation. We can make a line of these doors and a static reflector to repeatedly perform an operation.
```
>:[[[
```
Will perform `:` three times. This way if we push a `<` to the stack before hand we can make a lot of them with less bytes. We make 2 of these, one for each line, and in between them we lay down a newline, however the second one needs only go until it covers the `!` we added it for, anything else can be left empty saving us a few bytes. Ok now we need to add the vertical arrows to our streams. This is where the key optimization comes in. Instead of redirecting all the ips to the "start" of the program directly we will instead redirect them to the far left, because we already know that the ips starting in far left *must* work (or at least will work in the final version) we can also just redirect the other ips. This not only makes it cheaper in bytes, I think this optimization is what makes the quine possible.
However there are still some problems, the most important one being ips starting after the `>` has been pushed but before we start making copies of it. Such ips will enter the copier and make a bunch of copies of 0. This is bad because our stack clearing mechanism uses zeros to determine the bottom of the stack, leaving a whole bunch of zeros at the bottom. We need to add a stronger stack sanitation method. Since there is no real way of telling if the stack is empty, we will simply have to attempt to destroy as many items on the stack as possible. Here we will once again use the door method described earlier. We will add `((((((((((([[[[[[[[[[[[[[` to the end of the first line right after the sanitizor to get rid of the zeros.
Now there is one more problem, since we redirected our streams to the upper left ips starting at the `%` and moving down will already have turned the safety off and will exit prematurely. So we need to turn the safety off. We do this by adding a `#` to the stream, that way ips flowing through the stream will be turned off but ips that have already been sanitized will not. The `#` must also be hard coded into the first line as well.
That's it, hopefully you understand how this works now.
] |
[Question]
[
Write a program that will generate a "true" output [iff](http://en.wikipedia.org/wiki/If_and_only_if) the input matches the source code of the program, and which generates a "false" output iff the input does not match the source code of the program.
This problem can be described as being related to quines, as the program must be able to somehow compute its own source code in the process.
This is code golf: standard rules apply. Your program must not access any special files, such as the file of its own source code.
*Edit: If you so choose, true/false can be replaced with True/False or 1/0.*
# Example
If the source code of your program is `bhiofvewoibh46948732));:/)4`, then here is what your program must do:
## Input (Stdin)
```
bhiofvewoibh46948732));:/)4
```
## Output (Stdout)
```
true
```
## Input
```
(Anything other than your source code)
```
## Output
```
false
```
[Answer]
# JavaScript : 26
```
function f(s){return s==f}
```
I don't know if a JavaScript file really qualifies as a "program".
[Answer]
# Haskell, 72 characters
```
main=interact$show.(==s++show s);s="main=interact$show.(==s++show s);s="
```
Note: there is no end-of-line character at the end of the script.
```
$ runhaskell Self.hs < Self.hs
True
```
[Answer]
# Perl, ~~Infinity~~ ~~41~~ 38 Characters
```
$_=q(print<>eq"\$_=q($_);eval"|0);eval
```
**Update:** The program no longer ends with a newline, which means it will work correctly on multi-line files. You have to enter input from STDIN without hitting enter. On Windows I was only able to do this by reading from a file.
Original solution:
```
print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(...
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 68 bytes
Fishes love eating fish poop. Now we know they can distinguish theirs from their friends'.
```
00v 0+1~$^?)0~\;n0\
>:@@:@gi:0(?\:a=?/=?!/$1+
0n;n*=f$=2~~/
```
You can [try it online](https://fishlanguage.com/playground) !
[Answer]
## GolfScript, 11 chars
```
{`".~"+=}.~
```
Without the `=`, this code would be a quine that generates its own source code as a string. The `=` makes it compare this string to its input and output `1` if they match and `0` if they don't.
Note that the comparison is exact — in particular, a trailing newline at the end of the input will cause it to fail.
**Explanation:**
* `{ }` is a code block literal in GolfScript;
* `.` duplicates this code block, and `~` executes the second copy (leaving the first on the stack);
* ``` stringifies the code block, and `".~"+` appends `.~` to it;
* finally, `=` compares the resulting string with the input (which is pushed on the stack as a string by the GolfScript interpreter before the program starts) and returns `1` if they match and `0` if they don't.
[Answer]
# Python 2, 55
```
a='a=%r;print a%%a==raw_input()';print a%a==raw_input()
```
Tested:
`a='a=%r;print a%%a==raw_input()';print a%a==raw_input()` -> `True`
`(anything else)` -> `False`
[Answer]
# JavaScript ES6, ~~16~~ 14 bytes
```
$=_=>_==`$=`+$
```
Minus two bytes thanks to Neil.
31 bytes if we must take input via prompt.
```
$=_=>prompt()==`$=${$};$()`;$()
```
38 bytes if we must output via alert.
```
$=_=>alert(prompt()==`$=${$};$()`);$()
```
This is the *proper* way to do it, as Optimizer's answer does not accept the entire source code.
[Answer]
# Node.js : 54
```
function f(){console.log(f+'f()'==process.argv[2])}f()
```
You test it by saving it into a file `f.js` (the exact name has no importance) and using
```
node f.js "test"
```
(which outputs false) or
```
node f.js "$(< f.js)"
```
(which outputs true)
I also made a different version based on eval :
```
eval(f="console.log('eval(f='+JSON.stringify(f)+')'==process.argv[2])")
```
It's now at 72 chars, I'll try to shorten that when I have time.
[Answer]
# Smalltalk (Pharo 2.0 dialect), 41 bytes
Implement this **41** chars method in String (ugly formatting for code-golf):
```
isItMe^self=thisContext method sourceCode
```
Then evaluate this in a Workspace (printIt the traditional Smalltalk way)
The input is not read from stdin, it's just a String to which we send the message (what else a program could be in Smalltalk?):
```
'isItMe^self=thisContext method sourceCode' isItMe.
```
But we are cheating, sourceCode reads some source file...
Here is a variant with **51** chars which does not:
```
isItMe
^ self = thisContext method decompileString
```
And test with:
```
'isItMe
^ self = thisContext method decompileString' isItMe
```
If a String in a Workspace is not considered a valid input, then let's see how to use some Dialog Box in **116** chars
Just evaluate this sentence:
```
(UIManager default request: 'type me') = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)
```
Since decompile format includes CR and TAB, we change that withSeparatorsCompacted.
Then we skip the first 7 chars are 'doIt ^ '
Finally a **105** chars variant using stdin, just interpret this sentence from command line, just to feel more mainstream:
```
Pharo -headless Pharo-2.0.image eval "FileStream stdin nextLine = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)"
```
[Answer]
# flex - 312 chars
```
Q \"
N \n
S " "
B \\
P "Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');"
M "(.|{N})* putchar('0');"
%%
Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');
(.|{N})* putchar('0');
```
Can probably be made shorter, but it works with multi-line input (necessary since the source code is multiple lines) and even for inputs that contain the program as a substring. It seems many of the answers so far fail on one or both of these.
Compile command: `flex id.l && gcc -lfl lex.yy.c`
[Answer]
## D (133 chars)
```
enum c=q{import std.stdio;import std.algorithm;void main(){auto i=readln();writeln(equal("auto c=q{"~c~"};mixin(c);",i));}};mixin(c);
```
[Answer]
# JavaScript (V8), 35
```
function i(){alert(prompt()==i+[])}
```
call `i()` and it will prompt for input
[Answer]
# GolfScript - 26
```
":@;[34]@+2*=":@;[34]@+2*=
```
Inspired from <http://esolangs.org/wiki/GolfScript#Examples>
Another version:
```
"[34].@@;+2*="[34].@@;+2*=
```
Too bad that `\` is both swap and escape...
[Answer]
# Python 2, 47 bytes
```
_='_=%r;print _%%_==input()';print _%_==input()
```
A simple quine with the added check.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 12 bytes
```
{s"_~"+q=}_~
```
[Try it online!](https://tio.run/##S85KzP3/v7pYKb5OSbvQtja@DpUHAA "CJam – Try It Online")
### Explanation
This just uses the standard CJam quine framework.
```
{s"_~"+q=} e# Push this block (function literal).
_~ e# Copy and run it.
```
What the block does:
```
s e# Stringify the top element (this block itself).
"_~"+ e# Append "_~". Now the source code is on the stack.
q e# Read the input.
= e# Check if it equals the source code.
```
[Answer]
# Python, 187 bytes
```
import sys;code="import sys;code=!X!;print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace(!X!,code,1))";print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace("X",code,1))
```
Careful not to add newline at the end. Someone with better Python-fu might be able to shorten it.
[Answer]
## Tcl, 111 chars
```
set c {set c {$c};puts [expr {[read stdin] eq [subst -noc \$c]}]};puts [expr {[read stdin] eq [subst -noc $c]}]
```
[Answer]
## Perl, 52 char
```
$_='$/=$\;$_="\$_=\47$_\47;eval";print<>eq$_|0';eval
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 11 bytes
```
=hS+s"=hS+s
```
[Try it online!](https://tio.run/##yygtzv7/3zYjWLtYCUz@h/JiIFwA "Husk – Try It Online")
### Explanation
The explanation uses `¨` to delimit strings (to avoid unreadable escaping):
```
"=hS+s -- string literal: ¨=hS+s¨
S+ -- join itself with
s -- | itself "showed": ¨"=hS+s"¨
-- : ¨=hS+s"=hS+s"¨
h -- init: ¨=hS+s"=hS+s¨
= -- is the input equal?
```
By removing the function `=` you can [verify](https://tio.run/##yygtzv7/PyNYu1jJFkT@/w8A "Husk – Try It Online") that it will indeed only match the source itself.
[Answer]
# [Python 2](https://docs.python.org/2/), 40 bytes
```
s="print's=%r;exec s'%s==input()";exec s
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9hWqaAoM69EvdhWtcg6tSI1WaFYXbXY1jYzr6C0RENTCSr2/7@SkhKxioFKAQ "Python 2 – Try It Online")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 24 bytes
```
'1rd3*i={*}50l3-?.~i)*n;
```
[Try it online!](https://tio.run/##S8sszvj/X92wKMVYK9O2WqvW1CDHWNdery5TUyvPGrcMAA "><> – Try It Online")
Wrapping string literal followed by checking whether the input is identical to the stack, with a final check that there is no more input.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
“Ṿ;$⁼”Ṿ;$⁼
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5yHO/dZqzxq3POoYS6M@f9w@6OmNf//R6tjl1fX4VJQR4gjK0GTQtWCRymYg64ILBELAA "Jelly – Try It Online")
```
“Ṿ;$⁼”Ṿ;$⁼
“Ṿ;$⁼” String literal: 'Ṿ;$⁼'
$ Next two links act on the string literal
Ṿ Uneval: '“Ṿ;$⁼”'
; Append string: '“Ṿ;$⁼”Ṿ;$⁼' (source code)
⁼ Is the string above equal to the input?
```
[Answer]
# [Zsh](https://www.zsh.org/), 33 bytes
```
f () {
[ "`type -f f`" = $1 ]
}
```
[Try it online!](https://tio.run/##qyrO@P8/TUFDU6GaizNaQSmhpLIgVUE3TSEtQUnBVkHFUCGWq5YLqEJJRQMupanElZqcka@gYs/FpayQmJKiUFKUmJmTmZeuUFyQmJzKhaZcAbf6vNRyII2hgwtFR1Fqbn5ZKnZN1cjaVO1r4Rr/AwA "Zsh – Try It Online")
The extra spaces, tab, and newlines are required. `type -f f` does not print the original source, but the function formatted in a particular way, with indentation and a trailing newline.
[Answer]
# [R](https://www.r-project.org/), 54 bytes
```
f=function(s)s==paste0("f=function(s)s==", body(f)[3])
```
[Try it online!](https://tio.run/##K/r/P802rTQvuSQzP0@jWLPY1rYgsbgk1UBDCV1cSUchKT@lUiNNM9o4VvN/moY6eTrVNbmAehOTklPUNf8DAA "R – Try It Online")
`body` gets the body of the function (splitting it a bit, so that `body(f)[3]` is everything from `paste0` onwards). Interestingly, `body` reformats the code, adding spaces after commas, etc. This is thus a rare case of an R golf answer with a space after a comma.
This works because `body(f)` is an object of type `language`, and there exists an `as.character` method for this type. On the other hand, `f` and `args(f)` are of type `closure`, and cannot be converted to character type as far as I can tell. Please don't ask me what the language type is for…
[Answer]
# [R](https://www.r-project.org/) (version-dependent), 46 bytes
```
f=function(x)x==paste0('f=',capture.output(f))
```
`capture.output` - as the function name suggests - retrieves the text string that results from entering the function name `f` directly to [R](https://www.r-project.org/), which should output the body of the function. We manually prepend this with `f=` so that it exactly\* matches the program code, and check whether the function argument `x` is the same as this.
\*See below
There are a couple of caveats, though, that depend on the [R](https://www.r-project.org/) version used:
1. Early versions of [R](https://www.r-project.org/) (like my own version 3.2.1) return the originally-defined function body as-is when the function name is entered to [R](https://www.r-project.org/). However, later versions add additional formatting, like inserting spaces and newlines, which breaks this code: this unfortunately includes the installation (3.5.2) on 'Try it online'. Later still, much newer [R](https://www.r-project.org/) versions (I tested 4.0.3) return to the as-is output formatting and everything is Ok again... except...
2. The most recent versions of [R](https://www.r-project.org/) compile functions at the first run, and thereafter append a 'byte code' specific for the compiled function to the outputted function body. This means that `capture.output` returns two strings, beginning at the second time the function is run. Luckily, the function body is still the first one (the byte code is the second one), so the result of supplying the program code as input is `TRUE FALSE`, which evaluates to 'truthy' in [R](https://www.r-project.org/) and so counts as a 'true' output for this challenge.
Special thanks to [Robin Ryder](https://codegolf.stackexchange.com/users/86301/robin-ryder) for helping to uncover the version-dependence of [R](https://www.r-project.org/)'s function outputting.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 12 bytes
```
`:q$+=`:q$+=
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%60%3Aq%24%2B%3D%60%3Aq%24%2B%3D&inputs=%60%3Aq%24%2B%3D%60%3Aq%24%2B%3D&header=&footer=)
I finished making this, and then realized that it is almost identical to the Vyxal quine that @Lyxal wrote, but with the addition of `=` to check if the input is equal.
Explanation:
```
# Implicit input
`:q$+=` # Push the string ':q$+='
: # Duplicate the string
q # Quotify; put backticks around the topmost string
$ # Swap the top two values on the stack
+ # Concatenate the two strings
= # Check if the input is equal to the string
# Implicit output
```
[Answer]
## C - 186 176 characters
One liner:
```
*a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}
```
With whitespace (note that this breaks the program):
```
*a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];
main() {
sprintf(b,a,34,a,34);
gets(c);
putchar(strcmp(b,c)?'0':'1');
}
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 26 bytes
```
"34bLN26)s:f="34bLN26)s:f=
```
[Run and debug it](https://staxlang.xyz/#c=%2234bLN26%29s%3Af%3D%2234bLN26%29s%3Af%3D&i=%2234bLN26%29s%3Af%3D%2234bLN26%29s%3Af%3D%0A%2234bLN26%29s%3Af%3D%2234bLN26%29s%3Afb%0Aabc%0A34&m=2)
[Answer]
## JavaScript ES6, 14 bytes
Like the other javascript answer but includes it's entire source code and not just the function
```
a=q=>'a='+a==q
```
Example usage:
```
a("q=>'a='+a==q") // returns false
a("a=q=>'a='+a==q") // returns true
```
[Answer]
# q, 8 bytes
```
{x~.z.s}
```
Return boolean on input matching the self-referential [.z.s](https://code.kx.com/q/ref/dotz/#zs-self)
] |
[Question]
[
# The Problem
I have a bunch of regular expressions that I need to use in some code, but I'm using a programming language that doesn't support regex! Luckily, I know that the test string will have a maximum length and will be composed of printable ASCII only.
# The Challenge
You must input a regex and a number `n`, and output every string composed of printable ASCII (ASCII codes 32 to 126 inclusive, to `~`, no tabs or newlines) of length less than or equal to `n` that matches that regex. You may **not** use built-in regular expressions or regex matching functions in your code at all. Regular expressions will be limited to the following:
* Literal characters (and escapes, which force a character to be literal, so `\.` is a literal `.`, `\n` is a literal `n` (equivalent to just `n`), and `\w` is equivalent to `w`. You do not need to support escape sequences.)
* `.` - wildcard (any character)
* Character classes, `[abc]` means "a or b or c" and `[d-f]` means anything from d to f (so, d or e or f). The only characters that have special meaning in a character class are `[` and `]` (which will always be escaped, so don't worry about those), `\` (the escape character, of course), `^` at the beginning of the character class (which is a negation), and `-` (which is a range).
* `|` - the OR operator, alternation. `foo|bar` means either `foo` or `bar`, and `(ab|cd)e` matches either `abe` or `cde`.
* `*` - match the previous token repeated zero or more times, greedy (it tries to repeat as many times as possible)
* `+` - repeated one or more times, greedy
* `?` - zero or one times
* Grouping with parentheses, to group tokens for `|`, `*`. `+`, or `?`
The input regex will always be valid (i.e., you do not have to handle input like `?abc` or `(foo` or any invalid input). You may output the strings in any order you would like, but each string must appear only once (don't output any duplicates).
# The Test Cases
Input: `.*`, `1`
Output: (empty string), , `!`, `"`, ..., `}`, `~`
Input: `w\w+`, `3`
Output: `ww`, `www`
Input: `[abx-z][^ -}][\\]`, `3`
Output: `a~\`, `b~\`, `x~\`, `y~\`, `z~\`
Input: `ab*a|c[de]*`, `3`
Output: `c`, `cd`, `ce`, `aa`, `cde`, `ced`, `cdd`, `cee`, `aba`
Input: `(foo)+(bar)?!?`, `6`
Output: `foo`, `foo!`, `foofoo`, `foobar`
Input: `(a+|b*c)d`, `4`
Output: `ad`, `cd`, `aad`, `bcd`, `aaad`, `bbcd`
Input: `p+cg`, `4`
Output: `pcg`, `ppcg`
Input: `a{3}`, `4`
Output: `a{3}`
# The Winner
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes will win!
[Answer]
# Python v2.7 ~~1069~~ ~~1036~~ ~~950~~ ~~925~~ ~~897~~ ~~884~~ ~~871~~ ~~833~~ 822
This answer seems rather long for a code golf, but there are a lot operators that need to be handled and I know what purpose each byte in this answer does. Since there is no existing answer I submit this as a target for other users to beat. See if you can make a shorter answer :).
The two main functions are `f` which parses the regex starting at the `i`th character, and `d` which generates the matching strings, using `r` the sub-regexes we can recursed into, 'a' the array representing the part of the current sub-regex not yet processed, and a string suffix `s` which represents the part of the string generated so far.
Also check out the [sample output](https://github.com/gmatht/joshell/tree/master/golf/regex/regex_good.txt) and a [test harness](https://github.com/gmatht/joshell/tree/master/golf/regex/regex.sh).
```
import sys;V=sys.argv;n=int(V[2]);r=V[1];S=len;R=range;C=R(32,127)
Z=[];z=-1;D='d(r,p,';F='for j in '
def f(i,a):
if i>=S(r):return a,i
c=r[i];x=0;I="|)]".find(c)
if c in"([|":x,i=f(i+1,Z)
if I+1:return([c,a,x],[a],[c,a])[I],i
if'\\'==c:i+=1;x=c+r[i]
return f(i+1,a+[x or c])
def d(r,a,s):
if S(s)>n:return
while a==Z:
if r==Z:print s;return
a=r[z];r=r[:z]
e=a[z];p=a[0:z]
if'|'==a[0]:d(r,a[1],s);d(r,a[2],s)
elif']'==a[0]:
g=a[1];N=g[0]=='^';g=(g,g[1:])[N];B=[0]*127;O=[ord(c[z])for c in g]
for i in R(0,S(g)):
if'-'==g[i]:exec F+'R(O[i-1],O[i+1]):B[j]=1'
else:B[O[i]]=1
for c in C:N^B[c]<1or d(r,Z,chr(c)+s)
elif' '>e:d(r+[p],e,s)
else:c=p[:z];exec{'.':F+'C:'+D+'chr(j)+s)','?':D+'s);d(r,p[:z],s)','*':F+'R(0,n+1):d(r,c,s);c+=[p[z]]','+':"d(r,p+['*',p[z]],s)"}.get(e,D+'e[z]+s)')
d(Z,f(0,Z)[0],"")
```
Note that tabs in the original solution have been `expand`ed. To count the number of characters in the original use `unexpand < regex.py | wc`.
[Answer]
# Haskell ~~757 705 700 692 679~~ 667
```
import Data.List
data R=L Char|A R R|T R R|E
h=[' '..'~']
k(']':s)a=(a,s)
k('^':s)_=l$k[]s
k('-':c:s)(a:b)=k([a..c]++b)s
k('\\':c:s)a=k s$c:a
k(c:s)a=k s$c:a
l(a,b)=(h\\a,b)
c#E=L c
c#r=A(L c)r
o(a,b)=(foldr(#)E a,b)
t%0=E
t%n=A(t%(n-1))$T t$t%(n-1)
d s n=m(fst$r s)[[]] where{m E a=a;m(L c)a=[b++[c]|b<-a,length b<n];m(A r s)x=nub$(m r x)++m s x;m(T r s)a=m s$m r a;r s=w$e s E;w(u,'|':v)=(\(a,b)->(A u a,b))$r v;w x=x;e(')':xs)t=(t,xs);e s@('|':_)t=(t,s);e s@(c:_)t=g t$f$b s;e[]t=(t,[]);g t(u,v)=e v$T t u;f(t,'*':s)=(t%n,s);f(t,'+':s)=(T t$t%n,s);f(t,'?':s)=(A t E,s);f(t,s)=(t,s);b('(':s)=r s;b('\\':s:t)=(L s,t);b('.':s)=o(h,s);b('[':s)=o$k s[];b(s:t)=(L s,t)}
```
output:
```
ghci> d ".*" 1
[""," ","!","\"","#","$","%","&","'","(",")","*","+",",","-",".","/","0","1","2","3","4","5","6","7","8","9",":",";","<","=",">","?","@","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","[","\\","]","^","_","`","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","{","|","}","~"]
ghci> d "w\\w+" 3
["ww","www"]
ghci> d "[abx-z][^ -}][\\\\]" 3
["x~\\","y~\\","z~\\","b~\\","a~\\"]
ghci> d "ab*a|c[de]*" 3
["aa","aba","c","ce","cd","cee","cde","ced","cdd"]
ghci> d "(foo)+(bar)?!?" 6
["foo!","foobar","foo","foofoo"]
ghci> d "(a+|b*c)d" 4
["ad","aad","aaad","cd","bcd","bbcd"]
ghci> d "p+cg" 4
["pcg","ppcg"]
ghci> d "a{3}" 4
["a{3}"]
```
Explanation: this one's a textbook regex implementation. R is the regex type, with constructors A (alternate), L (literal), T (then) and E (empty/epsilon). The usual 'Star' doesn't appear because I inline it as alternates during the parse (see '%'). 'm' runs the simulation. The parser (start at 'r s=....') is just recursive descent; 'k' parses ranges. The function '#' expands ranges into alternations.
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), 586 bytes
The built in backtracking ability of Prolog makes it an awesome choice for this challenge. By taking advantage of backtracking, generating strings for a regex becomes exactly the same task as testing if a string is matched by a regex. Unfortunately, much of my golfing effort went into writing a shorter regex parsers. The actual task of decomposing a regular expression we easily golfed.
```
R-L-S:-R*A,-(B,A,[]),setof(Z,(0/L/M,length(C,M),C+B+[],Z*C),S).
-R-->e+S,S-R.
R-T-->{R=T};"|",e+S,u+R+S-T.
Z+Y-->(".",{setof(C,32/126/C,R)};"[^",!,\E,"]",{setof(C,(32/126/C,\+C^E),R)};"[",\R,"]";"(",-R,")";{R=[C]},([C],{\+C^`\\.[|+?*(`};[92,C])),("*",{S=k*R};"+",{S=c+R+k*R};"?",{S=u+e+R};{S=R}),({Y=c+Z+S};c+Z+S+Y).
\C-->{C=[H|T]},+H,\T;{C=[]};+A,"-",+B,\T,{setof(C,A/B/C,H),append(H,T,C)}.
+C-->[92,C];[C],{\+C^`\\]-`}.
S+e+S.
[C|S]+D+S:-C^D.
S+(B+L+R)+T:-B=c,!,S+L+U,U+R+T;S+L+T;S+R+T.
S+k*K+U:-S=U;S+K+T,S\=T,T+k*K+U.
A/B/C:-between(A,B,C).
A^B:-member(A,B).
A*B:-string_codes(A,B).
```
[Try it online!](https://tio.run/##bVFNb9pAEL3zK5o97XpmTANVpGK5CG8iIYVcvOYAtim2MRSFYAREVMX@7XQMVYoUfFjP@9idebubbbEqFrQ7LE8nnwZkOuRbPSTpYQ/DWOEu3xdzOUb5tTlovuAqXy/2v6TGF4UaPAhjHFtaoVF2g3yiHzkYNOTbDZ8ChkffDSpHlAJr4R18MBTYjTGMWJTCFni8dNDYbjXvWw9Njb7iHeFE4B1GTyjiK4/8MEWgJ0/qn1dg5NdGR0iBxKUSDncOdVyh5BWPtX0aRXZYQteS08oJv7dQx0qhFBY3MO6r5fNRcK4znvOCu2f8Djkw4sqveMdxxI4xmMo5/2DE4SNdp9Vu2C8D7gp9jAKnxnHlQA8FCQSPuf9Zek2Pc/QVJptNvp7JPgaoVWU3oD7qMp9zPXxMU1YNz2LsRqhLE8Mj8IPpyWNNSw8G4CsIOuS5GV@eYTzEIWcJnLquV65r76v1DMMOGXfI3DMEaCI3wODC243zaB1K8/0hz9eyhx5PxvTE69Bb/pbm25qrGYuZ3X67XC9@ZsUs313402m@XM@S1UoaFLYl6J4MDth/RR@i6ACC2p@VMEl/0584nHyhKg4j/uKbviS1kjILZ3ls3dTlvCgUyDTZqu5dV9DDDUsCZWplaibo22d1A9nippAc29VtoUw@wv4F "Prolog (SWI) – Try It Online")
# Ungolfed Code
```
generate_string(R, L, S) :-
% parse regex
string_codes(R, RC),
regex_union(RE, RC, []),
% bound string length
between(0, L, M),
length(SC, M),
% find string
match(SC, RE, []),
string_codes(S, SC).
% Parsers
%%%%%%%%%
regex_union(R) -->regex_concat(S), regex_union1(S, R).
regex_union1(R,T) --> [124], regex_concat(S), regex_union1(regex_union(R,S), T).
regex_union1(R, R) --> [].
regex_concat(R) --> regex_op(S), regex_concat1(S, R).
regex_concat1(R, T) --> regex_op(S), regex_concat1(regex_concat(R,S), T).
regex_concat1(R, R) --> [].
regex_op(regex_kleene(R)) --> regex_lit(R), [42].
regex_op(regex_concat(R,regex_kleene(R))) --> regex_lit(R), [43].
regex_op(regex_union(regex_empty,R)) --> regex_lit(R), [63].
regex_op(R) --> regex_lit(R).
regex_lit(regex_char([C])) --> [C], {\+ regex_ctrl(C)}.
regex_lit(regex_char([C])) --> [92], [C].
regex_lit(regex_char(CS)) --> [46], {findall(C, between(32,126, C), CS)}.
regex_lit(regex_char(DS)) -->
[91], [94], !, class_body(CS), [93],
{findall(C, (between(32, 126, C), \+ member(C, CS)), DS)}.
regex_lit(regex_char(CS)) --> [91], class_body(CS), [93].
regex_lit(R) --> [40], regex_union(R), [41].
class_body([C|T]) --> class_lit(C),class_body(T).
class_body(CS) -->
class_lit(C0), [45], class_lit(C1), class_body(T),
{findall(C, between(C0, C1, C), H), append(H,T,CS)}.
class_body([]) --> [].
class_lit(C) --> [C], {\+ class_ctrl(C)}.
class_lit(C) --> [92], [C].
class_ctrl(C) :- string_codes("\\[]-", CS), member(C, CS).
regex_ctrl(C) :- string_codes("\\.[]|+?*()", CS), member(C, CS).
% Regex Engine
%%%%%%%%%%%%%%
% The regex empty matches any string without consuming any characters.
match(S, regex_empty, S).
% A regex consisting of a single character matches any string starting with
% that character. The chanter is consumed.
match([C|S], regex_char(CS), S) :- member(C, CS).
% A union of two regex only needs to satisify one of the branches.
match(S, regex_union(L,R), T) :- match(S, L, T); match(S, R, T).
% A concat of two regex must satisfy the left and then the right.
match(S, regex_concat(L, R), U) :- match(S, L, T), match(T, R, U).
% The kleene closure of a regex can match the regex 0 times or it can the regex
% once before matching the kleene closure again.
match(S, regex_kleene(_), S).
match(S, regex_kleene(K), U) :- match(S, K, T), S \= T, match(T, regex_kleene(K), U).
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/185462/edit).
Closed 4 years ago.
[Improve this question](/posts/185462/edit)
In a fictional document management system, input documents are structured with weighted headings. Lowest weighted headings are the most important.
This is a sample document:
H1 All About Birds
H2 Kinds of Birds
H3 The Finch
H3 The Swan
H2 Habitats
H3 Wetlands
From this document we would like to produce an outline using nested ordered lists in HTML, which would look like this when rendered:
1. All About Birds
1. Kinds of Birds
1. The Finch
2. The Swan
2. Habitats
1. Wetlands
Your code only needs to take the input list and transform it into the expected data structure, which will be printed.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~53~~ 50 bytes
```
Ḋœṡ¥€⁶ZµḢVØ0jI>0ẋ"AƲị“<ol>“</ol>”żṪ“<li>“</li>”jⱮƊ
```
[Try it online!](https://tio.run/##y0rNyan8///hjq6jkx/uXHho6aOmNY8at0Ud2vpwx6KwwzMMsjztDB7u6lZyPLbp4e7uRw1zbPJz7ECUPpiee3TPw52rQPycTIgwmJ6b9WjjumNd/x/u3nK4/f9/D0MFx5wcBcek/NISBafMopRiLg8jBe/MvJRihfw0mIixQkhGqoJbZl5yBowTXJ6YB1LqkZiUWZJYAlYUnlqSk5gH0mCiEFJZkAo2ohwuaKoQllpUCRKACYI0OecnFpdwQd2RCHZHWmZxBsjs4IzEouxiAA "Jelly – Try It Online")
A monadic link taking a list of strings as input and outputting an HTML fragment with nested ordered lists. Should handle arbitrarily deep nesting of lists and return a syntactically valid HTML fragment.
## Example:
```
H1 All About Birds
H2 Kinds of Birds
H3 The Finch
H3 The Swan
H2 Habitats
H3 Wetlands
H4 Types of wetlands
H5 Very wet wetland
H3 Coast
H1 All about fish
H2 Sharks
```
yields:
```
<ol><li>All About Birds</li><ol><li>Kinds of Birds</li><ol><li>The Finch</li><li>The Swan</li></ol><li>Habitats</li><ol><li>Wetlands</li><ol><li>Types of wetlands</li><ol><li>Very wet wetland</li></ol></ol><li>Coast</li></ol></ol><li>All about fish</li><ol><li>Sharks</li></ol></ol>
```
1. All About Birds
1. Kinds of Birds
1. The Finch
2. The Swan
3. Habitats
1. Wetlands
1. Types of wetlands
1. Very wet wetland
3. Coast
3. All about fish
1. Sharks
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/183156/edit).
Closed 4 years ago.
[Improve this question](/posts/183156/edit)
# Challenge
You will be given an input represented by `x`, which is a string containing at least 3 characters. It will consist only of the standard numeric characters, 0 through 9. Your job is to find and output how many right triangles can be formed with the given numbers.
# Rules
* Numbers must be kept in the order they were given in. No mixing them up!
* The numbers for each right triangle must be consecutive.
* The order of numbers has to be `a` first, `b` second, and `c` third, and must satisfy the formula `a² + b² = c²`. `a` can be greater than or less than `b`, as long as it satisfies the formula.
* Decimal points may be added between any numbers.
* Decimals require one or more numbers to be placed before them, e.g. `.5` cannot be used as a number but `0.5` and `12.5` can.
* Decimals with at least 4 digits after the decimal point truncated to the third digit, e.g. `1.2345` would truncated to `1.234` and `1.9999` would be truncated to `1.999`.
* Numbers can be used more than once in 2 or more different triangles, but cannot be used multiple times in the same triangle.
* Multiple representations of the same value can count multiple times.
* Repeating zeros are allowed, e.g. `000.5` counts as a number.
* *All* possible combinations must be taken into account for your program to be valid.
# Example Inputs and Outputs
Input: 345
Output: 1
This can be split into `3`, `4`, and `5`, which, of course, form a right triangle.
Input: 534
Output: 0
While this does include the necessary numbers to form a right triangle, they are not in the correct order. It has to follow the formula `a² + b² = c²`, but in this case it follows `c² = a² + b²`. The order of numbers cannot be changed from the original input, so in this case no right triangles can be formed.
Input: 3415
Output: 0
This does contain a `3`, `4`, and a `5`, which can form a right triangle, but they are not consecutive; there is a `1` splitting the `5` from the `3` and `4`.
Input: 5567507
Output: 1
Because decimals can be added anywhere, it can be changed to `55.67.507`, which allows splitting it into `5`, `5.6`, and `7.507` to form a right triangle. Remember that decimals are truncated to the third digit after the decimal point, which is how we get `7.507`.
Input: 345567507
Output: 2
The first right triangle is formed by `3`, `4`, and `5`. The second one is formed by `5567507` (read the previous example for explanation). Numbers can be used more than once, so the first `5` was used in the first *and* second triangles.
Input: 51125
Output: 0
Because of rule 5, you cannot use `.5`, `1`, and `1.25`. An integer is required before `.5` for it to work.
Input: 051125
Output: 0
Unlike the previous example, there *is* a number before the first `5`, so it is now legal to use `0.5`, `1`, and `1.25`.
Input: 121418439
Output: 2
The numbers `12` and `14` would form a right triangle where side `c` has a length of approximately `18.43908891458577462000`. Because long decimals are truncated to the third digit after the decimal point, we would be left with `18.439`. This fits in with the original input, `121418439`. Additionally, `1.2`, `1.4`, and `1.843` counts as a separate combination, thus giving us our second right triangle.
Input: 10011005
Output: 8
Numbers count separately if they're represented in different ways, so this allows for (1, 00, 1), (1.0, 0, 1), (1, 0, 01), (1, 0.01, 1), (1, 0.01, 1.0), (1, 0.01, 1.00), (1.0, 0.1, 1.005), and (1, 00.1, 1.005).
---
This is code golf, so shortest answer in bytes wins. Good luck!
]
|
[Question]
[
A radiation-hardened program is a program where, if any character of the code is removed, the program will still function the same. For this question, we'll be writing a program that detects when it is irradiated.
Write a program or function that, when *any* single byte is removed, the resulting program will output that byte and only that byte. (*You may output that byte multiple times, as long as you don't output any other byte*)
### Rules:
* The program has to contain at least 2 distinct bytes. (No solutions of just 0s ;)
* It doesn't matter what the original program does
* No reading your own source code.
* The code will be scored on the number of distinct bytes, where the highest amount wins. For example, `abc` = 3 points, `ababba` = 2 points, `abc` wins.
+ Tie-breaker is the smaller byte count, followed by the earlier submission time
Good luck!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9~~ 7 bytes (Score of 3)
```
22'''rr
```
[Try it online!](https://tio.run/##MzBNTDJM/a9kZKSurl5UpBT6PyLdLeLwVr/jc5UCivLTixJzrRQUlOxt9cKUHJNLShNzgFwQP8Lv8Aol14qC1OSS1BQrkEjg6baLTW4xtUq6EKCkU3tove3//wA "05AB1E – Try It Online")
# Removing a `'`
With any `'` removed, `22''rr` will result in 22 being the first thing on the stack and a `'` being the last thing on the stack, which when reversed twice results in `'`.
# Removing an `r`
With any `r` removed, `22'''r` results in 22 being the first thing on the stack, a `'` being the second thing on stack, and an `r` being the last thing on the stack. This `r`, however, was preceeded by a `'` which makes it the literal string `"r"` (as opposed to the command `reverse stack`), which is implicitly printed.
# Removing a `2`
With any `2` removed, `2'''rr` will result in a `2` being the 1st thing on the stack, `'` being the 2nd thing on the stack and finally `r` being the last thing on the stack, which when reversed once results in `2`.
Therefore, this answer is valid. With nothing removed it outputs `'`, which is irrelevant. This works for any number other than 2 as well.
---
# [Created a validity checker, you can use it to compete in 05AB1E\*.](https://tio.run/##MzBNTDJM/a@kDgExMUqh/yPS3SIOb/U7PlcpoCg/vSgx10pBQcneVi9MyTG5pDQxB8gF8SP8Dq9Qcq0oSE0uSU2xAokEnm672OQWU6ukCwFKOrWH1tv@/w8A "05AB1E – Try It Online")
\*I'm not 100% sure how many solutions are even possible in 05AB1E...
---
# More valid solutions that are ***Worse or the Same***
* 1-Point (invalid)
+ [Any number of `'` above 2 will work...](https://tio.run/##MzBNTDJM/a@krq6uFPo/It0t4vBWv@NzlQKK8tOLEnOtFBSU7G31wpQck0tKE3OAXBA/wu/wCiXXioLU5JLUFCuQSODptotNbjG1SroQoKRTe2i97f//AA "05AB1E – Try It Online")
* 2-Point
+ `'''''''VV`, `'''''''XX` or `'''''''<any command that pops a without pushing>x2`
+ Any odd # of `'` above 3 followed by any even # of `s` above 1 (E.G. `'''''''''ssss`).
+ `'''..` with any number of periods above 1 and any odd number of `'` above 2.
* 3-Point
+ `'\\'''rr` - same idea as `22'''rr` but `\` is 'remove last stack item'.
[Answer]
# Brainfuck, Score 3
May be noncompeting as output is only seen through a memory dump.
```
+++++++++++++++++++++++++++++++++++++++++++++,-
```
Assuming input is empty and EOF leaves the cell unchanged. Uses an interpreter that dumps the memory to an output, such as [this one](https://copy.sh/brainfuck/).
Remove a plus, and the memory is the unicode value for "+" , else it is the unicode value for ",". Its more of a rule bender than a answer though. Pretty much the same with "-". Abuses the fact that these three characters are after each other in the unicode-characterset.
[Answer]
# A Pear Tree, 256 distinct bytes, 975 bytes
Unfortunately, the question pretty much requires an optimal solution to contain a NUL byte somewhere (as it needs to contain all 256 bytes somewhere). This means that a) I can't give you a TIO link (because TIO dislikes NUL in programs, or at the least, I haven't figured out a way to type it that my browser can cope with), and b) I can't paste the program into Stack Exchange literally. Instead, I've placed an `xxd` reversible hexdump hidden behind the "code snippet" link beneath.
```
00000000: 0a24 7a7b 242f 7d2b 2b3b 242f 3d24 5c3d .$z{$/}++;$/=$\=
00000010: 2440 3b21 247a 7b24 5f7d 3f24 7a7b 245f $@;!$z{$_}?$z{$_
00000020: 7d3d 313a 6465 6c65 7465 247a 7b24 5f7d }=1:delete$z{$_}
00000030: 666f 7220 7370 6c69 742f 2f2c 3c44 4154 for split//,<DAT
00000040: 413e 3b70 7269 6e74 206b 6579 7325 7a3e A>;print keys%z>
00000050: 353f 225c 6e22 3a6b 6579 7325 7a3b 5f5f 5?"\n":keys%z;__
00000060: 4441 5441 5f5f 2000 0102 0304 0506 0708 DATA__ .........
00000070: 090b 0c0d 0e0f 1011 1213 1415 1617 1819 ................
00000080: 1a1b 1c1d 1e1f 2326 2728 292a 2b2d 2e30 ......#&'()*+-.0
00000090: 3334 3536 3738 3942 4345 4647 4849 4a4b 3456789BCEFGHIJK
000000a0: 4c4d 4e4f 5051 5253 5556 5758 595a 5b5d LMNOPQRSUVWXYZ[]
000000b0: 5e60 6162 6367 686a 6d71 7576 7778 7c7e ^`abcghjmquvwx|~
000000c0: 7f80 8182 8384 8586 8788 898a 8b8c 8d8e ................
000000d0: 8f90 9192 9394 9596 9798 999a 9b9c 9d9e ................
000000e0: 9fa0 a1a2 a3a4 a5a6 a7a8 a9aa abac adae ................
000000f0: afb0 b1b2 b3b4 b5b6 b7b8 b9ba bbbc bdbe ................
00000100: bfc0 c1c2 c3c4 c5c6 c7c8 c9ca cbcc cdce ................
00000110: cfd0 d1d2 d3d4 d5d6 d7d8 d9da dbdc ddde ................
00000120: dfe0 e1e2 e3e4 e5e6 e7e8 e9ea ebec edee ................
00000130: eff0 f1f2 f3f4 f5f6 f7f8 f9fa fbfc fdfe ................
00000140: ff4b 3d20 ab0a 247a 7b24 2f7d 2b2b 3b24 .K= ..$z{$/}++;$
00000150: 2f3d 245c 3d24 403b 2124 7a7b 245f 7d3f /=$\=$@;!$z{$_}?
00000160: 247a 7b24 5f7d 3d31 3a64 656c 6574 6524 $z{$_}=1:delete$
00000170: 7a7b 245f 7d66 6f72 2073 706c 6974 2f2f z{$_}for split//
00000180: 2c3c 4441 5441 3e3b 7072 696e 7420 6b65 ,<DATA>;print ke
00000190: 7973 257a 3e35 3f22 5c6e 223a 6b65 7973 ys%z>5?"\n":keys
000001a0: 257a 3b5f 5f44 4154 415f 5f20 0001 0203 %z;__DATA__ ....
000001b0: 0405 0607 0809 0b0c 0d0e 0f10 1112 1314 ................
000001c0: 1516 1718 191a 1b1c 1d1e 1f23 2627 2829 ...........#&'()
000001d0: 2a2b 2d2e 3033 3435 3637 3839 4243 4546 *+-.03456789BCEF
000001e0: 4748 494a 4b4c 4d4e 4f50 5152 5355 5657 GHIJKLMNOPQRSUVW
000001f0: 5859 5a5b 5d5e 6061 6263 6768 6a6d 7175 XYZ[]^`abcghjmqu
00000200: 7677 787c 7e7f 8081 8283 8485 8687 8889 vwx|~...........
00000210: 8a8b 8c8d 8e8f 9091 9293 9495 9697 9899 ................
00000220: 9a9b 9c9d 9e9f a0a1 a2a3 a4a5 a6a7 a8a9 ................
00000230: aaab acad aeaf b0b1 b2b3 b4b5 b6b7 b8b9 ................
00000240: babb bcbd bebf c0c1 c2c3 c4c5 c6c7 c8c9 ................
00000250: cacb cccd cecf d0d1 d2d3 d4d5 d6d7 d8d9 ................
00000260: dadb dcdd dedf e0e1 e2e3 e4e5 e6e7 e8e9 ................
00000270: eaeb eced eeef f0f1 f2f3 f4f5 f6f7 f8f9 ................
00000280: fafb fcfd feff 4b3d 20ab 0a24 7a7b 242f ......K= ..$z{$/
00000290: 7d2b 2b3b 242f 3d24 5c3d 2440 3b21 247a }++;$/=$\=$@;!$z
000002a0: 7b24 5f7d 3f24 7a7b 245f 7d3d 313a 6465 {$_}?$z{$_}=1:de
000002b0: 6c65 7465 247a 7b24 5f7d 666f 7220 7370 lete$z{$_}for sp
000002c0: 6c69 742f 2f2c 3c44 4154 413e 3b70 7269 lit//,<DATA>;pri
000002d0: 6e74 206b 6579 7325 7a3e 353f 225c 6e22 nt keys%z>5?"\n"
000002e0: 3a6b 6579 7325 7a3b 5f5f 4441 5441 5f5f :keys%z;__DATA__
000002f0: 2000 0102 0304 0506 0708 090b 0c0d 0e0f ...............
00000300: 1011 1213 1415 1617 1819 1a1b 1c1d 1e1f ................
00000310: 2326 2728 292a 2b2d 2e30 3334 3536 3738 #&'()*+-.0345678
00000320: 3942 4345 4647 4849 4a4b 4c4d 4e4f 5051 9BCEFGHIJKLMNOPQ
00000330: 5253 5556 5758 595a 5b5d 5e60 6162 6367 RSUVWXYZ[]^`abcg
00000340: 686a 6d71 7576 7778 7c7e 7f80 8182 8384 hjmquvwx|~......
00000350: 8586 8788 898a 8b8c 8d8e 8f90 9192 9394 ................
00000360: 9596 9798 999a 9b9c 9d9e 9fa0 a1a2 a3a4 ................
00000370: a5a6 a7a8 a9aa abac adae afb0 b1b2 b3b4 ................
00000380: b5b6 b7b8 b9ba bbbc bdbe bfc0 c1c2 c3c4 ................
00000390: c5c6 c7c8 c9ca cbcc cdce cfd0 d1d2 d3d4 ................
000003a0: d5d6 d7d8 d9da dbdc ddde dfe0 e1e2 e3e4 ................
000003b0: e5e6 e7e8 e9ea ebec edee eff0 f1f2 f3f4 ................
000003c0: f5f6 f7f8 f9fa fbfc fdfe ff4b 3d20 ab ...........K= .
```
## Explanation
This program consists of three identical parts. (Concatenating multiple identical portions of a program is something of a theme for me in [radiation-hardening](/questions/tagged/radiation-hardening "show questions tagged 'radiation-hardening'") programs.) Every A Pear Tree requires a checksum somewhere to let the interpreter know which parts of the program to run; it rotates any portion of the program for which the checksum succeeds to the start before running it (or prints `a partridge` if no checksum matches). In this case, we have a checksum on each of the three parts, and thus a non-irradiated part will move to the start. So we can assume that the program consists of an unmodified part, followed by two other parts (one of which may have been modified).
Each part starts with a newline, then continues with the following code (I've added whitespace and comments below):
```
$z{$/}++; # In the hash table %z, set the key "\n" to 1
$/=$\=$@; # Turn off newline handling when reading ($/ = undef);
# Also don't add newlines when printing ($\ = undef)
# $@ is set to undef by default
!$z{$_}? # If the current character is not in the hash table %z
$z{$_}=1: # place it in the hash table %z
delete$z{$_} # else remove it from the hash table %z
for split//, # for each character in
<DATA>; # the text appearing from the line beneath __DATA__ to EOF
print # Print the following (no newline because $\ was undefined):
keys%z>5? # if the hash table %z contains more than 5 elements:
"\n": # a newline; otherwise
keys%z; # every key of %z, separated by spaces
__DATA__ # Start a string literal running from after this line to EOF
```
After that comes a copy of every octet that hasn't been used in the program so far (purely to run the score up), and finally the checksum. (There's no trailing newline; parts start with a newline but don't end with one.)
There are three distinct cases here:
* **A character other than a newline was deleted**. In this case, it'll appear an odd number of times in the second and third parts. That means it'll be added and/or removed from `%z` an odd number of times, finally ending up in the hash table. In fact, it'll be the *only* key in the hash table (as the string runs from after the newline of the second part to the end of the third part, and the hash table started with just a single newline), so it'll just be printed out on its own.
* **The first or third newline was deleted**. In this case, the program will be rotated such that it's the third of the newlines that's missing, effectively merging the second and third parts into a single line. The string literal accessed via `<DATA>` contains every character an even number of times, so the hash table will have its original content, a single newline, and that'll get printed.
* **The second newline was deleted**. In this case, the program won't be rotated (as the first part has a valid checksum), so the second part will be moved onto the same line as the first part. `<DATA>` only starts reading from the line below `__DATA__`, so it'll only see the third part. This has more than five characters that appear an odd number of times, so it'll trigger the special case to print a newline.
## Verification
One final thing that has to be checked for pretty much any radiation-hardened A Pear Tree program is whether a deletion happens to randomly cause an unwanted section of the code to checksum correctly and rotate the code into the wrong place; given that we're using 32-bit checksums, this is unlikely but not impossible. I used the following brute-force script to ensure that this doesn't happen for any deletion:
```
use 5.010;
use IPC::Run qw/run/;
use warnings;
use strict;
use Data::Dumper;
$Data::Dumper::Useqq=1;
$Data::Dumper::Terse=1;
$Data::Dumper::Indent=0;
undef $/;
$| = 1;
my $program = <>;
for my $x (0 .. (length($program) - 1)) {
my $p = $program;
my $removed = substr $p, $x, 1, "";
alarm 4;
say Dumper($p);
run [$^X, '-M5.010', 'apeartree.pl'], '<', \$p, '>', \my $out, '2>', \my $err;
if ($out ne $removed) {
print "Unexpected output deleting character $x ($removed)\n";
print "Output: {{{\n$out}}}\n";
print "Errors: {{{\n$err}}}\n";
exit;
}
}
say $program;
run [$^X, '-M5.010', 'apeartree.pl'], '<', \$program, '>', \my $out, '2>', \my $err;
if ($out ne '') {
print "Unexpected output not mutating\n";
print "Output: {{{\n$out}}}\n";
print "Errors: {{{\n$err}}}\n";
exit;
}
say "All OK!";
```
The verification script confirms that this program works correctly.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 11 bytes (Score of 4)
```
'''cc'~~'dd
```
[Run and debug online!](http://staxlang.xyz/index.html#c=%27%27%27cc%27%7E%7E%27dd&i=&a=1)
It is my honor to have the first (chronologically) answer to this challenge with a score higher than or equal to 4. Maybe the score can be even higher though.
In Stax, a string literal that is composed of a single character is written with `'`, so `'', 'c, 'd, '~` are all string literals. The corresponding commands for `c` `d` and `~` means duplicate the top of the main stack, pop the top of the main stack, and pop the top of the main stack and push to the input stack, respectively. For this challenge, input stack does not affect output and is not important, hence we can say `d` and `~` are identical.
## Explanation
It is best to divide the code into several parts and consider them separately.
When it is not tampered with, `'''cc` pushes a literal `'` and a literal `c` to the main stack, and duplicates the top, so the stack would be (from to bottom) `c,c,'`.
When not tampered with, `'~~` pushes the literal `~` and then pops it (and push to the input stack), which is basically a no-op for the main stack.
When not tampered with, `'dd` pushes the literal `d` and then pops it, another no-op for the main stack.
At the end of the program, since no explicit output is done, the top of the main stack will be implicitly printed out.
If the program is running as-is, the final stack is still `c,c,'` and will output `c`.
If the first part becomes `''cc`, then we have a literal `'`, and two copy instructions, the final stack will be `',','`. Given that the two other parts are no-op, the result will be `'`.
If the first part becomes `'''c`, the result is basically the same with the untampered one, but the `c` is not duplicated. So the stack will be `c,'`. After two no-op's the top of the stack is `c`.
So we can detect radiation in the first part.
The second part and the third part work in exactly the same way. I will take the third part as an example.
If the third part is tampered with, then the first two parts are kept as-is and the stack before running the third part is `c,c,'`
If the third part becomes `'d`, a literal `d` is pushed to the top of the main stack and nothing further is done. The top of the main stack is now `d` which will be output.
If the third part becomes `dd`, two elements are popped from the main stack and now the top of the stack is `'` and is output.
Hence we can detect radiation in the third part. For the same reason we can detect radiation in the second part.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), score 2, 6 bytes
```
„"""„„
```
Prints double the removed character sometimes. Doesn't contain `'`.
# How it works:
## Removing the first `„`
```
"""„„
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fSUnpUcM8IPr/HwA "05AB1E – Try It Online")
First, we push an empty string literal to the stack. Then we push `„„`, which is printed implicitly.
## Removing a `"`
```
„""„„
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcM8JSUgAUT//wMA "05AB1E – Try It Online")
First, we push `""` to the stack with the `2-char string` instruction. Then we try to get another 2-character string, but this is aborted (I'm not exactly sure why) and the `""` is printed.
## Removing the second or third `„`
```
„"""„
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcM8JSUlIPn/PwA "05AB1E – Try It Online")
First, we push `""` to the stack with the `2-char string` instruction. Then we push `„`, which is printed implicitly.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes, score 2
```
”””ḷḷ
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw1wIerhjOxD9/w8A "Jelly – Try It Online")
**With any `”` removed:**
```
””ḷḷ
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw1wgerhjOxD9/w8A)
The character `”` begins a one byte character literal. This programs begins with `””` which yields the string `”`. The `ḷ` dyad takes it's left argument. The string `”` just gets passed through the two instances of `ḷ`.
**With any `·∏∑` removed:**
```
”””ḷ
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw1wIerhj@///AA)
In this program `””` yields the character `”` then `”ḷ` yields the character `ḷ` and only this is output.
---
**Other solutions**
* Lots of other characters such as `a` or `o` would have worked in place of `·∏∑` for this submission.
* `⁾⁾⁾⁾FFF`. This works in a similar way. `⁾` is like `”` but it starts a *two* byte string literal. The "irradiated" programs output the deleted byte twice which was ruled valid in the comments.
---
[Here](https://tio.run/##y0rNyan8/9/n4c41j5rWHJ1cACQP7bTWB1JhIIE9Dod2uv////9Rw1wIerhjOxABAA) is a (much less fancy) Jelly version of Magic Octopus Urn's validity checker. The left column of the output is the deleted character and the right column is the output of the resulting program.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 65 bytes, score 22
```
\\\::\__\⅛⅛\££\→→\((\[[\‟‟\**\••\--\oo\PP\ḞḞ\↳↳\↲↲\⋏⋏\ǑǑ\FF\jj\∇∇
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJcXFxcXFw6OlxcX19cXOKFm+KFm1xcwqPCo1xc4oaS4oaSXFwoKFxcW1tcXOKAn+KAn1xcKipcXOKAouKAolxcLS1cXG9vXFxQUFxc4bie4bieXFzihrPihrNcXOKGsuKGslxc4ouP4ouPXFzHkceRXFxGRlxcampcXOKIh+KIhyIsIiIsIiJd)
Based on [Weijun Zhou's Stax answer](https://codegolf.stackexchange.com/a/155997/100664).
In Vyxal, `\` takes the next character as a single character. So, the bit at the start `\\\::` pushes `"\"`, pushes `":"`, then duplicates it with the operation `:`.
The stack is now `["\", ":", ":"]`.
If either `:` is removed, the `:` operation is not run and the stack is just `["\", ":"]`. If any `\` is removed, the stack becomes `["\","\","\"]`.
The rest of the program is chunks of `\xx`, where x is some operation that effectively does nothing but remove a string from the stack. These chunks normally do nothing, as they effectively push and pop a value.
If a backslash is removed, an operation that effectively pops the stack is run twice, removing the two `":"` from the stack and leaving the backslash we pushed at the start.
If either x is removed, the string `"x"` is pushed to the stack and not removed.
Finally, the top of the stack is implicitly output.
### Operations, and why they work
For these, `x` is the value already on the stack and `y` is the value
* `_` - Simply pops `y`
* `‚Öõ` - Pushes `y` to the global array.
* `£` - Stores `y` to the register
* `‚Üí` - Stores `y` to the empty variable
* `(` - starts a for loop over `y`. As it's a 1-character string the code inside is run once
* `[` - If `y` is truthy, execute the remaining code. It will always be truthy.
* `‚Äü` - Rotate `y` to the bottom of the stack.
* `*` - Ring translate `x` by `y`. Since the strings share no characters, nothing happens.
* `•` - Give `x` the casing of `y`. Since this occurs before anything alphabetical, nothing happens.
* `-` - Remove `y` from `x`
* `o` - Remove `y` from `x`
* `P` - Strip `y` from the outside of `x`
* `·∏û` - Replace spaces in `x` with `y`. There are no spaces in `x`.
* `↳` - Pad `x` according to `y`
* `↲` - Pad `x` according to `y`
* `‚ãè` - Center `x` according to `y`
* `«ë` - Remove `y` from `x` until `x` doesn't change
* `F` - Remove characters in `y` from `x`
* `j` - Join `y` by `x`. This does nothing to a 1-character `x`.
* `‚àá` - Rotate the top three items of the stack. Has to be at the end.
] |
[Question]
[
This one comes from a real life problem. We solved it, of course, but it keeps feeling like it could have be done better, that it's too lengthy and roundabout solution. However none of my colleagues can think of a more succinct way of writing it. Hence I present it as code-golf.
The goal is to convert a nonnegative integer into a string the same way Excel presents its column headers. Thus:
```
0 -> A
1 -> B
...
25 -> Z
26 -> AA
27 -> AB
...
51 -> AZ
52 -> BA
...
16,383 -> XFD
```
It has to work **at least** up to 16,383, but beyond is acceptable too (no bonus points though). I'm looking forward most to the C# solution, but, as per traditions of code-golf, any real programming language is welcome.
[Answer]
## Excel Formula:), 36 chars
```
=SUBSTITUTE(ADDRESS(1,A1,4),"1","")
```
Usage:
Sorry, couldn't resist ...
[Answer]
## Perl, 17 characters
```
say[A..XFD]->[<>]
```
The `..` operator does the same thing as the magical auto-increment, but without the need for the temporary variable and loop. Unless `strict subs` is in scope, the barewords `A` and `XFD` are interpreted as strings.
(*This answer was [suggested](https://codegolf.stackexchange.com/review/suggested-edits/1786) by an anonymous user as an edit to [an existing answer](https://codegolf.stackexchange.com/questions/3971/generate-excel-column-name-from-index/3979#3979). I felt it deserves to be a separate answer, and have made it one. Since it wouldn't be fair for me to gain rep from it, I've made it Community Wiki.*)
[Answer]
## Haskell, 48
```
f=(!!)(sequence=<<(tail$iterate(['A'..'Z']:)[]))
```
Less golfed:
```
f n = (concatMap sequence $ tail $ iterate (['A'..'Z'] :) []) !! n
```
### Explanation
Haskell's [`sequence`](http://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.html#v%3asequence) combinator takes a list of actions and performs them, returning the result of each action in a list. For example:
```
sequence [getChar, getChar, getChar]
```
is equivalent to:
```
do
a <- getChar
b <- getChar
c <- getChar
return [a,b,c]
```
In Haskell, actions are treated like values, and are glued together using the `>>=` (bind) and `return` primitives. Any type can be an "action" if it implements these operators by having a [Monad](http://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.html#t%3aMonad) instance.
Incidentally, the list type has a monad instance. For example:
```
do
a <- [1,2,3]
b <- [4,5,6]
return (a,b)
```
This equals `[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]` . Notice how the list comprehension is strikingly similar:
```
[(a,b) | a <- [1,2,3], b <- [4,5,6]]
```
Because lists are a type of "action", we can use `sequence` with lists. The above can be expressed as:
```
sequence [[1,2,3],[4,5,6]]
```
Thus, `sequence` gives us combinations for free!
Thus, to build the list:
```
["A","B"..."Z","AA","AB"]
```
I just need to build lists to pass to `sequence`
```
[['A'..'Z'],['A'..'Z','A'..'Z'],...]
```
Then use [`concatMap`](http://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.html#v%3aconcatMap) to both apply `sequence` to the lists, and concatenate the resulting lists. Coincidentally, `concatMap` is the `=<<` function for lists, so the list monad lets me shave a few characters here, too.
[Answer]
## C, 53 characters
It's like playing golf with a hammer...
```
char b[4],*p=b+3;f(i){i<0||(*--p=i%26+65,f(i/26-1));}
```
Normal version:
```
char b[4];
char *p = b+3;
void f(int i) {
if (i >= 0) {
--p;
*p = i%26 + 65;
f(i/26-1);
}
}
```
And the usage is like that:
```
int main(int argc, char *argv[])
{
f(atoi(argv[1]));
printf("%s\n", p);
return 0;
}
```
[Answer]
# Perl, 26 characters
```
$x='A';map$x++,1..<>;say$x
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~16~~ 14 bytes
```
{("A"..*)[$_]}
```
Works even beyond XFD. Thanks to infinite lists in Perl 6, this doesn't take forever (and a half) to execute.
[Try it online!](https://tio.run/##K0gtyjH7n1upoJKmYPu/WkPJUUlPT0szWiU@tva/NVdafpGCgY6CoY6CkSkQmwGxuY6CKZBvagQUNjO2MFbQtVNQqVCo5lIAguJEkEkaKhWa1ly1/wE "Perl 6 – Try It Online")
[Answer]
### Ruby, 35 characters
```
e=->n{a=?A;n.times{a.next!};a}
```
Usage:
```
puts e[16383] # XFD
```
Note: There is also a shorter version (30 characters) using recursion.
```
e=->n{n<1??A:e[n-1].next}
```
But using this function you might have to increase the stack size for large numbers depending on your ruby interpreter.
[Answer]
# Groovy, 47
```
m={it<0?'':m(((int)it/26)-1)+('A'..'Z')[it%26]}
[0:'A',1:'B',25:'Z',
26:'AA',
27:'AB',
51:'AZ',
52:'BA',
16383:'XFD'].collect {k,v-> assert v == m(k);m(k) }
```
[Answer]
# Python 45 ~~51~~
```
f=lambda i:i>=0and f(i/26-1)+chr(65+i%26)or''
```
[Answer]
# PHP, 30 bytes
```
for($c=A;$argn--;)$c++;echo$c;
```
Run as pipe with `-nr' or [try it online](http://sandbox.onlinephpfunctions.com/code/c14b95165411e7e3da7e79e05f1c08c9dd82f0f8).
[Answer]
## Excel (MS365), 32 bytes.
```
=TEXTBEFORE(ADDRESS(1,A1,4),"1")
```
[](https://i.stack.imgur.com/ghA8k.png)
[Answer]
## Scala, 62 characters
```
def f(i:Int):String=if(i<0)""else f((i/26)-1)+(i%26+65).toChar
```
Usage:
```
println(f(16383))
```
returns:
```
XFD
```
You can try this on [Simply scala](http://www.simplyscala.com/). Copy and paste the function and use `f(some integer)` to see the result.
[Answer]
# Excel VBA, 31 Bytes
Anonymous VBE immediate window function that takes input from cell `[A1]` and outputs to the VBE immediate window
```
?Replace([Address(1,A1,4)],1,"")
```
[Answer]
# Java, 57 bytes (recursive)
```
String f(int n){return n<0?"":f(n/26-1)+(char)(n%26+65);}
```
[Try it online.](https://tio.run/##RY/BisJADIbvfYpQEGYYrLXFslhln2BPHtXDWNvduG0qM6kg0mev4zjgJZDk5/uSi77p@eX8P1WtthZ@NNIjArCsGSuYdmyQfqERSAwkH6bmwRDQJv2O43UjaJEV86VUovrTRgqaZYUqVrIcpzJymOtwah0m0G49nqFzBvHG7o9avmQAXFsWqSx90/TG63CbpSVutrmrSkm/C1EMUd8si/wr94Mx@pzuZe/wixVEu7vlukv6gZOrO4FbEqji9YFj5X6UgTJOTw)
**Explanation:**
```
String f(int n){ // Recursive method with integer parameter and String return-type
return n<0? // If `n` is negative:
"" // Return an empty String
: // Else:
f(n/26-1) // Recursive call with `n` integer-divided by 26, minus 1
+(char)(n%26+65);} // And append `n%26+65` as character
```
---
# Java 10, 62 bytes (iterative)
```
n->{var r="";for(;n>=0;n=n/26-1)r=(char)(n%26+65)+r;return r;}
```
[Try it online.](https://tio.run/##ZZDBasMwDIbvfQoRGNiYZGnCwpjnvsF66XHbwUvTzl2qFFkJjJJnz5zEt10Ekn7@/5MudrDp5fgz1a31Ht6sw/sGwCE3dLJ1A/u5BTgwOTxDLcIGUOowHDeheLbsatgDgoEJ0919sARkkkSfOhIadybXaPCxqNKtJCPqb0tS4ENRqepJKtLUcE8IpMdJz463/qsNjtF46NwRroFKrATvn1auRNx4FvlCAjBnzWTOFLl2r6YMVSm57KLURenSbKvyufx3xRK2imevGHT49dxcs67n7BYQuEXhVPLywYnCLDxERp9x@gM)
**Explanation:**
```
n->{ // Method with integer parameter and String return-type
var r=""; // Result-String, starting empty
for(;n>=0; // Loop as long as `n` is not negative
n=n/26-1) // After every iteration: divide `n` by 26, and subtract 1
r=(char)(n%26+65)+r; // Prepend `n%26+65` as character to the result-String
return r;} // Return the result-String
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 50 bytes
```
f=_=>_<0?'':f(_/26-1)+String.fromCharCode(_%26+65)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbe1i7exsBeXd0qTSNe38hM11BTO7ikKDMvXS@tKD/XOSOxyBmoVCNe1chM28xU839yfl5xfk6qXk5@ukaahqGm5n8A "JavaScript (Node.js) – Try It Online")
Seeing that a lot of people started answering this I answered too.
# Note :
This is basically a rip off of @kevinCruijssen's answer in Java shortened thanks to this being JS.
[Answer]
# [Jq 1.5](https://stedolan.github.io/jq/), 71 bytes
```
[range(1;4)as$l|[65+range(26)]|implode/""|combinations($l)]|map(add)[N]
```
Expects input in `N`. e.g.
```
def N:16383;
```
Expanded:
```
[ # create array with
range(1;4) as $l # for each length 1,2,3
| [65+range(26)] # list of ordinal values A-Z
| implode/"" # converted to list of strings ["A", "B", ...]
| combinations($l) # generate combinations of length $l
]
| map(add)[N] # return specified element as a string
```
[Try it online!](https://tio.run/##JcnRDoIgGEDhV2HmhS5YicFavoMvwLz4C2o4BBKoG549cnX5nTM/i1R3NF7QEVOGKceM4o73535AOxRViOgFJqlQxAr2oZpuOLUQapMFZ/t/orydsl68cVIdqirf3HLVFqJ2NjS12eYCvgEpWzFOpXyc/61CiE3GEG19ihtWeBOX4oYv "jq – Try It Online")
[Answer]
# VBA/VB6/VBScript (non-Excel), 73 bytes
```
Function s(i):While i:i=i-1:s=Chr(i Mod 26+65)&s:i=i\26:Wend:End Function
```
Calling `s(16383)` will return `XFC`.
[Answer]
# Javascript, 147 bytes
I had a similar problem. This is the golf of the solution. Excel columns are [bijective base-26](https://en.wikipedia.org/wiki/Bijective_numeration#The_bijective_base-26_system).
```
n=>{f=Math.floor;m=Math.max;x=m(0,f((n-24)/676));y=m(0,f(n/26-x*26));return String.fromCharCode(...[x,y,n+1-x*676-y*26].filter(d=>d).map(d=>d+64))}
```
Expanded, except using 1-indices:
```
function getColName(colNum){ // example: 16384 => "XFD"
let mostSig = Math.max(0, Math.floor((colNum - 26 - 1)/26**2));
let midSig = Math.max(0, Math.floor((colNum - mostSig*26**2 - 1)/26));
let leastSig = colNum - mostSig*26**2 - midSig*26;
return String.fromCharCode(...[mostSig,midSig,leastSig].filter(d=>d).map(d=>d+64));
}
```
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 59 bytes
```
: f dup 0< if drop else 26 /mod 1- recurse 65 + emit then ;
```
[Try it online!](https://tio.run/##hczRCsIwDAXQ937FZa@yGgdOcfsZaVNX2GzJuu@vqc@CEEi4nNyQpCz9K7RV6wMB/sigGVEvSRm87oxhxHlLHpcewu4QjcYrTuAtFpSF35j0tzRH8AlRe/b8dIw1acdkCpzomIZuNDT4j92JvvSnM7aDtbarHw "Forth (gforth) – Try It Online")
## Explanation
```
dup 0< \ duplicate the top of the stack and check if negative
if drop \ if negative, drop the top of the stack
else \ otherwise
26 /mod \ divide by 26 and get the quotient and remainder
1- recurse \ subtract one from quotient and recurse on result
65 + emit \ add 65 to remainder and output ascii char
then \ exit if statement
```
[Answer]
# [R](https://www.r-project.org/), 65 bytes
Recursive answer as are many previous answers.
```
function(n,u=LETTERS[n%%26+1])"if"(n<=25,u,paste0(g(n%/%26-1),u))
```
[Try it online!](https://tio.run/##DcuxCoMwEIDhVxEhcEdPak4SO@jo1ql1Kx2KNHLLKWny/Gnm//9i2aeuhKxbkkNBKc/3ZV2Xx/OlxrC/2De2ElrQaWZHmc7PL3172EHNtfbOImXEEo4I0og2G/Rkqa7siUdylhyT9cNtQDyjaKpUKvgD "R – Try It Online")
[Answer]
# Powershell, 68 bytes
```
param($n)for(;$n-ge0;$n=($n-$r)/26-1){$s=[char](($r=$n%26)+65)+$s}$s
```
Alternative recursive version, 68 bytes:
```
filter g{if($_-ge0){(($_-($r=$_%26))/26-1|f)+[char]($r+65)}else{''}}
```
Test script:
```
$f = {
param($n)for(;$n-ge0;$n=($n-$r)/26-1){$s=[char](($r=$n%26)+65)+$s}$s
}
filter g{if($_-ge0){(($_-($r=$_%26))/26-1|f)+[char]($r+65)}else{''}}
@(
,(0 , "A")
,(1 , "B")
,(25 , "Z")
,(26 , "AA")
,(27 , "AB")
,(51 , "AZ")
,(52 , "BA")
,(676 , "ZA")
,(702 , "AAA")
,(16383 , "XFD")
) | % {
$n, $expected = $_
$result = &$f $n
# $result = $n|g # Alternative
"$($result-eq$expected): $result"
}
```
Output:
```
True: A
True: B
True: Z
True: AA
True: AB
True: AZ
True: BA
True: ZA
True: AAA
True: XFD
```
Note: Powershell does not provide a `div` operator.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 26 bytes
```
->n{(?A..).take(n+1).last}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuha7dO3yqjXsHfX0NPVKErNTNfK0DTX1chKLS2ohClYVKLhFG5oZWxjHQgQWLIDQAA)
[Answer]
# Excel, 30 bytes
```
=@TEXTSPLIT(ADDRESS(1,A1,4),1)
```
[Answer]
# Haskell, 48
I really thought that I would be able beat the other Haskell entry, but alas...
```
f(-1)=""
f n=f(div n 26-1)++[toEnum$mod n 26+65]
```
I am certain it is possible to shave a couple of characters off this, but I haven't coded in Haskell for nearly a year, so I am quite rusty.
It's not exactly what you would call elegant.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 29 bytes
```
!v:2d*%:"A"+@-2d*,1-:0(?!
$<o
```
[Try it online!](https://tio.run/##S8sszvj/X7HMyihFS9VKyVFJ20EXyNQx1LUy0LBX5FKxyf///79umYKhmbGFMQA "><> – Try It Online")
[Answer]
# [Icon](https://github.com/gtownsend/icon), 58 bytes
```
procedure f(n);return(n<0&"")|f(n/26-1)||char(65+n%26);end
```
[Try it online!](https://tio.run/##Xc5BCoNADAXQfU8hQktCKdWRSQt6GRkjzsJYguJm7m6nu5rs/oOfJIZFjuOjS@BhUy5GEGyV100FpKtuZYkp29PRo8aUwtQrkL/L1RG2LMNfde6jAF6KPLvGlWGECs@5Ntl5C2ThZcDbHd7ZI9S8m2y/774 "Icon – Try It Online")
[Answer]
# [Factor](https://factorcode.org) + `successor`, 27 bytes
```
[ "A"[ successor ] repeat ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70sLTG5JL9owc3LocGefu5WCumpealFiTmZVYklmfl5xQoFRaklJZUFRZl5JQrFqYWlqXnJqcUKxaXJQKo4v0jBmourmksBCAwUwEBRQddOwREsYogk4gQWMTJFiERBRMyQdEG0GZkjCUH0mRoiCUE0mhohGQ61z0zH2MIYIhTh5sJVu7S0JE3XYne0gpKjUjSSm2MVilILUhNLFGIhKlblJhYoFJckJmfrQQQWLIDQAA)
Yup, Factor has a vocab for this.
[Answer]
# C (GCC), 39 bytes
```
f(i){i>25&&f(i/26-1);putchar(65+i%26);}
```
[Try It Online!](https://tio.run/##jc7BCsIwDAbge58iDDZau2E32A5WfRH1UCqdOThHmV5Gn722ojiQDXPJT/IFootWa@8NRTbivqqzLMR11RQlk/190BdlaVNzTKuGSeexG@CqsKMxKNvqHCKBVciPw4mRkcC7zM3CiyHsQMjQtlCKEDhHBl/3qd4GbGiSnjeQ5IBM/pD4pZw9PHbJZOsIWQaGhm/EZLDE/nbz0Pkn)
Explanation:
```
f(i)
{
// If i cannot be represented as a single letter
i>25 &&
// Print the next letter
f(i/26-1);
// Print the current letter
putchar(65+i%26);
}
```
I thought using 0-based indexing was a little strange, so here's 1-based indexing in the same number of bytes:
```
f(i){i-->26&&f(i/26);putchar(65+i%26);}
```
[Try It Online!](https://tio.run/##jc69CsIwEADgPU9xFFoS02AtmMGoL6IOIZJ6g7GE6lL67DERxYK0eMv9fQdnRGNMCJYi61GIfS2LIjbLWjLV3jtz0Z7KNcc8DYaAroOrRkdToX1jSkgEFrF@HE6M9ATeYW8eXgxhBysV0zbmqlLAOTL4wk@0PmpLs/y8gawEZOqHpDfV5OHRZaPtQMg8sDR@U40Gc@xvNw0HEp4)
] |
[Question]
[
Alternate name: `ChessMoveQ`
Given a list of up to 32 elements, each consisting of 4 elements, and a second list with 4 elements, determine whether the move detailed in the second input is a valid chess move.
The first list indicates the position of all 32 pieces on the board. Each element will follow the structure `<colour>, <piece-name>, <x-coord>, <y-coord>`, such as `["W", "K", 5, 1]`, which indicates that the white king is on `5, 1` (`e1` on a normal chess board). All elements of the first input will be unique. `<x-coord>` and `<y-coord>` will always be between 1 and 8. One example would be:
```
[["B", "K", 3, 8], ["B", "Q", 1, 5], ["B", "N", 4, 7], ["B", "N", 7, 8],
["B", "B", 2, 4], ["B", "R", 4, 8], ["B", "R", 8, 8], ["B", "P", 1, 7],
["B", "P", 2, 7], ["B", "P", 3, 6], ["B", "P", 5, 6], ["B", "P", 6, 7],
["B", "P", 7, 7], ["B", "P", 8, 7], ["W", "K", 5, 1], ["W", "Q", 6, 3],
["W", "N", 3, 3], ["W", "B", 5, 2], ["W", "B", 6, 4], ["W", "R", 1, 1],
["W", "R", 8, 1], ["W", "P", 1, 3], ["W", "P", 2, 2], ["W", "P", 3, 2],
["W", "P", 4, 4], ["W", "P", 6, 2], ["W", "P", 7, 2], ["W", "P", 8, 3]]
```
which would represent the board:
[](https://i.stack.imgur.com/NhRX7.png)
The second input will consist of the same structures as the sublists of the first one, but rather than the x and y coordinates indicating where the piece is, they are indicating where it is trying to move to.
For the above example, a valid move could be `["W", "B", 4, 3]` (bishop moves one square forward and to the left), and an invalid move could be `["B", "R", 4, 1]` as the rook would have to move through the knight, and the pawn to get to the square. As the move could refer to multiple pieces at times, you must test whether *any* of the specified pieces can make the move, not just one of them. For instance, the first example is valid for only one bishop, but it is still a valid move. However, neither black rook can perform the second move, so it is invalid.
Your task is to determine whether the move detailed in the second input is a valid chess move. The validity of a rule varies, depending on the piece trying to move (click on the name of the piece for a diagram of valid moves):
* **Any piece**: No pieces can move onto an already occupied square, or off the board, unless that square is occupied by a piece from the other colour. For example, a white piece may move onto a square occupied by a black piece, but not a white piece. Additionally, no pieces, except for Knights, can move to squares which are directly obstructed by another piece.
+ A move by piece **B** to square **C** is "directly obstructed" by piece **A** if **A** is directly, in a straight (orthogonal or diagonal) line, between **B** and **C**.
* **Any piece**: The position of the king can also affect the validity of a piece's move. If either of these two conditions are met, the move is invalid:
+ Exposing the king to check, by moving a piece on the same side as the endangered king. This only applies if a non-opposing piece makes the move, rather than an opposing piece moving to place the king into check.
+ Leaving the king in check, in which case it *has* to move out of check. Therefore, if the king is in check and the move dictates that another piece moves, it is an invalid move, *unless* the other piece is preventing check. A piece can prevent check in one of two ways: either it takes the piece performing check, or it obstructs the path between the piece performing check and the king.
+ A "check" is a situation in which the king's opponent could (if it was their turn to move) legally move a piece onto that king. This rule does not apply recursively, i.e. a king is in check even if the move by the opponent onto that king would leave their own king in check.
* [**Pawns**](https://i.stack.imgur.com/VmwIB.gif): A pawn can move forwards (i.e. upwards if white, downwards if black) one square to an unoccupied square. There are also three special situations:
+ If the pawn hasn't yet moved (you can determine this using the Y-coordinate; white pawns haven't moved if their Y-coordinate is 2, black pawns haven't moved if their Y-coordinate is 7), the pawn is allowed to move two squares forward to an unoccupied square.
+ If there is an opponent's piece diagonally in front of the pawn (i.e. on the square to the north-west or north-east of the pawn if it is white, or to the south-west or south-east if it is black), the pawn is allowed to move onto the occupied square in question.
+ If a pawn moves to the final Y-coordinate (8 for white, or 1 for black) in normal chess rules it must be promoted to a queen, rook, knight, or bishop of the same color. For the purposes of this question, the choice of promotion is irrelevant to whether the move is valid or not (and cannot be expressed in the input format), but pawn moves that would result in promotion must be allowed.
* [**Bishops**](https://i.stack.imgur.com/0rNIP.gif): Bishops can move between 1 and 8 squares along any continuous non-obstructed intercardinal (i.e. diagonal) path.
* [**Knights**](https://i.stack.imgur.com/utNVJ.jpg): Knights can move in an `L` shape, consisting of either of the following (equivalent) moves:
+ A single square in any cardinal direction, followed by a 90/270° turn, followed by a final move of 2 squares forward.
+ 2 squares in any cardinal direction, followed by a 90/270° turn, followed by a final move of a single square forward.
(Remember that the path of a knight cannot be blocked by intervening pieces, although its final square must still be legal.)
* [**Rooks**](https://i.stack.imgur.com/aw0ID.gif): Rooks can move between 1 and 8 squares along any continuous non-obstructed cardinal path.
* [**Queens**](https://i.stack.imgur.com/J0d5P.gif): Queens can move between 1 and 8 squares along any continuous cardinal or intercardinal (i.e. diagonal) non-obstructed path.
* [**Kings**](https://i.stack.imgur.com/rUiHI.gif): Kings move like queens, except that they are limited to moving only one square per move (i.e. a king can only move to cardinally or diagonally adjacent squares). As a reminder, you cannot make a move that leaves your king in check; thus you cannot move your king into check, either.
The rules of chess also contain special moves called "castling" and "en passant". However, because the legality of these moves depend on the history of the game, not just the current position (and because castling requires moving two pieces at once, which doesn't fit with the input format), you should consider neither of these moves to exist (i.e. a move that would be castling or en passant should be considered illegal).
You may output any two distinct results to indicate the validity of a move, and you may take input in a method you want. You may also choose 0-indexing rather than 1-indexing for the positions if you prefer. This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code wins!
## Test cases
```
Board
Move => Output (Reason)
[["B", "K", 3, 8], ["B", "Q", 1, 5], ["B", "N", 4, 7], ["B", "N", 7, 8], ["B", "B", 2, 4], ["B", "R", 4, 8], ["B", "R", 8, 8], ["B", "P", 1, 7], ["B", "P", 2, 7], ["B", "P", 3, 6], ["B", "P", 5, 6], ["B", "P", 6, 7], ["B", "P", 7, 7], ["B", "P", 8, 7], ["W", "K", 5, 1], ["W", "Q", 6, 3], ["W", "N", 3, 3], ["W", "B", 5, 2], ["W", "B", 6, 4], ["W", "R", 1, 1], ["W", "R", 8, 1], ["W", "P", 1, 3], ["W", "P", 2, 2], ["W", "P", 3, 2], ["W", "P", 4, 4], ["W", "P", 6, 2], ["W", "P", 7, 2], ["W", "P", 8, 3]]
["W", "R", 8, 2] => True (The rook on h1 can move forward one)
[['B', 'K', 6, 8], ['B', 'Q', 1, 7], ['B', 'N', 1, 3], ['B', 'N', 7, 1], ['B', 'B', 8, 8], ['B', 'B', 2, 5], ['B', 'R', 4, 3], ['B', 'R', 1, 5], ['B', 'P', 5, 5], ['B', 'P', 7, 2], ['B', 'P', 5, 7], ['B', 'P', 5, 6], ['B', 'P', 4, 4], ['W', 'K', 7, 3], ['W', 'Q', 3, 2], ['W', 'N', 4, 8], ['W', 'N', 7, 5], ['W', 'B', 1, 1], ['W', 'B', 8, 1], ['W', 'R', 1, 8], ['W', 'R', 3, 7], ['W', 'P', 8, 2], ['W', 'P', 6, 3], ['W', 'P', 4, 2], ['W', 'P', 1, 4], ['W', 'P', 8, 7]]
['W', 'N', 1, 5] => False (Neither knight to move to a5 from where they are)
[['B', 'K', 7, 3], ['B', 'Q', 2, 4], ['B', 'N', 5, 2], ['B', 'N', 1, 6], ['B', 'B', 7, 7], ['B', 'B', 1, 8], ['W', 'K', 7, 1], ['W', 'Q', 6, 1], ['W', 'N', 5, 6], ['W', 'N', 3, 3], ['W', 'B', 2, 2], ['W', 'B', 6, 5]]
['B', 'K', 8, 3] => False (The white bishop would put the king in check)
[['B', 'K', 7, 6], ['B', 'Q', 8, 3], ['B', 'N', 7, 7], ['B', 'N', 8, 7], ['B', 'B', 2, 2], ['B', 'B', 3, 8], ['B', 'R', 1, 1], ['B', 'R', 1, 6], ['B', 'P', 8, 5], ['B', 'P', 4, 3], ['B', 'P', 8, 6], ['W', 'K', 7, 8], ['W', 'Q', 7, 2], ['W', 'N', 5, 1], ['W', 'N', 4, 6], ['W', 'B', 1, 2], ['W', 'B', 2, 6], ['W', 'R', 4, 4], ['W', 'R', 3, 6], ['W', 'P', 5, 2], ['W', 'P', 6, 2]]
['B', 'N', 5, 8] => False (The white queen currently has the king in check, and this move doesn't prevent that)
[['B', 'K', 7, 6], ['B', 'Q', 8, 3], ['B', 'N', 7, 7], ['B', 'N', 8, 7], ['B', 'B', 2, 2], ['B', 'B', 3, 8], ['B', 'R', 1, 1], ['B', 'R', 1, 6], ['B', 'P', 8, 5], ['B', 'P', 4, 3], ['B', 'P', 8, 6], ['W', 'K', 7, 8], ['W', 'Q', 7, 2], ['W', 'N', 5, 1], ['W', 'N', 4, 6], ['W', 'B', 1, 2], ['W', 'B', 2, 6], ['W', 'R', 4, 4], ['W', 'R', 3, 6], ['W', 'P', 5, 2], ['W', 'P', 6, 2]]
['B', 'N', 7, 5] => True (The king is in check, and the knight blocks that)
[['B', 'K', 8, 3], ['B', 'Q', 6, 5], ['B', 'N', 7, 8], ['B', 'N', 3, 7], ['B', 'B', 4, 1], ['B', 'B', 1, 1], ['W', 'K', 7, 7], ['W', 'Q', 7, 1], ['W', 'N', 2, 2], ['W', 'N', 1, 3], ['W', 'B', 3, 5]]
['B', 'B', 2, 2] => True (takes the white knight)
[['B', 'K', 6, 1], ['B', 'Q', 6, 2], ['W', 'K', 8, 1]]
['B', 'Q', 7, 1] => True (Smallest checkmate possible, in terms of bounding box)
```
This challenge was [sandboxed](https://codegolf.meta.stackexchange.com/a/14204/66833). It received downvotes, without any explanation, so I decided to post it anyway
[Answer]
# Regex (PCRE2), ~~931~~ ~~925~~ 837 bytes
This solution departs from the problem statement in that two board states are passed to the regex, instead of one board state and a move. The move is inferred from the difference between the two board states. So I made it the job of the TIO program to take the test cases in the format provided by this question, find all instances of the described piece on the board, and with each one, try moving it to the destination position and evaluating the regex with that possibility, finding if any are reported by the regex as valid. If this is not okay, let me know; it's possible to implement a regex as position + move, but would be much less elegant and require serious refactoring.
The board is represented in 8×8 ASCII where white pieces are uppercase and black are lowercase: **P**awn, k**N**ight, **B**ishop, **R**ook, **Q**ueen, **K**ing. Black's side (the 8th rank) is on the top and white's side (the 1st rank) is on the bottom. Each rank is separated by a newline, and empty squares are marked as `-`. The two board positions are separated by an extra newline.
The actual aim of this project is to validate entire games, not just single moves. See below for the current state of progress.
```
()?(?>|((.|
(?=.)){2})((?=(\X{72})-))((?=(?(1)[-a-z]|[-A-Z])))((?5)(?(?=(.*
)
)[qnrb]|p))((?5)(?(?=(?8){8}
)[QNRB]|P)))(?>((.)(?=(?5)\11)|(?(m)$)((?(1)(-(?=(?9))(?=(?3){8}((?3){9})?P(?4))(?(-1)(?=(?8){4}
))|[a-z](?=(?9))(?=(?3){7}(?2)?P(?4)))|(p(?4)((?=(?3){8}((?3){9})?-(?7))(?(-1)(?=(?8){7}
))|(?=(?3){7}(?2)?[A-Z](?7)))))|(?<e>(?6).)?(?=(?i:(?|(?(e)|(B|Q))(?27)(?(e)(B|Q))|(?(e)|(R|Q))(?31)(?(e)(R|Q))|(?(e)|(N))(?34)(?(e)(N))|(?(e)|(K))(?35)?(?(e)(K))))(?(e)(?<=(?!(?6)).)(?4)|(?6).(?5)\19))(?(e)(?=(?5)\20)|(?!(?6)).(?4)))(?<m>)|(?(+1)$)(.))+
)+\k<m>
(?!\X{0,70}((?(1)p|k)(?=(?3){7}(?2)?(?(1)K|P))|(?i:(?<E>(?!(?6))K)?((?(E)|((?6)[BQ]))(()?((?(-1)-)(?3){7}(?(-2)(?2)))+)(?(E)(?-4))|(?(E)|((?6)[RQ]))(-*|((?(-1)-)(?3){8})+)(?(E)(?-3))|(?(E)|((?6)N))((?<=..)(?2){3}|(?=.)(?2){5}|(?2){8}(?2)?)(?(E)(?-2)))(?(E)|(?&E))|K((?3){7,9})?K)))
```
[Try it online!](https://tio.run/##7Vhbc9pIFn7nV7SZnajbIMcSFynGmDIxW3ExITbG60wwRcnQGBUgKZII6xj/9fGcvgipkWf3ZR72YakUqL9z6/Od06flTIJAf5xMXn@Z0pnrUXT1sd8xxx@/XHTGt73Lwfju8mLwCdmFX1xvslxPKToNJiE1j@ZnhcncCdE4GI5QE/WL7c1m8VBZ//709HUwr2/m@BWTFm6dbTE@2hZwq3lEyLP5QjA84vuvzxY860QsW9ggQ93Rf462Q/1c/zYiXFAjIAHx0WGBFMjwuxc@jLaBImrZ5Nl@AeF1r98eba@YYesMQhIurZF7wyBb0F2RfzA7CIR1LvpAhEqFOcD898MLaV3hVpVJsG6QJEAVApDtkO1v39R6wS0zsYJAAXvAbzmGqNa@Y4s73vM1ZARwZe6xdUrPcKtOjohI2D3BLZYQBVl7e81cmhbhgFgnwr4QVgwp7GeFPS6qSlEvFXS5oMaCMUmXcEbZY@sUoh@wrRDGbpWZwLYEyR92WoJ185iJpbYgBxysznicksGKAf1QKpDS/QJg6I8D6InjsnX8IqoUbBf7JHO8y2q8FTScds6SGF0Qg7wDIrYetq9HrE8ECozrZOcJ6ybjDHZUItwEt/SqIGBn3ufm@uFWNbdfMjYV1abH@/K0eXTEvT9XXra86fmixhYmbwiWyc6HKdhlPlrvOuCwKxrGKrOWYeS/kv2DVSyjw6A5DkpGI3Mqo3jq@uxUZqHQ9R5VzPUBpc4qr3dWcL0YBfAYj2kY@iGe@F4UI37KD1c0ipxHSp4hzsnJBBTQ6SmSKHvkOPWmywYKabwOPWQ0XnIu2XriTylBzwUEH@5cehmatfqowWF3hjAfM@NHKk3HUgsz8zLCYk7dfvx03rcPiRSWUeT@pP4MJ9tF7xMkow@s8ijso6RT5EqIxztBxb/MkFvvsiyINFeO6@Ekr2AIpC6phwOiG6PmcQOtQadijmPkN49hmz7MTLGlm9v2zeBycDvojDtfB53eRecCbfOy295NZzDufL4a/N5ALN4jeC3sUhA1BEGwjhtIcMeYQochTdYrJ57Mx1MndqCeu2fhLaTRehmXRe6NJPzltw5HZrOIgtBfx5DTYzxXFA79H3QSg5WkBTJL4q8Cd0mx5P7matAnQVmafuv0v4wHnf7ny975oHNRRsDKOx5d/sqYxyRtiYMQKip5z3YV/5Z6mSSbubzHsHZiOp6F/mocOHFMQw@H0Da9299@kw5mfoh4n/5kZePkQhMu4W7Eollcryx4Jg3QMZKSJ5v8SRDIWGNj7d7TpNdEyg2Hx6NmUxtqWdPdaXjwnXAa8Uu1qMvPvff3PP1dfrIeiw01h8zQiJo83aPJGNoTEzawsqqc6UYjKjUNe58K9pFM4GhoGCNdM4CvEsKaremAVEfkENtwkzCioqE14jJH07VzDSTR0GQct7P8Z@sAHuqjg6ZWBqcP0BQLVe0lX5cVj2PW84GMNyOxFvrhLN1pck6VtAVBcVPk2NjlyjI6tGFilOMmkDaZhxgOwQpaLS6V3iJpRVeT4AkL@5K0Lxll6REmpYDgEstHYQ3a@EveE18s4WhYOd6vQaWSrQEk09SutHfvuACebQ21kHatoRMhCzIyg8u@C1kDvX@P2K0Ed4WzYUfbX/mx63vIiZCz3DhPkf59TamH8BwQz0d0NoORg0AjnlPBshs/IX/G1ysYSCSXVZwmxLYL9ctnLqagOjj4fMiOsIRYebGIJYx5PsLgXzpulLmy34Ey1ilMuDfKuqd1kNwWnX7/S3/c@/L5fPDxE1GmoFB9I9oLostI0lQqlYXRDBd/jRDmIIFTnDQM@U8Hge1IWOSCJE7vvV@n6F9MB27Qsgi655Pt5r80HTsAmX3ee5fej53PpAD7vtO9zjahG1OsTB85tI9Y2dgK6gXz3F8njAnr3I0xCynF6ZpkL1chhEtp984jagCvBK/DYbENey124atSRvaojCRyXeTBaynSg69qGVkqYilW7MsEtRTpCytbRWwFuRKxLBUxcwjssK4itRxSz1lZOcROkLskd/BjpMi18FNJkZ6InkHawspUkXqS@12SqaF4lrlnEJl7RUVMxbPMfQ@pKrFk7ns6Vg6xWazchkwYNmdoEK4pwgMYTqHvL9jgmhto4nh8VrEbYQMtDTDMrcJwCJdJGWldjcfl1RTItZZWUyA9Lc0xRSzJg0DYl634YV@m7ECB9DWedUVFDEXnSuN12UMSHhQdK4fUVSRhWLtLMrWS6HdJpkldBNLT0m5PESvZz12SV9IVKWIriMzLVpFKsue7ZIe2Ev1KS/s2Rao5HUPJS/qxRuqmOa2sK/7psLmMe9SFaytEC899nMco9kVXwK9TQ@xVFW1ATNnd9oSccL9HLKVu11o6J9KOqClVkpuoqx1hKXVr53jqZjtrV6W6gvSy1d4hFYU52X2mitQZKWn4riYPVIYndnw2cxjs6MGN5n6ANv56OWVv2/zaX4g/gOBtjU4WeY7qKkf2W6dm72TZOUZMhce2ls525dQYOWSv/@3cOVJPn9Sp59i3Vfat3Bmp5epRVfzIupq5etTVE6GeUHlG6mpv1946I@Yo13r221UU73STdRhSL14@IfZylytkGTneFGA3Eqdi6tPI09j/KtAfYAYSJ/5/sf9Xim0loy298EQ1o1xBaTLvHpb@ZBG9VUg7N9nqCpW9LE3tzLTZK2Q1dx@qt0Q32xBZuvfINXMFMHKTraLOsV0fpaTEzoKKRhfHQNCQv/iNXOqmumV@salKfM9pqJuVs1xS/vc4MA9vsRQFfhS5D0vKXodRTMNVxP5sevDX3pQV6sH/N/ljMls6j9GrvuSvurr9Jw "C++ (gcc) – Try It Online")
Pretty-printed, and partially ungolfed (absolute backrefs changed to relative, and capturing groups changed to non-capturing, or in some cases atomic for speed):
```
# Chess move validation regex (PCRE)
()? # decide whether to evaluate this as white's or black's move; \1 set = white, \1 unset (NPCG) = black
(?>| # subroutines:
((.|\n(?=.)){2}) # (?3) = for moving within the board, without wrapping to the next board, (?2) = (?3){2}
((?= # (?4) = assert that position of just-consumed piece is vacated on the next turn
(\X{72}) # (?5) = skip to the position of the just-consumed piece on the next turn
-))
((?=(?(1)[-a-z]|[-A-Z]))) # (?6) = assert that the piece at the current position belongs to the current player's opponent or is empty
((?5)(?(?=(.*\n)\n)[qnrb]|p)) # (?7) = black pawn that might be promoted, (?8) = .*\n
((?5)(?(?=(?8){8}\n)[QNRB]|P)) # (?9) = white pawn that might be promoted
)
(?>
(?>
# Handle squares that don't change (empty->empty or pieces that doesn't move)
(.)(?=(?5)\g{-1}) |
# Handle a piece that moves (and optionally captures an enemy piece)
(?(m)$) # allow only one move to be made per turn
(?>
(?(1)
(?: # white pawn
- (?=(?9))(?=(?3){8}((?3){9})?P(?4))(?(-1)(?=(?8){4}\n)) | # move 1 or 2 spaces forward
[a-z](?=(?9))(?=(?3){7}(?2)? P(?4)) ) # capture diagonally
|
(?:p(?4)(?: # black pawn
(?=(?3){8}((?3){9})? - (?7))(?(-1)(?=(?8){7}\n)) | # move 1 or 2 spaces forward
(?=(?3){7}(?2)? [A-Z](?7)) ) ) # capture diagonally
) |
# bishops, rooks, queens, knights, or kings
(?<e>(?6).)? # decide between scanning forward (<e> is unset) or backwards (<e> is captured)
(?=
(?i:
(?|
(?(e)|(B|Q)) (?&B) (?(e)(B|Q)) | # bishops or queens
(?(e)|(R|Q)) (?&R) (?(e)(R|Q)) | # rooks or queens
(?(e)|(N )) (?&N) (?(e)(N )) | # knights
(?(e)|(K )) (?&K)? (?(e)(K )) # kings
)
)
(?(e)(?<=(?!(?6)).)(?4)|(?6).(?5)\g{-2}) # verify that the piece moved, and optionally captured piece, are of the correct color
)
(?(e)(?=(?5)\g{-1})|(?!(?6)).(?4)) # verify that the piece moved is the same type and color at its destination in the next turn's board position
)(?<m>) |
(?(+1)$)(.) # handle the destination/source square that a piece moved to/from (only allow matching one of these per turn)
)+\n
)+
\k<m> # assert that a move has taken place
\n
# don't allow moving into check
(?!
\X{0,70}
(?:
# pawns (capture diagonally)
(?(1)p|k)(?=(?3){7}(?2)?(?(1)K|P)) |
# bishops, rooks, queens, knights, or kings
(?i:
(?<E>(?!(?6))K)? # decide between scanning forward (<E> is unset) or backwards (<E> is captured)
(?:
(?(E)|((?6)[BQ])) (?<B>()?((?(-1)-)(?3){7}(?(-2)(?2)))+) (?(E)(?-4)) | # bishops or queens
(?(E)|((?6)[RQ])) (?<R>-*|((?(-1)-)(?3){8})+) (?(E)(?-3)) | # rooks or queens
(?(E)|((?6) N )) (?<N>(?<=..)(?2){3}|(?=.)(?2){5}|(?2){8}(?2)?) (?(E)(?-2)) # knights
)
(?(E)|(?&E)) |
K(?<K>(?3){7,9})?K # kings
)
)
)
```
*-88 bytes by using non-atomic subroutine calls, thus retargeting from PCRE1 to PCRE2*
The version above has been modified not to allow en passant or castling, but the full project is currently at a state where it validates every type of move, starting at the initial board state (which must be the standard chess starting position – Chess960 is not supported, yet at least). The full rules of en passant and castling are enforced.
[Here is a sample game validated by the full regex [regex101.com]](https://regex101.com/r/GUZl7X/6).
An invalid move will result in every subsequent board position not being matched/highlighted. Checkmate/stalemate detection, and thus detection of who the winner is (or if it's a draw), is not yet implemented; that's why the final board state in this example is not highlighted.
[Here is a C/C++ program that converts algebraic notation into the format recognized by this regex.](https://github.com/Davidebyzero/chessconv) The algebraic notation currently must be put in the form of an array inline in the source code, with separate strings for each move, but reading it as single string from stdin or a command-line argument, with the entire sequence of moves separated by spaces and dot-terminated move numbers, is planned.
I also started on a regex that validates a full game purely in algebraic chess notation, with the standard initial position being implied. All it needs is an empty "scratch board" appended at the end of the input (after the list of moves). I'm pretty sure it's possible to implement this in full, and plan on finishing it sometime.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 693 bytes
```
(b,M,[c,p,x,y]=M,m=Math.abs,J='some',F=(C,X,Y,W,T,Q=P=>P[2]==X&P[3]==Y)=>W.filter(([i,j,k,l])=>i==C&j==(T||j)&[B=m(H=k-X)==m(V=l-Y)&!W[J](([I,J,K,L])=>(K-k)/H==(L-l)/V&(k>X?K<k&K>X:K>k&K<X)&(l>Y?L<l&L>Y:L>l&L<Y)),R=!(k-X&&l-Y)&!W[J](([I,J,K,L])=>k-X?L==Y&(k>X?K<k&K>X:K>k&K<X):K==X&(l>Y?L<l&L>Y:L>l&L<Y)),B|R,k==X?!W[J](Q)&(l-Y==1-2*(C<'E')|l-Y==2-4*(C<'E')&!W[J](E=>E[2]==X&E[3]==Y+1-2*(C<'E'))):m(k-X)==1&l-Y==1-2*(C<'E')&W[J](E=>Q(E)&E[0]!=i),(k-X)**2+(l-Y)**2==5,(k-X)**2+(l-Y)**2<3]['BRQPNK'.search(j)]))=>x>0&x<9&y>0&y<9&!b[J](([i,j,k,l])=>k==x&l==y&(i==c|j=='K'))&F(c,x,y,b,p).some(e=>!F(c<'E'?'W':'B',...(W=b.map(E=>E[J]((a,i)=>a!=e[i])?E:M)).find(Z=>Z[0]==c&Z[1]=='K').slice(2),W)[0])
```
[Try it online!](https://tio.run/##7Vddj9o4FH3nV4R5iO2pSZsASRbhIDGi6k4YBKhqYNJIDTSzBcKHJqia0bK/fdbOB8nF9L0PfbHRiX3vPeceO2Ed/gyT5fPqcGzs9t@jtyf2hhf0gfpLeqAv9DVgD3TLHsLjDy1cJPSeoWS/jRD9yPAdndE59ehnOmFj5ox9I2Bspo79Jp/nhDme9rSKj9Ezxv6KrumGxgFHV4zdqWvG8OfTaU1Uv8@2@BPbNGaE8V9fWNyYE7Xu@fcB3/c3vacuHYp92G1syPtPfOOwEZP3X1S8cWY9t7tRXWfWcR0@d2dExbEz7w27sTp05p2hw@funBA6ZXXMc6jqr8Lzh70hr/t62I4rqP0idv80pRv@vJeFnYgiGnPG9IZxi@@6aIDIKQWMRqsA8hIGzBnkug0y3d5VdhHS2eJMGV29DKkWASZ4QPjuD0GdrQhN19/eGu9EDeIHY20Z7DYDH/Wnk/HIRVoShc/LH3hNAsKFeHE@qC/dv9RXPr/yub7ItKq0kJN9UWPGXlXMu7k88W4il5erfsRLYRq6oAeiCaPgiDl1joqKe8hDHdRHVNM07LGFtg0PmQAifkhXPHJYZ5G/Ckhv0HkghPtn9x0/MueRs@OJ1EdfD7JcWhKvlhE2CPUIf0jejlFyvAuTKFGY8u0J@/5N/4YqNy4fmlSxA6rkyIQPOlXaJTLiQ4sqFkQssEsMBl9WItNslw0RGyDjLJcFEUNCeIUmRNoSYkq7LAmxC8QruPM4eolMsjjNEhll2StIP9tlQMQsuHsFUx1EzrlXkJx7EyIGiJxzv0BaIFfO/WKNJSG2yCUVZASkVhN2EMZTuHPSYGmLMmSCyhZlyAiVhZeIlZPLEDHYII4YjNxWGTJFKZUmRHSwZoxSsS@QghxYY0mICZFCNn7McqZWkd0rmBZiZ8gIlRYuEauoxyt4Fa0uERsgOS8bIs2iZq@o0AbZx6g0Y4m0pDU64JXHsQJYdCqr1GoLyD9B5RkuG9sGYuexTNhYC8jfl@i6VYOcxTYBMqo27Yw0gQC5iQyImIJbmd5Fudmv0TUhXfuajy@8bkvkDCBJH5VXKPCxLiEXjrQlZ8PzkK8xJSFtKKQlubYtSdsCcfIWGZK0JvQoPDO5a03otvY11xqB5CL7T0N@o4ZYVy8EW7oQTCDJqEq3XzmkFw1pSW8DeEe61cZWZbsQyZCE1KULoQmP/9kP115sukTOgEWlFzdclFZFvtVq6ScU/xMgPqHOn1NacohXR4y@7r7ukEi5f1bwcr9LjsqSr1X2T8p5H1H@rSmKeLiPIy3e/4Ojn2GMxTpCav@9/Q8 "JavaScript (Node.js) – Try It Online")
I sought out this challenge with the aim of combining CodeGolf with a project idea for a chess app. I realized that most of the functionality of a chess app hinges on the ability to validate a chess move, and while the challenge's input format does not explicitly include *which* piece in particular (which white bishop?) is moving, I still found this fun to write. My original working code was 1200 bytes, so I'm proud I managed to cut it down to 693. It takes input in the same format as the spec and outputs 0 for invalid, 1 for valid.
## Explanation
Really simple when you get down to it. We call a huge function `F` which returns the list of pieces that can move to an `X,Y` coordinate with color `C` and type `T` within a board `W`. This is called to retrieve the list of eligible pieces based on the `[c,p,x,y]` input, and again to determine whether there is check or not. Here we do not call with a type parameter as we want to consider every piece.
The large list in the `filter` function body is simply a list of booleans which check Xs and Ys, the code is too unreadable for me to explain how that works... but it should be easy to figure it out by reading the code. Notably, all a queen needs is either bishop eligibility or rook eligibility. The pawn code was what took the longest to write.
Then we have a simple `some` call which operates on the filtered list, checking if there is any piece where, after recalling `F` with a slightly modified board (that particular piece is moved to the target), we get an empty list (no eligible pieces of the opposite color) or in other words there is no first element.
Here's an expanded version of my code (thanks Emanresu A!):
```
(b,M,
[c,p,x,y]=M,
m=Math.abs,
J='some',
F=(C,X,Y,W,T,
Q=P=>
P[2]==X&
P[3]==Y
)=>W.filter(
([i,j,k,l])=>
i==C&
j==(T||j)&
[
B=m(H=k-X)==m(V=l-Y)
&!W[J](
([I,J,K,L])=>
(K-k)/H==(L-l)/V
&(
k>X?
K<k&K>X
:K>k&K<X
)
&(
l>Y?
L<l&L>Y
:L>l&L<Y
)
),
R=
!(k-X&&l-Y)
&!W[J](
([I,J,K,L])=>
k-X?
L==Y
&(
k>X?
K<k&K>X
:K>k&K<X
)
:K==X
&(
l>Y?
L<l&L>Y
:L>l&L<Y
)
),
B|R,
k==X?
!W[J](Q)
&(
l-Y==1-2*(C<'E')
|l-Y==2-4*(C<'E')
&!W[J](
E=>
E[2]==X
&E[3]==Y+1-2*(C<'E')
)
)
:m(k-X)==1
&l-Y==1-2*(C<'E')
&W[J](E=>Q(E)&E[0]!=i),
(k-X)**2+(l-Y)**2==5,
(k-X)**2+(l-Y)**2<3
]['BRQPNK'.search(j)]
)
)=>
x>0
&x<9
&y>0
&y<9
&!b[J](
([i,j,k,l])=>
k==x
&l==y
&(
i==c
|j=='K'
)
)
&F(c,x,y,b,p).some(
e=>!F(
c<'E'?
'W'
:'B',
...(
W=b.map(
E=>E[J](
(a,i)=>
a!=e[i]
)
?E
:M
)
).find(
Z=>
Z[0]==c
&Z[1]=='K'
).slice(2),
W)[0]
)
```
[Answer]
# [Python 2](https://docs.python.org/2/) (with [python-chess](https://github.com/niklasf/python-chess)), ~~141 138 134 133~~ 132 bytes
Without doing any of the really interesting code - but maybe this can compete with golfing languages or (dare I mention it) Mathematica?
Note: [python-chess](https://github.com/niklasf/python-chess) is a [Pypi](https://pypi.python.org/pypi) package install it on Python 2.7.9+ with:
`python -m pip install python-chess`)
```
import chess
a,p,n=input()
S=chess.Board(a+' - - 0 1')
for m in S.legal_moves:1/(m.to_square!=n)**(`p`in`S.piece_at(m.from_square)`)
```
A full-program accepting input of three items:
1. the beginning of a [FEN record](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation) - the string containing the first two fields. This is to define the board state AND which colour is moving (since this is the information in the input in the OP, whereas fields three through six are "fixed" by the OP hence should not be a part of the input)
2. the piece-name attempting to move (as given in the OP -- one of `PRNBQK`)
3. the square to which the named piece is attempting to move where `a1` is `0`, `b1` is `1`, ... `a2` is `8`, ..., `h8` is `63`,
The program [outputs via its exit-code](https://codegolf.meta.stackexchange.com/a/5330/53748) given valid input:
* `1` if the move is a valid one (the program raised an error - due to division by
zero);
* `0` it it is not (the program exited normally)
(Don't) **[Try it online!](https://tio.run/##NY/BTsQgEIbvfQo8AWsXHPZgNOmlVxOD26MxLa6sSywwC6zGp6/YaCYzyffnm8OP3@UUg1qcx5gKQYdNXeGNC@yZupCLmWfaEoqruD2cbM70hf8/rNyYFtvQuYCXwngzdGsq@mjSGzPXlGzr3BCgvDnGRDxxgQxitu9mHn38tPkeJPOixDGfLybZqy7wzYZNOLkwDQKdPdjRlKocU/R/Ep/4slD1kVRIEhECIKJUCLiT51sJr6ChV1LDo3pSEnQlrbXc7x7Unnz9Vurrgbsf "Python 2 – Try It Online")** (because the python-chess package is not installed there and TIO does not allow internet connectivity so the pip-install code in the header wont work).
Note that the power operator in Python makes `1**1 == 1**0 == 0**0 == 1` but `0**1 == 0`
...hence `1/0**1` raises a division by zero error while `1/1**1`, `1/1**0`, and `1/0**0` all succeed
(...and that in Python `False` and `True` equate to `0` and `1` respectively).
[Answer]
# [Python 2](https://docs.python.org/2/) (with [python-chess](https://github.com/niklasf/python-chess)), ~~127~~ ~~125~~ 124 bytes
```
import chess
a,m=input()
S=chess.Board(a+' - - 0 1')
for l in S.legal_moves:1/(m!=str(S.piece_at(l.from_square))+`l`[17:19])
```
[Try it on replit.com - test cases](https://replit.com/@Davidebyzero/cgcc-148587-python2-test)
Jonathan Allan never responded to the golf optimization and other comments I provided under [his answer](https://codegolf.stackexchange.com/a/148609/17216). So I'm finally doing that here. This program is based on his.
Input consists of two items:
1. The board state, in the form of a [FEN record](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation). As per the challenge's specifications, this is abbreviated not to include extra information about the state (castling, en passant, halfmove clock, or fullmove number) but it must include the color whose turn is next to move.
2. The move whose legality is being queried; this is a 3-character string. The first character is the piece type; as in the challenge's input specification, this is one of `PRNBQK`, except that a white piece must be in uppercase, and a black piece must be in lowercase. The next two characters are the destination square for the move. This is given in standard chess column,row format, where the column is one of `abcdefgh` and the row is one of `12345678`.
Python 2 automatically runs `eval()` on `input()`, so the input is taken in the form of comma-delimited Python string literals. Examples:`'rnbqkbnr/pppppppp/8/8/8/5N2/PPPPPPPP/RNBQKB1R b','nf6'`
`'rnbqkb1r/pppppppp/5n2/8/8/5N2/PPPPPPPP/RNBQKB1R w','Pc4'`
[Here is a C++ program that converts the test cases.](https://tio.run/##7VdNc9pIEL3zKzqknEEG7yIJJJUJSYXDXlxF2dlUcWAplxBjIyMkVhL2Jil@u7dnRkJqjZzzHpaDbD/153s9PTg4HK4eg@D19X0YB9Fxw@FjmGR5yv39p06QxFkO6ySJgD/70X0YH4454GcKeXrkk7pB4X4fJFGSng3COIe9H8Y9A352hGeWb66vMX4YP4IMN5HwA/r0hPGP6XCijB55HoUx78k/gjAeKHtjUoYSn/BBuCG8HK6mU7Zk9ZelwQ8D0CLY@mmP/RUzY4JZzAkxEy@xDz/dLL1Lb4X1/xyeGiayV2l4mU1l0t@Ce2ylZ/Qb0WQ3k0nWn5pesyDxUYl6zGNX2dIcrYxLD/rQw9/N1RUzmSEKyJbuSqDMZ1fsCzMu8b0lmpxhB1pI0Sf6O6t3UzZAFtao4I6anTq0BhRtHfnB7j5P7vfJM5c5LVOlaKHnEPKgMHJkZdT7MxSVwjUMjRZ/NHzZ8pQvrb4pGZaKZEt7uOqrLrFzY4DxbXs1gCb/osNqCuuSsiYh52l6EtP09NHDR7/fpoQI@gTvplhxFfD3NoLPMUMRM8SYbfHOzQbYoJL5SYobriatxqKA4K1I4lNWFeDY9vthe5QT8Cjjv4giCo@n4QQ2iYwCL9sw4ighKXE6HcKHD6I5TIbmV/Hk7YhYeFwjbcj6sfFGdZ1fIydNZ7JMMAmui/yh14WLoDsAbezWYuTYS1O1wqu2uT5Dlw2AXQQX2UXG4P1F1kVPEVYAGFqO@KCxy9BLmLUEUt5dnNlytnF6kUnbq5Wiujt1Tq@vy2V3hlm6N/iwB@DhlBfIHT7MAYwrZI6P0QBcirjESzwsNKuQr8rLo4hHkFuVy6WIpSFYoUORsYY4mperIV6JLMreMY5ZIXcqjl0hc5W9hsyUl0URp@x9UXZqkshF7zWk6N2miEUiF703kBHJVfTesHE1xBO5tIIsXH@f4BvekND7tuWQJskOkhi2JgR@DHKucd@84NlEmBudznKJOxkn7obJvFJNhdyxSk2FzFnVY4W4BQ8KEQ@PxBEPq5hAhXxlsmubIiaxuWVSlwZS8kBsXA1xKFIyzBZlp26ZfVF2WuqikDmrpr1C3LKeRdlXORUV4hGk6MujiF3WvCgr9Ej2W1bNbYWMNBuT9FXEcVe0aEmrmIo/fLHJe3Me5rhQYBeHj9sc94uaCvzpj@EhTfYg9w2g0Xfw0@aMuES3O1btiWoixkSlogiHToRLdJtpPN3UJ@uskkOQeV3tM2IT5orpsyjiCFKq9DesOFA1nsTxwbss57AOs21ygJfkGG3EtSSogZ36nol3Mg92OkcO5chrOzWNk@VpjFiExxmrdjs5NaaGNObf084RPX2FjaOx71H2Xe2MjDU9RiROoaul6eHQE0FPaHFGHDrb47YzYq200fPaVfz7yDnKdUxTHufRd9j6mS7kAPx4g3CYqVOxSXgWsxxvfP6MbvjGz/8X@78itluuturCU2pmmqC83HfrKAl2WZuQnrbZHELlvE7TrLZtGkKOtPuQ3hI39YGo090g19IEMLXNZtM9dp6jipTc33E16OoYKBr0i9/UWrdoyfJio0ay5irVn3s/irj8VxaZ3/uY7ZBkWbiO5DdfyHm6zyB5wH9fjvFGCLVO/jH@BQ "C++ (gcc) – Try It Online")
The program [outputs via its exit-code](https://codegolf.meta.stackexchange.com/a/5330/53748) given valid input:
* `1` if the move is legal (the program raised a `ZeroDivisionError`)
* `0` it the move is illegal (the program exited normally)
[Try it on replit.com](https://replit.com/@Davidebyzero/cgcc-148587-python2)
Can't [Try it online!](https://tio.run/##HYhLCsIwFAD3PUVcJUFtfFXxA910K0i0S5EaNWoxn2cSBU9fiwwDw@A3Pbwruq616EMil4eOMVMjW7YO34nxrC7/L6@8ClemhpSMeyYEKM9uPhBDWkfq3Oi7Mo31Hx3XIJgdlDEFVufY6otuVGImvwVvm/h6q6A5H57M6QCLNayOvOtocOfXE1wQiFj0iqWYyamASs77lLLYoJRiv4UdVNs9OdMRxTvQHw "Python 2 – Try It Online") (python-chess is not installed on TIO, nor is internet connectivity allowed, and even if it were, [Pypi](https://pypi.python.org/pypi) and the latest version of python-chess no longer support Python 2)
python-chess v0.23.11 was the last version to support Python 2. To install it for use with this program, you may run the following git command:
```
git clone --branch 0.23.x https://github.com/niklasf/python-chess.git
```
And then symlink, copy, or move its `chess` subdirectory to the directory from where you are running this CGCC program.
# [Python 3](https://docs.python.org/3/) (with [python-chess](https://github.com/niklasf/python-chess)), ~~134~~ ~~132~~ ~~121~~ 120 bytes
```
import chess
b,m=eval(input())
S=chess.Board(b)
for l in S.legal_moves:1/(m!=str(S.piece_at(l.from_square))+str(l)[2:4])
```
This is a straight port of the Python 2 version. Python 3 dropped support for the backtick alias for `repr`, so `str` is used instead. We can't use `str(l)[2:]` because an extra character is appended to `str(l)` in the case of pawn promotions, specifying what it is to be promoted to.
We save 11 bytes by using the latest python-chess, more than making up for the 7 bytes sacrificed by using Python 3, because python-chess v0.27 [added support for omitting the last 5 parts of the FEN string](https://github.com/niklasf/python-chess/commit/65e872995c6380522d3839e60a7235f06899fced?diff=split). This still accomplishes exactly what the challenge requires – it defaults to treating castling and en passant as impossible moves. (We still need to include the current turn, because otherwise it defaults to white's turn.)
[Attempt This Online!](https://ato.pxeger.com/run?1=LY7NisIwGEX3fYrMqgmjDek4UIRuuhUktstBSuqkWszPZ5KWmWdx043zTn0bO-riwoUD597rH_yGkzXjeOtDu8ymn06DdQEdTtL7qFnoXA5C4c5AHzAhUZU_SFJY4b5xQ6LWOqRQZ1CVKHkUqtZ2kH7NKNZvuQ8OVwl08iBrEbBKWmd17S-9cJKQ93-syFe6Xu3Jc_91Y5yy2JnmcmbGUQBI59CMrvgHZQX_nCvn6QY4p-WW7VixLVETL2I4svgpuAM "Python 3 – Attempt This Online")
[Attempt This Online! - test cases](https://ato.pxeger.com/run?1=nZS_b-M2FMfRdvNf8eoOklCdGFKxEzjQ4qFLAEFxbksPgmjRliCZpEkqjnN75-5dbmn_p7uxf0kfLecu7bVLbRgC33v8ft4v-bc_9NE1Sn74-L7daWUctCq2RxuPp77lk1psoGylHlwYLWDbK1714IR1N2CEG4w8HSZlyYe2d620ZZmcwiE737sBpYUMpz7OJvo4jaeHaZQcTOtEaKbT6e-D27y5_vh0TmHdCGsnPN5l4rHqwzM7mtxnJ0-yVJWpQx5NNspAD62E-6QX26ovd-pR2AUl4e77zDoT3ie6FWtRVi7sk41Ru9Luh8qIKPrRu_vogS0u30Uj_9M3EebyQBdv6LvoBrALia5cg8VYYVx4EUMQoP05uziBnQf7IOvqVi4mgJ92A88L0KaVmPCLxT2gYJYFP8tgAb4r7sEjTm7fEm8ZD-Y4yviP9u0rx46U5bl50-izf0R9HlNiRK-qOtRjhHhaC-1eqZ1SoljCn7_8GsTgYhCyzqZnQdFb8c_gi_8Kfs7ozdixD5---zZgnWHSEK2ppFprwjTVKdlfEcppQZeMFDRnd7QgtMAj_sgqvWUrOKBysGpYAD_AWzMICN82AoxSHSgJDYV1JcEPFLDbB5w4mkU0CVYspx3lZE9XVLOCXCLNcKTmlBRMXxLJDC1uKWF3eCzIciaXIyyvZh72U4XVQpiL1jXCQCfbbePAqRGGz2oGflfggG40NOIIfmcmAb8ic06JTPOUzLAyup8TlqcdJVinRNvdLQXuUV2TvkL5wg4Nbjvw1jZKw0ENfQ3-HUF16Fq59cuE273uEMN4iunPpSRmucpZp8mVJunqkqQ63ZMlZ0VxR4nBLEaYFNf_CtsPQqDqYIyQrj9CU9mveTFUskZza8f6ayWsDBwugXjEa-ip3P_JaTv7-2BHqP2KK14GwHu17uwLby5xgNIzrwlbsj3DZz7vCM3nhDOOCzVyOH-1QK7qxFji2IBRGdWuyZfvDLVmHb0d7--39Mv9-13V9_6NPGW4q1BCK2tb3ovYJ-6E2VlQG-BqkLUviKun87_HXw "Python 3 – Attempt This Online")
To install the latest release of python-chess:
```
pip install chess
```
# [Python 3](https://docs.python.org/3/) (with [python-chess](https://github.com/niklasf/python-chess)), ~~158~~ ~~152~~ ~~141~~ 138 bytes
```
import chess
b,p,n=input().split()
S=chess.Board(b)
S.turn=p<'a'
for m in S.legal_moves:p[p+n==str(S.piece_at(m.from_square))+str(m)[2:4]]
```
The [**132 byte**](https://codegolf.stackexchange.com/a/148609/17216), **124 byte**, and **120 byte** versions of this program have a problem. Their input is not bijective to the input specification given by the challenge – the color to move next must be given in two places, and if they disagree, the move is considered illegal.
This version solves that in the most natural way, by taking the color of the piece to move in the same place as the move itself is specified (i.e., whether the the piece identifier is in uppercase).
Also, evaluating the input as Python code is bad; there's a reason that was dropped in Python 3. So this answer uses `split` instead of `eval` on the input.
For optimal golf, the piece type and its destination coordinates are to be separated by a space in the move to be queried. Examples:`rnbqkbnr/pppppppp/8/8/8/5N2/PPPPPPPP/RNBQKB1R n f6`
`rnbqkb1r/pppppppp/5n2/8/8/5N2/PPPPPPPP/RNBQKB1R P c4`
[Here is a C++ program that converts the test cases.](https://tio.run/##7VdNc9pIEL3zKzqknEEG7yIBksqEpMJhL66i7GyqOLCUS4jByAiJlYTZJMVv9/bMSEitkXPew@owxk/9/bp7wD8cbp58//X1fRD54XHN4WMQp1nCvf2nlh9HaQarOA6Bv3jhYxAdjhngM4GNF6Z8XJXI9R/9OIyTUiKIMth7QdQx4GdL6KbZ@vYWPQTRE0iDYwlvUKkjhH9M@mMl9MSzMIh4R/7jB1FPyRvjwpR4go1QQ3jRX04mbMGqLwuBHwaghL/1kg77K2LGGL2YYyImXmIiXrJeuNfuEhP42T/XRGSyUvA6nUinv/mPmErH6NasyWzG47Q7Md16QOJRjjrMZTfpwhwujWsXutDBz@byhpnMEAGkC2cpUOaxG/aFGdf43hJJTjEDzaTIE/Xt5bsJ62EVVsjhjoqdWzQGZG0Vev7uMYsf9/ELlz4tU7loKM8h4H4uZMvIqPZnyCOFW@gbDfooeNryhC@srikrLBlJF4P@squyxMyNHtofDJY9qNdfZFj2YZVSVi/IpZueRTc9f3Tx6HabmBBGn@HdBCMuDf7eVOCLzUDYDNBmk71Lsj4mqGh@luQGy3GjsAjAf8uSeIqofGzbbjdotnIGjuP2Cysi8GgSjGEdSytw2gYhRwpJiJNJHz58EMmhMxS/icZvW8TAo0rR@qwbGW9E1/o1ctZ4JtsEneC6yDadNlz57R5obbcSLcdOddZyrcru@gxt1gN25V@lVymD91dpGzWFWQGgadnivdoyQy0h1mBIabexZ4vexu7FSg7cSigqu3Pr/Pq6WLSn6KV9h8egBy52eY484GH2YFQiMzyGPXAo4hAtcVgoViJflZZLEZcg98qXQxFLQzBCmyIjDbE1LUdD3AKZF7mjHbNEHpSdQYnMlPcKMlVaFkXsIvd5kalJLOe5V5A89wFFLGI5z72GDImvPPeajKMhrvClBWTh@vsE35IjTuC3LYckjncQR7A1wfcikH2N@@aEs4kwN1qtxQJ3MnbcHZN@JZsKeWAlmwqZsTLHEnHyOihEHC6xIw4r70CFfGUy6wFFTCJzzyQvNaSoA5FxNMSmSFFhNi8ydQrv8yLTgheFzFjZ7SXiFPHMi7yKrigRlyB5Xi5FBkXM8yJCl3i/Z2XflshQkzFJXrkdZ0mDlmUVXfGH@OIEnRkPMlwosIuCp22G@0V1Bf71RrBJ4j3IfQMo9B28pN4jDuHtgZV7ouyIEWEpD8KmHeEQ3qZane6qnXVhySbIrMr2BRmQyuXdZ1HEFkUp3d@xfKAqdRLjg3dZxmEVpNv4AKf4GK7FtSRKAzv1PRPvZO7v9BrZtEZu09TUJsvVKmKROk5ZudvJ1JgaUut/V5sjOn25jK1V36XVd7QZGWl8DImdnFdL48OmE0EnNJ8Rm/b2qGlGrKXWem4zi38fOUe6jknCoyz8Dlsv1YnsgRetEQ5SNRXrmKcRy/DG5y@ohm@87H@y/ytkO8VqKy88xWaqEcqLfbcKY3@XNhHpapvNJqWcVcs0rWybGpFD7T6kt8RdtSGq5a4V19IIMLXNNqB77NJHZVEyb8dVo6sxUGXQL35TS92iIcuLjQrJmEtXf@69MOTypyxWfu@ht0OcpsEqlN98IePJPoV4gz9fjtFaELWK/zH@BQ "C++ (gcc) – Try It Online")
Unlike the others, the error used to trigger an exit code of `1` in this version is `IndexError`, by attempting to access the second character of a single-character string.
[Attempt This Online!](https://ato.pxeger.com/run?1=LY7BisIwGITvfYrcbFETUhVEzKVXQaI9ipRUUw02ye-fVNhX2FfYSy-77-TbbHf1MMwwHwPz9QMf8epd3393sZkun5_GgsdITlcdQlJPYOKEcdDFNKMBWjN4Uop_Sguv8JzWQ0Fjh07AeqRGSeORWGIcKWmrL6qtrH_osIIDjJ0QIWJaUjD6pCsVU0sb9LYK906hzrLxH7bZIV_Nj8fXo_ex_jlDV99v3CEDgHwQW7K5nDFeyMUQpcw3ICXbb_mOF9s9AXLhr-0v "Python 3 – Attempt This Online")
[Attempt This Online! - test cases](https://ato.pxeger.com/run?1=lVGxbtswFERWfcWDFkmIIuZRtmPI1aLVgCDboxsIYkzbgmSKouimTvcOnbp3ydL-UzL2S0pZRloU6FASAvHeO94dT99-yJPeN-L55VN5kI3SUDZ-d-r8oapLZm34FvJSyKN2vQh2dcOKGjTv9AwU10clzoWV5-xY1roUXZ4HZzjEl3szaCQXrt3jukCebN9-tL3gUZWau8q27e9Hvb2Zvny5WHjY866zmC99EV-Eg07WpTmtVXyeBklTqI3LTCPoPcTynVM41rZRcIBSwCqo-a6o80PzgXeRXMtrEcedVu4qkCV_4Hmh3UOwVc0h79pjobjnXffjg7em0ej-fnD0euUZd2uMbvDem4HJJZCF3pvndVxp99YHxzH9p_j2rKx75R7U6U0pIgvMKrfwFIFUpejdXzp6bQjj2HkvnAj6nPS6lziP-5D6zlCo00DTL9kHmg8Z5fklTtt7mw9Sbz8uULxuio0rBwT_-MCl_oPtbAnNE35-_ur4oH3gYhPbF0Jed_xv8O2_wE8xzobEnl-vElopKhSREgVKKQmVKEPS3hFkmGFCSYYpXWBGMDOl-cgynNMlLGFPrSVNsUJGWlyipBkZmauKGYoUSUbliAiqMJsjoQtTZiQZiwRSKMYWuyMThkSEaUjGRgXbCaFpWCExmsL0FnOECvahRVloCCZCEJUsU1pJcidJuByRUIYtSRjNsgUSZYhAAJ_-H343tibC2BP9nSmhCW2pOdNJRTCdEEaZeTswYNSakt97bFDjCufQwg6HLH8B "Python 3 – Attempt This Online")
# [Python 2](https://docs.python.org/2/) (with [python-chess](https://github.com/niklasf/python-chess)), ~~294~~ ~~278~~ ~~276~~ ~~270~~ 197 bytes
```
from chess import*
b,m=input()
S=Board()
S.clear()
S.turn=m[0]<'a'
for P in b:S.set_piece_at(P[1],Piece.from_symbol(P[0]))
for l in S.legal_moves:1/(m!=[str(S.piece_at(l.from_square)),l.to_square])
```
Even the 138 byte program's input is not quite bijective to the input specification given by the challenge, in which the board's pieces can be listed in any order.
In this version, the board is provided as a list of pieces, as in the challenge's specification. Each piece's type (one of `PRNBQK`) is specified in lowercase for black or uppercase for white, instead of providing the color as a separate element. The coordinates are specified as single numbers, where `a1` is `0`, `b1` is `1`, …, `a2` is `8`, …, and `h8` is `63`. Following this list is a comma, followed by the move to be queried (in the same format as the pieces already on the board). Examples:
```
[['r', 56], ['n', 57], ['b', 58], ['q', 59], ['k', 60], ['b', 61], ['n', 62], ['r', 63], ['p', 48], ['p', 49], ['p', 50], ['p', 51], ['p', 52], ['p', 53], ['p', 54], ['p', 55], ['P', 8], ['P', 9], ['P', 10], ['P', 11], ['P', 12], ['P', 13], ['P', 14], ['P', 15], ['R', 0], ['N', 1], ['B', 2], ['Q', 3], ['K', 4], ['B', 5], ['N', 21], ['R', 7]], ['n', 45]
[['r', 56], ['n', 57], ['b', 58], ['q', 59], ['k', 60], ['b', 61], ['n', 45], ['r', 63], ['p', 48], ['p', 49], ['p', 50], ['p', 51], ['p', 52], ['p', 53], ['p', 54], ['p', 55], ['P', 8], ['P', 9], ['P', 10], ['P', 11], ['P', 12], ['P', 13], ['P', 14], ['P', 15], ['R', 0], ['N', 1], ['B', 2], ['Q', 3], ['K', 4], ['B', 5], ['N', 21], ['R', 7]], ['P', 19]
```
In this way, the input is fully bijective with the challenge's specification, but optimally golfy.
[Here is a Python program that converts the test cases.](https://tio.run/##7VZNj5swEL3nV4y2B5OWrgokgCptD5G2l5XS3bZSDlEOJHEKCmBqnE33129tbMdMvD@gh@bgwMPMx3szY7oXUbI2eX2tmo5xAZxOJnt6gB1rnykXjxXd0aBT6/TzBOSPU3HiLawHbB1toDqAvv60ubsjKwK07inYx7c1O1MeTEPQVtbx5mM0hQ/2NlG37/PNZHIuq5pCpL0I/qIv1G/LCr6HO6DPRR1UbXcSwXR6edqwZxrKeJuGtkLuMhtu@66uREDg7gsQvNuaUtdTz0td9SJoii4YUxDqx1PPEOIJG@x41YqgFzzQ734gIQlB3Q/7QiDvzL0JfmTdJDHc0z872gm4//b1nnPGR7xwWhxfX9frm8VNCDcPcklCyDchGORJLlEIc4cs5TILIcNIht5SSyy3OeS7fivHSI6QR@0rw0jsITLCFCNzD0m9tzIPyS2ysrlLO5FDnrSdxCFL7X2ELPRbMUZSm/vKZhohyyb3EWJyTzASI8sm9ytkhnyZ3K/2ZB6SK1@bCY4n3qhS/8lPFIKfJQXO2BFYC2UEu6LV9Xpg/KyqnLWyTifrNVnICiQPZHA7iKmRJ@LE1MiSuBQdkhkaNKKWHNlRS2wKUCPfyZB0gpEI7XkkgyxXiKUB7ck8JMWIJVgOJpNpZr2vbKZWFo0siSt2h2Q2npXNyxaFQ3KEmLxyjCQ25pWNMEfeH4krW4fMvD0RysvYyVRRuJgHVlVRfC3USA6WtBIl5XBsq1@lAMF0Ucj/Yg4Hzho4y8cSKOkLFPy6RDIk2xNxU8IVxByJZIJIcUFkSLaFR9PDuLAuIqUIWY7FviAJIs4UX4yRVJGiaLrkNXTTiCbVPPIwEhS2VV@yDs7sVO9BDmTFDByr9pecz7Ar6e7oU5RiivK3euaqr3KPkBjRuCBusKOeiTzkqvpzr4tw75k9qUd@jsnPvA6Ze3LMkB0ja@zJkeJ@wP1pOiTFlT1/q0NiJ6KJJ39bxN8nSqVaJ87lEVu/QFn0vo4hFO1ewlWve2LPaN8SIc9w@qw@K0RZiP9a/yNaZ3auucNOi9l7elI77LY12x37t3TMvbGWIiaXY5YWo1FzpePMOwvxCfEwrocx21fcxh7/kTfWEjTELlXkOBHFkeoy102gWfDP/MjLPMYRD2faxdMlYufpR1PUNe2F5r0ppLOO9X21reVHs5RDUN70wA7yA/rU7pVMW/Zn@hc "Python 3 – Try It Online")
[Try it on replit.com](https://replit.com/@Davidebyzero/cgcc-148587-v3-python2)
[Try it on replit.com - test cases](https://replit.com/@Davidebyzero/cgcc-148587-v3-python2-test)
Can't [Try it online!](https://tio.run/##Rc5Bb4MgFAfwu5@CnZTFOLWF2mZeel2yuHk0xKilqxmIBVzST@8EG7z9eLz/e2986JsY0nm@SsFBd6NKgZ6PQupXrw153g/jpAPolflZNPJiFHWMNtJKT3LIeRWTd7/xvauQoAD9ANpTGSmq67GnHa0bHRRVQsLCvCKzp1YP3gq2lGMCoc0xkysjRn8aVnPxR9UpeQv4S14pLYMycqPYc8J9aiSFMGSRFs8XgfNcVb70Q4AwCUHlD4YHy9Yws7wbHi1/F@LY9eLU0kzAO8tx4T7beHRE8catF@03IsdkbSgW7tbLzgtT5Kopdsyc1l0fJp@6YrLfuOa/F663fJqi1ZfZ5BYh94td4kDcdZj8Aw "Python 2 – Try It Online")
# [Python 3](https://docs.python.org/3/) (with [python-chess](https://github.com/niklasf/python-chess)), ~~309~~ ~~306~~ ~~290~~ ~~288~~ ~~282~~ ~~271~~ 203 bytes
```
from chess import*
b,m=eval(input())
S=Board()
S.clear()
S.turn=m[0]<'a'
for P in b:S.set_piece_at(P[1],Piece.from_symbol(P[0]))
for l in S.legal_moves:1/(m!=[str(S.piece_at(l.from_square)),l.to_square])
```
This is a straight port of the Python 2 fully-bijective-input version.
[Attempt This Online!](https://ato.pxeger.com/run?1=RdDNToMwHADweN1T1BNgEIGNji1y2dXEoBxJQ2B2jthSVsqSPYuXXfRlfAJ9GvtByu3Xf_9f7ed3fxFH1l2vX6M43Ke_PwfOKNgf8TCAlvaMi7tF49MMn2vitl0_CtfzFkW2YzV_c6WCPcE11xIj7zJahujRqZ3FgXGQg7YDzbYIBiyqvsV7XNXCzcsI-bk6BWpaNVxow4gMh0j2VnVE1RUBwe81qSg742EbPbj0NisHwd0isK3I1OE01hx7nk8CwaYT8syTppdd_25gWTrc8UECkQ9Kp1NcazaKqeZJcaP5IQlDmwtjTdUBLjV7yVU6c2OZhDPn3GQ1M7GMTEIuuTSb7STjxEZjaJlamVlPqj62wWg109S_SppdnlVQ60VNsoMSewttxRrZ7SAy__cP "Python 3 – Attempt This Online")
[Attempt This Online! - test cases](https://ato.pxeger.com/run?1=5Za9juM2EMeRKoCBvMNEKSgHWkXy1629cbPFNQcY3tvrFEOQbHolWCZlkl6fN33q9GmuSV4mT3BX5klCcmTSl0ueIG7802jImflzOPZvf7RnVXH24ePP9b7lQkHNI3mWET41ddnb0C3kNWuPKuzP4KnhZdGAolLdgaDqKJh96OV5eawbVTOZ57F1h3m37g54S1kYGD8Zt-cgCk5BPz6JWtFQBEHw-1Ftb24__rkVfA_rikoJGP_7Xhnt5_S5aMIug37vcX7PC7EJNcXrhhbCkklkvs-S1Y-kIL0tF7CEmkE5e4wlVXlb0zXNCxUus3QVLc1TbKLl8rwveaPNyUrvbdY1Zt1j3NCnosn3_JnKWfpDuP92nkklwsfYbdV0OxyOhaD9ftTEindPqz6W9OmrG11els5u0lX_DrSwcVuoSusjqVBhEgEh2v4yT2xoZUIbJ6k2NZv1QH_qLbzMoBU1UyH5iZH-xaoyvel8bmwzMGKrzISxr43SxoIP4oxbmU9rTiVHdfO8O5Og795jOHf6saANLzZhix70_Zq26mo3m1aqy_jrl19JBCoCyjbzoNuQNpL-0zn5L-eXeXqHqn349PU3WRbsggjGt6sIsuCgcTiwyIw1dThBa6lxMLYojMPU4WRosdU4uvU49TjwOHI49svGV1YM8cb4WnowcTGbhcYUI9wbHDgcYLC3GhNHrywtjefE4dQbE4eDK9ehx5F3GK7ctul4Bd_BO3GkEL6rKAjOd8AZVCmsCwamn0G32knfIG2m_V6WkZ0-jIktghzIRSbCyCU1i0gluShqcYgojOvUIZ4UaQ1OHGLCFsfeYeStWCd5YxAdHshFCLIgl1O1OMQc70knqSVc_9Z4Tjzi-yWx2lwQzwytHgcjh_qkfbCB0fR1obsZwgWtVUUF7Fj9VClQHDXV38UY7AA76dfaUNEzmMFwUbirySiMnYoKDxyOEqcrthzixKkycaKMXW6dfgZTr8nU0fAV1mEzGF7VYZrjVOkJDGUtK97CiR-bDZi5rVOHXc2ezDTS03i9czWMJr6GoUu8y5aRywWxiU99CbeuNRJHXbW2Saa-STyOfDtMrtrB13tFQ1ev12CUuh4Y-M7A244Hf4V4g7DRk39V6XCkVMtxFIIy1ZyhKuSXQkVQsI021xK7YsOpZETp0Uef9TL9plD_KzH1Pf1sHKFa8gvB6OU-lQ1f7-TnQnXqHLCd3Tn5mzP2N8fPpsRV3En64K7Qwim68EPO3pbR6kpyl7kqdhRPG3sBc3X5jV16OJ9t0O7eHWxQt9Pjvmga8-Nsq98XerOWS1mXDY2MKIqKvQS-hZIf2caIVfL33Z-JvwE "Python 3 – Attempt This Online")
It's almost a shame there turned out to be an interface in python-chess whereby the direct placing of the pieces and setting of the current turn could be done concisely, because there was some fun golf in converting the board to FEN in the **271 byte** version:
```
import chess
b,m=eval(input())
B=['1']*64
for P in b:B[P[1]]=P[0]
B='/'.join(map(''.join,[*zip(*[iter(B)]*8)][::-1]))
i=8
while i:B=B.replace('1'*i,str(i));i-=1
S=chess.Board(B+' '+'bw'[m[0]<'a'])
for l in S.legal_moves:1/(m!=[str(S.piece_at(l.from_square)),l.to_square])
```
[Attempt This Online!](https://ato.pxeger.com/run?1=RdDNToMwHADweN1T1BNgEIGNji1y2dXEoBxJQ2B2jthSVsqSPYuXXfRlfAJ9GvtByu3Xf_9f7ed3fxFH1l2vX6M43Ke_PwfOKNgf8TCAlvaMi7tF49MMn2vitl0_CtfzFkW2YzV_c6WCPcE11xIj7zJahujRqZ3FgXGQg7YDzbYIBiyqvsV7XNXCzcsI-bk6BWpaNVxow4gMh0j2VnVE1RUBwe81qSg742EbPbj0NisHwd0isK3I1OE01hx7nk8CwaYT8syTppdd_25gWTrc8UECkQ9Kp1NcazaKqeZJcaP5IQlDmwtjTdUBLjV7yVU6c2OZhDPn3GQ1M7GMTEIuuTSb7STjxEZjaJlamVlPqj62wWg109S_SppdnlVQ60VNsoMSewttxRrZ7SAy__cP "Python 3 – Attempt This Online!")
[Attempt This Online! - test cases](https://ato.pxeger.com/run?1=5Za9kts2EMcnVWY0k8krbJgC5JlHixJFS7qwUeHGMzd3PncMh0NK0BERRVAgdLIufWr3btwk7xSXeZLggwTkOHmCqNGPiyV2978LSB__aM-8os2nP38l-5YyDoT63bnz9VNNytEGbyEnTXvkrreEx5qWRQ0cd_wGGOZH1qiHUZ6XR1Jz0nR5Hih3SPr3boC2uHEd6dcF7dnxnZPjBSdGOHaZ4zi_H_n2ev75m-_7HNYV7rpR6e8T_FTUbh_cG62SFIUou4qj0ZYyuAPSQLlcpXdpmGXJXTrOhAt6iYJfKGncfdG6SLOfXj2T1r1KRUTmrrzsau5l6XJ5HWZiW5LMR6eK1BjIcpWsAobbulhjV8S6In7HmUs874ZcJ-HoIVG5BStasI27eoEAvUDlCaV7EfwnVKDMU6nVMrWHoMaPRZ3v6RPuluFLd_9DksrtHoKW4DXOC-7WwZbRfd4djgXDnufXAaf9U-YNulwLjdJQZXsDojtBW_BKiNxhxt2xDwgJ-3MyVqG5DC2dOr4hzXIE4kO28LyElpGGu-jnBnmDladi0ySRtiXIjvFUhlHLsl3Soh_YWW8lP61sba6bled9Yx3PrOtwZoSEoDUtNm6rPfD7NW75xW4qrVCU8ddvH5AP3AfcbBKn3xDXHf6n8_i_nJ-T8Ear9unzt9-lqbNzfJjNMx9S5yBwOlHYSGtoMNbWUuBkppBJh4XBeKqwFRjNLS4sTixGBmf2tdmFVYd4I30V3cu4OptbgaGOsJI4MTjRwd4KHBt6pehOesYGF9Y4Nji5cJ1ajKzDNDPbhrMMfoR37IjBfVdhYJTugDZQhbAuGpDzDGLUTuIMCDP2RmmKdqIZsSoCHdAgE2rQkJpCTSUaFFU41cik68Kg7hRqJcYGdcIKZ9YhslZdJ3ojUTvco0EIdIuGriqc6hxXqJdUkX7_rfSMLer1O6S0GVD3TFstTiKDotM22ERq-roQ0wzuLSa8wgx2DXmsOHCqNRXfxQzkhQAnsSwMFT6DvBgGhfuapMJ6UrXCE4PR2OiqR05jbFSJjSgzk1uvn8TQarIwNH2l61AZTC_qkMMhbk6OoSRdRVs40WO9AXn5i9RhR5pHeRuJO3O9MzVEsa1hahLvs23QcEBU4gtbwtyMxthQX60akoUdEouRHYf4YhxsvRc0NfVaDaLQzMDEToY-7brxF6hPkB708b-qdDhiLOQ4MoYbXp-hKrqvhfKhaDbCTDo9FRuKuwZxcfXhJ_GaWCn4_0pMcU6_uI60Wt1XguHhPJU1Xe-6L4Xq1TnocTZ9sidnZk-OvZvGpuJe0ntzhG6Norf2klOnJcouJDeZ82KHdbf1LOhcTX4zk56-n1XQ_twdVFCz08O-qGv546yq3xdis5Z2HSlr7EtRxH-cfQd0CyU9NhspVknf938m_gY "Python 3 – Attempt This Online!")
# [Python 3](https://docs.python.org/3/) (with [python-chess](https://github.com/niklasf/python-chess)), 163 bytes
```
from chess import*
b,m=eval(input())
S=Board()
S.clear()
S.turn=m[0].color
S.set_piece_map(b)
for l in S.legal_moves:1/(m!=[S.piece_at(l.from_square),l.to_square])
```
An even smaller code size is achieved here by setting a rather ridiculously specific input specification. Examples:
```
{56: Piece(ROOK, BLACK), 57: Piece(KNIGHT, BLACK), 58: Piece(BISHOP, BLACK), 59: Piece(QUEEN, BLACK), 60: Piece(KING, BLACK), 61: Piece(BISHOP, BLACK), 62: Piece(KNIGHT, BLACK), 63: Piece(ROOK, BLACK), 48: Piece(PAWN, BLACK), 49: Piece(PAWN, BLACK), 50: Piece(PAWN, BLACK), 51: Piece(PAWN, BLACK), 52: Piece(PAWN, BLACK), 53: Piece(PAWN, BLACK), 54: Piece(PAWN, BLACK), 55: Piece(PAWN, BLACK), 8: Piece(PAWN, WHITE), 9: Piece(PAWN, WHITE), 10: Piece(PAWN, WHITE), 11: Piece(PAWN, WHITE), 12: Piece(PAWN, WHITE), 13: Piece(PAWN, WHITE), 14: Piece(PAWN, WHITE), 15: Piece(PAWN, WHITE), 0: Piece(ROOK, WHITE), 1: Piece(KNIGHT, WHITE), 2: Piece(BISHOP, WHITE), 3: Piece(QUEEN, WHITE), 4: Piece(KING, WHITE), 5: Piece(BISHOP, WHITE), 21: Piece(KNIGHT, WHITE), 7: Piece(ROOK, WHITE)}, [Piece(KNIGHT, BLACK), 45]
{56: Piece(ROOK, BLACK), 57: Piece(KNIGHT, BLACK), 58: Piece(BISHOP, BLACK), 59: Piece(QUEEN, BLACK), 60: Piece(KING, BLACK), 61: Piece(BISHOP, BLACK), 45: Piece(KNIGHT, BLACK), 63: Piece(ROOK, BLACK), 48: Piece(PAWN, BLACK), 49: Piece(PAWN, BLACK), 50: Piece(PAWN, BLACK), 51: Piece(PAWN, BLACK), 52: Piece(PAWN, BLACK), 53: Piece(PAWN, BLACK), 54: Piece(PAWN, BLACK), 55: Piece(PAWN, BLACK), 8: Piece(PAWN, WHITE), 9: Piece(PAWN, WHITE), 10: Piece(PAWN, WHITE), 11: Piece(PAWN, WHITE), 12: Piece(PAWN, WHITE), 13: Piece(PAWN, WHITE), 14: Piece(PAWN, WHITE), 15: Piece(PAWN, WHITE), 0: Piece(ROOK, WHITE), 1: Piece(KNIGHT, WHITE), 2: Piece(BISHOP, WHITE), 3: Piece(QUEEN, WHITE), 4: Piece(KING, WHITE), 5: Piece(BISHOP, WHITE), 21: Piece(KNIGHT, WHITE), 7: Piece(ROOK, WHITE)}, [Piece(PAWN, WHITE), 19]
```
[Here is a Python program that converts the test cases.](https://ato.pxeger.com/run?1=7VdNbuM2FF5050XPQKQL2o3HGMm2JARwgXrgAQZpHSczgBeGEcg2PRIsiypFxeMUPclsspmeoKeZ05QUSVHPzAG6qBeM9Onp_Xzfe6Ty9e_izBOav7x8q_j-TfT9hx_TY0EZR4z00TYhZdnp7MgebWn-RBhfpGRLuoVcezcdJH4Fmii7Qf1ssGf0-FiejxuaKbuVt0bpHqnrt-vJBC8xIllJkHk8yOiJsG6vVztkhFcsRyusYuFr7f3D7N3scf7r77OPq2JQv_rIzwVZD6qikG9f4z4yxu_ufrt7aIy3NKOsZdcTljo3f_3G66FrczuUtz9H607nefK2c0rSjCBP1cnZWV3I34bGbCcKJ09x1k3zouIme_k70idJHj0eSc6FlTYYlEWW8i5Gk18QhtbGlby2TwRrzzeoYGku3m7Q54nXXKtn-E9REMl3E9xyexYFmOs9ZUKnNFd52zJ0kLMJIhl0PSlvHrhfSNVBS0B75a_krLsQAgvOb4Q2CyG_617XD7xBHnRyf_Vlfit8LZ8KV0pwGaMG6jBrif0kFglrBXpuTK1IfU--bEnB0ezu_YwxyloiMxIf1Fjo6Xj53vlntbqaXvXR1a1Yhn0UiYo0ci8Wr4_GFpmLZdRHIURC8JZcfGFmkQf1VgSRCCALFSuEiO8gIsMAImMHCZy3QgeJDLI0tQs_nkXulZ-hReYqeguZqrd8iASm9qWp1AOede0tRNc-hIgPPOvaL5ARiKVrv7AJHSSSsdYdmI-_lmP8iVUEdT8lBDFKD4jmKPHQNs5VU4uxO8l9guaimTurFZ7K7rzFddhaTIXcYyumQubYlmiRUNOgELlEwI9cfN2ACnnAddFDiHjAZoFrWS4QQwOwCR0kgIghWGzxutLQRF-aSo0sCplj2-wWCU0-S1OXaQqLRADRdUUQGZqclybDCERfYNu2Fhk5Nh6oS_sJZVPYnGtWZVO8j-Xh1p2TlCeEoUOefk444lQ1hfgbj5E8JdFJPBZAQs4oZpctEgLZ7rHdJWxDjIFIOokANkQIZJs6NN22G6sRKQDIvC12gwwBcbr5fIgEkhRJU1NXPU0tmuTwiIOWE7RJy4QW6ESrbIfE_iyZQYc0_yxPLnGubw8uRQGkKHptZi7mKnII8QGNU2w3djAznoNcdH_kTBGcPW0TOORHkPzQmZCxI8cI-NGy-o4cLZsHZz71hASws8evTYhvRdT5RK-L-EdFiFCrYkycvNkZJXHp6thHcb4TcFqqmdhRUuaYi4OePMlPJp7E_H-t_yNah2Zfs4edErN09CRms9tkdHsoX9Mxcra1ADA5b7PUIENHx5FzFsIT4rbdD222L7j1Hf49Z1sbgk2s6SLLCY8PRLW5GgLFgnvme07lPsy4PtOaSE3GNtLHY5xlpOSK92MsghW0LNNNJv7jEHJwwo4lonvxpV_lOynThn7pqa_XfwE "Python 3 – Attempt This Online")
[Attempt This Online!](https://ato.pxeger.com/run?1=ddPNTsIwAAfwgyd5inoxnZlz33wkO4AhsmAAHYYDIUuZRZZ06-w6EmN8Ei8kRt9Jn0YQhmNZb-3v37X_pN37V_LClzRerz8zvrhsfH8sGI1AsMRpCsIooYxf1OZy5OAVIjCMk4xDSap5Toci9gg3IyUgGLG_Ec9Y7ERTdaYElFC2kRRzPwlxgP0IJXAu1RaUAQLCGHgKwU-I-BFd4bSlXcHozJl6ym4x4pAo2yJ--pwhhiWZKJzuJzNpV3XfeP1zcv5q2S0w2n4K74fDvgw6t-3rviQDq557f-De9MaFpJEnHdfrDUeFpJkndw_d7uA_sNXDZu7gpuCaaCtbFx1vG9WFzUOtUXtSONtsVrulClwTuC5wQ-CmwK1qL9Wf9Nxxd8PNatZUgWsC1wVuCNwUuFXt6vGlHJaXbzEP9PLF54FRekK5m8cvKGdLtI8uPLpeVfVNBtPq92Zas9Pd__IL "Python 3 – Attempt This Online")
[Attempt This Online! - test cases](https://ato.pxeger.com/run?1=7Vc9b-NGEEVaFalTTpRCZEAzIilKsgwV54NzNhzYTuTgCsUgKGllEqK4vN2VdbKRNnX6NAcEyX-6K_NLsitKpLTkBEh_bCS-2Y_ZN29mln_8nW1ERNMPH1_iZUaZgJhafMOt_C2JJ40ZmUMQp9lKGOYAHhM6CRMQhIszYESsWLp9aQTBZBUnIk55ENjb4TDczTsDmpHUaKpx3M42Tau5bpr2msWCGKzZbP61EvOT_sc_54wuYRoRziHf_9vGxFoOyVOYGDsPzMZoeE5DNjPkP3uakJBt_ylHhstx-8Ge0oQyiXAigiwmUxIsw8yYmI05ZZBAnMLITshjmARL-kT4wPnOWH49HI_sfHAojMRWjgT83SpkxLQSW9Ddy4OZu_rpixPp9tgZnDgP5hlIwuwsFJE8NydMGG0LWi2JPw_b212F2lUN4mIWp4MGyCeew_MAMhanwmj9krbMPSrGctHhUGEDUCSKsdpma1YMKiR_YZt8KfVkiu0gZy0Idlw3zcKeb1dE1WYkoeHMyPIR5P2UZOJgta1bjjzGP7_93rJAWEDS2bC5W5AknOiD29jg56FzlrP24dOXX734_QHcKaaN66ubNxac__Dq9bVpgefu8R9_vri4KQ2-U0y4uXpzeV9aui5mcf295fxqdHl7d7Da6d7y0-3t9cFaXj3eKdy9e_X2wKvOKYK7CN6px30PwbHxPrL-MatvL6_uLxQRjsbq3uD0de4Ki6tzVyx2ilnax-Tt4V497HSPz7DHT-thp12Puz1kvIfgHWSd2vG_WjCudd5_gG_gnq0IGPcRAUbpAmgKkQPTMAVVU0Dm_FqWKAkTs_HSdeoVX0pLU3zJT0XxqMHDBO-hFgdJhTITNbxbLz2d10Kq_zMV9HgWuFuv7VIXmrbLHNe17aGqb2PS7mEGv1uvbh9JBsdH5OcgckVwF5GxXhl0GVe4cJWQvw9lLQfjhsQiIgwWafwYCRA0F7L8DX3YtuW1NEsgIhtQXbHxooelWnt1WaPlutPGLGUZrBTyLmbp1stFd2uPl3KsVEJULWgh9BC5HIThmCzvIAiqnKwjeSmCScwjmsGarpIZqKuU5B0WcfqoLhLygjRdyAB0ukgAPCQAfuWk1a6iWyonLab0MYum_2qQtbKCdFIH67BImehiZaKDBR6LbsfDLJUzF1MczOIiTbDj1uOOW5fGWFerpndBR7tWWe9WhEgJrRgjqUg2EIW8Ki4LwnQm4ZjnZWBGCU9bQt70yJOcJi2h-CzAzwL8TwF6_eOLUq4wXhEZ2TedSUKnC74XVyki7Tuhh4gL_xrw0faC3o0q14EaCR8FuYvEGL2KVC95RQ-p9Dydat2p05JpES5IntF5vufcSj79ejodLFd7decsXdDJLz0YLcMkUd-p2ygvQ-lERjmPJwmxVPAFYUsOdA4TukpnShQT-n73Xf0v "Python 3 – Attempt This Online")
] |
[Question]
[
# Goal
You will be given a positive integer number less than 10^20. You must convert it to Korean.
For example, if the input is `12345`, the output should be `일만이천삼백사십오`.
# Technical details (Small)
Let's starts with simple numbers.
```
// 1 - 9
1 -> 일
2 -> 이
3 -> 삼
4 -> 사
5 -> 오
6 -> 육
7 -> 칠
8 -> 팔
9 -> 구
// 10, 100, 1000
10 -> 십
100 -> 백
1000 -> 천
```
You can concatenate `2` ~ `9` front of `10`, `100`, `1000`.
However, you should not concatenate `1` front of `10`, `100`, `1000`.
```
// 20 = 2 * 10
20 -> 이십
// 300 = 3 * 100
300 -> 삼백
// 9000 = 9 * 1000
9000 -> 구천
// 1000 is just 1000
1000 -> 천
```
For integer less than 10000, below rule is used for pronunciation.
```
// 1234 = 1000 + 200 + 30 + 4
1234 -> 천이백삼십사
// 1002 = 1000 + 2
1002 -> 천이
// 2048 = 2000 + 40 + 8
2048 -> 이천사십팔
// 510 = 500 + 10
510 -> 오백십
// 13 = 10 + 3
13 -> 십삼
```
# Technical details (Large)
Now let's go to the hard part.
First, you need to know some parts used in larger numbers:
```
1 0000 -> 만
1 0000 0000 -> 억
1 0000 0000 0000 -> 조
1 0000 0000 0000 0000 -> 경
```
When Koreans pronounce big numbers
1. Cut it with width 4
2. Convert each of them using methods for less than 10000
3. Combine them with default form of big numbers
Here is some detailed examples. (I added some space to korean for readability)
```
// 12345678 = 1234 5678
// 1234 -> 천이백삼십사
// 5678 -> 오천육백칠십팔
12345678 -> 천이백삼십사 만 오천육백칠십팔
// 11122223333 = 111 2222 3333
// 111 -> 백십일
// 2222 -> 이천이백이십이
// 3333 -> 삼천삼백삼십삼
11122223333 -> 백십일 억 이천이백이십이 만 삼천삼백삼십삼
// 10900000014 = 109 0000 0014
// 109 -> 백구
// 0000 -> (None)
// 0014 -> 십사
10900000014 -> 백구 억 십사
// 100000000 -> 1 0000 0000
// 1 -> 일
// 0000 -> (None)
// 0000 -> (None)
100000000 -> 일 억
```
[Here](https://pastebin.com/p528RuTL) are some more examples.
# Rule
You can make your program gets input from `stdin` and output to `stdout`, or make a function that gets string/integer and returns string.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so answers will be scored in bytes with fewer bytes being better.
[Answer]
# [Aheui](https://aheui.github.io/), 1555 bytes
```
살밦발따밝따빠따밦발다빠따다빠밞빠따받다빠따밝발따두
수터더떠벋벓떠뻐더벖떠뻐벍뻐터터떠벌벖떠뻐떠벋벎뻐더
방뺘우차빠발발다빠따빠뚜
우노여뗘뻐떠뻐더벌벌썪러
샦우싹어
아삳부
ㅇ아삭뺘우차빠불
ㅇ유어우여려더벌
ㅇ요ㅇ빠받반타탸우처삳뺘우처밝밤뚜
ㅇㅇ우쑨여텨여볋여뗘여뼈여뎌벅떠벓
ㅇ요아삭뺘우차삳빠박탸유처발불
ㅇㅇ우어ㅇ여따뱖볆뚜텨벎떠뻐떠
ㅇ요ㅇ우어쎤여뎌여별여어
ㅇㅇㅇ빠밤탸우처밣빠따밞다뿌
ㅇ요ㅇ우어쎤여뗘벎더떠벋벓떠
ㅇㅇㅇ빠밦탸우처밞밦따빠뚜
ㅇ뇨ㅇ숙어쎤여뗘벎떠벅터벖
ㅇㅇㅇ빠박탸우처밝밤따밣따북
ㅇ됴ㅇ우어썬여텨더벓벓떠뻐더
ㅇㅇㅇ빠받탸우처밣밝다빠따붇
ㅇ뵬ㅇ우어썬여뎌떠벍벓떠뻐터
ㅇㅇㅇ빠밤탸우처밣밝다빠따붇
ㅇ뵬ㅇ우어썬여뎌떠벌벓떠뻐터
ㅇㅇㅇ빠발탸우처밣밝다빠따뿌
ㅇ묘ㅇ우어썬여뎌떠벎더벌벖떠
ㅇㅇㅇ빠밦탸우처밣밝다빠따빠뚜
ㅇ쇽ㅇ우어썬여뎌떠벓더벓떠뻐벖
ㅇㅇㅇ빠밝탸우처밞밞따빠따붒
ㅇ됴ㅇ우어썬여뗘벓더더벍떠뻐
ㅇㅇㅇ빠밣탸우처발발따발따붒
ㅇ뵥ㅇ우어썬여뗘벎더범떠벓떠
ㅇㅇㅇ빠밟탸우처밝발따빠따붏
ㅇ숃어어어쎤여뎌벓떠벎떠범더
ㅇ마샬우싹샥우파뺘무차파쑨
ㅇㅇ오유여어유여ㅇ며ㅇㅇ우
오ㅇㅇㅇㅇㅇㅇㅇㅇㅇㅇㅇ어
우ㅇㅇ어ㅇㅇ어어
샨희맣어
```
**[Try it online!](https://tio.run/##lZRdbtpAEIDffaMcpw@V0gP0PY1xsYRNSDGOC4Yg4RASudLWOFbSH/UwfZz1GcjM7Hr9E4wUhEaz3tlvZudnP5x//PzpcJCXOYgtiBgCAWJJ8mXNOn8cJXqpFLGqdhf1Fp5Sx68nlnSjciDADyBcQzaCbErK7wl9yUKtZz5KNCNLMvPqLX1qrI5YIB7gVyTnQood@49bQaGcxxZug/Msb1K4iTRDO0SwJ/1HuE0taW8JM3qRYW7J2UBe7qG4sP47Q178aLkpXN6I12hMXxG9ThSRN@YBSo5nASIq7YvSfia7LCKsImURJyahCNGajwl5vUNY6ZCE/UjFTPKPS3KMATucg6n20wmO8OR2Rg4xPHIS63C1hzAnBWGYn58h7L9iAOiQclqluL6DOiDHifLOUQ1QUpIUsrpoYq4IYlMVfkWl@Of18LAa6LTdCh3qtkFdUcuZopLFcEdI93sXSTyHmicLO7xZg8fJpyg3JIsvjJzkdZR@qmrBhZ02W7VDXbTujmDTgMWQqU9ph0qVpCh9Q8VwT2b0PVTvBDXupao6QRr1UMfVyISn69SmmmrJ4d8e8FQnWA9/t2bLdg@s6ieo@Ha8ZtwGTCWwr8Ad6qZBjavnLW5Qn@6OUVUSAh33mzzctvsrbsR6xUlwbeKpfzVV@u66cQPdX3DvSjvVb5J9h0rpeTjokOY46KjjW1GNdZTQsPNYKoXOPwgz9BZamED7/vzwzYVZGIU37F25TOF@g4vD4ezIz3oF "Aheui (esotope) – Try It Online")** (trailing new line for input is necessary)
Why not?
Hours of coding, and another hours of packing and layouting. I think it can be golfed furthermore, but it already took so much effort. I really wanted to pack it into a rectangle.
Because 10^20 is larger than 2^64, not every implementation of Aheui will not support 경-scale numbers.
Luckily, Python and [pyaheui](https://github.com/aheui/pyaheui) implementation (which is used on TIO) uses much-larger precision numbers, so it can support not only 경, but more than [해, 자, 양, 구, 간, 정, 재, 극](https://en.wikipedia.org/wiki/Korean_numerals#Numerals_(Cardinal)).
And my code can be *easily* extended to use more larger unit suffixes.
This code will not terminate on input `0`, but this spec was not defined in the question (which should output `영`).
# Explanation-ish Unpacked Code
```
ㅣPush unit suffixes (만, 억, 조, 경) to stack ㄹ
ㅣ
술
밦발따밝따빠따밦발다우
우ㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
빠따다빠밞빠따받다빠따밝발따다다우
우ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
빠밞받따빠따밦발따타타우
우ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
빠밝빠따밦다빠따밣받따다타우
우ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣ
ㅣGet input as number
ㅣ
사방우
우ㅡ어
ㅣ
ㅣSplit input by four digits
ㅣ
ㅣㅣIf input is zero, end the loop
아아뺘우차우
우ㅇㅡ어 ㅣ
ㅣㅣ우ㅡㅡ어
ㅣㅣㅣTake mod 10000 to stack ㄲ
ㅣㅣ빠발발다빠따빠따라싺우
ㅣㅣ우ㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣDivide by 10000
ㅣㅣ발발다빠따빠따나우
ㅣ오ㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣ
ㅣReverse stack ㄲ to stack ㄱ
ㅣ
샦우싹어
우어
ㅣ
ㅣProcess four digits
ㅣ
아우ㅣUse ㄷ stack for index (0, 2, 4, 6)
ㅣ아삳바우
ㅣ우ㅡㅡ어
ㅣㅣ
ㅣㅣㅣConvert four digits into korean
ㅣ아아숙
ㅣㅣㅣㅣIf current multiplier is zero, escape
ㅣㅣㅣ뺘우차우
ㅣ우ㅇㅡ어 ㅣ
ㅣㅣㅣ우ㅡㅡ어
ㅣㅣㅣㅣTake mod 10
ㅣㅣㅣ빠발발다라우
ㅣㅣㅣ우ㅡㅡㅡㅡ어
ㅣㅣㅣㅣIf remainder - 1 is 0 (remainder is 1) and index is 0 (ones digit), push 일 on stack ㄴ
ㅣㅣㅣ빠받반타탸우처삳뺘우처밝밤따밣따박다빠따밣타싼우
ㅣㅣㅣ우ㅡㅡㅡㅡ어ㅡㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣIf remainder is not 0
ㅣㅣㅣ삭뺘우차우
ㅣㅣㅣ우ㅡ어 ㅣ
ㅣㅣㅣㅣ우ㅡㅡ어
ㅣㅣㅣㅣ숟
ㅣㅣㅣㅣㅣIf index is [2, 4, 6], push [십, 백, 천] on stack ㄴ
ㅣㅣㅣㅣ빠박탸우처발발따빠따밞타밞따밞따발다싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밤탸우처밣빠따밞다빠따밣받따다밞따싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밦탸우처밞밦따빠따밦타박따밞따싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣㅣ
ㅣㅣㅣㅣㅣIf remainder is [2 ... 9], push [이 ... 구] on stack ㄴ
ㅣㅣㅣㅣ숙
ㅣㅣㅣㅣ빠박탸우처밝밤따밣따박다빠따밣밣다타싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠받탸우처밣밝다빠따받타빠따밣밝따다싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밤탸우처밣밝다빠따받타빠따밣발따다싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠발탸우처밣밝다빠따빠따밦발다밞따다싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밦탸우처밣밝다빠따빠따밦빠따밣다밣따다싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밝탸우처밞밞따빠따밦빠따밝다다밣따싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밣탸우처발발따발따밦따밣따밤다밞따싼우
ㅣㅣㅣㅣ우ㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ빠밟탸우처밝발따빠따밣다밤따밞따밣다싼우
ㅣㅣㅣ우ㅡㅡㅡ어ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣㅣㅣ
ㅣㅣㅣㅣIncrease index, move onto next digit
ㅣㅣㅣ삳박다삭마발발다나우
ㅣㅣ오ㅡㅡㅡㅡㅡㅡㅡㅡㅡ어
ㅣㅣ
ㅣㅣㅣPop zero
ㅣ아무
ㅣㅣㅣ
ㅣㅣㅣㅣMove one suffix to stack ㄱ
ㅣㅣㅣㅣIf all suffix has been used, escape
ㅣㅣ아샬우싹삭우
ㅣ우ㅇㅡ어 ㅣ
ㅣㅣㅣ우ㅡㅡㅡ어
ㅣㅣㅣㅣIf next multiplier is zero, discard next multiplier and suffix, then check next
ㅣㅣㅣㅣIf next multipler is not zero, move suffix to stack ㄴ and continue
ㅣㅣㅣㅣIf all multiplier has been processed, escape
ㅣㅣㅣ야우파뺘우차파싼우
오ㅇㅇㅡㅇㅡㅡㅇㅡㅡㅡ어
우어ㅇㅡ어ㅡㅡㅣ
ㅣㅡ오ㅡㅡ머머어
샨희맣어
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 147 bytes
```
^
0경0조0억0만
\G0?\D?
0천0백0십$&
+`0(\D)(\d+)(\d)
$2$1$3
0(천0백0십0.?|천|백|십)
1(천|백|십)
$1
T`d`_일이삼사오육칠팔구
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wP47L4NWmvQZvFm4weDNtq8Hr5T1cMe4G9jEu9lwGbzbNMXi9YaPBm@61Kmpc2gkGGjEumhoxKdogQpNLxUjFUMWYy0ADSZ2Bnn0NkFsD5NYAuZpcXIYaKHwVQ66QhJSE@Ddz97yZu@VN0543TWvezFjyZs7CNzsXvO2Z8mrrmv//DY2MTUzNzC24DA0NjYDAGAi4DA0sDcDA0ATIhgIA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
^
0경0조0억0만
```
Insert the symbols for powers of 10,000.
```
\G0?\D?
0천0백0십$&
```
Insert the thousands, hundreds and tens symbols.
```
+`0(\D)(\d+)(\d)
$2$1$3
```
Replace the zeros between the symbols with the input digits.
```
0(천0백0십0.?|천|백|십)
```
Delete zero thousands, hundreds or tens, or a whole power of 10,000.
```
1(천|백|십)
$1
```
Delete the 1 of one thousand, one hundred or one ten.
```
T`d`_일이삼사오육칠팔구
```
Transliterate the remaining digits, deleting any remaining zeros.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~96 95 94~~ 92 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“Ŀ|ĿtĊỴĊḄİ$Ŀ!Ṫ`ạÞḌlĖḣỴ1ṘƈỤṘḢỌṀpḄẒ‘s2ḅ⁹Ọ
bȷ4DUµż“¢½¿€‘ṁ$Ṛœl€1P€0¦ẠÐfFµ€Ṛµ;"“¡ÆÇÐÑ‘ṚL’$ÐfFḟ0ị¢
```
A monadic link taking a positive integer and returning a list of characters.
**[Try it online!](https://tio.run/##y0rNyan8//9Rw5wj@2uO7C850vVw9xYgsaPlyAaVI/sVH@5clfBw18LD8x7u6Mk5Mu3hjsVAecOHO2cc63i4ewmQfrhj0cPdPQ93NhQA9TzcNelRw4xio4c7Wh817gSKcyWd2G7iEnpo69E9QCsOLTq099D@R01rgIoe7mxUebhz1tHJOUC@YQCQMDi07OGuBYcnpLkd2grkAiUPbbVWAmlbeLjtcPvhCYcngvXN8nnUMFMFpO7hjvkGD3d3H1r0//9/QwNLAzAwNAEA "Jelly – Try It Online")** or see a [test-suite](https://tio.run/##ZU09S8RAEO39F0rKKXY3Ob3DVmy0sLGwE0ELSSFoI1jkRD3RK04FOQ9RL4qFWFgY3E1OArsb8W/M/pE4GytxmK/35j1mezOO9@vaJbe2PLDlnj3D4p2aPLJvgS2nUb2sYz42dyj7sb1G@Uh3jmr4dYrFE02UKRZ9VMkOeTC/dMlwV6A8dl1F/NTG90e0sKqzakIvdKo/dekOX0mEqhugGlVXMWG@Qo3pZ8wfzGBrUWcE6aiz@RlvG5sT0zMDc9H4RssuuQm8DuU9w@Jcp3U1MT3yLFGt1TUHASFE0IJZmIM2dIAzyqYYCAYhjY7fuQgjzwpioza0vC5sZL9i9nf7j3z8AA "Jelly – Try It Online") (numbers referenced in the OP)
...or see assertion of the pastebin values [here](https://tio.run/##pVNNb9NAEL33V4CVYw676ziNxRVx4sCFUxQJIcEB5YAEl0ockgoooj6UD1WhCpCEqpVQkdIoFnbiKpLtIv7G@tiW32Bmd70fjc2JlbyZeTuz82b25cmjbncrz7PeMF29SFfP07d0OYcteJlOa@nqJg2/P6CLcfKFBl433afBNzjHNBz8ekOXh/BLgwldejTsPYUcunif9QbPCA1eZf0Q8I2Hv382bt@P/fMISsST@CxeZdsnEETDfo2GB@cfuuDje7Ch@IguRsne4zuxDy4cxv4ti6WNk9fJTrKXvON5B3ez3qcai6PBV0SXu/EkBxbJTtaPgC5PzvN2G9etq8@R1alv3GgTZs@FbYO9XeANZp8I2wF7cCjsJtjDsbA3wQ5Hwm7VrT/eR2G7devCL3IxgqDdH4WDuaOKY1L4BQFsC1@SIJzp3EwhroRUCRtx3qqKgzhf5bstzgd8zdCVkEEU0i6np9Ij3NPUsDg2esESMPpBMkvHEWxgRqhtwqpjxgIwRYRgBegrEY@aDVWOiDGQRksi8Ipm5wTrYLMINkA9bIxsE5cs3dZmUwxwNoSb2VE4Ym1IZTCGvEx0eexpCEvIHANyNCoIR@xCKThiN5ymGAFEwDPzlkREqWQx6@Iuc9xwjJl2xBwhQM1eKwBKITnaYuRcVqyeaoMHceFWBZlqdl3ksk9OCnaIZvuxt4bIBLFKCYJlOW1Nv2LxaV7t@9dhLOFrI0HYSGCPDB1IETEm@s7KyqqKa6x/x/5PV7qz8VTLHpndzeFIS9euOhXyMYeA1havcTE7K9dAyHHEXweOQXxKgloY61@VSFhyCWTcyiB/kgqNlUCr0/kL "Jelly – Try It Online")
### How?
Constructs the parts-characters required as indexes of the list:
```
[1,2,3,4,5,6,7,8,9,10,100,1000,10000,100000000,1000000000000,10000000000000000]
i.e.: 일이삼사오육칠팔구십백천만억조경
```
and indexes into the list. Thus `30210` would become `[3,13,2,11,10]` and then `삼만이백십`
```
“Ŀ|ĿtĊỴĊḄİ$Ŀ!Ṫ`ạÞḌlĖḣỴ1ṘƈỤṘḢỌṀpḄẒ‘s2ḅ⁹Ọ - Link 1, get part-characters: no arguments
“Ŀ|ĿtĊỴĊḄİ$Ŀ!Ṫ`ạÞḌlĖḣỴ1ṘƈỤṘḢỌṀpḄẒ‘ - code-page indices = [199,124,199,116,192,188,192,172,198,36,199,33,206,96,211,20,173,108,194,237,188,49,204,156,185,204,197,181,200,112,172,189]
s2 - split into twos = [[199,124],[199,116],[192,188],[192,172],[198,36],[199,33],[206,96],[211,20],[173,108],[194,237],[188,49],[204,156],[185,204],[197,181],[200,112],[172,189]]
ḅ⁹ - convert from base 256 = [51068,51060,49340,49324,50724,50977,52832,54036,44396,49901,48177,52380,47564,50613,51312,44221]
Ọ - cast to characters = "일이삼사오육칠팔구십백천만억조경"
bȷ4DUµż“¢½¿€‘ṁ$Ṛœl€1P€0¦ẠÐfFµ€Ṛµ;"“¡ÆÇÐÑ‘ṚL’$ÐfFḟ0ị¢ - Main link: integer, n e.g. 102031
ȷ4 - 10^4 = 10000
b - convert (n) to base (10000) [10,2031]
D - convert (each) to base 10 [[1,0],[2,0,3,1]]
U - reverse each [[0,1],[1,3,0,2]]
µ µ€ - monadic chain for €ach:
$ - last two links as a monad:
“¢½¿€‘ - code-page indices = [1,10,11,12]
ṁ - mould like e.g. [1,10] or [1,10,11,12]
ż - zip [[0,1],[1,10]] or [[1,1],[3,10],[0,11],[2,12]]
Ṛ - reverse [[1,10],[0,1]] or [[2,12],[0,11],[3,10],[1,1]]
œl€1 - left-strip ones [[10],[0,1]] or [[2,12],[0,11],[3,10],[]]
P€0¦ - product @ index 0 [[10],0] or [[2,12],[0,11],[3,10],1] (Note: the empty product is 1)
ẠÐf - filter keep if any [[10]] or [[2,12],[3,10],1]
F - flatten [10] or [2,12,3,10,1]
Ṛ - reverse [[2,12,3,10,1],[10]]
µ - new monadic chain
“¡ÆÇÐÑ‘ - code-page indices = [0,13,14,15,16]
;" - zip with concatenation [[2,12,3,10,1,0],[10,13],14,15,16]
Ṛ - reverse [16,15,14,[10,13],[2,12,3,10,1,0]]
Ðf - filter keep if:
$ - last two links as a monad:
L - length 1 1 1 2 6
’ - decrement 0 0 0 1 5
- i.e. [[10,13],[2,12,3,10,1,0]]
- (This also removes any 0-sized 10K parts e.g. the [13] from 200001234 -> [16,15,[2,14],[13],[12,2,11,3,10,4,0]])
F - flatten [10,13,2,12,3,10,1,0]
ḟ0 - filter discard zeros [10,13,2,12,3,10,1] (Note: not there for multiples of 10000 so cann't simply pop with Ṗ)
¢ - call the last link as a nilad "일이삼사오육칠팔구십백천만억조경"
ị - index into "십만이천삼십일"
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 158 bytes
This task has been haunting me for a few days, but after several iterations of tinkering with the code and gaining max 1-2 bytes at a time, I think it isn't going to become much shorter than this, unless somebody points out a conceptually different approach.
```
->n{i=0;n.digits.map{|d|'-만억조경'[i%4>0?'':i/4]+'천-십백'[(i+=1)%4]+'0일이삼사오육칠팔구'[d]}.join.reverse.gsub /(0.){4}.|0.|일(?!-)|-/,''}
```
[Try it online!](https://tio.run/##AaYAWf9ydWJ5//8tPm57aT0wO24uZGlnaXRzLm1hcHt8ZHwnLeunjOyWteyhsOqyvSdbaSU0PjA/Jyc6aS80XSsn7LKcLeyLreuwsSdbKGkrPTEpJTRdKycw7J287J207IK87IKs7Jik7Jyh7Lmg7YyU6rWsJ1tkXX0uam9pbi5yZXZlcnNlLmdzdWIgLygwLil7NH0ufDAufOydvCg/IS0pfC0vLCcnff// "Ruby – Try It Online")
## Explanation
Takes input as integer and extracts the digits (listed from the least to most significant) using the convenient built-in available since Ruby 2.4.
Then, we combine the corresponding Korean digits with position markers and where necessary, 104 block markers. `-` is a placeholder for the missing markers of lower digits.
`천-십백` has such strange ordering because it is rotated by one place to compensate for the fact that we are also incrementing the counter `i` in the same step.
Finally, we reverse the resulting string back to normal direction and remove some redundant stuff with RegEx replacements:
* `(0.){4}.` : 4 \* (0+marker) + another marker = a completely empty 104 block.
* `0.` : zeroes at any single position
* `일(?!-)` : ones followed by any meaningful (non-placeholder) markers
* `-` : finally, get rid of the placeholders themselves
## Alternative
Interestingly, a similar approach, but working with string input is just 1 byte longer:
```
->s{i=s.size;s.chars.map{|c|'0일이삼사오육칠팔구'[c.to_i]+'-십백천'[(i-=1)%4]+'-만억조경'[i%4>0?'':i/4]}.join.gsub /(0.){4}.|0.|일(?!-)|-/,''}
```
[Try it online!](https://tio.run/##AacAWP9ydWJ5//8tPnN7aT1zLnNpemU7cy5jaGFycy5tYXB7fGN8JzDsnbzsnbTsgrzsgqzsmKTsnKHsuaDtjJTqtawnW2MudG9faV0rJy3si63rsLHsspwnWyhpLT0xKSU0XSsnLeunjOyWteyhsOqyvSdbaSU0PjA/Jyc6aS80XX0uam9pbi5nc3ViIC8oMC4pezR9LnwwLnzsnbwoPyEtKXwtLywnJ33//w "Ruby – Try It Online")
[Answer]
# Wolfram Language 23 bytes
Mathematica has a built-in for this. (What a surprise!)
```
IntegerName[#,"Korean"]&
```
To save one byte...
```
#~IntegerName~"Korean"&
```
[Answer]
# [Haskell](https://www.haskell.org/), 270 bytes
```
(0#_)_=""
(n#1)_=[" 일이삼사오육칠팔구"!!fromInteger n]
(n#b)(c:r)|d<-div n b=[k |d>1,k<-d#1$r]++[c |d>0]++(mod n b#div b 10)r
t=10^4
(n%1)_=f n
(n%b)(c:r)|d<-div n b=[k |d>0,k<-f d++[c]]++(mod n b%div b t)r
f n|n<t=n#1000$"천백십"|1>0=n%(t^4)$"경조억만"
```
[Try it online!](https://tio.run/##nVXLbtpAFN3zFZOBSLZwpRkbEhzF2VdqV@0OkQhi56GAQbbTdsEq22ZZVVkQKUiRsiESRWQRif5Q4n4DvXcetgtk05FsnTn3@tzHXIazdnwRdLvLpcHKR@aRR2nJCMscUJOS9HaR3s7Tq0V6NUlv7tPROH2@@3P94@VpQre2TqJ@732YBKdBRMIWftYxjeO9yBz6@@/88y8kJB2veUGG/gG3LoAq80rUqlabx0gxQEav76NXGb07hDMzKiUeZ4c1UNvGJE5IiPBNYYbCJ8RH1VZBcVsqJiAIEsNwP/GgKsZYhaaz0ev0V/r9kQ75AfPCbSM5rJkV@jL7nY6n6c@n14drugy@tXuDbhCTvT3SNFSZFvmUROfhqdkqZXYPzNyi0CpqWoaNaI7IAXQluBqiCaI6oJt7RDuARmNEu4Ce7xA1LAq9ReRaFFsMiDMwQ6oIuYAqELfVTgTjjtzJgLbIZ547264mlKzDRHZKuc5EXmrnNkR02OlsXE1kScEH0EOJbYF1Ilyaspy53mZ5M@2vfWxeYDI3p0iqujAuMCq0zbOtlmLCYzZS3tKe7WsNvcd5zuqzee6YS/MCpdvImVNkZVZuY3dHNmg2AkU0PN9h0vJ8MSchv8C5UgTXRF4uq@ecTHGBUnJcbKdW35HFgh0OTpQg7SuhVDeVTt5QMHKcA9ktMGfd1acKQZhuoGqrGBGMpFIXLmL0Nrnk8@i6zMVH9wXe4Ivvh@sVRrrLteYus1v/6J9ZlEt0D369RZJrstAExgvOeJCQtxwQzCBX2xhR6buF9bbn/9eS1zOe6lFmxZrmeFOpoXQ22eSI5IWzlSXU4cZbVWesXpc/BrwOb@6zEdPHv/psGgX8dI3ErNZJcQQbJmmNpHDn9trnIdy3fr9EYHWDhCRBnBihFZtDuOU9L/aiILmMQmKY4m4PoqgfkQqJz/pf4V@hWiUU8WXXJ50AMBDCFEtT2E9y0gBFUwTqtQcfj0Qoom99wQ8uE/g7@BBCAPoZrDEZtOM48Lfo8i8 "Haskell – Try It Online")
This could probably be improved as there is a bit of duplication but I can't think of a good way of unifying the `#` and `%` operators.
Both of those operators work in a similar way but `#` is for `n<10^4` and `%` is for big numbers. They take the number `n`, the current "base" `b` and a list of characters representing the relevant powers of ten in decreasing order. First I divide `n` by `b` to get `d` and stick it's korean representation in front if it's greater than 1 (in the case of numbers less than ten thousand) or 0 (otherwise). Then I insert the representation of the power itself (which should correspond to `c`) if `d>0`. Then we just recur by modding `n` by `b` and dividing b down to get the base corresponding to the next character.
When we reach `n==1` in `#` We know it's down to a one digit number so we just index into a list (I need `fromInteger` because `Int` isn't large enough to store numbers as large as `10^20`). When `n==1` in `%` then `n` is now `<10^4` so we recur to `#` (via `f`) to do the rest of the number.
] |
[Question]
[
You must write a program or function that takes a string of brackets and outputs whether or not that string is fully matched. Your program should print a [truthy or falsy](http://meta.codegolf.stackexchange.com/questions/2190/interpretation-of-truthy-falsey) value, and IO can be in any [reasonable format](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
# Rules and definitions:
* For the purpose of this challenge, a "bracket" is any of these characters: `()[]{}<>`.
* A pair of brackets is considered "matched" if the opening and closing brackets are in the right order and have no characters inside of them, such as
```
()
[]{}
```
Or if every subelement inside of it is also matched.
```
[()()()()]
{<[]>}
(()())
```
Subelements can also be nested several layers deep.
```
[(){<><>[()]}<>()]
<[{((()))}]>
```
* A string is considered "Fully matched" if and only if:
1. Every single character is a bracket,
2. Each pair of brackets has the correct opening and closing bracket and in the right order, and
3. Each bracket is matched.
* You may assume the input will only contain [printable ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters).
# Test IO
Here are some inputs that should return a truthy value:
```
()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]
```
And here are some outputs that should return a falsy value:
```
( Has no closing ')'
}{ Wrong order
(<)> Each pair contains only half of a matched element
(()()foobar) Contains invalid characters
[({}<>)> The last bracket should be ']' instead of '>'
(((())) Has 4 opening brackets, but only 3 closing brackets.
```
As usual, this is code-golf, so standard loopholes apply, and shortest answer in bytes wins.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~1101, 1085~~, 981 bytes
```
{(<(({}))((((()()()()()){}){}){})({}[{}]<(())>){((<{}{}>))}{}>{({}<>)(<>)}{}<(({
}))((((()()()()()){}){}){}())({}[{}]<(())>){((<{}{}>))}{}>{({}<>)({}[{}](<()>)){
{}{}(<(())>)}{}{<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))(((((()()()()()){}){})){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()(<>)}{}<(({}))(((((()()()()()){}){})(
)){}{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((()()()){}){}()){({}[()])}{})({}[{}]<(()
)>){((<{}{}>))}{}>{<({}()()<>)>()(<>)}{}<(({}))((((((()()()()()){})){}{}())){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{<>{{
}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((((()()()()()){}){}){}())){}{})({}[{}]<(())>
){((<{}{}>))}{}>{<({}()()()<>)>()(<>)}{}<(({}))((((((()()()()()){}){}){}())()){}
{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<{}>[()]){<>{{}}(<()>)<>{{}}(<()>)}{}}<>([]<>)({}<
(())>){((<{}{}>))}{}
```
[Try it online!](https://tio.run/##rZNBDsIgFESvM7PoDQgXaVjgwsRoXLj94ew4QDU11Uq1pYVfGCZvUnq4xdN1OF7iOWeDAyyRKBcfjZpqtxZHS0Eq0tMAZ8mSJ0tvWnWe0KPXdSeVXV5NIyxJaEWAaYNKc15TqfWYRFWyIFggsHh9YXAooDLzYI8ntrvulW@GUcbiCwb20qylfI1ZE6rsT7p71g/naQtRf97naf3N/6/McqxfcdI1wbxOdTfG0H6Vt1A5o7I7P4aYh3gH "Brain-Flak – Try It Online")
This is 980 bytes of source code, and `+1` for the `-a` flag allowing ASCII input (but decimal output)
This is an answer I've been wanting to write for a *very very* long time. At least 6 months. I waited to post this because I knew that answering this challenge would be extra hard in brain-flak. But it's worth it for one very important reason: The source code itself is a truthy input, which is the entire point of this language itself.
And as I wrote about [here](http://meta.codegolf.stackexchange.com/a/9957/31716), this question was what inspired me to write brain-flak.
>
> Shortly after I wrote Are the brackets fully matched?, it made me wonder how much information you can store with only matched brackets. One thing that stood out to me, was that even though you only have 4 "atoms" of sorts:
>
>
>
> ```
> (){}[]<>
>
> ```
>
> you really have 8 units of information to convey, since each of these bracket types can be empty, or have other brackets in between, which are fundamentally different pieces of information. So, I decided to write a language that only allowed for matched brackets, and where empty brackets convey something different than brackets with other brackets inside of them.
>
>
>
This answer took roughly two hours to write. I'll admit it's pretty poorly golfed, mostly because a lot of the code is repeated for each bracket type. But I'm mostly amazed that I was able to write an answer at all, especially given that Brain-Flak is
>
> A minimalist esolang designed to be painful to use
>
>
>
I'm going to attempt to golf it down later, but I wanted to get this out there anyway.
I have a detailed explanation, but it's about 6 thousand characters long, so I think it would not be wise to paste the entire thing into this answer. You can read through it [here](https://gist.github.com/DJMcMayhem/52453a771830a0dcd42323d39396ce54) if you want. I'll add a shorter explanation here.
The basic idea, is that we repeat the following steps for every character on the stack:
* We check each character to see if it matches any bracket. If it is an opening bracket, we push a number onto the other stack according to the following mapping:
```
( = 1
< = 2
[ = 3
{ = 4
```
* Then we check to see if it matches any closing bracket. If it does, we push the equivalent number onto the alternate stack, just like for opening brackets. *Then*, we check if the top two numbers are equal. If they are, the both get popped and the program continues as normal. If they are not, we clear both stacks (to stop the looping) and push a one onto the alternate stack. This is essentially a "break" statement.
* After checking the 8 bracket types, we push the value of this run through the loop. Since we zero out most of it, the only snippets that have any value are the conditionals when we compare against brackets. So if any bracket is matched, the whole loop has a value of 1. If none of them did, the whole loop has a value of 0. In this case, we will clear both stacks and push a 0 onto the alternate stack. Again, this is like a "break" statement.
After this main loop is running, the rest is fairly simple. We are on the (empty) main stack, and the alternate stack is empty (if the brackets were matched) or non-empty if they were not. So we run this:
```
#Toggle to the alternate stack
<>
#Push this stack-height onto main-stack
([]<>)
#Logical not
({}<(())>){((<{}{}>))}{}
```
This will push a 0 or a 1 onto the main-stack, and when the program ends it is implicitly printed.
---
* *Thanks to [@WheatWizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard) for coming up with a good stack-clean "equals" and "logical not" snippet, and for regularly updating the [github wiki](https://github.com/DJMcMayhem/Brain-Flak/wiki) with useful examples.*
* *Thanks to [@ASCII-only](https://codegolf.stackexchange.com/users/39244/ascii-only) for writing an online [integer metagolfer](https://brain-flak.github.io/integer/) which helped immensely in writing this program*
---
*revisions*
* *Removed some push pop redundancy*
* *Changed my zero counter logic*
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~204~~ ~~196~~ 190 bytes
```
{({}<>)<>((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())(({<({}<>[({})])>[()]{()(<{}>)}{}<>}{}()<({}<>[({})]){(<{}({}())>)}{}<>>)){(<({}{}<>[{}]{}<>)>)}{}{<>{{}}}{}}<>((){[()]<>})
```
[Try it online!](https://tio.run/##1Y5BCsMwDAS/oz3kB0IfKT64h0Bo6KHXRW9PVyIp5AmVwZI1y3qfn7m9l3Wfr@OgMT3gYVW4Dpgwoe6Apn7Zb@eGgKqg0dvlUXBAHYNycWYgi@gy3EQsWrbAqZGdllq1ijk6WEN6kJmasoKC9YNc8ff5l/kF "Brain-Flak – Try It Online")
-8 bytes thanks to Wheat Wizard. -6 bytes thanks to Jo King.
### Explanation
This program stores the character codes of all current unclosed brackets on the second stack. The bracket pairs `<>`, `[]`, and `{}` each have character codes that differ by exactly 2, so there is no need to check for them specifically. The pair `()` only differs by 1, so we check for `(` specifically, and effectively decrement that byte (actually increment every other byte) before continuing.
```
# While there are bytes left to process
{
# Move byte to second stack
({}<>)<>
# Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())
((
# For each opening bracket type:
{
# Evaluate as zero
<
# Compute difference between bracket type and input byte
({}<>[({})])
>
# Evaluate loop iteration as -1 if equal, 0 otherwise
[()]{()(<{}>)}{}<>
}
# Remove the 0 that was inserted to terminate that loop
{}
# Add 1 to result
()
# Evaluate rest of this expression as zero
<
# Determine whether the byte is open parenthesis
({}<>[({})])
# If not:
{
# Add 1 to byte and break if
(<{}({}())>)
}{}
# Return to main stack
<>
>
# Push result twice (0 if matched an opening bracket, 1 otherwise)
))
# If byte was not an opening bracket:
{
# Push zero to break out of if
(<
# Push (open bracket + 2 - byte) below that zero
({}{}<>[{}]{}<>)
>)
}{}
# If byte was neither an opening bracket nor the appropriate closing bracket:
{
# Clear alternate stack and stay there to break out of main loop early
<>{{}}
}{}
# End of main loop
}
# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket. If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.
# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 19 bytes
Input is given in *quotes*. Code:
```
"[](){}<>"2÷)"":g2Q
```
Well crap, a *lot* of bugs and unimplemented features were found. Explanation:
```
"[](){}<>" # Push this string
2÷ # Split into pieces of two
) # Wrap it into an array (which should not be needed)
"" # Push an empty string
: # Infinite replacement
```
This is actually a tricky part. What this looks like in pseudocode is:
```
input().replace(['[]', '()', '{}', '<>'], "")
```
This is covered by this part from the [05AB1E code](https://github.com/Adriandmen/05AB1E/blob/master/05AB1E.py#L1498):
```
if type(b) is list:
temp_string = temp_string_2 = str(a)
while True:
for R in b:
temp_string = temp_string.replace(R, c)
if temp_string == temp_string_2:
break
else:
temp_string_2 = temp_string
stack.append(temp_string)
```
As you can see, this is **infinite replacement** (done until the string doesn't change anymore). So, I don't have to worry about setting the replacement into a loop, since this is already builtin. After that:
```
g # Take the length of the final string
2Q # Check if equal with 2 (which are the quotes at the end)
```
Uses **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=IltdKCl7fTw-IjLDtCIiOmcyUQ&input=J1soW117fSk8e1soKTwoKT5dfSgpPnt9XSc) (slightly modified because the above version is deprecated).
[Answer]
## JavaScript (ES6), ~~52~~ 50 bytes
```
f=s=>(t=s.replace(/\(\)|\[]|{}|<>/,''))==s?!s:f(t)
```
Repeatedly remove brackets until the result is the same as the original, then return false unless the string is now empty.
Edit: Saved 2 bytes thanks to @edc65.
[Answer]
## Python, 67 bytes
```
lambda s:eval("s"+".replace('%s','')"*4%([],(),{},'<>')*len(s))==''
```
Generates and evals an expression that looks like
```
s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')
```
and checks if the result is empty.
Sp3000 saved 8 bytes by pointing out that `[],(),{}` can be subbed in without quotes because they're Python objects, and that two parens were unneeded.
[Answer]
# Retina, 20 bytes
```
+`\(\)|\[]|{}|<>
^$
```
[Try it online](http://retina.tryitonline.net/#code=K2BcKFwpfFxbXXx7fXw8PgoKTWBeJA&input=WygpKCkoKSgpXQ)
[Answer]
## CJam, ~~25~~ ~~24~~ ~~23~~ 21 bytes
*Thanks to Sp3000 for saving 2 bytes.*
*Thanks to jimmy23013 for saving 2 bytes.*
```
q_,{()<>}a`$2/*{/s}/!
```
[Test suite.](http://cjam.aditsu.net/#code=qN%2F%7B%3AQ%7B%0A%0AQ_%2C%7B()%3C%3E%7Da%60%242%2F*%7B%2Fs%7D%2F!%0A%0A%7D%26%5DoNo%7D%2F&input=()%0A%5B%5D()%7B%7D%3C%3E%0A(((())))%0A(%7B%5B%3C%3E%5D%7D)%0A%5B%7B()%3C%3E()%7D%5B%5D%5D%0A%5B(%5B%5D%7B%7D)%3C%7B%5B()%3C()%3E%5D%7D()%3E%7B%7D%5D%0A%0A(%0A%7D%7B%0A(%3C)%3E%0A(()()foobar)%0A%5B(%7B%7D%3C%3E)%3E%0A(((())))
Works essentially the same as the other answers: we repeatedly remove `()`, `[]`, `<>` and `{}` from the string and check if we end up with the empty string. To avoid having to check when we're done, we remove the pairs `N` times where `N` is the length of the string, which is always sufficient (since each iteration will remove at least two characters, unless we're done). I'm glad to see that this doesn't beat Retina. :) (Although Pyth or Jelly might...)
There's one fun golfing trick here: to get the string `()<>[]{}` we use the following:
```
{()<>}a`$
```
The, `{()<>}` is just a block (i.e. a function), which contains the other brackets as code. With `a` we wrap the block in an array. The ``` stringifies that array, which gives `"[{()<>}]"`. Finally, we sort the string with `$`, which rearranges the brackets to `()<>[]{}`.
[Answer]
# Yacc, 119 bytes
Does not use regex/replace.
```
%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}
```
## Ungolfed
```
%% # Grammar in BNF
input:
r;
r:
%empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%% # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}
```
## Compilation
```
yacc -o bracket.c bracket.y
cc -o bracket bracket.c
```
## Usage
```
~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 % :(
```
[Answer]
## Pyth, ~~31~~ ~~25~~ 24 bytes
Golfed down to 25 bytes thanks to FryAmTheEggMan
Removed 1 byte
```
VQ=:Q"<>|\[]|{}|\(\)"k;!
```
Try it here: [Test suite](https://pyth.herokuapp.com/?code=Vz%3D%3Az%22%3C%3E%7C%5C%5B%5D%7C%7B%7D%7C%5C%28%5C%29%22k%3B%21z&test_suite=1&test_suite_input=%28%29%0A%5B%5D%28%29%7B%7D%3C%3E%0A%28%28%28%28%29%29%29%29%0A%28%7B%5B%3C%3E%5D%7D%29%0A%5B%7B%28%29%3C%3E%28%29%7D%5B%5D%5D%0A%5B%28%5B%5D%7B%7D%29%3C%7B%5B%28%29%3C%28%29%3E%5D%7D%28%29%3E%7B%7D%5D%0A%28%0A%7D%7B%0A%28%3C%29%3E%0A%28%28%29%28%29foobar%29%0A%5B%28%7B%7D%3C%3E%29%3E%0A%28%28%28%28%29%29%29&debug=0) !
I'm still a Pyth newbie, any help is appreciated.
## Explanation
```
VQ For N in range(0, len(z)), with Q being the evaluated input.
Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
=:Q"<>|\[]|{}|\(\)"k assign Q without {}, [], <> nor () (regex replacement) to Q
; End of For loop
! Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise
```
BTW, congrats to the other Pyth answer (which is currently 20 bytes)
[Answer]
# Pyth, 20 bytes
```
!uuscNTc"[](){}<>"2G
```
Try it online: [Test Suite](http://pyth.herokuapp.com/?code=!uuscNTc%22[]%28%29%7B%7D%3C%3E%222G&input=%22%28[%29]%22&test_suite=1&test_suite_input=%22%28%29%22%0A%22[]%28%29%7B%7D%3C%3E%22%0A%22%28%28%28%28%29%29%29%29%22%0A%22%28%7B[%3C%3E]%7D%29%22%0A%22[%7B%28%29%3C%3E%28%29%7D[]]%22%0A%22[%28[]%7B%7D%29%3C%7B[%28%29%3C%28%29%3E]%7D%28%29%3E%7B%7D]%22%0A%22%28%22%0A%22%7D%7B%22%0A%22%28%3C%29%3E%22%0A%22%28%28%29%28%29foobar%29%22%0A%22[%28%7B%7D%3C%3E%29%3E%22%0A%22%28%28%28%28%29%29%29%22&debug=0)
Repeatedly removes occurrences of `[]`, `()`, `<>` and `{}` by splitting and re-merging. Checks if the resulting string is empty or not.
[Answer]
# Javascript ES6, 54 bytes
```
f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_
```
Uses a recursive replace implementation. Simple enough.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 204 bytes
```
(()){{}{({}<>)<>}<>({<(<(({})<>)>)(((((((([(())()()()]){}){}){}())(()))(((())()){}()){})){})(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))<>{}<>{{}({}[({})]<>({})){(<>)(<>)}{}{}(<>)}{}>{}<>}<>)}{}((){<>[()]})
```
[Try it online!](https://tio.run/##3U9BDsMgDPuOfegPonyk6oEdKlWbdtg1yts7G/aKAUbBdgw8PuN6b@drPO8bIKu6UB3JSO2oQECEjkziN3ZbMedBiXOZEqbJ6qIkGXDSDK7e3cUEyxWiOtmW2mY7BDXbKebwM5wCvcGQTeoqprlXrWsr0pnNP/vNNr4 "Brain-Flak – Try It Online")
Not quite as short as [Nitroden's answer](https://codegolf.stackexchange.com/a/142224/76162), but uses a very different approach. This one runs through the input repeatedly, removing neighbouring matching pairs of brackets each time until there are none left. At that point if there is anything left on the stack, then the string was not fully matched.
### Explanation:
```
(()) Push 1 to simulate the check at the start of the loop
{ While check
{} Pop check
{({}<>)<>}<> Reverse input
({ Loop over input
< Don't push the values of these calculations
(<(({})<>)>) Create a copy of the top of the input and push to the other stack
(((((
((([(())()()()]){}){}){}())
(()))
(((())()){}()){})
){}) Push the differences in values of the end brackets
(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{})) If the copy is the same as any of these, push the difference between the other bracket twice
<>{}<> Pop copy
{ If this character is a start bracket
{}({}[({})]<>({})) Check if the next character is the end bracket
{(<>)(<>)}{} If not, push a 0 to each stack as buffer
{} Pop the top of the input stack, either the start bracket if they matched or the buffer 0
(<>) Push 0 to other stack to end check
}{}>
{} Pop the top of the other stack
If the character was not an end bracket, pop the copy of check, which is 0
If it was, but didn't match the next character, pop the buffer 0
If the brackets matched, pop the end bracket and add it to the loop total
<>} Repeat with the rest of the input
<>) Push the loop total
If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1
```
[Answer]
# Regex (PCRE flavor), ~~41~~ 37 bytes
```
^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$
```
Just a standard solution with recursive regex.
*Thanks jimmy23013 for shaving off 4 bytes*
[Answer]
## Brainfuck, 132 bytes
```
+>,[[<->>+>[-]<<-]<[>+>[<+<+>>>+<-]+++++[>--------<-]>[<<+>++++[>-----<-]>[<++++
+[>------<-]>-[<++++[>--------<-]>[,>]]]]<],]<<[>]>.
```
Formatted:
```
+>,
[
[<-> >+>[-]<<-]
<
[
not matching closing bracket
>+>[<+<+>> >+<-]
+++++[>--------<-]
>
[
not open paren
<<+>
++++[>-----<-]>
[
not open angle bracket
<+++++[>------<-]>-
[
not open square bracket
<++++[>--------<-]>
[
not open brace
,>
]
]
]
]
<
]
,
]
<<[>]
>.
```
Expects input without a trailing newline. Prints `\x00` for false and `\x01` for true.
[Try it online.](http://brainfuck.tryitonline.net/#code=Kz4sW1s8LT4-KzwtXTxbPis-PlstXTxbPCs8Kz4-Pis8LV0rKysrK1s-LS0tLS0tLS08LV0-Wzw8Kz4rKysrWz4tLS0tLTwtXT5bPCsrKysrWz4tLS0tLS08LV0-LVs8KysrK1s-LS0tLS0tLS08LV0-Wyw-XV1dXTxdLF08PFs-XT4u&input=WyhbXXt9KTx7WygpPCgpPl19KCk-e31d)
Approach: Maintain a stack starting with `\x01`, and push the corresponding closing bracket whenever an opening bracket is encountered. Before checking whether the current character is an opening bracket, first check whether it's equal to the closing bracket at the top of the stack, and if so pop it. If it's neither the proper closing bracket nor an opening bracket, consume the rest of the input while moving the pointer to the right. At the end, check whether the pointer is next to the initial `\x01`.
[Answer]
# Perl, ~~34~~ 33 bytes
Includes +2 for `-lp`
Run with input on STDIN:
```
./brackets.pl <<< "{<>()}"
```
`brackets.pl`:
```
#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_
```
Finds the first bracket pair without anything between them and removes it as long as there are any. Then checks if the final string is empty.
[Answer]
# Java 7, ~~156~~ 151 bytes
```
class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}
```
I'm not expecting this to win any awards but I didn't see a Java answer yet. Additionally, I like to lurk around PPCG and I would enjoy being able to vote/comment on other answers.
Input is given as program parameters. This follows the same format as many other answers here in that it preforms a regex replacement in a loop. Originally I had it loop N times where N is the length of the original string but looping to `Integer.MAX_VALUE` is shorter :]. This should be ok because `Integer.MAX_VALUE` is the maximum length of a `String` in Java so there's an implicit assumption that the length of input is something that is handle-able by Java. The runtime is pretty bad (took about 20 minutes on my lappytop) on account of the loop but I didn't see any restriction on that.
[Answer]
# [Haskell](https://www.haskell.org/), 151 bytes
```
infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0
```
[Try it online!](https://tio.run/##PcuxCsMgFIXh3acoWlDHrkEd@wTd5BIcLJXaUJIWDHKf3ZoLdTnwHfgfYXvGnFtLyz2V00UwqeRUxG6LkFpOO5Nm2JH9MJDrMJL1YWr71@3IbhjIMIxk/Jtzwbm9rd/IZjHba8hbZO0V0mLfa1o@Z@6Vh4raVK@0UdoB9qkIR9h@ "Haskell – Try It Online")
[Answer]
## [Grime](https://github.com/iatorm/grime/tree/v0.1) v0.1, 34 bytes
```
M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M
```
Prints `1` for a match and `0` for no match.
[Try it online!](http://grime.tryitonline.net/#code=TT1cKE1cKXxcW01cXXxce01cfXxcPE1cPnxNTXxfCmVgTQ&input=WyhbXXt9KTx7WygpPCgpPl19KCk-e31d)
## Explanation
Grime is my 2D pattern-matching language designed for [this challenge](https://codegolf.stackexchange.com/questions/47311/language-design-2-d-pattern-matching); it can also be used to match 1D strings.
This is my first answer with it.
I did modify Grime today, but only to change the character of one syntax element (``` instead of `,`), so it doesn't affect my score.
```
M= Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\> a smaller M inside matched brackets,
|MM or two smaller Ms concatenated,
|_ or the empty pattern.
e`M Match the entire input against M.
```
[Answer]
# Reng v.3.3, 137 bytes, noncompeting
[Try it here!](https://jsfiddle.net/Conor_OBrien/avnLdwtq/)
```
aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2< < < +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
\$2+)1z+#z/ ~n1/
```
There's a bit more golfing to be done, but at least it works. I added a command `ð` to keep track of stacks after this challenge in order for this to be remotely possible/easily. I'll explain this in a bit, but it generally keeps track of all strings iterated over and looks for repeats; if there is a repeat, then the string is irreducible. Otherwise, the string will be reduced to the empty string/stack, and will output `1`. Otherwise, no output will be produced.
[Answer]
## PowerShell v2+, ~~63~~ 62 bytes
```
param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a
```
Can't quite catch JavaScript, but is currently edging out the other non-esolangs.
Similar approach as other answers: a simple loop that continues so long as we can remove one of `[]`, `()`, or `<>` (with several extraneous characters because we need to escape the regex specials). We use `$b` as a helper along the way to remember what our previous loop's `$a` was set as. An uninitialized variable is `$null`, so the first time the loop is encountered, `$a` is obviously not equal to `$null`.
At the end of the loop, `$a` is either empty or not, and the Boolean-not of that string is either `True` or `False`.
### Example
```
PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True
PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False
```
[Answer]
# C, ~~121~~ ~~122~~ 114 bytes
Shaved of 8 bytes thanks to @xsot!
```
a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}
```
Uses a stack.
[Answer]
### Python 2.7, 96 bytes
```
def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])
```
[Answer]
# Julia, 51 bytes
```
~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n
```
The least insane of several options. Unsurprisingly, leveraging the power of regex is the shortest path to string matching, but this really only applies if the pattern to match is regular. Trying to do PCRE recursive patterns ends up ballooning the size of the code, either by seeing if the whole string is the match or by anchoring the ends and then creating a construct to specify the inner body for regex recursion. Neither of which are pretty or conducive to code golf.
## Explanation:
```
~z= # Define ~z to be the following:
z==( # If z is equal to
n=replace(z, # z with the replacement of
r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
"" # with empty strings
) # (which is assigned to n)
)?z=="" # whether z is an empty string
:~n # else ~ applied to the substituted string
```
The function repeatedly removes adjacent pairs of parentheses from its only argument, and returns true if it can derive an empty string this way.
[Answer]
# R, 298
```
function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}
```
The approach here is to convert the sequence into R code, and then try to parse and evaluate it. If that gives an error, then return `FALSE`.
But there is a minor problem ... R's rules for brackets are different, so `<` and `>` are not brackets at all, and the other types have rules of their own. This is solved by a revolutionary approach -- a squeaking function, whose only function is to signal an error if its head and tail squeak in different ways.
For example, `[]` is transformed into `S('[', {}, ']')`, where S is defined as ...
```
S=function(H,B,T)if(H!=T)stop()
```
Because the head squeak and tail squeak match, no error is thrown.
A few other examples (the left part is a sequence of brackets and right part is its transformation into valid R code that can be evaluated):
```
[} --> S('[', {}, '}') # squeaks an error
[()] --> S('[', {S('(',{},'(')}, "[")
({[]}) --> S('(',{S('{',{S('[',{},'[');},'{');},'(');
```
Some other sequences of brackets will result in parse errors:
```
[[) --> S('[',{S('[',{},'(');
```
So the remaining part just catches the errors and returns FALSE if there are any, and TRUE if there are none.
The human-readble code:
```
sqk <- function(.){
s=strsplit;u=paste0
.=s(.,"")[[1]] # break the argument up into 1-character pieces
p=s("><)(}{][","")[[1]] # vector of brackets
.[!.%in%p]="§" # replace anything besides brackets by § (--> error)
for(i in 1:4*2){
.[.==p[i]]=sprintf("S('%s',{",p[i]) # '<' --> S('<',{ ... etc
.[.==p[i-1]]=sprintf("},'%s');",p[i]) # '>' --> },'<'); ... etc
}
S=function(H,B,T)if(H!=T)stop() # define the working horse
r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
if(inherits(r,"try-error"))FALSE else TRUE # any errors?
}
```
Applying it on sample cases:
```
truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
() [](){}<> (((())))
TRUE TRUE TRUE
({[<>]}) [{()<>()}[]] [([]{})<{[()<()>]}()>{}]
TRUE TRUE TRUE
> sapply(falsy,sqk)
( } (<2)> (()()foobar) [({}<>)> (((()))
FALSE FALSE FALSE FALSE FALSE FALSE
```
[Answer]
# Lua (92 bytes)
The older Lua answer is everything but golfing code. There's my proposal instead:
```
function x(s)m=""return s:gsub("%b<>",m):gsub("%b[]",m):gsub("%b{}",m):gsub("%b()",m)==m end
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~11~~ 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
é:råvm∟&1Γ
```
[Run and debug it](https://staxlang.xyz/#p=823a7286766d1c2631e2&i=%28%29%0A%5B%5D%28%29%7B%7D%3C%3E%0A%28%28%28%28%29%29%29%29%0A%28%7B%5B%3C%3E%5D%7D%29%0A%5B%7B%28%29%3C%3E%28%29%7D%5B%5D%5D%0A%5B%28%5B%5D%7B%7D%29%3C%7B%5B%28%29%3C%28%29%3E%5D%7D%28%29%3E%7B%7D%5D%0A%28%0A%7D%7B%0A%28%3C%29%3E%0A%28%28%29%28%29foobar%29%0A%5B%28%7B%7D%3C%3E%29%3E%0A%28%28%28%28%29%29%29&a=1&m=2)
Got lucky, as stax has a literal constant in it with matched pairs of brackets.
[Answer]
# Curry, ~~64~~ 56 bytes
*Tested to work in both [PAKCS](https://www.informatik.uni-kiel.de/%7Epakcs/) and [KiCS2](https://www-ps.informatik.uni-kiel.de/kics2/)*
```
f(x:a++y:b)|elem[x,y]["{}","<>","[]","()"]=f a*f b
f""=1
```
[Try it on Smap!](https://smap.informatik.uni-kiel.de/smap.cgi?browser/80)
[Try it online!](https://tio.run/##HcixCoMwEADQ3a84jg5JtYWuIcneSfeQIdocSFUkVjCk@fZUurzhDXsI8ba697CVQuwQrq6j6PnXT342RxOtwZSxQalPjD1hHK0icFeCviJE9SizGxcQArrgp/3l788WGK/@q2AN4/KBCxAgM9akLLWVmqXMOZYf)
This returns `1` if string is balanced and nothing otherwise.
## Explanation
Our definition of `f` then matches the empty string as balanced for a base case:
```
f""=1
```
Then we have the main logic:
```
f(x:a++y:b)|[x,y]=:=anyOf["{}","<>","[]","()"]=f a*f b
```
Here `*` is used like a logical and. Since the only value we can get back is `1`, this always gives back `1` when it finds results. But when it doesn't this doesn't give any result.
With that this pattern matches strings with a pair of matching brackets so that they divide the input into two balanced strings.
[Answer]
# C, 258 bytes
```
#define E else if(a==
#define D(v) {if (b[--p]!=v)z=1;}
#define F b[p++]=
main(a, v) char* v[]; {char b[99],p=0,z=0;for(;*v[1];v[1]++) {a=*v[1];if(a=='(')F 0;E '[')F 1;E '{')F 2;E '<')F 3;E '>')D(3)E '}')D(2)E ']')D(1)E ')')D(0)else z=1;}puts(z|p?"0":"1");}
```
## Degolfed, macro-substituted, commented
```
int main(int a, char* v[]) {
// ^ this variable is used as a general purpose int variable and not as its intended purpose (argc)
char b[99], // create a 99 byte array for storing bracket types
p = 0, // pointer within the array
z = 0; // error flag
// loop through every byte of input (argv[1])
for(;*v[1];v[1]++) {
a=*v[1];// a is the current byte
if(a=='(') b[p++] = 0; // record bracket type
else if(a== '[') b[p++] = 1;
else if(a== '{') b[p++] = 2;
else if(a== '<') b[p++] = 3;
else if(a== '>') {
if (b[--p] != 3) z = 1; // error: bracket type mismatch
} else if(a== '}') {
if (b[--p] != 2) z = 1;
} else if(a== ']') {
if (b[--p] != 1) z = 1;
}else if(a== ')') {
if (b[--p] != 0)z = 1;
}else z = 1; // error: invalid character
}
// if either z or p is not 0 print a '0', otherwise print a '1'
// if p is not zero that means not all brackets were closed
// if z is not zero that indicates an erro
puts(z|p ? "0":"1");
}
```
```
[Answer]
# [Kotlin](https://kotlinlang.org), ~~100~~ ~~89~~ 86 bytes
-11 bytes: Use `any` instead of `firstOrNull`
-3 bytes: Use `chunked` instead of `split` (thanks to @leo848)
```
fun f(s:String):Boolean="()<>[]{}".chunked(2).any{it in s&&f(s.replace(it,""))}||s==""
```
[Try it online!](https://tio.run/##bVG7bsMwDNz9FQIRBCTQeOhoyB76Cx0VDWpqt0JcybDlIWD07a4cd6jVchDA4x0fp6sPvXVLNzvxZaxDElyIFMNoXUAA@p0h7XOlkTjKJmOloBQZyko2OuYdGEk2SFFpnVVQaY4kWSUGUpKmh@PK2rXdqyJnUyX92Y6QOu/fzJjvgust9P81CYxFsdq04dYNc6jEa0jZB4l6g3uHcIbDo3gGcWrEgbuNSxHoYXOHU/Ujq16871vjalhdWO@F8vI5u2v7js9UGndjG4R1Yjoek6wc26E3lxZteEo/Q/F@n@oaYFm@AQ "Kotlin – Try It Online")
[Answer]
# Python 2, 80 bytes
```
def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 5 years ago.
[Improve this question](/posts/167007/edit)
# Introduction
I recently came across an oral exam where the candidates were asked to find a logical circuit than can negate 3 inputs A,B,C using only two `NOT` gates.
The question also specified that such a circuit is unique up to removal of useless gates and reordering inputs/outputs. The candidates were asked to prove this assertion by writing a piece of code that generates all such circuits.
# Challenge
No inputs whatsoever are given.
The program must output all logical circuits using unlimited `AND` and `OR` gates but only two `NOT` gates which take in three inputs which map to three outputs. The outputs should be the negation of each input.
The outputted circuits should not have any redundant/trivial gates (gates that always output the same thing) or unused gates (whose output doesn't influence the outcome).
The program should use no precalculated or cached data.
Output format is left up to the coders.
The winner will be determined by the fastest algorithm. Since input doesn't scale, whoever has the least loops and calculations wins.
Please remember your code must not cache or use any precalculated data.
# Example Input and Output
Input:
>
> N/A
>
>
>
Output:
```
R = (A & B) | (A & C) | (B & C)
notR = !R
S = (notR & (A | B | C)) | (A & B & C)
notS = !S
notA = (notR & notS) | (notR & S & (B | C)) | (R & notS & (B & C))
notB = (notR & notS) | (notR & S & (A | C)) | (R & notS & (A & C))
notC = (notR & notS) | (notR & S & (A | B)) | (R & notS & (A & B))
```
]
|
[Question]
[
# Task
Given an array of non-negative integers `a`, determine the minimum number of rightward jumps required to jump "outside" the array, starting at position 0, or return zero/null if it is not possible to do so.
A *jump* from index `i` is defined to be an increase in array index by at most `a[i]`.
A *jump outside* is a jump where the index resulting from the jump `i` is out-of-bounds for the array, so for 1-based indexing `i>length(a)`, and for 0-based indexing, `i>=length(a)`.
## Example 1
Consider `Array = [4,0,2,0,2,0]`:
```
Array[0] = 4 -> You can jump 4 field
Array[1] = 0 -> You can jump 0 field
Array[2] = 2 -> You can jump 2 field
Array[3] = 0 -> You can jump 0 field
Array[4] = 2 -> You can jump 2 field
Array[5] = 0 -> You can jump 0 field
```
The shortest path by "jumping" to go out-of-bounds has length `2`:
We could jump from `0->2->4->outside` which has length `3` but `0->4->outside` has length `2` so we return `2`.
## Example 2
Suppose `Array=[0,1,2,3,2,1]`:
```
Array[0] = 0 -> You can jump 0 fields
Array[1] = 1 -> You can jump 1 field
Array[2] = 2 -> You can jump 2 field
Array[3] = 3 -> You can jump 3 field
Array[4] = 2 -> You can jump 2 field
Array[5] = 1 -> You can jump 1 field
```
In this case, it is impossible to jump outside the array, so we should return a zero/null or any non deterministic value like `∞`.
## Example 3
Suppose `Array=[4]`:
```
Array[0] = 4 -> You can jump 4 field
```
We can directly jump from index 0 outside of the array, with just one jump, so we return `1`.
# Edit:
Due to multiple questions about the return value:
Returning `∞` is totally valid, if there is no chance to escape.
Because, if there is a chance, we can define that number.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins!
[Answer]
# [Haskell](https://www.haskell.org/), ~~70~~ 58 bytes
```
f[]=0
f(0:_)=1/0
f(x:s)=minimum[1+f(drop k$x:s)|k<-[1..x]]
```
[Try it online!](https://tio.run/##JYhBDsIgFAX3PQULFxAR@eqqKSchxBALlrTQBmrswrsjtIt5mXmDTqOZppytVII3FvP2SQRcq25tIsK74PzHSzhb3Md5QeOp/r@xu0hgbFMqe@2CcGE1Ub9WnIb5y7xe0JtFo3uSpVS0QfJxLOX0drA3p1D8XoC9q0Nx9Qc "Haskell – Try It Online")
EDIT: -12 bytes thanks to @Esolanging Fruit and the OP for deciding to allow infinity!
Returns `Infinity` when there is no solution which makes the solution a lot simpler. Since we can only move forwards `f` just looks at the head of the list and drops `1<=k<=x` items from the list and recurs. Then we just add 1 to each solution the recursive calls found and take the minimum. If the head is 0 the result will be infinity (since we cannot move there is no solution). Since `1+Infinity==Infinity` this result will be carried back to the callers. If the list is empty that means we have left the array so we return a cost of 0.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
Γö→▼Mo₀↓ŀ
```
Returns `Inf` when no solution exists.
[Try it online!](https://tio.run/##yygtzv6vkKtR/KipsUjz0Lb/5yYf3vaobdKjaXt88x81NTxqm3y04f///9EmOgY6RhAcyxVtoGMIZBkDsSGQZwLExkA5Y6AoSIURSDYWAA "Husk – Try It Online")
## Explanation
Husk's default return values come in handy here.
```
Γö→▼Mo₀↓ŀ Implicit input: a list, say [2,3,1,1]
Γ Deconstruct into head H = 2 and tail T = [3,1,1]
ö and feed them into this function:
ŀ Range from 0 to H-1: [0,1]
Mo For each element in range,
↓ drop that many element from T: [[3,1,1],[1,1]]
₀ and call this function recursively on the result: [1,2]
▼ Take minimum of the results: 2
→ and increment: 3
```
If the input list is empty, then `Γ` cannot deconstruct it, so it returns the default integer value, 0.
If the first element is 0, then the result of `Mo₀↓ŀ` is an empty list, on which `▼` returns infinity.
[Answer]
# [Python 2](https://docs.python.org/2/), 124 bytes
```
def f(a):
i={0};l=len(a)
for j in range(l):
for q in{0}|i:
if q<l:i|=set(range(q-a[q],q-~a[q]))
if max(i)/l:return-~j
```
[Try it online!](https://tio.run/##JYtBCsIwEEXX9hSznECKVVxFc5LiImCiU2LapBEUa68eJ5SB//mPN9MnP8ZwLOVmHTg0QjVA@tv9zl57Gxg04MYEA1CAZMLdomdnV1lkxuZCvIEcxItXtOjZZtzM2Jo@XmVs19pCbNrTvJHE3qtk8yuFdh3KlChkdNif5EF2siYff5Q/ "Python 2 – Try It Online")
-11 bytes thanks to Mr. Xcoder
-12 bytes thanks to Mr. Xcoder and Rod
[Answer]
# ~~[APL (Dyalog Classic)](https://www.dyalog.com/)~~ [ngn/apl](https://github.com/ngn/apl), 18 bytes
EDIT: switched to my own implementation of APL because Dyalog doesn't support infinities and the challenge author [doesn't allow](https://codegolf.stackexchange.com/questions/156497/we-do-tower-hopping?noredirect=1#comment381474_156497) finite numbers to act as "null"
```
⊃⊃{⍵,⍨1+⌊/⍺↑⍵}/⎕,0
```
~~[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob2pm/qO2CQZcjzra0/4/6moGoupHvVt1HvWuMNR@1NOl/6h316O2iUChWn2gah2D/0CV/9O4TBQMFIwgmCuNy0DBEMgyBmJDIE/HBEgYgiVAgoYKhgA "APL (Dyalog Classic) – Try It Online")~~
[try it at ngn/apl's demo page](https://ngn.github.io/apl/web/index.html#code=%u2395%u2190%20%u2283%u2283%7B%u2375%2C%u23681+%u230A/%u237A%u2191%u2375%7D/%u2395%2C0)
returns ~~`⌊/⍬`~~
`∞` for no solution
[Answer]
# [Haskell](https://www.haskell.org/), 45 bytes
```
(1%)
0%_=1/0
a%(h:t)=min(1+h%t)$(a-1)%t
_%_=0
```
[Try it online!](https://tio.run/##LYrRCsIgGEbvfYpdJCi55V9dBT6JjfFjLkfTZAq9fWbbLs7H@eA4TC87z2VU98KAciLpoOAkCVLmbpkrPwUGR0czPzBsgdNMhprI4nEKagrZLmgyS@796TzGZuwWiw9etO4FafR1WyHFeWP9UkD1SwXW/3fYfd9a9l8zzvhMpTUx/gA "Haskell – Try It Online")
Outputs `Infinity` when impossible. The auxiliary left argument to `%` tracks how many more spaces we can move in our current hop.
[Answer]
# [Perl 5](https://www.perl.org/), ~~56~~ 53 bytes
Includes `+1` for `a`
```
perl -aE '1until-@F~~%v?say$n:$n++>map\@v{$_-$F[-$_]..$_},%v,0' <<< "4 0 2 0 2 0"; echo
```
Just the code:
```
#!/usr/bin/perl -a
1until-@F~~%v?say$n:$n++>map\@v{$_-$F[-$_]..$_},%v,0
```
[Try it online!](https://tio.run/##JYpBC4IwGIbv/ooPmyedbKWXRuXJc/cKWfQFgs6xzVVE/vTWoAcensP7ajRDHWaLUJeclUwEPivXD7RplyXzBytfRG2JyvP9KPW58W/SUdKeKOkuZUm6T5H5ggURfymlNBVE7ZiY1Q3vkHmIrOBoeuXAopZGusnAFd0DUQE@5agHtAUYtHFAsE46DBUwWP9NGPDYTZQn1XfSrp@UDVT@AA "Perl 5 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 80 bytes
```
sub f{$_[0]>=@_||1+((sort{$a?$b?$a-$b:-1:1}map f(@_[$_..$#_]),1..$_[0])[0]||-1)}
```
[Try it online!](https://tio.run/##K0gtyjH9/7@4NEkhrVolPtog1s7WIb6mxlBbQ6M4v6ikWiXRXiXJXiVRVyXJStfQyrA2N7FAIU3DIT5aJV5PT0U5PlZTxxDIAGnVBOKaGl1Dzdr/xYmVQFUmOgYwqGnNhRAzgmC4mIGOIZBvDMSGCHWa1v//5ReUZObnFf/X9TXVMzA0AAA "Perl 5 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 32 bytes
```
ṛ/ṆȧJ’Ṛ
Rḟ"ÇƤZ$$Tị$Œp+\€Ṁ<Li0ȧ@Ḣ
```
[Try it online!](https://tio.run/##AUQAu/9qZWxsef//4bmbL@G5hsinSuKAmeG5mgpS4bifIsOHxqRaJCRU4buLJMWScCtc4oKs4bmAPExpMMinQOG4ov///1s0XQ "Jelly – Try It Online")
This is just too long...
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~19~~ 18 bytes
```
<LḢ
ḊßÐƤṁḢḟ0‘Ṃµ1Ç?
```
[Try it online!](https://tio.run/##y0rNyan8/9/G5@GORVwPd3Qdnn94wrElD3c2AvkPd8w3eNQw4@HOpkNbDQ@32/8/3P6oac3//9HRJjoGOkYQHKsTbaBjCGQZA7EhkGcCxCCeIZAXCwA)
## Explanation
```
<LḢ Helper link. Input: array
< Less than
L Length
Ḣ Head - Returns 0 if its possible to jump out, else 1
ḊßÐƤṁḢḟ0‘Ṃµ1Ç? Main link. Input: array
Ç Call helper link
? If 0
1 Return 1
Else
µ Monadic chain
Ḋ Dequeue
ßÐƤ Recurse on each suffix
Ḣ Head of input
ṁ Mold, take only that many values
ḟ0 Filter 0
‘ Increment
Ṃ Minimum
```
[Answer]
# [JavaScript ES6](https://nodejs.org), 118 bytes
```
(x,g=[[0,0]])=>{while(g.length){if((s=(t=g.shift())[0])>=x.length)return t[1];for(i=0;i++<x[s];)g.push([s+i,t[1]+1])}}
```
[Try it online!](https://tio.run/##bc29DsIgHATw3adw/JMiAXWr9EUIQ1P5MqQ0QLVJ02dHauJiHG763eUe/bNPQ3RTPo3hrormBRZsuBAUUykR79aXdV6BIV6NJlu0Og2QOGRuSLJOZ0BIUIk6vnwrUeU5jscsmGx1iOA4bV3T3BaRZIsMmeZkQaTG4b3SMIm2rQxhTMEr4oMBDfWe4TO@1FRGhx/dhf2VK6Z180nV8gY "JavaScript (Node.js) – Try It Online")
Performs a breadth first search of the array to find the shortest path.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 80 bytes
```
f(A,l,M,j,r)int*A;{M=~0;for(j=0;l>0&&j++<*A;)if(M<1|M>(r=f(A+j,l-j)))M=r;A=-~M;}
```
[Try it online!](https://tio.run/##XY1BCsIwFETvUrD8b38h0eImTSEHyAnUhVQiCWmU4C62V68f3Ygws5nHzIztbRzX1YGhSJYCZfTpuTWqWL0I5e4ZghYqDqKuQ9P0TNA7sL182QGy5mITKLYBEa3Oyuh2sWpep4tPgOWRec1BtbnSR6dUkQPg8HjG0pGg3dczHfCHCJKc7tnyj3QzSUR@eAM "C (gcc) – Try It Online")
[Answer]
# [Julia 0.6](http://julialang.org/), 79 bytes
Returns the number of jumps or `Inf` if you can't escape. Recursively look at the first element and either return `Inf` or `1` depending on if you can escape, otherwise add `1` to the shortest solution for truncated arrays representing each valid jump. The control flow is done with two ternary statements like `test1 ? ontrue1 : test2 ? ontrue2 : onfalse2`.
```
f(a,n=endof(a))=a[1]<1?Inf:a[1]>=n?1:1+minimum(f(a[z:min(z+a[1],n)]) for z=2:n)
```
[Try it online!](https://tio.run/##yyrNyUw0@/8/TSNRJ882NS8lH8jS1LRNjDaMtTG098xLswIx7Wzz7A2tDLVzM/Myc0tzNYCKoqusgDyNKm2QvE6eZqymQlp@kUKVrZFVnuZ/h@KM/HKFNI1oAx1DHSMdYyA2jNXkggub6BgAhcAYWRik0hCk8j8A "Julia 0.6 – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 97 bytes
```
f=l=>{for(int c=l.Count,s=0,j=l[0];j>0;s=f(l.GetRange(j,c-j--)))if(s>0|j>=c)return s+1;return 0;}
```
[Try it online!](https://tio.run/##tZI9a8MwEIZ3/4obJeoPOemmyEugXVIo7dAhZDCqbGRUGXRyS3H92107SU1wO2RwbzgOdHqfe4@TGMnaqV6aHBEegzaAIdDnXkt4r/UrPOTaEvRO23J/gNyVSI89p84xnj/Rq7f4rrFyc663tTFKel1bjO@VVU7LeKfRb7T1WQhjhgIE2MYY3hfCiKwtakeGB5DCDP8b60MULKyE2bMDrzLGURTEDHL@KbelIlUooyqKKKW6IJixryoTkjrlG2cBb1J@Lhnveh7Mp90Oo9VGxS9Oe7XTVpGCWPUB1xiAFm5DYCGspgwdpXyUT5LVwqiBkB4h62NOL1BsaVeT9iySJP3nBU7GkmS9MOokP3Jm9pZf4Pr3Qfyglj6L9E9LF666oOu/AQ "C# (.NET Core) – Try It Online")
Returns 0 if no path was found.
**Explanation**
```
f =
l => //The list of integers
{
for (
int c = l.Count, //The length of the list
s = 0, //Helper to keep track of the steps of the recursion
j = l[0]; //The length of the jump, initialize with the first element of the list
j > 0; //Loop while the jump length is not 0
s = f(l.GetRange(j, c - j--)) //Recursive call of the function with a sub-list stating at the current jump length.
//Then decrement the jumplength.
//Returns the number of steps needed to jump out of the sup-list or 0 if no path was found.
//This is only executed after the first run of the loop body.
)
{
if (j >= c | //Check if the current jump lengt gets you out of the list.
//If true return 1 (s is currently 0). OR
s > 0 ) //If the recursive call found a solution (s not 0)
//return the number of steps from the recursive call + 1
return s + 1;
}
return 0; //If the jump length was 0 return 0
//to indicate that no path was found from the current sub-list.
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~83~~ ~~73~~ 72 bytes
-10 thanks to @user202729
-1 thanks to @JonathanFrech
```
lambda a:a and(a[0]and-~min(f(a[k+1:])for k in range(a[0]))or 1e999)or 0
```
[Try it online!](https://tio.run/##JYpBCsMgEEX3PYVkpUSCpt0k0JNYkSlqK4lGjBRy@nSSDLyZ94eft/pdUr/752ufIb4tEBiRZCkoofGSGBL1mKZWjpq10i@FTCQkUiB93FljDH/SDcNwiNhzCanSCJl67n4wU2NCzEupxtBm3daGdWu1IXXFgaUMZ1dK8xtRj2tzwfuLMwsu0e@IPPPhEl3/AQ "Python 2 – Try It Online") Returns infinity for a null value.
] |
[Question]
[
Using your language of choice, golf a [quine](http://en.wikipedia.org/wiki/Quine_%28computing%29).
>
> A **quine** is a non-empty computer program which takes no input and produces a copy of its own source code as its only output.
>
>
>
No cheating -- that means that you can't just read the source file and print it. Also, in many languages, an empty file is also a quine: that isn't considered a legit quine either.
No error quines -- there is already a [separate challenge](https://codegolf.stackexchange.com/questions/36260/make-an-error-quine) for error quines.
Points for:
* Smallest code (in bytes)
* Most obfuscated/obscure solution
* Using esoteric/obscure languages
* Successfully using languages that are difficult to golf in
The following Stack Snippet can be used to get a quick view of the current score in each language, and thus to know which languages have existing answers and what sort of target you have to beat:
```
var QUESTION_ID=69;
var OVERRIDE_USER=98;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}
function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}
function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=!1;comment_page=1;getComments()}})}
function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}
getAnswers();var SCORE_REG=(function(){var headerTag=String.raw `h\d`
var score=String.raw `\-?\d+\.?\d*`
var normalText=String.raw `[^\n<>]*`
var strikethrough=String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>`
var noDigitText=String.raw `[^\n\d<>]*`
var htmlTag=String.raw `<[^\n<>]+>`
return new RegExp(String.raw `<${headerTag}>`+String.raw `\s*([^\n,]*[^\s,]),.*?`+String.raw `(${score})`+String.raw `(?=`+String.raw `${noDigitText}`+String.raw `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+String.raw `</${headerTag}>`+String.raw `)`)})();var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}
function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))
body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)
valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,})});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)
lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<i>'+a.language+'</i>').text().toLowerCase();languages[lang]=languages[lang]||{lang:a.language,user:a.user,size:a.size,link:a.link,uniq:lang}});var langs=[];for(var lang in languages)
if(languages.hasOwnProperty(lang))
langs.push(languages[lang]);langs.sort(function(a,b){if(a.uniq>b.uniq)return 1;if(a.uniq<b.uniq)return-1;return 0});for(var i=0;i<langs.length;++i)
{var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
```
```
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>
```
[Answer]
## [Hexagony](https://github.com/mbuettner/hexagony), side-length ~~17~~ 16, ~~816~~ 705 bytes
```
180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.
```
[Try it online!](http://hexagony.tryitonline.net/#code=MTgwOTYzMTA5MTY4ODQzODgwNTU4MjQ0NDkxNjczOTUzMzI3NTc3MjMzOTM4MTI5MzM5MTczMDU4NzIwNTA0MDgxNDg0MDIyNTQ5ODExNDAyMDU4MjcxMzAzODg3NjcwNzEwMjc0OTY5NDU1MDY1NTU3ODgzNzAyMzY5ODA3MTQ4OTYwNjA4NTUzMjIzODc5NTAzODkyMDE3MTU3MzM3Njg1NTc2MDU2NTEyNTQ2OTMyMjQzNTk0MzE2NjM4MjQ3NTk3MDc1NDIzNTA3OTM3OTQzODE5ODEyNjY0NDU0MTkwNTMwMjE0ODA3MDMyNjAwMDgzMjg3MTI5NDY1NzUxMTk1ODM5NDY5Nzc3ODQ5NzQwMDU1NTg0MDQzMzc0NzExMzYzNTcxNzExMDc4NzgxMjk3MjMxNTkwNjA2MDE5MzEzMDY1MDQyNjY3NDA2Nzg0NzUzNDIyODQ0Ii4iLj4uQC4jLiMuIy4jLiMuIy4jLj4uKC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLjwuIi4uLi4uLi4iLiIuPi4vLjQuUS47LisuPC4jLj4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi48LiIuLi4uLiIuIi4-LiMuIy4-Lk4uMi4nLlwuPi4uLi4uLi4uLi4uLi49Lj0uLi4uLi4uXy48LiIuLi4uLiIuIi4-Lj4uOy4nLj0uOi5cLj4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLjwuIi4uLiIuIi4-LlwuJy4lLicuPC4jLj4uLi4uLi4uLi4uLi4uLi5fLi4uLi48LiIuLi4iLiIuPi4jLiMuPi48LiMuPi4uLi4uLi4uLi4uLi4uLj0uPS48LiIuIi4iLj4uIy5cLicuUi4vLj4uLi4uLi4uLi4uLi4uLi4uLjwuIi4hLi4uLi4uLi4uLi4vLj4u&input=)
This is what it looks like unfolded:
```
1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
" . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
. . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
. " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
. . . . . . . . . . . . . . . . . . . . < . " . . . . .
" . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
. . . . . . . = . = . . . . . . . _ . < . " . . . .
. " . " . > . > . ; . ' . = . : . \ . > . . . . .
. . . . . . . . . . . . . . . . . . < . " . . .
" . " . > . \ . ' . % . ' . < . # . > . . . .
. . . . . . . . . . . _ . . . . . < . " . .
. " . " . > . # . # . > . < . # . > . . .
. . . . . . . . . . . . = . = . < . " .
" . " . > . # . \ . ' . R . / . > . .
. . . . . . . . . . . . . . . < . "
. ! . . . . . . . . . . . / . > .
. . . . . . . . . . . . . . . .
```
Ah well, this was quite the emotional rollercoaster... I stopped counting the number of times I switched between "haha, this is madness" and "wait, if I do *this* it should actually be fairly doable". The constraints imposed on the code by Hexagony's layout rules were... severe.
It might be possible to reduce the side-length by 1 or 2 without changing the general approach, but it's going to be tough (only the cells with `#` are currently unused *and* available for the decoder). At the moment I also have absolutely no ideas left for how a more efficient approach, but I'm sure one exists. I'll give this some thought over the next few days and maybe try to golf off one side-length, before I add an explanation and everything.
Well at least, I've proven it's possible...
Some CJam scripts for my own future reference:
* [Encoder](http://cjam.aditsu.net/#code=qS-N-Y%2514f-W%2582b)
* [Literal-shortcut finder](http://cjam.aditsu.net/#code='%5B%2C_el%5EA%2Cm*%7B_N%2B%5CAb256%2546%3D*%7D%2F)
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), side length 11, 314 bytes
```
164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q
```
[Try it online!](https://tio.run/##jYy7CsJQEAW/RUgINnF37z7z0l@wvyApRCtt9evjtRAbUadZZg7s@XibT9fLfVlQmdg9OALFURDVEphpsoggRJJQsnIUIIG6eIQYiRCwSyAEgQuKhklYJAU0ouAShDSKMBMSk5sbg0nZLAlQKj/ZU/tkten69sW6bsa56XL7gfxfy79L/u5Fq93bqmmYmi2NTd0OuesPPe@X5QE "Hexagony – Try It Online")
---
Note: Currently [the shortest program](https://codegolf.stackexchange.com/questions/69/golf-you-a-quine-for-great-good/193220#193220) is only **261** bytes long, using a similar technique.
Older version:
# [Hexagony](https://github.com/m-ender/hexagony), side length 11, 330 bytes
```
362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/
```
[Try it online!](https://tio.run/##jY29CsJAEISfRVBSCHH/bzfR6CNof00K0UpbJQ8fL2ChIOpUO98yM@fjrT9dL/dxZCMAVkRVFoIwFOJkRtNhpKQcIG5sShwaYk4GUSSiEj6lWR0lOblIQkH1UpMSBAIYu5QUA4mWqcTixJoCsDRF4YYp6qJVM7TLaoP7alH1Q1PXuf6k/B/Lv0n@7t9tns279ctr1w1bqhZP1LStHFbj@AA "Hexagony – Try It Online")
Encoder: [Try it online!](https://tio.run/##jZHNTsMwEITvfoohApoQ6v4hIdKmIMGFG6hHysEkTmyRJpVj0Up9@LJxCuKEnMiyvfPtatarRPspq@p41JttYyyehBX8UQnDmKyzJpdIEqys0XWJ4RLPtZWlND9aa5GiwDkKXVlpENaN5bpdbUUmI1IZdkoayYgJAvRfinF3Dwd8kHTLRq6GxdUU8cRJmQJcnAG6wHiR5rrUFpeXcIfFh2ipKKySNUKXiy6EuNcjuk9JlxXFpDENOQu6pkTWuQwQx3jL1Hu3B9AtyDa@RKXzIKI057mvRNZsc2oaYWNyZCrCEE1RtNIythG6JkYT0RWnl2hVs@Phej9chvtrVLIurTqFsY8i3r8cY85virtb1tei82x2PHLOyQHHCAkOmFNHA1ImeKH9gpagaEI6xxpEcs9/7Yr6kv6gN@eLeVJ@kBeDMxrPEov/EHd/IOqAe0zdKBz/h/hNS2hqc9zgFaNv "Haskell – Try It Online")
The program is roughly equivalent to this Python code: [Try it online!](https://tio.run/##ZZDbbsMgDIbv8xSWpimJJrWAzWnS9i5JR9RITakCVZW@fGbSXuzABdgf/u0fLks@xjOu6zDHCdKSYJwucc6Q8le85qqawgQfgEYJgVpKrZGU8EaSQmuMKoFRWmn0gpxBoxV67ck4ZYTnRaTJu6JG7SRZpxyRlSS14zbWCi@FMOiIVSgUaR5lkZxCbb2Q3MkzN9L6qnp42t3mMYcm5blhc21b3Y7jKUAx@gnivQLo2LHis@ez4FfoOBsHBs8KgF@96t2ubjf8eG7Z9/tNBXCI5zyer4GTcErhIe//VvVdCszi/NXUXd3CC3i7XSxMe7ZQCjYQhyGFXD4Vt/zO4QJvT/7f3OE4N/f2p72@jC391vUb "Python 3 – Try It Online")
Unfolded code:
```
3 6 2 0 0 3 5 1 1 5 5
3 4 2 0 9 6 1 4 2 3 7 6
6 2 6 1 4 2 6 2 5 2 5 3 9
0 4 8 6 3 6 5 2 3 9 5 9 4 6
8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
. / : { ; + ' = 1 P ' % ' a { : . . \ .
. . . . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . \
. . . . . . . . . . . . . \
! $ > < . . . . . . . . \
. . @ > { ? 2 ' % < . .
. . . . : ; ; 4 Q / .
```
Two `.`s takes 1 bit. Any other characters take 1 bit and a base-97 digit.
# Explanation
Click at the images for larger size. Each explanation part has corresponding Python code to help understanding.
### Data part
Instead of the complex structure used in some other answers (with `<`, `"` and some other things), I just let the IP pass through the lower half.
[](https://i.stack.imgur.com/qNCdC.png)
First, the IP runs through a lot of numbers and no-op's (`.`) and mirrors (`\`). Each digit appends to the number in the memory, so in the end the memory value is equal to the number at the start of the program.
```
mem = 362003511...99306179
```
`!` prints it,
```
stdout.write(str(mem))
```
and `$` jumps through the next `>`.
Starting from the `<`. If the memory value `mem` is falsy (`<= 0`, i.e., the condition `mem > 0` is not satisfied), we have done printing the program, and should exit. The IP would follow the upper path.
[](https://i.stack.imgur.com/JbSX5.png)
(let the IP runs ~~around the world~~ for about 33 commands before hitting the `@` (which terminates the program) because putting it anywhere else incurs some additional bytes)
If it's true, we follow the lower path, get redirected a few times and execute some more commands before hitting another conditional.
[](https://i.stack.imgur.com/cDsec.png)
```
# Python # Hexagony
# go to memory cell (a) # {
a = 2 # ?2
# go to memory cell (b) # '
b = mem % a # %
```
Now the memory looks like this:
[](https://i.stack.imgur.com/LXFfU.png)
If the value is truthy:
```
if b > 0:
```
the following code is executed:
[](https://i.stack.imgur.com/ykMH1.png)
```
# Python # Hexagony
b = ord('Q') # Q
b = b*10+4 # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256)) # ;
stdout.write(chr(b%256)) # ;
```
See detailed explanation of the `Q4` at [MartinEnder's HelloWorld Hexagony answer](https://codegolf.stackexchange.com/a/57600/69850). In short, this code prints `.` twice.
Originally I planned for this to print `.` once. When I came up with this (print `.` twice) and implement it, about 10 digits were saved.
Then,
```
b = mem // a # :
```
Here is a important fact I realized that saved me about 14 digits: You don't need to be at where you started.
---
To understand what I'm saying, let's have a BF analogy. (skip this if you already understood)
Given the code
```
while a != 0:
b, a = a * 2, 0
a, b = b, 0
print(a)
```
Assuming we let `a` be the value of the current cell and `b` be the value of the right cell, a straightforward translation of this to BF is:
```
[ # while a != 0:
[->++<] # b, a = a * 2, 0
>[-<+>] # a, b = b, 0
<. # print(a)
]
```
However, note that we don't need to be at the same position all the time during the program. We can let the value of `a` be whatever we are at the start of each iteration, then we have this code:
```
[ # while a != 0:
[->++<] # b, a = a * 2, 0
# implicitly let (a) be at the position of (b) now
. # print(a)
]
```
which is several bytes shorter.
---
Also, the corner wrapping behavior also saves me from having a `\` mirror there - without it I would not be able to fit the digits (+2 digits for the `\` itself and +2 digits for an unpaired `.` to the right of it, not to mention the flags)
(details:
* The IP enters the lower-left corner, heading left
* It get warped to the right corner, still heads left
* It encounters a `\` which reflects it, now it heads right-up
* It goes into the corner and get warped again to the lower-left corner
)
---
If the value (of the mod 2 operation above) is falsy (zero), then we follow this path:
[](https://i.stack.imgur.com/NCG9k.png)
```
# Python # Hexagony # Memory visualization after execution
b = mem // a # : # [click here](https://i.stack.imgur.com/s53S3.png)
base = ord('a') # 97 # a
y = b % base # '%
offset = 33 # P1
z = y + offset # ='+
stdout.write(chr(z)) # ; # [click here](https://i.stack.imgur.com/Dfalo.png)
mem = b // base # {: # [click here](https://i.stack.imgur.com/bdRHf.png)
```
I won't explain too detailed here, but the offset is actually not exactly `33`, but is congruent to `33` mod `256`. And `chr` has an implicit `% 256`.
[Answer]
# MySQL, 167 characters
```
SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));
```
That's right. :-)
I really did write this one myself. It was originally [posted at my site](https://joshduff.com/2008-11-29-my-accomplishment-for-the-day-a-mysql-quine.html).
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~9.8e580~~ ~~1.3e562~~ ~~9.3e516~~ ~~12818~~ ~~11024~~ ~~4452~~ ~~4332~~ ~~4240~~ ~~4200~~ ~~4180~~ ~~3852~~ ~~3656~~ ~~3616~~ ~~3540~~ 2485 + 3 = 2488 bytes
*Now fits in the observable universe!*
```
(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>
```
[Try it online!](https://tio.run/nexus/brain-flak#zVVBEoMgDLz3JcmhP2CY6TsYXsLwdhpIEaoE0KrTKgjrmmRhtQEAkVo8EErrzfPB4zXSY69b6949mQunjYzzfnO38ca1ztTSXo85bM9ovr9@3@r5lTnxdO/3FG390os662U5i@Tlnp@liO2q73Do2H8z@zTymlRlb9XPft/mdO39xoz2QVZ4TOteXVfp7Lv/376vv6iXn2u/B2f/e0nxjbEWHTgPqACM85ZQxQAqDelXojrPJw0NoCXGQqULnZnNHOqJXpFqSg6YSBzC@TVlyYigNPp4nwgxOaf3Pj@jADUBqXYVR9RrLLNI0Z9aFgQkgRgnqMvS0DUpZjhlrSNtIKUfIYTn6w0 "Brain-Flak – TIO Nexus")
---
## Explanation
This Quine works like most Quines in esoteric languages; it has two parts an encoder and a decoder. The encoder is all of the parentheses at the beginning and the decoder is the more complex part at the very end.
A naive way of encoding the program would be to put the ASCII value of every character in the decoder to the stack. This is not a very good idea because Brain-Flak only uses 8 characters (`()<>[]{}`) so you end up paying quite a few bytes to encode very little information. A smarter idea, and the one used up until now is to assign each of the 8 braces to an much smaller number (1-8) and convert these to the ASCII values with our decoder. This is nice because it costs no more than 18 bytes to encode a character as opposed to the prior 252.
However this program does neither. It relies on the fact that Brain-Flak programs are all balanced to encode the 8 braces with the numbers up to 5. It encodes them as follows.
```
( -> 2
< -> 3
[ -> 4
{ -> 5
),>,],} -> 1
```
All the close braces are assigned 1 because we can use context to determine which of them we need to use in a particular scenario. This may sound like a daunting task for a Brain-Flak program, but it really is not. Take for example the following encodings with the open braces decoded and the close braces replaced with a `.`:
```
(.
((..
<([.{...
```
Hopefully you can see that the algorithm is pretty simple, we read left to right, each time we encounter a open brace we push its close brace to an imaginary stack and when we encounter a `.` we pop the top value and put it in place of the `.`. This new encoding saves us an enormous number of bytes in the encoder while only losing us a handful of bytes on the decoder.
### Low level explanation
*Work in progress*
[Answer]
## GolfScript, 2 bytes
```
1
```
(note trailing newline) This pushes the number 1 onto the stack. At the end of the program, GolfScript prints out all items in the stack (with no spaces in between), then prints a newline.
This is a true quine (as listed in the question), because it actually executes the code; it doesn't just "read the source file and print it" (unlike the PHP submission).
---
For another example, here's a GolfScript program to print `12345678`:
```
9,(;
```
1. `9`: push 9 to the stack
2. [`,`](http://www.golfscript.com/golfscript/builtin.html#%2C): consume the 9 as an argument, push the array `[0 1 2 3 4 5 6 7 8]` to the stack
3. [`(`](http://www.golfscript.com/golfscript/builtin.html#%28): consume the array as an argument, push the array `[1 2 3 4 5 6 7 8]` and the item `0` to the stack
4. [`;`](http://www.golfscript.com/golfscript/builtin.html#%3B): discard the top item of the stack
The stack now contains the array `[1 2 3 4 5 6 7 8]`. This gets written to standard output with no spaces between the elements, followed by a newline.
[Answer]
# [Prelude](http://esolangs.org/wiki/Prelude), ~~5157~~ ~~4514~~ ~~2348~~ ~~1761~~ ~~1537~~ ~~664~~ ~~569~~ ~~535~~ ~~423~~ ~~241~~ ~~214~~ ~~184~~ ~~178~~ ~~175~~ ~~169~~ ~~148~~ ~~142~~ ~~136~~ 133 bytes
*Thanks to Sp3000 for saving 3 bytes.*
~~This is rather long...~~ (okay, it's still long ... at least it's beating the shortest ~~known Brainfuck~~ C# quine on this challenge now) *but* it's the first quine I discovered myself (my Lua and Julia submissions are really just translations of standard quine techniques into other languages) *and* as far as I'm aware no one has written a quine in Prelude so far, so I'm actually quite proud of this. :)
```
7( -^^^2+8+2-!( 6+ !
((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)
```
That large number of digits is just an encoding of the core code, which is why the quine is so long.
The digits encoding the quine have been generated with [this CJam script](http://cjam.aditsu.net/#code=qW%25%7Bi2%2BAb%7D%2F&input=7(%20-%5E%5E%5E2%2B8%2B2-!(%206%2B%20!%0A%20%20((%23%5E%23(1-%20)%23)8(1-)8)%23)).
This requires a standard-compliant interpreter, which prints characters (using the values as character codes). So if you're using [the Python interpreter](http://web.archive.org/web/20060504072747/http://z3.ca/~lament/prelude.py) you'll need to set `NUMERIC_OUTPUT = False`.
## Explanation
First, a few words about Prelude: each line in Prelude is a separate "voice" which manipulates its own stack. These stacks are initialised to an infinite number of 0s. The program is executed column by column, where all commands in the column are executed "simultaneously" based on the previous stack states. Digits are pushed onto the stack individually, so `42` will push a `4`, then a `2`. There's no way to push larger numbers directly, you'll have to add them up. Values can be copied from adjacent stacks with `v` and `^`. Brainfuck-style loops can be introduced with parentheses. See the link in the headline for more information.
Here is the basic idea of the quine: first we push loads of digits onto the stack which encode the core of the quine. Said core then takes those digits,decodes them to print itself and then prints the digits as they appear in the code (and the trailing `)`).
This is slightly complicated by the fact that I had to split the core over multiple lines. Originally I had the encoding at the start, but then needed to pad the other lines with the same number of spaces. This is why the initial scores were all so large. Now I've put the encoding at the end, but this means that I first need to skip the core, then push the digits, and jump back to the start and do the printing.
### The Encoding
Since the code only has two voices, and and adjacency is cyclic, `^` and `v` are synonymous. That's good because `v` has by far the largest character code, so avoiding it by always using `^` makes encoding simpler. Now all character codes are in the range 10 to 94, inclusive. This means I can encode each character with exactly two decimal digits. There is one problem though: some characters, notably the linefeed, have a zero in their decimal representation. That's a problem because zeroes aren't easily distinguishable from the bottom of the stack. Luckily there's a simple fix to that: we offset the character codes by `2`, so we have a range from 12 to 96, inclusive, that still comfortably fits in two decimal digits. Now of all the characters that can appear in the Prelude program, only `0` has a 0 in its representation (50), but we really don't need `0` at all. So that's the encoding I'm using, pushing each digit individually.
However, since we're working with a stack, the representations are pushed in reverse. So if you look at the end of the encoding:
```
...9647344257
```
Split into pairs and reverse, then subtract two, and then look up the character codes:
```
57 42 34 47 96
55 40 32 45 94
7 ( - ^
```
where `32` is corresponds to spaces. The core does exactly this transformation, and then prints the characters.
### The Core
So let's look at how these numbers are actually processed. First, it's important to note that matching parentheses don't have to be on the same line in Prelude. There can only be one parenthesis per column, so there is no ambiguity in which parentheses belong together. In particular, the vertical position of the closing parenthesis is always irrelevant - the stack which is checked to determine whether the loop terminates (or is skipped entirely) will always be the one which has the `(`.
We want to run the code exactly twice - the first time, we skip the core and push all the numbers at the end, the second time we run the core. In fact, after we've run the core, we'll push all those numbers again, but since the loop terminates afterwards, this is irrelevant. This gives the following skeleton:
```
7(
( )43... encoding ...57)
```
First, we push a `7` onto the first voice - if we don't do this, we'd never enter the loop (for the skeleton it's only important that this is non-zero... why it's specifically `7` we'll see later). Then we enter the main loop. Now, the second voice contains another loop. On the first pass, this loop will be skipped because the second stack is empty/contains only 0s. So we jump straight to the encoding and push all those digits onto the stack. The `7` we pushed onto the first stack is still there, so the loop repeats.
This time, there is also a `7` on the second stack, so we do enter loop on the second voice. The loop on the second voice is designed such that the stack is empty again at the end, so it only runs once. It will *also* deplete the first stack... So when we leave the loop on the second voice, we push all the digits again, but now the `7` on the first stack has been discarded, so the main loop ends and the program terminates.
Next, let's look at the first loop in the actual core. Doing things simultaneously with a `(` or `)` is quite interesting. I've marked the loop body here with `=`:
```
-^^^2+8+2-!
(#^#(1- )#)
==========
```
That means the column containing `(` is not considered part of the loop (the characters there are only executed once, and even if the loop is skipped). But the column containing the `)` *is* part of the loop and is ran once on each iteration.
So we start with a single `-`, which turns the `7` on the first stack into a `-7`... again, more on that later. As for the actual loop...
The loop continues while the stack of digits hasn't been emptied. It processes two digits at a time,. The purpose of this loop is to decode the encoding, print the character, and at the same time shift the stack of digits to the first voice. So this part first:
```
^^^
#^#
```
The first column moves the 1-digit over to the first voice. The second column copies the 10-digit to the first voice while also copying the 1-digit back to the second voice. The third column moves that copy back to the first voice. That means the first voice now has the 1-digit twice and the 10-digit in between. The second voice has only another copy of the 10-digit. That means we can work with the values on the tops of the stacks and be sure there's two copies left on the first stack for later.
Now we recover the character code from the two digits:
```
2+8+2-!
(1- )#
```
The bottom is a small loop that just decrements the 10-digit to zero. For each iteration we want to add 10 to the top. Remember that the first `2` is not part of the loop, so the loop body is actually `+8+2` which adds 10 (using the `2` pushed previously) and the pushes another 2. So when we're done with the loop, the first stack actually has the base-10 value and another 2. We subtract that 2 with `-` to account for the offset in the encoding and print the character with `!`. The `#` just discards the zero at the end of the bottom loop.
Once this loop completes, the second stack is empty and the first stack holds all the digits in reverse order (and a `-7` at the bottom). The rest is fairly simple:
```
( 6+ !
8(1-)8)#
```
This is the second loop of the core, which now prints back all the digits. To do so we need to 48 to each digit to get its correct character code. We do this with a simple loop that runs `8` times and adds `6` each time. The result is printed with `!` and the `8` at the end is for the next iteration.
So what about the `-7`? Yeah, `48 - 7 = 41` which is the character code of `)`. Magic!
Finally, when we're done with that loop we discard the `8` we just pushed with `#` in order to ensure that we leave the outer loop on the second voice. We push all the digits again and the program terminates.
[Answer]
# Javascript ES6 - 21 bytes
```
$=_=>`$=${$};$()`;$()
```
I call this quine "The Bling Quine."
Sometimes, you gotta golf in style.
[Answer]
# Vim, 11 bytes
```
q"iq"qP<Esc>hqP
```
* `iq"qP<Esc>`: Manually insert a duplicate of the text that *has to be* outside the recording.
* `q"` and `hqP`: Record the inside directly into the unnamed `""` register, so it can be pasted in the middle. The `h` is the only repositioning required; if you put it inside the macro, it will be pasted into the result.
**Edit**
A note about recording with `q"`: The unnamed register `""` is a funny thing. It's not really a true register like the others, since text isn't stored there. It's actually a pointer to some other register (usually `"-` for deletes with no newline, `"0` for yanks, or `"1` for deletes with a newline). `q"` breaks the rules; it actually writes to `"0`. If your `""` was already pointing to some register other than `"0`, `q"` will overwrite `"0` but leave `""` unchanged. When you start a fresh Vim, `""` automatically points to `"0`, so you're fine in that case.
Basically, Vim is weird and buggy.
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), side length ~~15 14 13~~ 12, ~~616 533 456~~ 383 bytes
After several days of careful golfing, rearranging loops and starting over, I've *finally* managed to get it down to a side 12 hexagon.
```
1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>
```
[Try it online!](https://tio.run/##bcxNSsRAEAXgsxhGGnFM6r@qne7gEXSfjQvRlW719LEyGIXBBw3V1Ffv7eXz@fXj/WtdMUQd0UkApFYBdDNwUSYJAA9WoUBQCVdV5lAFYHFgAgZiwoSGis4gCNWjqknyyLXUUHYMk3xIlVggCOrWAMrBwu4UTObu6lxNzY2rK4krikXeBdVAs/wxVctrq6yhMQzzOLXD6a6NW@bjuKf337ENP0Pqcma3ZRnnf@guE97PN@3Qs/bPnXPYVZqlPMmpD9PDhdl7kjz2ct0uOrbtVWnj0u1YpnldvwE "Hexagony – Try It Online")
Unfolded:
```
1 8 4 5 7 1 1 7 2 4 0 0
4 9 9 4 0 1 7 6 6 0 7 4 5
3 2 4 8 0 0 7 8 3 5 4 2 8 1
0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
" " > . / < $ ; - < . . . . . > , . . . . . .
. . . = = . . . . . . . . . < " . . . . . .
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
. . . . . . . . . $ . . < " . . . .
" " > \ ' Q 4 ; = " / @ > . . . .
. . . . . . . . . . . < " . . .
. . " " > P = ' % < . > . . .
. . . . . . . . . . < " . .
! ' < . \ = 6 , ' / > . .
. . . . . . . . . . . .
```
While it doesn't look like the most golfed of Hexagony code, the type of encoding I used is optimised for longer runs of no-ops, which is something you would otherwise avoid.
### Explanation
This beats the [previous Hexagony answer](https://codegolf.stackexchange.com/a/74294/76162) by encoding the no-ops (`.`) in a different way. While that answer saves space by making every other character a `.`, mine encodes the *number* of no-ops. It also means the source doesn't have to be so restricted.
Here I use a base 80 encoding, where numbers below 16 indicate runs of no-ops, and numbers between 16 and 79 represent the range 32 (`!`) to 95 (`_`) (I'm just now realising I golfed all the `_`s out of my code lol). Some Pythonic pseudocode:
```
i = absurdly long number
print(i)
base = 80
n = i%base
while n:
if n < 16:
print("."*(16-n))
else:
print(ASCII(n+16))
i = i//base
n = i%base
```
The number is encoded in the first half of the hexagon, with all the
```
" " >
" " >
... etc
```
on the left side and the
```
> ,
< "
>
< "
... etc
```
on the right side redirecting the pointer to encode the number into one cell. This is taken from [Martin Ender's answer](https://codegolf.stackexchange.com/a/74294/76162) (thanks), because I couldn't figure out a more efficient way.
It then enters the bottom section through the `->`:
```
" " > \ ' Q 4 ; = " / @ > . . . .
. . . . . . . . . . . < " . . .
. . " " > P = ' % < . > . . .
. . . . . . . . . . < " . .
-> ! ' < . \ = 6 , ' / > . .
```
`!` prints the number and `'` navigates to the right memory cell before starting the loop. `P='%` mods the current number by 80. If the result is 0, go up to the terminating `@`, else go down and create a cell next to the mod result with the value `-16`.
```
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
. . . . . . . . . $ . . < " . . . .
" " > \ ' Q 4 ; = " / @ > . . . .
/
/
```
Set the cell to (mod value + -16). If that value is negative, go up at the branching `>+'\`, otherwise go down.
If the value is positive:
```
" " > . / < $ ; - < . . . . . > , . . . . . .
. . . = = . . . . . . . . . < " . . . . . .
. " " > ' . . . . > + ' \ . > . . . . . .
```
The pointer ends up at the `;-<` which sets the cell to (mod value - -16) and print it.
The the value is negative:
```
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
```
Go down to the `> ) <` section which starts the loop. Here it is isolated:
```
. . > ) < $ = < . .
. . . . . . . . .
\ ' Q 4 ; = " /
```
Which executes the code `'Q4;="=` which prints a `.` (thanks again to Martin Ender, who wrote a [program](http://cjam.aditsu.net/#code=q%3AC%3B%27%5B%2C_el%5EA%2Cm*%7B_Ab256%25c%5C%2B%7D%25%7B0%3DC%26%7D%2C1f%3EN*&input=.) to find the letter-number combinations for characters) and moves back to the starting cell. It then increments (`)`) the mod value cell and loops again, until the mod value is positive.
When that is done, it moves up and joins with the other section at:
```
" " > . / < $ ; - < . . .
\
\
```
The pointer then travels back to the start of the larger loop again
```
" " > . / <--
. . . = =
. " " > '
. . . = =
. " " > :
. . . . .
" " > \ ' . .
. . . . . . .
. . " " > P = ' % < . > . . .
```
This executes `='=:'` which divides the current number by 80 and navigates to the correct cell.
### Old version (Side length 13)
```
343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""
```
[Try it online!](https://tio.run/##fY/NSgUxDIWfxaKMV7DT/DS38bbFV3A/GxHRlW716cekM4jixUJ/wvnOSfr6/PH48v72ua7ExIqIfCQVYGT1ShIpEYKg7USbBqpWozsQiCWl4rWwuwUyZM1YQFE2Jg1GxFR7q9ee6Bqoa2AuATAeE2fvyqaD7kwZflc902exlG/1OFTgZI7i82YlkWRzFFKbZ1Ah9Hm6a/XyNNXoq1/Hs6uG7TaDX5OjbbHjP3qH@6HG2/ibbe0nOcCw5879fJ5BywOfqM3x/k9fJ0KI/enQpqs6el3Ylxa4adMclxDW9Qs)
~~I can most definitely golf another side length off this, but I'll have to leave it til' tomorrow because it's getting late.~~ Turns out I'm impatient and can't wait until tomorrow. ~~Maybe another side can be golfed?~~ ~~:(~~ *ahhhhhhhhh* i did it!
I even golfed off a [couple of extra digits](https://tio.run/##fZPLTsMwEEX3@YoBFUUIMH7FcWhr8QMs2GfTBYIVbOHrw52x86S0o4ztyfHN9ST9ePs@vX99/gwDLX4tBfJkKCJbcpjxqq0WSAeoQbYYc@ZVoLiAAmpWqg0i4vKICEE9Ux7lFtnhCqQF1zJqChNmWBpiBtHgjhE5hwqHqyZXTopaJFtgTrZ68YfDFFBjO1e1uNbyaGa0PMbw/kw68efLITLgC@ow56N3gjZYtaVXnWSuWLEThDRsilkrXbHiIjc5Yh1xO8rRcj@zsBbRWI6bpceus7Sao0KqEYke6UA72tMDxhlIdL/Gy@yIUH/iAKU1Xab14kaiO6x6mW3gC@Ir6dzn0fkTrltxfyze0xY943W3lR2/hyzaI7@id3uIXqM5z7Po9IGpszFJzt@rmry@QK6mG/GZttglueX/6AolFughFvCCavhLW@gfd2oYfgE) with a base 77 encoding, but it doesn't really matter, since it has the same bytecount.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 20 bytes
```
3434Qu$v@!<"OOw\o;/"
```
*Almost got the* `\o/`...
**Net**:
```
3 4
3 4
Q u $ v @ ! < "
O O w \ o ; / "
. .
. .
```
# Try it online
Try it [here](https://ethproductions.github.io/cubix/?code=MzQzNFF1JC9AITwiT093XG87LyI=)!
# Additional notes
## Background story
After being impressed by reading [this great answer](https://codegolf.stackexchange.com/a/103532/63774) by @ais523, I started thinking about further golfing the quine. After all, there were quite a few no-ops in there, and that didn't feel very compressed. However, as the technique his answer (and mine as well) uses, requires the code to span full lines, a saving of at least 12 bytes was needed. There was one remark in his explanation that really got me thinking:
>
> On the subject of golfing down this quine further, [...] it'd need [...] some other way to represent the top face of the cube [...]
>
>
>
Then, suddenly, as I stood up and walked away to get something to drink, it struck me: What if the program didn't use character codes, but rather numbers to represent the top face? This is especially short if the number we're printing has 2 digits. Cubix has 3 one-byte instructions for pushing double-digit numbers: `N`, `S` and `Q`, which push `10`, `32` and `34` respectively, so this should be pretty golfy, I thought.
The first complication with this idea is that the top face is now filled with useless numbers, so we can't use that anymore. The second complication is that the top face has a size which is the cube size squared, and it needed to have an even size, otherwise one number would also end up on the starting position of the instruction pointer, leading to a polluted stack. Because of these complications, my code needed to fit on a cube of size 2 (which can contain 'only' 24 bytes, so I had to golf off at least 21 bytes). Also, because the top and bottom faces are unusable, I only had 16 effective bytes.
So I started by choosing the number that would become half of the top face. I started out with `N` (10), but that didn't quite work out because of the approach I was taking to print everything. Either way, I started anew and used `S` (32) for some reason. That did result in a proper quine, or so I thought. It all worked very well, but the quotes were missing. Then, it occured to me that the `Q` (34) would be really useful. After all, 34 is the character code of the double quote, which enables us to keep it on the stack, saving (2, in the layout I used then) precious bytes. After I changed the IP route a bit, all that was left was an excercise to fill in the blanks.
## How it works
The code can be split up into 5 parts. I'll go over them one by one. Note that we are encoding the middle faces in reverse order because the stack model is first-in-last-out.
### Step 1: Printing the top face
The irrelevant instructions have been replaced by no-ops (`.`). The IP starts the the third line, on the very left, pointing east. The stack is (obviously) empty.
```
. .
. .
Q u . . . . . .
O O . . . . . .
. .
. .
```
The IP ends at the leftmost position on the fourth line, pointing west, about to wrap around to the rightmost position on that same line. The instructions executed are (without the control flow character):
```
QOO
Q # Push 34 (double quotes) to the stack
OO # Output twice as number (the top face)
```
The stack contains just 34, representlng the last character of the source.
### Step 2: Encode the fourth line
This bit pretty much does what you expect it to do: encode the fourth line. The IP starts on the double quote at the end of that line, and goes west while pushing the character codes of every character it lands on until it finds a matching double quote. This matching double quote is also the last character on the fourth line, because the IP wraps again when it reaches the left edge.
Effectively, the IP has moved one position to the left, and the stack now contains the representation of the fourth line in character codes and reverse order.
### Step 3: Push another quote
We need to push another quote, and what better way than to recycle the `Q` at the start of the program by approaching it from the right? This has the added bonus that the IP directly runs into the quote that encodes the third line.
Here's the net version for this step. Irrelevant intructions have been replaced by no-ops again, the no-ops that are executed have been replaced by hashtags (`#`) for illustration purposes and the IP starts at the last character on the fourth line.
```
. .
. .
Q u $ . . . . .
. . w \ . . / .
. #
. #
```
The IP ends on the third line at the first instruction, about to wrap to the end of that line because it's pointing west. The following instructions (excluding control flow) are excecuted:
```
$uQ
$u # Don't do anthing
Q # Push the double quote
```
This double quote represents the one at the end of the third line.
### Step 4: Encoding the third line
This works exactly the same as step 2, so please look there for an explanation.
### Step 5: Print the stack
The stack now contains the fourth and third lines, in reverse order, so all we need to do now, it print it. The IP starts at the penultimate instruction on the third line, moving west. Here's the relevant part of the cube (again, irrelevant parts have been replaced by no-ops).
```
. .
. .
. . . v @ ! < .
. . . \ o ; / .
. .
. .
```
This is a loop, as you might have seen/expected. The main body is:
```
o;
o # Print top of stack as character
; # Delete top of stack
```
The loop ends if the top item is 0, which only happens when the stack is empty. If the loop ends, the `@` is executed, ending the program.
[Answer]
## Brainf\*ck (755 characters)
This is based off of a technique developed by Erik Bosman (ejbosman at cs.vu.nl). Note that the "ESultanik's Quine!" text is actually necessary for it to be a quine!
```
->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
```
[Answer]
# Vim, ~~17~~, 14 keystrokes
Someone randomly upvoted this, so I remembered that it exists. When I re-read it, I thought "Hey, I can do better than that!", so I golfed two bytes off. It's still not the shortest, but at least it's an improvement.
---
For a long time, I've been wondering if a vim quine is possible. On one hand, it must be possible, since vim is turing complete. But after looking for a vim quine for a really long time, I was unable to find one. I *did* find [this PPCG challenge](https://codegolf.stackexchange.com/questions/2985/compose-a-vim-quine), but it's closed and not exactly about literal quines. So I decided to make one, since I couldn't find one.
I'm really proud of this answer, because of two *firsts*:
1. This is the first quine I have ever made, and
2. As far as I know, this is the worlds first *vim-quine* to ever be published! I could be wrong about this, so if you know of one, please let me know.
So, after that long introduction, here it is:
```
qqX"qpAq@q<esc>q@q
```
[Try it online!](https://tio.run/nexus/v#@19YGKFUWOBY6FAoDcT//wMA "V – TIO Nexus")
Note that when you type this out, it will display the `<esc>` keystroke as `^[`. This is still accurate, since `^[` represents `0x1B`, which is escape [in ASCII](http://www.asciitable.com/), and the way vim internally represents the `<esc>` key.
*Also* note, that testing this might fail if you load an existing vim session. I wrote a [tips](/questions/tagged/tips "show questions tagged 'tips'") answer explaining that [here](https://codegolf.stackexchange.com/a/74663/31716), if you want more information, but basically you need to launch vim with
```
vim -u NONE -N -i NONE
```
*or* type `qqq` before running this.
Explanation:
```
qq " Start recording into register 'q'
X " Delete one character before the cursor (Once we play this back, it will delete the '@')
"qp " Paste register 'q'
Aq@q<esc> " Append 'q@q' to this line
q " Stop recording
@q " Playback register 'q'
```
On a side note, this answer is probably a world record for most 'q's in a PPCG answer, or something.
[Answer]
# PostScript, 20 chars
Short and legit. 20 chars including trailing newline.
```
(dup == =)
dup == =
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 45 bytes
```
.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"
```
You can test this code [here](https://ethproductions.github.io/cubix/?code=Li4uLi4+Li4uUiRSLi4uLlcuLl4iLjxSLiEnLlwpISciUkA+Pm87Py9vJ3Ui&input=&speed=20).
This program is fairly hard to follow, but to have any chance to do so, we need to start by expanding it into a cube, like the Cubix interpreter does:
```
. . .
. . >
. . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
. . .
. . .
. . .
```
This is a Befunge-style quine, which works via exploiting wrapping to make string literals "wrap around" executable code (with only one `"` mark, the code is both inside and outside the quote at the same time, something that becomes possible when you have programs that are nonlinear and nonplanar). Note that this fits our definition of a proper quine, because two of the double quotes don't encode themselves, but rather are calculated later via use of arithmetic.
Unlike Befunge, though, we're using four strings here, rather than one. Here's how they get pushed onto the stack;
1. The program starts at the top of the left edge, going rightwards; it turns right twice (`R`), making it go leftwards along the third and last of the lines that wrap around the whole cube. The double quote matches itself, so we push the entire third line onto the stack backwards. Then execution continues after the double quote.
2. The `u` command does a U-turn to the right, so the next thing we're running is from `'"` onwards on the middle line. That pushes a `"` onto the stack. Continuing to wrap around, we hit the `<` near the left hand side of the cube and bounce back. When approaching from this direction, we see a plain `"` command, not `'"`, so the entire second line is pushed onto the stack backwards above the third line and the double quote.
3. We start by pushing a `!` onto the stack (`'!`) and incrementing it (`)`); this produces a double quote without needing a double quote in our source code (which would terminate the string). A mirror (`\`) reflects the execution direction up northwards; then the `W` command sidesteps to the left. This leaves us going upwards on the seventh column, which because this is a cube, wraps to leftwards on the third row, then downwards on the third column. We hit an `R`, to turn right and go leftwards along the top row; then the `$` skips the `R` via which we entered the program, so execution wraps round to the `"` at the end of the line, and we capture the first line in a string the same way that we did for the second and third.
4. The `^` command sends us northwards up the eleventh column, which is (allowing for cube wrapping) southwards on the fifth. The only thing we encounter there is `!` (skip if nonzero; the top of the stack is indeed nonzero), which skips over the `o` command, effectively making the fifth column entirely empty. So we wrap back to the `u` command, which once again U-turns, but this time we're left on the final column southwards, which wraps to the fourth column northwards. We hit a double quote during the U-turn, though, so we capture the entire fourth column in a string, from bottom to top. Unlike most double quotes in the program, this one doesn't close itself; rather, it's closed by the `"` in the top-right corner, meaning that we capture the nine-character string `...>.....`.
So the stack layout is now, from top to bottom: fourth column; top row; `"`; middle row; `"`; bottom row. Each of these are represented on the stack with the first character nearest the top of the stack (Cubix pushes strings in the reverse of this order, like Befunge does, but each time the IP was moving in the opposite direction to the natural reading direction, so it effectively got reversed twice). It can be noted that the stack contents are almost identical to the original program (because the fourth column, and the north/top face of the cube, contain the same characters in the same order; obviously, it was designed like that intentionally).
The next step is to print the contents of the stack. After all the pushes, the IP is going northwards on the fourth column, so it hits the `>` there and enters a tight loop `>>o;?` (i.e. "turn east, turn east, output as character, pop, turn right if positive"). Because the seventh line is full of NOPs, the `?` is going to wrap back to the first `>`, so this effectively pushes the entire contents of the stack (`?` is a no-op on an empty stack). We almost printed the entire program! Unfortunately, it's not quite done yet; we're missing the double-quote at the end.
Once the loop ends, we reflect onto the central line, moving west, via a pair of mirrors. (We used the "other side" of the `\` mirror earlier; now we're using the southwest side. The `/` mirror hasn't been used before.) We encounter `'!`, so we push an exclamation mark (i.e. 33; we're using ASCII and Cubix doesn't distinguish between integers and characters) onto the stack. (Conveniently, this is the same `!` which was used to skip over the `o` command earlier.) We encounter a pair of `R` commands and use them to make a "manual" U-turn (the second `R` command here was used earlier in order to reach the first row, so it seemed most natural to fit another `R` command alongside it.) The execution continues along a series of NOPs until it reaches the `W` command, to sidestep to the left. The sidestep crashes right into the `>` command on the second line, bouncing execution back exactly where it was. So we sidestep to the left again, but this time we're going southwards, so the next command to execute is the `)` (incrementing the exclamation mark into a double quote), followed by an `o` (to output it). Finally, execution wraps along the eighth line to the second column, where it finds a `@` to exit the program.
I apologise for the stray apostrophe on the third line. It doesn't do anything in this version of the program; it was part of an earlier idea I had but which turned out not to be necessary. However, once I'd got a working quine, I just wanted to submit it rather than mess around with it further, especially as removing it wouldn't change the byte count. On the subject of golfing down this quine further, it wouldn't surprise me if this were possible at 3×3 by only using the first five lines, but I can't see an obvious way to do that, and it'd need even tighter packing of all the control flow together with some other way to represent the top face of the cube (or else modifying the algorithm so that it can continue to use the fourth column even though it'd now be ten or eleven characters long).
[Answer]
# Python 2, 30 bytes
```
_='_=%r;print _%%_';print _%_
```
[Taken from here](https://web.archive.org/web/20130701215340/http://en.literateprograms.org/Quine_(Python))
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 261 bytes, side length 10
```
113009344778658560261693601386118648881408495353228771273368412312382314076924170567897137624629445942109467..../....%'=g':..\..................\.................\................\...............\..............\.............\............\!$/'?))='%<\..>:;/$;4Q/
```
[Try it online!](https://tio.run/##hYk7DsIwEETPgpTISmPvz7vrhMAZ6N1QoFBBC6c3pkbAaPSkN3O9PM7b/fZsDZEBCouYuWbPCqSohRWQXRFdxd1RwKVkzkzkZkjGrC5I3OudAqaFBA2ymhdDNiVRKiK5CCEUUYs96Y0xrFuYY6zxI/X/Un97/W51N6RwnKY1jPt@HOYlDYucUmsv "Hexagony – Try It Online")
Uses the same encoding [user202729's answer](https://codegolf.stackexchange.com/a/156271/76162), but terminates in a divide by zero error.
Formatted, this looks like:
```
1 1 3 0 0 9 3 4 4 7
7 8 6 5 8 5 6 0 2 6 1
6 9 3 6 0 1 3 8 6 1 1 8
6 4 8 8 8 1 4 0 8 4 9 5 3
5 3 2 2 8 7 7 1 2 7 3 3 6 8
4 1 2 3 1 2 3 8 2 3 1 4 0 7 6
9 2 4 1 7 0 5 6 7 8 9 7 1 3 7 6
2 4 6 2 9 4 4 5 9 4 2 1 0 9 4 6 7
. . . . / . . . . % ' = g ' : . . \
. . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . \
. . . . . . . . . . . . . \
. . . . . . . . . . . . \
! $ / ' ? ) ) = ' % < \
. . > : ; / $ ; 4 Q /
. . . . . . . . . .
```
[Try it online!](https://tio.run/##hZC9DsIwDIT3PsUhtapY6F@atEDhGdi7MKAywQpPH84mBAbU9iTbtb@cnFwvj/N0vz29R/wqqkFJ9cyGckkcOnSwaBlb5hI1YxXHVo9IXyyEFLMuiWPDpqhiVTIbHmjRBIAVDWv2HVWxcuyIYbAw2mxC7EItVg5WkZ49oRx7sqHs26tZ82EEsIy93q3VXBMotbJ6201QEasMOQZMjFv9H5M4mtP4YzZPLUOAXnGRemOLVMCW1ppDIoAVUj5WjiPW1MAqw/5nrviBb7cjljIanFB8x//svX8B "Hexagony – Try It Online")
Some python-like psuedo-code to explain:
```
n = ridiculously long number
base = 103
print(n)
while n > 0:
b = 2
if n%b == 1:
c = '.'
print(c)
else:
n = n//b
b = base
c = chr(n%b + 1)
print(c)
n = n//b
```
I'm using base 103 rather than the optimal base 97 just to make sure the number fully fits the top half of the hexagon and doesn't leave an extra `.` to encode.
Here's a [link](https://tio.run/##jZJPU4MwEMXv@RRPploilv7RE5Z60ItHp0frIUIgGSl0Qsb22@MmYMdTMZmE7L5fdl52UKL9klXVdXp/aIzFi7AiflbCMCbrrMklkgRba3RdYrbBa21lKc2v1lqkKDBBoSsrDcK6sbFutweRSU4qw1FJIxkxQYB@pFi4OJzG08Qty30Ni9sVoqWXMgX4PAN0gcU6zXWpLW5u4A/rT9FSUVgla4T@LlwKUa9zileky4py0piGnAXuUSJzLgNEEd4z9eG@AXQLso1vUek84HTNe@4rkTXbDI9G2JgcmeKYoSmKVlrG9kLXxGgiXHHqRKuaYxzuTrNNeLpDJevSqiGNE@dx3znGvN8Uy8U964u5oOuAeJjz8@kaUxJL2hMf79hZujQJ@yc1DgEOG6d6bJQasDFbl5AzgCtq75ya8wQO9y9NqWHrP7rHN9S7R8ImtD/gDfMf) to user202729's encoder that I used to get the large number and check that the number actually fit in the hexagon.
[Answer]
# C, ~~64~~ 60 bytes
```
main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
```
This may segfault on 64-bit systems with some compilers, such as newest Clang, due to the type of `s` being interpreted as 32-bit `int` instead of a pointer.
So far, this is the shortest known C quine. There's an [extended bounty](https://codegolf.meta.stackexchange.com/a/12581/61563) if you find a shorter one.
This works in [GCC](https://tio.run/##S9ZNT07@/z83MTNPo1izuqAoM68kTaPYVglDRDVZtVjVUCVZx9hEp1jTulYJxvj/HwA), [Clang](https://tio.run/##S9ZNzknMS///PzcxM0@jWLO6oCgzryRNo9hWCUNENVm1WNVQJVnH2ESnWNO6VgnG@P8fAA), and [TCC](https://tio.run/##S9YtSU7@/z83MTNPo1izuqAoM68kTaPYVglDRDVZtVjVUCVZx9hEp1jTulYJxvj/HwA) in a [POSIX](https://en.wikipedia.org/wiki/POSIX) environment. It invokes an excessive amount of undefined behavior with all of them.
Just for fun, here's a [repo](https://github.com/aaronryank/quines/tree/master/c) that contains all the C quines I know of. Feel free to fork/PR if you find or write a different one that adds something new and creative over the existing ones.
Note that it only works in an [ASCII](https://en.wikipedia.org/wiki/ASCII) environment. [This](https://pastebin.com/raw/MESjTMQt) works for [EBCDIC](https://en.wikipedia.org/wiki/EBCDIC), but still requires [POSIX](https://en.wikipedia.org/wiki/POSIX). Good luck finding a POSIX/EBCDIC environment anyway :P
---
How it works:
1. `main(s)` abuses `main`'s arguments, declaring a virtually untyped variable `s`. (Note that `s` is not actually untyped, but since listed compilers auto-cast it as necessary, it might as well be\*.)
2. `printf(s="..."` sets `s` to the provided string and passes the first argument to `printf`.
3. `s` is set to `main(s){printf(s=%c%s%1$c,34,s);}`.
4. The `%c` is set to ASCII `34`, `"`. This makes the quine possible. Now `s` looks like this:
`main(s){printf(s="%s%1$c,34,s);}`.
5. The `%s` is set to `s` itself, which is possible due to #2. Now `s` looks like this:
`main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}`.
6. The `%1$c` is set to ASCII 34 `"`, `printf`'s first\*\* argument. Now `s` looks like this:
`main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}`
... which just so happens to be the original source code.
\* [Example](https://tio.run/##S9ZNT07@/185My85pzQlVcGmuCQlM18vw46LKzOvRCE3MTNPoyw/M0WTq5pLAQhAghkKtgpKHqk5Ofk6CuH5RTkpikrWYMmC0pJijQxNa67a//8B) thanks to @Pavel
\*\* first argument after the format specifier - in this case, `s`. It's impossible to reference the format specifier.
---
I think it's impossible that this will get any shorter with the same approach. If `printf`'s format specifier was accessible via `$`, this would work for 52 bytes:
```
main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
```
---
Also here's a longer 64-byte version that will work on all combinations of compilers and ASCII environments that support the POSIX printf `$` extension:
```
*s;main(){printf(s="*s;main(){printf(s=%c%s%1$c,34,s);}",34,s);}
```
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), ~~120 116 98 96 76 70~~ 66 bytes
Edit: yay, under 100
Edit: Saved a bunch o' bytes by switching to all `/`s on the bottom line
```
:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////
```
[Try it online!](https://tio.run/##y8kvLvn/38pI29RIy9JUy0jbzsrK0N4q2ioaCBziVO3tNKIVlLj0CQCu////6zoCAA) + [verification it's deterministic for all possible states](https://tio.run/##y8kvLvn/38pI29RIy9JUy0jbzsrK0N4q2ioaCBziVO3tNKIVlLj0CQCu////6zoGAgA)
Lost is a 2D language in which the starting position and direction are completely random. This means there has to be a lot of error-checking at every stage to make sure you've got the correct instruction pointer, and it isn't one that has just wandered in randomly.
### Explanation:
All the `/`s on the bottom line are there to make sure that all the pointers that spawn in a vertical direction or on the bottom line get funneled in the right direction. From there, they end up at several different places, but all of them end up going right into the
```
^%?>
////
```
Which clears out all the non-zero numbers in the stack. The `([` after that clears out any extra 0s as well.
In the middle of the clear, it hits the `%`, which turns the 'safety' off, which allows the program to end when it hits the `@` (without this, the program could end immediately if a pointer started at the `@`).
From there it does a pretty simple 2D language quine, by wrapping a string literal (`"`) around the first line, pushing a `"` character by duping a space (`:2+`) and then a newline (`52*`). For the second line, it creates a `/` character (`95*2+`) and duplicates it a bunch (`>::1?:[:[[[[`), before finally ending at the `@` and printing the stack implicitly. The `?1` is to stop the process from creating too many 0s if the pointer enters early, saving on having to clear them later.
I saved 20 bytes here by making the last line all the same character, meaning I could go straight from the duping process into the ending `@`.
### Explanation about the duping process:
`[` is a character known as a 'Door'. If the pointer hits the flat side of a `[` or a `]` , it reflects, else it passes through it. Each time the pointer interacts with a Door, it switches to the opposite type. Using this knowledge we can construct a simple formula for how many times an instruction will execute in a `>:[` block.
Add the initial amount of instructions. For each `[`, add 2 times the amount of instructions to the left of it. For the example `>::::[:[[[`, we start with 5 as the initial amount. The first Door has 4 dupe instructions, so we add 4\*2=8 to 5 to get 13. The other three Doors have 5 dupes to their left, so we add 3\*(5\*2)=30 to 13 to get 43 dupe instructions executed, and have 44 `>`s on the stack. The same process can be applied to other instructions, such as `(` to push a large amount of items from the stack to the scope, or as used here, to clear items from the stack.
A trick I've used here to avoid duping too many 0s is the `1?`. If the character is 0, the `?` doesn't skip the 1, which means it duplicates 1 for the remainder of the dupe. This makes it *much* easier to clear the stack later on.
[Answer]
# [Chicken](http://esolangs.org/wiki/Chicken), 7
```
chicken
```
No, this is not directly echoed :)
[Answer]
## Cross-browser JavaScript (41 characters)
It works in the top 5 web browsers (IE >= 8, Mozilla Firefox, Google Chrome, Safari, Opera). Enter it into the developer's console in any one of those:
```
eval(I="'eval(I='+JSON.stringify(I)+')'")
```
It's not "cheating" — unlike Chris Jester-Young's single-byte quine, as it could easily be modified to use the `alert()` function (costing 14 characters):
```
alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))
```
Or converted to a bookmarklet (costing 22 characters):
```
javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
```
[Answer]
# [Fission](http://esolangs.org/wiki/Fission), 6 bytes
It appears this is now the shortest "proper" quine among these answers.
```
'!+OR"
```
## Explanation
Control flow starts at `R` with a single right-going `(1,0)` atom. It hits `"` toggling print mode and then wraps around the line, printing `'!+OR` before hitting the same `"` again and exiting print mode.
That leaves the `"` itself to be printed. The shortest way is `'"O` (where `'"` sets the atom's mass to the character code of `"` and `O` prints the character and destroys the atom), but if we did this the `"` would interfere with print mode. So instead we set the atom's value to `'!` (one less than `"`), then increment with `+` and *then* print the result with `O`.
## Alternatives
Here are a couple of alternatives, which are longer, but maybe their techniques inspire someone to find a shorter version using them (or maybe they'll be more useful in certain generalised quines).
### 8 bytes using `J`ump
```
' |R@JO"
```
Again, the code starts at `R`. The `@` swaps mass and energy to give `(0,1)`. Therefore the `J` makes the atom jump over the `O` straight onto the `"`. Then, as before, all but the `"` are printed in string mode. Afterwards, the atom hits `|` to reverse its direction, and then passes through `'"O` printing `"`. The space is a bit annoying, but it seems necessary, because otherwise the `'` would make the atom treat the `|` as a character instead of a mirror.
### 8 bytes using two atoms
```
"'L;R@JO
```
This has two atoms, starting left-going from `L` and right-going from `R`. The left-going atom gets its value set by `'"` which is then immediately printed with `O` (and the atom destroyed). For the right-going atom, we swap mass and energy again, jump over the `O` to print the rest of the code in print mode. Afterwards its value is set by `'L` but that doesn't matter because the atom is then discarded with `;`.
[Answer]
## Java, 528 bytes:
A Java solution with an original approach:
```
import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}
```
in readable form:
```
import java.math.*;
class a
{
public static void main (String [] a)
{
BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36);
int i=0;
for (byte c:b.toByteArray ())
{
if (++i==92)
System.out.print (b.toString (36));
System.out.print ((char) c);
}
}
}
```
[Answer]
These are the two shortest **Ruby** quines [from SO](https://stackoverflow.com/questions/2474861/shortest-ruby-quine/2475931#2475931):
```
_="_=%p;puts _%%_";puts _%_
```
and
```
puts <<2*2,2
puts <<2*2,2
2
```
Don't ask me how the second works...
[Answer]
## [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~20~~ ~~14~~ ~~9~~ 7 bytes
Before we get started, I'd like to mention the trivial solution of a file which contains a single `0`. In that case Retina will try to count the `0`s in the empty input, the result of which is also `0`. I wouldn't consider that a proper quine though.
So here is a proper one:
```
>\`
>\`
```
[Try it online!](https://tio.run/##K0otycxLNPz/3y4mgQuI//8HAA "Retina – Try It Online")
Alternatively, we could use `;` instead of `>`.
### Explanation
The program consists of a single replacement which we print twice.
In the first line, the ``` separates the configuration from the regex, so the regex is empty. Therefore the empty string (i.e. the non-existent input) is replaced with the second line, verbatim.
To print the result twice, we wrap it in two output stages. The inner one, `\` prints the result with a trailing linefeed, and the outer one, `>`, prints it without one.
If you're a bit familiar with Retina, you might be wondering what happened to Retina's implicit output. Retina's implicit output works by wrapping the final stage of a program in an output stage. However, Retina doesn't do this, if the final stage is already an output stage. The reason for that is that in a normal program it's more useful to be able to replace the implicit output stage with special one like `\` or `;` for a single byte (instead of having to get rid of the implicit one with the `.` flag as well). Unfortunately, this behaviour ends up costing us two bytes for the quine.
[Answer]
## GolfScript, 8 bytes
I always thought the shortest (true) GolfScript quine was 9 bytes:
```
{'.~'}.~
```
Where the trailing linefeed is necessary because GolfScript prints a trailing linefeed by default.
But I just found an 8-byte quine, which works exactly around that linefeed restriction:
```
":n`":n`
```
[Try it online!](http://golfscript.tryitonline.net/#code=IjpuYCI6bmA&input=)
So the catch is that GolfScript doesn't print a trailing linefeed, but it prints the contents of `n` at the end of the program. It's just that `n` contains a linefeed to begin with. So the idea is to replace that with the string `":n`"`, and then stringifying it, such that the copy on the stack prints with quotes and copy stored in `n` prints without.
As pointed out by Thomas Kwa, the 7-byte CJam quine can also be adapted to an 8-byte solution:
```
".p"
.p
```
Again, we need the trailing linefeed.
[Answer]
# [Fueue](https://github.com/TryItOnline/fueue), 423 bytes
Fueue is a queue-based esolang in which the running program *is* the queue.
```
)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
```
[Try it online!](https://tio.run/##TU9bjsQgDLtMKzVTVRvzSAH1AHsHxOfsDeY3V@8mzKy0VFAnJrb5eT1fz/umZUkh53XFptS6lSGtK7erayOloX0BlPTqfV/ScaRa9sfR9AATtUGXjk5EOq4xtu@DmppIt18nbapbb0qPWS/Y9lSGwX2YgJIpqI6vsbdsStrGBpYYShU/geBnlIhTYpUqAAoq4NiYbEycCHZfQkAEo7IIPl2TwMSG@D3lKv94297zCjkF95cY2f0wl8Bx5OlRZssz5HcC03fn07wzcggsltdmIvu87fqXx7J6Pd2ct@nCJ9tkYBaWd5J5x9/gTLSPXdPZ@/4F "Fueue – Try It Online")
# How it works
This explanation ~~may or may not have~~ got way out of hand. On the other hand I don't know how to explain it *much* shorter in a way I hope people can follow.
## Fueue cheat sheet
See [esolang wiki article](https://esolangs.org/wiki/Fueue) for details, including the few features not used in this program.
* The initial program is the initial state of the queue, which can contain the following elements:
+ Integer literals (only non-negative in the source, but negative ones can be calculated), executing them prints a character.
+ Square-bracket delimited nested blocks, inert (preserved intact unless some function acts upon them).
+ Functions, their arguments are the elements following them immediately in the queue:
- `+*/-%`: integer arithmetic (`-` is unary, `%` logical negation). Inert if not given number arguments.
- `()<`: put element in brackets, remove brackets from block, add final element to block. The latter two are inert unless followed by a block.
- `~:`: swap, duplicate.
- `$`: copy (takes number + element). Inert before non-number.
- `H`: halt program.Note that while `[]` nest, `()` don't - the latter are simply separate functions.
## Execution trace syntax
Whitespace is optional in Fueue, except between numerals. In the following execution traces it will be used to suggest program structure, in particular:
* When a function executes, it and its arguments will be set off from the surrounding elements with spaces. If some of the arguments are complicated, there may be a space between them as well.
* Many execution traces are divided into a "delay blob" on the left, separated from a part to the right that does the substantial data manipulation. See next section.
Curly brackets `{}` (not used in Fueue) are used in the traces to represent the integer result of mathematical expressions. This includes negative numbers, as Fueue has only non-negative literals – `-` is the negation function.
Various metavariable names and `...` are used to denote values and abbreviations.
## Delaying tactics
Intuitively, execution cycles around the queue, partially modifying what it passes through. The results of a function cannot be acted on again until the next cycle. Different parts of the program effectively evolve in parallel as long as they don't interact.
As a result, a lot of the code is devoted to synchronization, in particular to delaying execution of parts of the program until the right time. There are a lot of options for golfing this, which tends to turn those parts into unreadable blobs that can only be understood by tracing their execution cycle by cycle.
These tactics won't always be individually mentioned in the below:
* `)[A]` delays `A` for a cycle. (Probably the easiest and most readable method.)
* `~ef` swaps the elements `e` and `f` which also delays their execution. (Probably the least readable, but often shortest for minor delays.)
* `$1e` delays a single element `e`.
* `-` and `%` are useful for delaying numbers (the latter for `0` and `1`.)
* When delaying several equal elements in a row, `:` or `$` can be used to create them from a single one.
* `(n` wraps `n` in brackets, which may later be removed at convenience. This is particularly vital for numeric calculations, since numbers are too unstable to even be copied without first putting them in a block.
## Overall structure
The rest of the explanation is divided into seven parts, each for a section of the running program. The larger cycles after which most of them repeat themselves will be called "iterations" to distinguish them from the "cycles" of single passes through the entire queue.
Here is how the initial program is divided between them:
```
A: )$$4255%%1(~
B: ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:
D: (H-
E:
F:
G: ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
```
The big numeral at the end of the program encodes the rest in reverse, two digits per character, with 30 subtracted from each ASCII value (so e.g. `10` encodes a `(`.)
On a higher level you can think of the data in this program (starting with the bignum) as flowing from right to left, but control flowing from left to right. However, at a lower level Fueue muddles the distinction between code and data all the time.
* Section G decodes the bignum into ASCII digits (e.g. digit `0` as the integer `48`), splitting off the least significant digits first. It produces one digit every 15 cycles.
* Section F contains the produced digit ASCII values (each inside a block) until section E can consume them.
* Section E handles the produced digits two at a time, pairing them up into blocks of the form `[x[y]]`, also printing the encoded character of each pair.
* Section D consists of a deeply nested block gradually constructed from the `[x[y]]` blocks in such a way that once it contains all digits, it can be run to print all of them, then halt the entire program.
* Section C handles the construction of section D, and also recreates section E.
* Section B recreates section C as well as itself every 30 cycles.
* Section A counts down cycles until the last iteration of the other sections. Then it aborts section B and runs section D.
## Section A
Section A handles scheduling the end of the program.
It takes 4258 cycles to reduce to a single swap function `~`, which then makes an adjustment to section B that stops its main loop and starts running section D instead.
```
)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
```
* A `$` function creates 4255 copies of the following `%` while the `(` wraps the `~` in brackets.
* Each cycle the last `%` is used up to toggle the following number between `0` and `1`.
* When all `%`s are used up, the `$1` creates 1 copy of the `[~]` (effectively a NOP), and on the next cycle the `)` removes the brackets.
## Section B
Section B handles regenerating itself as well as a new iteration of section C every 30 cycles.
```
) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] [BkB]
)$ $24% %0 :< [~:)~)] ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1 < < [~:)~)] [BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0 < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
~:) ~)[BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB] ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] (2)
) [BkB] [BkB] $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
```
* A `:` duplicates the big block following (one copy abbreviated as `[BkB]`), then `)` removes the brackets from the first copy.
* `$$24%%0` sets up a countdown similar to the one in section A.
* While this counts down, `:<` turns into `<<`, and a `~` swaps two of the blocks, placing the code for a new section C last.
* The two `<` functions pack the two final blocks into the first one - this is redundant in normal iterations, but will allow the `~` from section A to do its job at the end.
* (1) When the countdown is finished, the `)` removes the outer brackets. Next `~:)` turns into `):` and `~)` swaps a `)` to the beginning of the section C code.
* (2) Section B is now back at its initial cycle, while a `)` is just about to remove the brackets to start running a new iteration of section C.
In the final iteration, the `~` from section A appears at point (1) above:
```
~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] )
```
The `~` swaps the `)` across the block and into section C, preventing section B from being run again.
## Section C
Section C handles merging new digit character pairs into section D's block, and also creating new iterations of section E.
The below shows a typical iteration with `x` and `y` representing the digits' ASCII codes. In the very first iteration, the incoming "D" and "E" elements are the initial `[H]` and `-` instead, as no previous section E has run to produce any digit character pairs.
```
C D E
$11~ ) ~<[[+$4--498+*-:~-10)):])<~] [)))~] < [)))~[...]] [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~] < [)))~] [)))~[...][x[y]]]
~~~ ~~~ ) ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~ ~ ) [)))~[....]] [[+$4--498+*-:~-10)):])<~]
~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
[)))~[....]] ~[+$4--498+*-:~-10)):])<~
```
* This uses a different method of synchronization which I discovered for this answer. When you have several swap functions `~` in a row, the row will shrink to approximately 2/3 each cycle (because one `~` swaps two following), but occasionally with a remainder of `~`s that ~~wreaks havoc on~~ carefully manipulates what follows.
* `$11~` produces such a row. The next `~` swaps a `<` across the following block. Another `<` at the end appends a new digit pair block (digits x and y as ASCII codes) into the section D block.
* Next cycle, the `~` row has a `~~` remainder, which swaps a `~` over the following `)`. The other `<` appends section D to a `[)))~]` block.
* Next the swapped `~` itself swaps the following block with new section E code across the section D block. Then a new leftover `~` swaps a `)` across, and finally the last `~~` in the `~` row swap one of them across to section E just as the `)` has removed its brackets.
In the final iteration, section A's `~` has swapped a `)` across section B and into section C. However, section C is so short-lived that it already has disappeared, and the `)` ends up at the beginning of section D.
## Section D
Section D handles printing the final big numeral and halting the program. During most of the program run, it is an inert block that sections B–G cooperate on building.
```
(H -
[H]-
⋮
[)))~[H-]] After one iteration of section C
⋮
[)))~[)))~[H-][49[49]]]] Second iteration, after E has also run
⋮
) [)))~[...]] [49[48]] Final printing starts as ) is swapped in
))) ~[...][49[48]]
)) )[49[48]] [...]
)) 49 [48][...] Print first 1
) )[48] [...]
) 48 [...] Print 0
)[...] Recurse to inner block
...
⋮
)[H-] Innermost block reached
H - Program halts
```
* In the first cycle of the program, a `(` wraps the halting function `H` in brackets. A `-` follows, it will be used as a dummy element for the first iteration instead of a digit pair.
* The first real digit pair incorporated is `[49[49]]`, corresponding to the final `11` in the numeral.
* The very last digit pair `[49[48]]` (corresponding to the `10` at the beginning of the numeral) is not actually incorporated into the block, but this makes no difference as `)[A[B]]` and `)[A][B]` are equivalent, both turning into `A[B]`.
After the final iteration, the `)` swapped rightwards from section B arrives and the section D block is deblocked. The `)))~` at the beginning of each sub-block makes sure that all parts are executed in the right order. Finally the innermost block contains an `H` halting the program.
## Section E
Section E handles combining pairs of ASCII digits produced by section G, and both prints the corresponding encoded character and sends a block with the combined pair leftwards to sections C and D.
Again the below shows a typical iteration with `x` and `y` representing the digits' ASCII codes.
```
E F
~ [+$4--498+*-:~-10)):] ) < ~ [y] [x]
) [+$4--498+*-:~-10)):] < [x] [y]
+ $4- - 498 +*- :~ -10 ) ) : [x[y]]
+--- -{-498} +*- ~~{-10} ) ) [x[y]] [x[y]]
+-- - 498 +* -{-10} ~ ) x [y] [x[y]]
+- -{-498} + * 10 x )[y] [x[y]]
+ - 498 + {10*x} y [x[y]]
+ {-498} {10*x+y} [x[y]]
{10*x+y-498} [x[y]]
[x[y]]
```
* The incoming digit blocks are swapped, then the y block is appended to the x block, and the whole pair block is copied. One copy will be left until the end for sections C and D.
* The other copy is deblocked again, then a sequence of arithmetic functions are applied to calculate `10*x+y-498`, the ASCII value of the encoded character. `498 = 10*48+48-30`, the `48`s undo the ASCII encoding of `x` and `y` while the `30` shifts the encoding from `00–99` to `30–129`, which includes all printable ASCII.
* The resulting number is then left to execute, which prints its character.
## Section F
Section F consists of inert blocks containing ASCII codes of digits. For most of the program run there will be at most two here, since section E consumes them at the same speed that G produces them with. However, in the final printing phase some redundant `0` digits will collect here.
```
[y] [x] ...
```
## Section G
Section G handles splitting up the big number at the end of the program, least significant digits first, and sending blocks with their ASCII codes leftward to the other sections.
As it has no halting check, it will actually continue producing `0` digits when the number has whittled down to 0, until section D halts the entire program with the `H` function.
`[BkG]` abbreviates a copy of the big starting code block, which is used for self-replication to start new iterations.
Initialization in the first cycles:
```
) :~ : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
) ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [10...11] [BkG]
```
Typical iteration, `N` denotes the number to split:
```
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [N] [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 ) : [N] : [BkG]
) ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] +5 5 ) [N] [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] ~ 10 N [N] [BkG] [BkG]
) ~:~ ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~] / N 10 [N] [BkG] [BkG]
) ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~] ( {N/10} [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~] : [{N/10}] [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 ) ~ ~ [{N/10}] [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 ) ) [{N/10}] ~ [{N/10}] [N] [BkG] [BkG]
) ~ * [):~[$1(+48]):~+] -10 ~ ) {N/10} [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+] * {-10} {N/10} ) [N] [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~ + {-10*(N/10)} N [{N/10}] [BkG] [BkG]
) ~ ~ [$1(+48] ) ~ ~ {N%10} [{N/10}] [BkG] [BkG]
) [$1(+48] ~ ) {N%10} ~ [{N/10}] [BkG] [BkG]
$1( + 48 {N%10} ) [BkG] [{N/10}] [BkG]
( {48+N%10} BkG [{N/10}] [BkG] New iteration starts
[{48+N%10}] ....
```
* The delay blob here is particularly hairy. However, the only new delaying trick is to use `+:5` instead of `--10` to delay a `10` two cycles. Alas only one of the `10`s in the program was helped by this.
* The `[N]` and `[BkG]` blocks are duplicated, then one copy of `N` is divided by `10`.
* `[{N/10}]` is duplicated, then more arithmetic functions are used to calculate the ASCII code of the last digit of `N` as `48+((-10)*(N/10)+N)`. The block with this ASCII code is left for section F.
* The other copy of `[{N/10}]` gets swapped between the `[BkG]` blocks to set up the start of a new iteration.
# Bonus quine (540 bytes)
```
)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63
```
[Try it online!](https://tio.run/##VVBbjsMwCDxLpESCjaoFO2/lAL2D5c/2Bv3l6lnwo/FaIwsPzIB5f16f13Vh33u/8jBwkE6kwy7iEZR1NAwU8IiCIkawM@Ls@3UQITwkjA890zb@PESYEOMZT@mOJJhIgkYoWocCIr9WPm1myBRHTxE1jjFgeMYIzECLwXHCDLwDrQYNFoZds97uHFi9hyUFbrOC24GAt6qtKatJcuZi0kq0hapaiafqNhuZJZrKVkWu3ecbzoFbEunsWSR7USl0ALXNd/5FtmpHUhOu/t9sLrj7pidTbbH@G6aM0X45zWC78rbbEjdrKchDMkwuM9f1Bw "Fueue – Try It Online")
Since I wasn't sure which method would be shortest, I first tried encoding characters as two-digit numbers separated by `(`s. The core code is a bit shorter, but the 50% larger data representation makes up for it. Not as golfed as the other one, as I stopped when I realized it wouldn't beat it. It has one advantage: It doesn't require an implementation with bignum support.
Its overall structure is somewhat similar to the main one. Section G is missing since the data representation fills in section F directly. However, section E must do a similar divmod calculation to reconstruct the digits of the two-digit numbers.
[Answer]
# [Amazon Alexa](https://en.wikipedia.org/wiki/Amazon_Alexa), 31 words
```
Alexa, Simon Says Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says Alexa, Repeat That Alexa, Simon Says, Alexa, Repeat That Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says quiet
```
(each command is on a newline)
When said out loud to a device with the Amazon Alexa digital assistant enabled (I've only tested this on the Echo Dot though), it should say the same words back to you. There will be some different lengths of pauses between words, as you wait for Alexa to reply, and it says everything without breaks, but the sequence of words are the same.
### Explanation:
Each line is a new Alexa command, one of either:
* `Alexa, Simon Says ...`, which will prompt Alexa to say everything afterward the command
* `Alexa, Repeat That`, which repeats the last thing Alexa said
(neither of these appear on most lists of Alexa commands, so I hope someone has actually learned something from this)
We can simplify this to the commands `S` and `R` respectively, separated by spaces. For example, `SR` will represent `Alexa, Simon Says Alexa, Repeat That`. The translation of our program would be:
```
SS R SRSRS R SQ
```
Where `Q` is `quiet` (but can be anything. I chose `quiet` because that's what Alexa produced when I tried to give it `quine`, and it fit, so I kept it). Step by step, we can map each command to the output of each command:
```
Commands: SS
Output: S
Commands: SS R
Output: S S
Commands: SS R SRSRS
Output: S S RSRS
Commands: SS R SRSRS R
Output: S S RSRS RSRS
Commands: SS R SRSRS R SQ
Output: S S RSRS RSRS Q
Total Commands: SSRSRSRSRSQ
Total Output: SSRSRSRSRSQ
```
The general approach for this was to get the output *ahead* of the input commands. This happens on the second to last command, which gets an extra `S` command. First we have to get behind on output though. The first two commands `SS R` only produce `SS`, leaving us to make up the `R`. However, this allows us to start a `S` command with an `R`, which means we can repeat a section (`RSRS`) multiple times, which allows us to get the spare `S` leftover. After that, all we had to do was use it to say whatever we wanted.
[Answer]
## Javascript (36 char)
```
(function a(){alert("("+a+")()")})()
```
This is, AFAICT, the shortest javascript quine posted so far.
[Answer]
# [Labyrinth](https://github.com/mbuettner/labyrinth), ~~124~~ ~~110~~ 53 bytes
*Thanks to Sp3000 for golfing off 9 bytes, which allowed me to golf off another 7.*
```
44660535853919556129637653276602333!
1
:_98
/8 %
@9_.
```
[Try it online!](http://labyrinth.tryitonline.net/#code=NDQ2NjA1MzU4NTM5MTk1NTYxMjk2Mzc2NTMyNzY2MDIzMzMhCjEKOl85OAovOCAlCkA5Xy4&input=)
## Explanation
Labyrinth 101:
* Labyrinth is a stack-based 2D language. The stack is bottomless and filled with zeroes, so popping from an empty stack is not an error.
* Execution starts from the first valid character (here the top left). At each junction, where there are two or more possible paths for the instruction pointer (IP) to take, the top of the stack is checked to determine where to go next. Negative is turn left, zero is go forward and positive is turn right.
* Digits in the source code don't push the corresponding number – instead, they pop the top of the stack and push `n*10 + <digit>`. This allows the easy building up of large numbers. To start a new number, use `_`, which pushes zero.
* `"` are no-ops.
First, I'll explain a slightly simpler version that is a byte longer, but a bit less magical:
```
395852936437949826992796242020587432!
"
:_96
/6 %
@9_.
```
[Try it online!](http://labyrinth.tryitonline.net/#code=Mzk1ODUyOTM2NDM3OTQ5ODI2OTkyNzk2MjQyMDIwNTg3NDMyIQoiCjpfOTYKLzYgJQpAOV8u&input=)
The main idea is to encode the main body of the source in a single number, using some large base. That number can then itself easily be printed back before it's decoded to print the remainder of the source code. The decoding is simply the repeated application of `divmod base`, where print the `mod` and continue working with the `div` until its zero.
By avoiding `{}`, the highest character code we'll need is `_` (95) such that base 96 is sufficient (by keeping the base low, the number at the beginning is shorter). So what we want to encode is this:
```
!
"
:_96
/6 %
@9_.
```
Turning those characters into their code points and treating the result as a base-96 number (with the least-significant digit corresponding to `!` and the most-significant one to `.`, because that's the order in which we'll disassemble the number), we get
```
234785020242697299628949734639258593
```
Now the code starts with a pretty cool trick (if I may say so) that allows us to print back the encoding and keep another copy for decoding with very little overhead: we put the number into the code in reverse. I computed the result [with this CJam script](http://cjam.aditsu.net/#code=qW%2596bsW%25&input=!%0A%22%0A%3A_96%0A%2F6%20%25%0A%409_.) So let's move on to the actual code. Here's the start:
```
395852936437949826992796242020587432!
"
```
The IP starts in the top left corner, going east. While it runs over those digits, it simply builds up that number on top of the stack. The number itself is entirely meaningless, because it's the reverse of what we want. When the IP hits the `!`, that pops this number from the stack and prints it. That's all there is to reproducing the encoding in the output.
But now the IP has hit a dead end. That means it turns around and now moves back west (without executing `!` again). This time, conveniently, the IP reads the number from back to front, so that now the number on top of the stack *does* encode the remainder of the source.
When the IP now hits the top left corner again, this is not a dead end because the IP can take a left turn, so it does and now moves south. The `"` is a no-op, that we need here to separate the number from the code's main loop. Speaking of which:
```
...
"
:_96
/6 %
@9_.
```
As long as the top of the stack is not zero yet, the IP will run through this rather dense code in the following loop:
```
"
>>>v
^< v
^<<
```
Or laid out linearly:
```
:_96%._96/
```
The reason it takes those turns is because of Labyrinth's control flow semantics. When there are at least three neighbours to the current cell, the IP will turn left on a negative stack value, go ahead on a zero and turn right on a positive stack value. If the chosen direction is not possible because there's a wall, the IP will take the opposite direction instead (which is why there are two left turns in the code although the top of the stack is never negative).
The loop code itself is actually pretty straightforward (compressing it this tightly wasn't and is where Sp3000's main contribution is):
```
: # Duplicate the remaining encoding number N.
_96 # Push 96, the base.
%. # Take modulo and print as a character.
_96 # Push 96 again.
/ # Divide N by 96 to move to the next digit.
```
Once `N` hits zero, control flow changes. Now the IP would like to move straight ahead after the `/` (i.e. west), but there's a wall there. So instead if turns around (east), executes the `6` again. That makes the top of the stack positive, so the IP turns right (south) and executes the `9`. The top of the stack is now `69`, but all we care about is that it's positive. The IP takes another right turn (west) and moves onto the `@` which terminates the code.
All in all, pretty simple actually.
Okay, now how do we shave off that additional byte. Clearly, that no-op seems wasteful, but we need that additional row: if the loop was adjacent to the number, the IP would already move there immediately instead of traversing the entire number. So can we do something useful with that no-op.
Well, in principle we can use that to add the last digit onto the encoding. The encoding doesn't really need to be all on the first line... the `!` just ensures that whatever *is* there also gets printed there.
There is a catch though, we can't just do this:
```
95852936437949826992796242020587432!
3
:_96
/6 %
@9_.
```
The problem is that now we've changed the `"` to a `3`, which also changes the actual number we want to have. And sure enough that number doesn't end in `3`. Since the number is completely determined by the code starting from `!` we can't do a lot about that.
*But* maybe we can choose another digit? We don't really care whether there's a `3` in that spot as long as we end up with a number that correctly encodes the source. Well, unfortunately, none of the 10 digits yields an encoding whose least-significant digit matches the chosen one. Luckily, there's some leeway in the remainder of the code such that we can try a few more encodings without increasing the byte count. I've found three options:
1. We can change `@` to `/`. In that case we can use any digit from `1357` and get a matching encoding. However, this would mean that the program then terminates with an error, which is allowed but doesn't seem very clean.
2. Spaces aren't the only "wall" characters. Every unused character is, notably all letters. If we use an upper case letter, then we don't even need to increase the base to accommodate it (since those code points are below `_`). 26 choices gives plenty of possibilities. E.g. for `A` any odd digit works. This is a bit nicer, but it still doesn't seem all that elegant, since you'd never use a letter there in real code.
3. We can use a greater base. As long as we don't increase the base significantly, the number of decimal digits in the encoding will remain the same (specifically, any base up to 104 is fine, although bases beyond 99 would actually require additional characters in the code itself). Luckily, base 98 gives a single matching solution: when we use the digit `1`, the encoding also ends in `1`. This is the only solution among bases 96, 97, 98, 99, so this is indeed very lucky. And that's how we end up with the code at the top of this answer.
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), ~~293~~ ~~262~~ 249 bytes
```
>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\
```
[Try it online!](https://tio.run/##y8kvLvn/387KSNvUSMvKTMtKw8JES9vcVEvTys4KBKIhwCpaA6hA0w4hZBUNUulgp2qvaKOBANEoQEGJK0bZhlaAi0L9MVz////XdQQA "Lost – Try It Online")
## Explanation
This entire project has been an up and down. I kept thinking it was impossible and then coming up with a crazy idea that just might work.
Why is a Lost Quine so hard?
As you may know Lost is a 2D programming language where the start location and direction are entirely random. This makes writing any lost program about as difficult as writing radiation hardened code. You have to consider every possible location and direction.
That being said there are some standard ways to do things. For example here is the standard way of printing a string.
```
>%?"Stringv"(@
^<<<<<<<<<<<<<
```
This has a collection stream at the bottom that grabs the most of the ips and pulls them to the start location. Once they reach are start location (upper left) we sanitize them with a loop getting rid of all the values on the stack then turn the safety of push the string and exit. (safety is a concept unique to Lost every program must hit a `%` before exiting, this prevents the possibility of the program terminating upon start). Now my idea would be to extend this form into a full fledged quine.
The first thing that had to be done was to rework the loop a bit, the existing loop was specific to the String format.
```
>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<
```
We need to add a second stream to avoid the possibility of the `!` jumping over the stream and creating a loop.
Now we want to mix this with the standard Quine format. Since Lost is based very much on Klein I've ~~basically stolen~~ borrowed the Klien Quine for [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender).
```
:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<
```
This quite conveniently prints the first line of the quine. Now all we need to do is hard-code the streams. Well this is easier said than done. I tried approximately four different methods of doing this. I'll just describe the one that worked.
The idea here is to use doors to get the desired number of arrows. A Door is a special type of mirror that changes every time it is hit. `[` reflects ips coming from the left and `]` from the right. When they are hit by an ip from either of these sides the switch orientation. We can make a line of these doors and a static reflector to repeatedly perform an operation.
```
>:[[[
```
Will perform `:` three times. This way if we push a `<` to the stack before hand we can make a lot of them with less bytes. We make 2 of these, one for each line, and in between them we lay down a newline, however the second one needs only go until it covers the `!` we added it for, anything else can be left empty saving us a few bytes. Ok now we need to add the vertical arrows to our streams. This is where the key optimization comes in. Instead of redirecting all the ips to the "start" of the program directly we will instead redirect them to the far left, because we already know that the ips starting in far left *must* work (or at least will work in the final version) we can also just redirect the other ips. This not only makes it cheaper in bytes, I think this optimization is what makes the quine possible.
However there are still some problems, the most important one being ips starting after the `>` has been pushed but before we start making copies of it. Such ips will enter the copier and make a bunch of copies of 0. This is bad because our stack clearing mechanism uses zeros to determine the bottom of the stack, leaving a whole bunch of zeros at the bottom. We need to add a stronger stack sanitation method. Since there is no real way of telling if the stack is empty, we will simply have to attempt to destroy as many items on the stack as possible. Here we will once again use the door method described earlier. We will add `((((((((((([[[[[[[[[[[[[[` to the end of the first line right after the sanitizor to get rid of the zeros.
Now there is one more problem, since we redirected our streams to the upper left ips starting at the `%` and moving down will already have turned the safety off and will exit prematurely. So we need to turn the safety off. We do this by adding a `#` to the stream, that way ips flowing through the stream will be turned off but ips that have already been sanitized will not. The `#` must also be hard coded into the first line as well.
That's it, hopefully you understand how this works now.
] |
Subsets and Splits