[Question]
      [
In some nations there are recommendations or laws on how to form emergency corridors on streets that have multiple lanes per direction. (In the following we only consider the lanes going in the direction we are travelling.) These are the rules that hold in Germany:
* If there is only one lane, everyone should drive to the right such that the rescue vehicles can pass on the left.
* If there are two or more lanes, the cars on the left most lane should drive to the left, and everyone else should move to the right.
### Challenge
Given the number `N>0` of regular lanes, output the layout of the lanes when an emergency corridor is formed using a string of `N+1` ASCII characters. You can use any two characters from ASCII code `33` up to `126`, one to denote the emergency corridor, and one for denoting the cars. Trailing or leading spaces, line breaks etc are allowed.
### Examples
Here we are using `E` for the emergency corridor, and `C` for the cars.
```
N  Output
1  EC
2  CEC
3  CECC
4  CECCC
5  CECCCC
6  CECCCCC
   etc
```

[Answer]
# Python 2, 29 26 bytes
```
lambda n:10**n*97/30-1/n*9
```
Example:
```
>>> f(1)
23
>>> f(2)
323
>>> f(3)
3233
```
[Answer]
# Python 3, ~~35~~ 33 bytes
```
lambda N:'C'*(N>1)+'EC'+'C'*(N-2)
```
Edit: dropping `f=` to save 2 bytes, thanks to [@dylnan](https://codegolf.stackexchange.com/users/75553/dylnan)'s reminder.
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUcHPSt1ZXUvDz85QU1vd1VldG8LVNdL8n5ZfpJCpkJmnUJSYl56qYahjrmnFpVBQlJlXopGpk6aRqan5HwA)
To visualize it:
```
lambda N:'üöò'*(N>1)+'üöîüöò'+'üöò'*(N-2)
```
Output:
```
1 üöîüöò
2 üöòüöîüöò
3 üöòüöîüöòüöò
4 üöòüöîüöòüöòüöò
5 üöòüöîüöòüöòüöòüöò
6 üöòüöîüöòüöòüöòüöòüöò
```
[Try üöî online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUcHPSv3D/Fkz1LU0/OwMNbVBnClgAW24uK6R5v@0/CKFTIXMPIWixLz0VA1DHXNNKy6FgqLMvBKNTJ00jUxNzf8A)
# Python 3, 40 bytes
A straightforward solution:
```
lambda N:str(10**N).replace('100','010')
```
[Try it online!](https://tio.run/##BcExCoAwDADA3VdkayJFUhwEwS/4ApeqrQa0ltjF19e7/JXzSX2N01Ivf6@7h3mEtyg6btuZOg358ltA45iNNezYUI2PgoAkUJ@OgM4ONDaQVVJBsRGFqP4)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 32 bytes
```
f(n){printf(".%.*f"+1%n,n-1,0);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zuqAoM68kTUNJT1VPK01J21A1TydP11DHQNO69j9QRiE3MTNPQ1OhmoszLb9IQQMklKlgq2BoDaRsbBXMgLS2NlieM00jU9MaSMOMjMlTAvFruWr/AwA "C (gcc) ‚Äì Try It Online")
Uses `0` and `.` characters:
```
.0
0.0
0.00
0.000
0.0000
```
[Answer]
# Japt, ~~5~~ 4 bytes
Uses `q` for cars and `+` for the corridor.
```
√ß¬¨i√Ñ
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=56xpxA==&input=OA==)
Credit to Oliver who golfed 4 bytes off at the same time as I did.
---
## Explanation
A short solution but a tricky explanation!
The straightforward stuff first: The `√ß` method, when applied to an integer, repeats its string argument that number of times. The `i` method takes 2 arguments (`s` & `n`) and inserts `s` at index `n` of the string it's applied to.
Expanding the 2 unicode shortcuts used gives us `√ßq i+1`, which, when transpiled to JS becomes `U.√ß("q").i("+",1)`, where `U` is the input. So we're repeating `q` `U` times and then inserting a `+` at index 1.
The final trick is that, thanks to Japt's index wrapping, when `U=1`, `i` will insert the `+` at index `0`, whatever value you feed it for `n`.
[Answer]
# R, 50 bytes
-11 thanks to Giuseppe!
```
pryr::f(cat("if"(x<2,12,c(21,rep(2,x-1))),sep=""))
```
Outputs 1 for emergency corridor and 2 for normal lanes
## My attempt, 61 bytes
Nothing fancy to see here, but let's get R on the scoreboard =)
```
q=pryr::f(`if`(x<2,cat("EC"),cat("CE",rep("C",x-1),sep="")))
```
Usage:
```
q(5)
CECCCC
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~38~~ ~~34~~ 32 bytes
```
f 1="EC"
f n="CE"++("C"<*[2..n])
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P03B0FbJ1VmJK00hz1bJ2VVJW1tDyVnJRivaSE8vL1bzf25iZp5tbmKBb7yCRkFpSXBJkU@eXpqmQrShnp5Z7H8A "Haskell ‚Äì Try It Online")
[Answer]
# Python 2, ~~30~~ ~~29~~ 28 bytes
```
lambda n:`10/3.`[1/n:n-~1/n]
```
Print `3` instead of `C` and `.` instead of `E`.
**Explanation:**
[Try it online.](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKsHQQN9YLyHaUD/PKk@3DkjF/k/LL1LIVMjMUyhKzEtP1TDUUTA00LTiUlAoKMrMK1HI1EnTyNT8DwA)
```
lambda n:    # Method with integer parameter and string return-type
  `10/3.`    #  Calculate 10/3 as decimal (3.333333333) and convert it to a string
  [1/n       #   Take the substring from index 1 if `n=1`, 0 otherwise
   ,n-~      #   to index `n+1` +
       1/n]  #    1 if `n=1`, 0 otherwise
```
---
# Python 2, ~~33~~ ~~32~~ ~~31~~ ~~29~~ 28 bytes
```
lambda n:1%n-1or'1-'+'1'*~-n
```
Prints `1` instead of `C` and `-` instead of `E`.
-2 bytes thanks to *@ovs*.
-1 byte thanks to *@xnor*.
**Explanation:**
[Try it online.](https://tio.run/##BcExDoAgDADA3Vd0MQWFxDqS@BMXjKJNtJCGxcWv411565VlbmlZ2x2fbY8ggXrxlBXJ44iEw@elpazAwAIa5TwMOaDJhg6gKEsFdsmwbT8)
```
lambda n:    # Method with integer parameter and string return-type
  1%n-1      #  If `n` is 1: Return '-1'
  or         #  Else:
    '1-'+    #   Return '1-', appended with:
    '1'*~-n  #   `n-1` amount of '1's
```
[Answer]
# Pyth, ~~10~~ ~~9~~ 8 bytes
```
Xn1Q*NQZ
```
Uses `0` to denote the emergency corridor and `"`.
[Try it here](http://pyth.herokuapp.com/?code=Xn1Q%2aNQZ&input=5&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5&debug=0)
### Explanation
```
Xn1Q*NQZ
    *NQ     Make a string of <input> "s.
 n1Q         At index 0 or 1...
X      Z    ... Insert 0.
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 42 bytes
```
,[[>]+[<]>-]>>[<]<[<]>+>+<[<-[--->+<]>.,>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fJzraLlY72ibWTjfWzg5I24DY2nbaQFo3WldXF8iKtdPTsYv9/x8A "brainfuck ‚Äì Try It Online")
Takes input as char code and outputs as `V` being normal lanes and `W` being the cleared lane. (To test easily, I recommend replacing the `,` with a number of `+`s)
### How it Works:
```
,[[>]+[<]>-] Turn input into a unary sequence of 1s on the tape
>>[<]<[<]    Move two cells left of the tape if input is larger than 1
             Otherwise move only one space
>+>+<        Add one to the two cells right of the pointer
             This transforms:
               N=1:  0 0' 1 0  -> 0 2' 1 0
               N>1:  0' 0 1 1* -> 0 1' 2 1*
[<-[--->+<]>.,>]  Add 86 to each cell to transform to Ws and Vs and print
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
√é>‚àç1I‚â†«ù
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cJ/do45eQ89HnQuOz/3/3xgA "05AB1E ‚Äì Try It Online")
0 is C and 1 is E.
**Explanation**
```
√é>          # Push 0 and input incremented            -- [0, 4]
  ‚àç         # Extend a to length b                    -- [0000]
   1I‚â†      # Push 1 and input falsified (input != 1) -- [0000, 1, 1]
      «ù     # Insert b in a at location C             -- [0100]
            # Implicit display
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/) (MATLAB\*), ~~31 30 28 27~~ 22 bytes
```
@(n)'CE'(1+(n>1==0:n))
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999BI09T3dlVXcNQWyPPztDW1sAqT1Pzv6pjTklqUV5iSapCWn6RQnFibqpCUiWQl5xfmldipQDSFq2urmBigaQtlosrTcNQU0HV1RnIMAIynMEsYwgLxDSBMkFsUxgbxDGDc5z/AwA "Octave ‚Äì Try It Online")
The program works as follows:
```
@(n)                   %Anonymous function to take input
            n>1==0:n   %Creates [1 0] if n is 1, or [0 1 (0 ...)] otherwise
         1+(        )  %Converts array of 0's and 1's to 1-indexed
    'CE'(            ) %Converts to ASCII by addressing in string
```
The trick used here is XNORing the seed array of `0:n` with a check if the input is greater than 1. The result is that for `n>1` the seed gets converted to a logical array of `[0 1 (0 ...)]` while for `n==1` the seed becomes inverted to `[1 0]`, achieving the necessary inversion.
The rest is just converting the seed into a string with sufficient appended cars.
---
(\*) The TIO link includes in the footer comments an alternate solution for the same number of bytes that works in MATLAB as well as Octave, but it results in a sequence of '0' and '1' rather than 'E' and 'C'. For completeness, the alternate is:
```
@(n)['' 48+(n>1==0:n)]
```
---
* Saved 1 byte by using `n==1~=0:1` rather than `0:1~=(n<2)`. `~=` has precedence over `<`, hence the original brackets, but is seems that `~=` and `==` are handled in order of appearance so by comparing with 1 we can save a byte.
* Saved 2 bytes by changing where the negation of `2:n` is performed. This saves a pair of brackets. We also have to change the `~=` to `==` to account for the fact that it will be negated later.
* Saved 1 byte using `<` again. Turns out that `<` has same precedence as `==` after all. Placing the `<` calculation before the `==` ensures correct order of execution.
* Saved 5 bytes by not creating two separate arrays. Instead relying on the fact that the XNOR comparison will convert a single range into logicals anyway.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~11~~ 9 bytes
```
‚Äô0·∫ã‚Åæ0E;·πô·ªä
```
[Try it online!](https://tio.run/##AR8A4P9qZWxsef//4oCZMOG6i@KBvjBFO@G5meG7iv///zEw "Jelly ‚Äì Try It Online")
Full program.
Uses `0` instead of `C`.
[Answer]
# C (gcc), 39 bytes
```
f(n){printf("70%o"+!n,7|(1<<3*--n)-1);}
```
[Try it online!](https://tio.run/##NYzBDsIgEETvfMWKMWFFjMQDB9Av8WKo6CZ2MbWeKt@OtImnmbx5mWjuMdY1cXx@uhuE99hR3j/ONSnG6TUQj0lJd9hkqVe8c19lQzhujWE0Fn2pTYD@SqxQTAIg5QHUzAhOYH2LAK6F1tjW2WiOIvRL@/9fWC6kiFJ/ "C (gcc) ‚Äì Try It Online")
Borrowed and adapted the printf trick from [ErikF's answer](https://codegolf.stackexchange.com/a/161306/20779).
[Answer]
# Python 3, 32 bytes
```
lambda n:f"{'CE'[n<2:]:C<{n+1}}"
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPKk2pWt3ZVT06z8bIKtbK2aY6T9uwtrhW6X9afpFCnkJmnkJRYl56qoahjpmmFZcCEBQUZeaVaOTpKKRp5Glq/gcA "Python 3 ‚Äì Try It Online")
Uses an f-string expression to format either`'E'`or`'CE'` padded on the right with`'C'`so it has width of`n+1`.
```
f"{          :       }    a Python 3 f-string expression.
   'CE'[n<2:]             string slice based on value of n.
             :            what to format is before the ':' the format is after.
              C           padding character
               <          left align
                {n+1}     minimum field width based on n
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~100~~ 66 bytes
```
{({}[()]<((((()()()()){}){}){}())>)}{}(({}<>)())<>{<>{({}<>)<>}}<>
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/v1qjujZaQzPWRgMENCFQs7oWgoBMO81aIA1UZWMHkrGxqwYiCNfGrhZI/f9v@F/XEQA "Brain-Flak ‚Äì Try It Online")
Uses `"` as the emergency lane and `!` as the normal lanes.
[Answer]
# C#, 34 bytes
```
n=>n++<2?"EC":"CE".PadRight(n,'C')
```
[Try it online!](https://tio.run/##LY09C8IwFADn5lc8upgQLepoWx2KTgpFBwdxCOmHD9oXyIuCSH97Leh0yx1neWHZjrYzzFB613rTw0dEHExACy@HFZwMkuTgkdrbHYxvWU2KuLw51H1yeJLNkMIcfsoWGshHyrekdbbexfsi3sTFPk5KU52xfQRJ81kxU@koROM8yKkFhBxW6YQMVsuJWisR/QeFI3ZdnVw9hvqIVMtGolKpENEghvEL)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~21 17~~ 16 bytes
```
(-‚â†‚àò1)‚åΩ'E',‚ç¥‚àò'C'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P9UnMS@1@FHbBA3dR50LHnXMMNR81LNX3VVd51HvFiBX3Vn9//9HbRMh6g6teNS72cgAAA)
Thanks to Erik for saving 4 bytes and Ad√°m for one further byte.
### How?
```
(-‚â†‚àò1)‚åΩ'E',‚ç¥‚àò'C' ‚çù Tacit function
           ‚ç¥‚àò'C' ‚çù Repeat 'C', according to the input
       'E',      ‚çù Then append to 'E'
      ‚åΩ          ‚çù And rotate
    1)           ‚çù 1
  ‚â†‚àò             ‚çù Different from the input? Returns 1 or 0
(-               ‚çù And negate. This rotates 0 times if the input is 1, and once if not.
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~35~~ ~~33~~ 32 bytes
*2 bytes saved thanks to Angs, 1 byte saved thanks to Lynn*
```
(!!)$"":"EC":iterate(++"C")"CEC"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P91WQ1FRU0VJyUrJ1VnJKrMktSixJFVDW1vJWUlTyRko9j83MTPPtqAoM69EJV3B5D8A "Haskell ‚Äì Try It Online")
# [Haskell](https://www.haskell.org/), ~~32~~ ~~30~~ 29 bytes
*This is zero indexed so it doesn't comply with the challenge*
```
g=(!!)$"EC":iterate(++"C")"CEC"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P91WQ1FRU0XJ1VnJKrMktSixJFVDW1vJWUlTyRko9j83MTPPtqAoM69EJV3B@D8A "Haskell ‚Äì Try It Online")
# [Haskell](https://www.haskell.org/), 30 bytes
*This doesn't work because output needs to be a string*
```
f 1=21
f 2=121
f n=10*f(n-1)+1
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P03B0NbIkCtNwcjWEEzn2RoaaKVp5Okaamob/s9NzMyzLSjKzCtRSVMw@Q8A "Haskell ‚Äì Try It Online")
Here we use numbers instead of strings, `2` for the emergency corridor, `1` for the cars. We can add a `1` to the end by multiplying by 10 and adding `1`. This is cheaper because we don't have to pay for all the bytes for concatenation and string literals.
It would be cheaper to use `0` instead of `1` but we need leading zeros, which end up getting trimmed off.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~30~~ 29 bytes
```
lambda n:"CEC"[~n:]+"C"*(n-2)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPSsnZ1Vkpui7PKlZbyVlJSyNP10jzf1p@kUKmQmaeQlFiXnqqhqGOuaaVQkFRZl6JRqZOmkampuZ/AA "Python 3 ‚Äì Try It Online")
OK, there is a lot of Python answers already, but I think this is the first sub-30 byter among those still using "E" and "C" chars rather than numbers.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 28 bytes
```
n=>n<2?21:"12".padEnd(n+1,1)
```
[Try it online!](https://tio.run/##bck5CoAwEADA3mekSvCAXY9CjFY@JBgVRTai4vcjggcS25lR7WptlmHeQjK6tZ20JEsqsELIGSCLZqVr0px8CEDYxtBqpjaaTM87DkJKhsCE93U8HX4ivsKd5B630qfcy9470x4 "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 [bytes](https://github.com/abrudz/SBCS)
```
‚â°‚àò1‚åΩ'CE',1‚Üì‚ç¥‚àò'C'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HnwkcdMwwf9exVd3ZV1zF81Db5Ue8WoJC6szpQtneugm9iZp5CWmlecklmfp6CRnFpUm5mcTGQrcnFlabwqG2CAj4zuLhAZoSkFpekFsFN4eIqAQpA9PZO1VG3UlDXSUOoVEhOLE4thioyhFBGEMoYQplAKFMIZQahzCGUBYSyhGo3AAA "APL (Dyalog Unicode) ‚Äì Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
√º‚ô£√†j#F
```
[Run and debug it](https://staxlang.xyz/#p=8105856a234620&i=1%0A2%0A3%0A20&a=1&m=2)
This uses the characters "0" and "1". This works because when you rotate an array of size 1, it doesn't change.
Unpacked, ungolfed, and commented, it looks like this.
```
1]( left justify [1] with zeroes. e.g. [1, 0, 0, 0]
|)  rotate array right one place
0+  append a zero
$   convert to string
```
[Run this one](https://staxlang.xyz/#c=1]%28%09left+justify+[1]+with+zeroes.+e.g.+[1,+0,+0,+0]%0A%7C%29%09rotate+array+right+one+place%0A0%2B%09append+a+zero%0A%24%09convert+to+string&i=1%0A2%0A3%0A20&m=2)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 19 bytes
```
n=>--n?"0"+10**n:10
```
[Try it online!](https://tio.run/##DcVBCoAgEADAc71i8aSJoZcOlfUWqQxDdkPD75tzmccVl48U3k8hnVf1tqLdlMKdaSaNHgacja6eEvDiEgSwYJbWamFqSyn67iDMFK8x0s09D0Is9Qc "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~27~~ ~~20~~ 19 bytes
```
$_=1x$_;s/1?\K1/E1/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3tawQiXeuljf0D7G21Df1VD//3/jf/kFJZn5ecX/dQsA "Perl 5 ‚Äì Try It Online")
Saved a byte by using `1` for the cars and `E` for the emergency corridor.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
‚Åµ*·πæ·πô·ªä·πô
```
Displays car lanes as **0**, the emergency lane as **1**.
[Try it online!](https://tio.run/##y0rNyan8//9R41athzv3Pdw58@HuLiD53@xw@6OmNZH/AQ "Jelly ‚Äì Try It Online")
### How it works
```
‚Åµ*·πæ·πô·ªä·πô  Main link. Argument: n
‚Åµ*      Compute 10**n.
  ·πæ     Uneval; get a string representation.
   ·πô·ªä   Rotate the string (n‚â§1) characters to the left.
     ·πô  Rotate the result n characters to the left.
```
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), ~~141~~ ~~104~~ 103 bytes
```
[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  S N
_Push_2][T  S S T   _Subtract][S N
S _Duplicate_input-2][N
T   T   N
_If_negative_Jump_to_Label_-1][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][S S T    T   N
_Push_-1][T N
S T _Print_as_integer][T    S S T   _Subtract][N
S S T   N
_Create_Label_LOOP][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_EXIT][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][T    S S T   _Subtract][N
S N
T   N
_Jump_to_LOOP][N
S S N
_Create_Label_-1][T N
S T _Print_as_integer][N
S S S N
_Create_Label_EXIT]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.
`[..._some_action]` added as explanation only.
Prints `1` instead of `C` and `-` instead of `E`.
-1 byte thanks to *@JoKing* by suggesting the use of `1` and `-1` instead of `0` and `1`.
### Explanation in pseudo-code:
```
Integer i = STDIN-input as integer - 2
If i is negative (-1):
  Print i (so print "-1")
Else:
  Print "1-1"
  Start LOOP:
    If i is negative:
      EXIT program
    Print "1"
    i = i-1
    Go to the next iteration of the LOOP
```
### Example runs:
**Input: `1`**
```
Command   Explanation                 Stack      Heap    STDIN   STDOUT   STDERR
SSSN      Push 0                      [0]
SNS       Duplicate top (0)           [0,0]
TNTT      Read STDIN as integer       [0]        {0:1}   1
TTT       Retrieve heap at 0          [1]        {0:1}
SSSTSN    Push 2                      [1,2]      {0:1}
TSST      Subtract top two            [-1]       {0:1}
SNS       Duplicate input-2           [-1,-1]    {0:1}
NTSN      If neg.: Jump to Label_-1   [-1]       {0:1}
NSSN      Create Label_-1             [-1]       {0:1}
TNST      Print top as integer        []         {0:1}           -1
NSSSN     Create Label_EXIT           []         {0:1}
                                                                         error
```
[Try it online](https://tio.run/##VYrLCcAwDEPP0hRaoSOVEkhvgRQ6vivbp9rgz9N75/2Mvc5rREiiG0SWP4io6Q0m6FxJrflAwQ4s6Wd1aM@07EwZcXw) (with raw spaces, tabs and new-lines only).
Stops with error: Exit not defined.
**Input: `4`**
```
Command   Explanation                   Stack      Heap    STDIN   STDOUT   STDERR
SSSN      Push 0                        [0]
SNS       Duplicate top (0)             [0,0]
TNTT      Read STDIN as integer         [0]        {0:4}   4
TTT       Retrieve heap at 0            [4]        {0:4}
SSSTSN    Push 2                        [4,2]      {0:4}
TSST      Subtract top two              [2]        {0:4}
SNS       Duplicate input-2             [2,2]      {0:4}
NTSN      If neg.: Jump to Label_-1     [2]        {0:4}
SSSTN     Push 1                        [2,1]      {0:4}
SNS       Duplicate top (1)             [2,1,1]    {0:4}
TNST      Print as integer              [2,1]      {0:4}           1
SSTTN     Push -1                       [2,1,-1]   {0:4}
TNST      Print as integer              [2,1]      {0:4}           -1
TSST      Subtract top two              [1]        {0:4}
NSSTN     Create Label_LOOP             [1]        {0:4}
 SNS      Duplicate top (1)             [1,1]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [1]        {0:4}
 SSSTN    Push 1                        [1,1]      {0:4}
 SNS      Duplicate top (1)             [1,1,1]    {0:4}
 TNST     Print as integer              [1,1]      {0:4}           1
 TSST     Subtract top two              [0]        {0:4}
 NSNTN    Jump to Label_LOOP            [0]        {0:4}
 SNS      Duplicate top (0)             [0,0]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [0]        {0:4}
 SSSTN    Push 1                        [0,1]      {0:4}
 SNS      Duplicate top (1)             [0,1,1]    {0:4}
 TNST     Print as integer              [0,1]      {0:4}           1
 TSST     Subtract top two              [-1]       {0:4}
 NSNTN    Jump to Label_LOOP            [-1]       {0:4}
 SNS      Duplicate top (-1)            [-1,-1]    {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [-1]       {0:4}
NSSSN     Create Label_EXIT             [-1]       {0:4}
                                                                            error
```
[Try it online](https://tio.run/##VYrLCcAwDEPP0hQaoguVEkhvgRQ6vivbp9rgz9N75/2Mvc5rREiiG0SWP4io6Q0m6FxJrflAwQ4s6Wd1aM@07EwZcXw) (with raw spaces, tabs and new-lines only).
Stops with error: Exit not defined.
[Answer]
# [AutoHotkey](https://autohotkey.com/docs/AutoHotkey.htm) 32 bytes
Replaces the letter "C" with "EC" unless amount of C > 1, then it sends "CEC" and exits the app.
```
::C::EC
:*:CC::CEC^c
^c::ExitApp
```
C => EC
CC => CEC then exits the program. Any further Cs will be entered after the program exits.
[Answer]
# APL+WIN, ~~20~~ 16 bytes
4 bytes saved thanks to Ad√°m
Prompts for integer n:
```
(-2‚â†‚ç¥n)‚åΩn‚Üê1‚éï/‚çï10
```
1 for emergency corridor o for cars.
[Answer]
# [J](http://jsoftware.com/), 11 bytes
```
1":1&<=i.,]
```
[Try it online!](https://tio.run/##y/r/P81WT8FQycpQzcY2U08n9n9qcka@QpqanYKhdqaeoel/AA "J ‚Äì Try It Online")
Based on ngn‚Äôs [comment](https://codegolf.stackexchange.com/questions/161281/make-an-emergency-corridor/161294#comment391068_161294).
üöò and üöî:
[`1&<,~/@A.'üöî',~'üöò'$~,&4`](https://tio.run/##y/r/P81WT8FQzUanTt/BUU/9w/xZU9R16kD0DHWVOh01k/@pyRn5CmlqdgqG2pl6hob/AQ "J ‚Äì Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/create_explanation.py), ~~7~~ 6 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
√∫‚ñë\‚î¥‚ïú‚ï™
```
[Try it online.](https://tio.run/##AS8A0P9tYXRoZ29sZv9xIiDihpIgInH/w7rilpFc4pS04pWc4pWq//8xCjIKMwo0CjUKOQ)
Output `1` for `E` and `0` for `C`.
**Explanation:**
```
√∫         # 10 to the power of the (implicit) input
          #  i.e. 1 ‚Üí 10
          #  i.e. 4 ‚Üí 10000
 ‚ñë        # Convert it to a string
          #  i.e. 10 ‚Üí "10"
          #  i.e. 10000 ‚Üí "10000"
  \       # Swap so the (implicit) input is at the top of the stack again
   ‚î¥‚ïú     # If the input is NOT 1:
     ‚ï™    #  Rotate the string once towards the right
          #   i.e. "10000" and 4 ‚Üí "01000"
          # Output everything on the stack (which only contains the string) implicitly
```
]


[Question]
      [
Different systems have different ways to describe colors, even if all of them are speaking in R-G-B-A space. A front-end developer who is familiar with CSS may prefer `#RRGGBBAA`. But Android developers may prefer `#AARRGGBB`. When handling AAS file format, `#AABBGGRR` is needed. That's too confusing. Maybe we need a program which can convert between different color formats.
**Input:**
The input contains 3 parts:
* The color to be transformed (e.g. `#1459AC0F`), a string starting with sharp sign `#` followed by 8 hex digits.
* The format of the given color (e.g. `#RRGGBBAA`), a string starting with `#` followed by 8 letters which fall into 4 different groups and each group is one of `RR`/`GG`/`BB`/`AA`.
* The format to convert to.
**Output:**
* Output the color in converted format
**Test Cases:**
```
Color, OriginalFormat, TargetFormat -> Result
#12345678, #RRGGBBAA, #AARRGGBB -> #78123456
#1A2B3C4D, #RRGGBBAA, #AABBGGRR -> #4D3C2B1A
#DEADBEEF, #AARRGGBB, #GGBBAARR -> #BEEFDEAD
```
Input / output are case insensitive. You may input / output in any acceptable way.
**Rules:**
This is code golf, shortest (in byte) codes of each language win

[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 6 [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")
Full program. Prompts on STDIN for Original, then Target, then Color. Prints Result to STDOUT.
```
⍞[⍞⍋⍞]
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97f@j3nnRQPyotxtIxoLE/iuAQRqXclCQu7uTk6Mjl7KjI4TNpWxoZGxiamZuwYVVlZOTu3tQEFCVo5GTsbOJC0IVRA1IDmGWi6uji5OrqxsA "APL (Dyalog Unicode) – Try It Online")
  `⍞` prompt for Original
 `⍞⍋` prompt for Target and find the indices into Original that would make Original into Target
`⍞[`…`]` prompt for Color and use the above obtained indices to reorder Color
[Answer]
# JavaScript (ES6), ~~53~~ 52 bytes
*Saved 1 byte thanks to @tsh*
Takes input as 3 distinct parameters: `(Color, From, To)`.
```
(C,F,T)=>T.replace(/\w/g,(x,i)=>C[F.search(x)-~i%2])
```
[Try it online!](https://tio.run/##bc1PC4IwGMfxe69CkHCD6fBP6cVgc7r78FYdxKYZ4kSjPPXWLZOIsOP34cfnuWS3rM@7qr2ajTrJsQhHEKEEpTDcpVYn2zrLJcCHOy4RGFD1Okf7xOpl1uVnMEDzUa2dIxxz1fSqllatSlAAQ7cd19ts/cBAmqELwTmlhLyDkDkNCDWMNd0P5u1qQRCHupHH/hGUci7Eh/CYGznUJguCxYTROE5@H08xa19iWk3r8Qk "JavaScript (Node.js) – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ç▼☺↔kàÅJ
```
[Run and debug it](https://staxlang.xyz/#p=871f011d6b858f4a&i=%22%2312345678%22+%22%23RRGGBBAA%22+%22%23AARRGGBB%22%0A%22%231A2B3C4D%22+%22%23RRGGBBAA%22+%22%23AABBGGRR%22%0A%22%23DEADBEEF%22+%22%23AARRGGBB%22+%22%23GGBBAARR%22&a=1&m=2)
This program takes input in this format.
```
"{Color}" "{OriginalFormat}" "{TargetFormat}"
```
Here's the commented ungolfed unpacked version of the same program.
```
u       drop duplicated characters from target format
{       for each character remaining in target format, map using block...
  [     duplicate original format at second position in stack
  |I    get all indices of target character in original format
  xs@   retrieve characters from those indices from the color string
m       perform map
        output implicitly when complete
```
[Run this one](https://staxlang.xyz/#c=u++++%09drop+duplicated+characters+from+target+format%0A%7B++++%09for+each+character+remaining+in+target+format,+map+using+block...%0A++[++%09duplicate+original+format+at+second+position+in+stack%0A++%7CI+%09get+all+indices+of+target+character+in+original+format%0A++xs%40%09retrieve+characters+from+those+indices+from+the+color+string%0Am++++%09perform+map%0A+++++%09output+implicitly+when+complete&i=%22%2312345678%22+%22%23RRGGBBAA%22+%22%23AARRGGBB%22%0A%22%231A2B3C4D%22+%22%23RRGGBBAA%22+%22%23AABBGGRR%22%0A%22%23DEADBEEF%22+%22%23AARRGGBB%22+%22%23GGBBAARR%22&a=1&m=2)
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
```
lambda c,o,t:'#'+''.join(c[o.find(v):][:2]for v in t[1::2])
```
[Try it online!](https://tio.run/##bY1BC4IwAEbv/YqBhymJ4LSUQYfN2e67mgdTRovaRIbQr1@tXQw6Pnjv@@aXvRmNnDxd3GN4XqcBjKlJLYYR3EOY3Y3S8diZTCo9xWuC@w6jXpoFrEBpYLscfzhx86K0BTKGUY6K8nCsapgCGAnBOaWEfIGQgDABUVUHb7cJCaJFU7J/IaWcC@HDkhUNojnZhKwljLbt@ffEQ9gIoTe86d4 "Python 2 – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 33 bytes
```
(.)(?<=(..).{7}\1\1.*)\1
$2
.*#
#
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wX0NPU8PexlZDT09Tr9q8NsYwxlBPSzPGkEvFiEtPS5lL@f9/ZUMjYxNTM3ML5aAgd3cnJ0dHZUdHCJNL2dDRyMnY2cQFWc7Jyd09KIhL2cXV0cXJ1dUNrlwZoiQoCAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
(.)(?<=(..).{7}\1\1.*)\1
$2
```
For each pair of identical characters, look back for another copy of that pair, and then the 9th and 8th characters before that, and replace the pair with those characters. This is only possible for the pairs of characters in the target format, and replaces them with the desired result.
```
.*#
#
```
Delete the colour and source format.
[Answer]
# [Haskell](https://www.haskell.org/), ~~108 104 100 94~~ 87 bytes
```
(s,(r@(x,y):z))!c|x==c=(s++[y],z)|(p,q)<-(s,z)!c=(p,r:q)
c%i=fst.(foldl(!)("",zip i c))
```
[Try it online!](https://tio.run/##bc3baoNAEAbge59iHBvYJbYQtU0IXehutF6kNGAvSyHBA0qtGteASt7drghS2s7dHP5v0pP8jPN8GIg0Sf1EWrOj255SPby2jIWMyOXyvfswe3ollXmmj7fqsFdrptp6e6ZauMhYIps7kpR5lBOdEkSzzyrIIKR0aOEo0/KSRyI@QgcMqkvz1tQvBdxAlkALjKlxk8YF4GGPEOcyBnwtGzjsddS0r1NWqFRUaqCKoLGybOf@Yb3BBRpB4PtCcI4U0OB8avHnRzTWmymBM8AtYe8c9x9ACN8Pgl@A49o7S6z4DLged4XnPY/A/HQEJusPMN6OGRy@AQ "Haskell – Try It Online")
---
### Old version
Thanks to Laikoni for shortening 6 bytes by finding a shorter way to use `lookup`!
```
f(Just x)=x
p('#':z)=p z
p(x:y:z)=[x,y]:p z
p e=[]
c!i=('#':).(f.(`lookup`zip(p i)(p c))=<<).p
```
[Try it online!](https://tio.run/##bY1Ba4NAFITv/oqXZyG7UISobYJkD7vRCk1pwB5DwJCsKLG6VIXVP281gpS27/Bghplv0nN1k3ne9wl5baoaNGXaUGRpLr2OMgXdILTXjuKoH9uTd7dAsuPJuCwydk9SiyQWifOyvDUq7jJFFGR0eBdK2XZLLdVriKu0bPKrkDG0wEA19Uf99VbAA2QJaGBssOtUFoCHPYLMKwn4XtZw2C/QMD7PWTG0rqUBwxE0V7bjPj2vN7hAM4rCUAjOkQKanE8Sfy6iud5MDZwB3BbOzvX/AQgRhlH0C@D6zs4WKz4D/ID7IgheRsA8OgIm1h/AmB072H8D "Haskell – Try It Online")
### Explanation:
* the `p` function "parses" a string by ignoring the leading `#` and returning groups (lists) of 2 chars.
* the `(!)` operator takes as input the color and the input format and returns a function that takes as a parameter the output format and returns the converted color. It turned out that the pointfree version was shorter, but I started with the more readable version:
`f c i o='#':concat[x#zip(p<$>[i,c])|x<-p o]`
[Try it online!](https://tio.run/##bY1Pa4NAFMTvforn20J2IQT80yaIe9iN1kNKA/YYAgnJFqVWpRqySr671QhS2r7DgxlmfpMcqw@VZV2nCaXNvGXeld005w1vb5Zvc02uRklnZOa1jJfQ9kJ7zSB2et7svbsFiu/2xslM@T3JFpSSNi1pCSnr34kx7vtsUXYaDlVSXLKzVAdogEN5qd/qr5ccHiB9Bw2c93adqBxwu0FQWaUAX4sathsTDePzmOZ961wY0B9FYtmO@/i0XKGJJI6jSEohkAESIUaJPxeRLFdjAyeAsKWzdoN/AFJGURz/AriBs7alJSZAEIpAhuHzAJhGB8DI@gMYskMHu28 "Haskell – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~33~~ ~~32~~ 27 bytes
Give input in the order: target, original, number
```
#!/usr/bin/perl -p
s%.%$2x/(..)+$&(.){10}/g%eg
```
[Try it online!](https://tio.run/##K0gtyjH9/79YVU9VxahCX0NPT1NbRU1DT7Pa0KBWP101Nf3/f2VHx6Agd3cnJwVlCO3oqKBsaGRsYmpmbvEvv6AkMz@v@L9uAQA "Perl 5 – Try It Online")
For each character in the input find the same character an even number of places forward then from there go 10 more characters forward and take that character as replacement. If you can't do these steps replace by nothing.
```
    +--even-+----10---+
    |       |         |
#AARRGGBB #RRGGBBAA #12345678
    |    >-will get removed-<
    v
    2
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
2FI2ô™J}I‡
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fyM3T6PCWRy2LvGo9HzUs/P/f0TEoyN3dyYkLQjk6chkaGZuYmplbAAA "05AB1E – Try It Online")
---
```
2F     }   # Loop twice...
  I        # First 2 inputs.
   2ô™     # Title case in pairs of 2.
      J    # Rejoin together.
        I  # Last input (The color).
         ‡ # Transliterate, put color in pattern from a into pattern from b.
```
This works because I change the input from:
```
AARRGGBB
```
To:
```
AaRrGgBb
```
So each value is mapped uniquely, then I can use transliterate.
The arguments are reversed.
[Answer]
# Java 10, ~~179~~ ~~105~~ 102 bytes
```
(a,b,c)->{var r="#";for(int i=1,t;i<9;)r+=a.substring(t=b.indexOf(c.substring(i,i+=2)),t+2);return r;}
```
Whopping -77 bytes thanks to *@OlivierGrégoire*.
**Explanation:**
[Try it online.](https://tio.run/##hY9fa4MwFMXf@yku@pJgKtR2/8gc6HQ@rQP3OPYQo450NpYYZaP42V2qbmwwNkjgnJvwO/fsWMeWu/x14BVrGrhnQh4XAELqQpWMF7A9WYBHrYR8AY5mwcgssk/BMTU/e3PNaTTTgsMWJPgwIEYywvHy5tgxBcq3bIuWtUImBYS/IpqK6yuKleMzt2mzZgQi7WeukHnx9lAi/m0uiHB8D2OiHQ9TVehWSVC0H@iUfWizymTPK3S1yGFvas2bPz0zPFd6b3Sxd@tWuwfzoiuJpMuRZa@89ebs/OLSImDZaZokYRgEowmCyVp4LPsXI/DC9e0m@o0RhkmSpv8zojiIwji@@xl9MhPui9Ev@uED)
```
(a,b,c)->{            // Method with String as three parameters and return-type
  var r="#";          //  Result-String, starting at "#"
  for(int i=1,t;i<9;  //  Loop `i` from 1 to 9 (exclusive)
    r+=               //   Append the result with:
       a.substring(   //    A substring from the first input,
        t=b.indexOf(  //    where an index is determined in the second input
           c.substring(i,i+=2)),t+2);
                      //    based on a substring of the third input
    return r;}        //  Return the result-String
```
[Answer]
# [J](http://jsoftware.com/), 5 bytes
```
/:i./
```
The left argument is the color. The right argument is a character matrix where the first row is the target format and the second row is the original format. [Try it online!](https://tio.run/##y/r/P81WT0HfKlNP/z9XanJGvoK6sqGRsYmpmbmFukIakOfoGBTk7u7kpK5jpa4MYTo6qsPUurg6uji5urpB1EIkg4LAauEa4eY6GjkZO5u4wMx1cnJ3h6qFm/sfAA "J – Try It Online")
[Answer]
# CJam, 14 bytes
```
{'#\1f>2f/~er}
```
[Try it Online!](http://cjam.aditsu.net/#code=%5Blll%5D%7B'%23%5C1f%3E2f%2F~er%7D~&input=%23AARRGGBB%0A%23RRGGBBAA%0A%2312345678%0A)
Input is an array in the reverse order.
```
{
 `#\      e# Push '#'+[input array] on to stack
  1f>     e# Remove the '#' symbol from each input string
  2f/     e# Split each input string into an array of substrings of length 2.
  ~       e# Dump the substring-arrays from the container array onto the stack
  er      e# Perform a string replace operation
}
```
[Answer]
# Python 2, 62 bytes
```
lambda c,s,e:[c[s.index(e[i]):][:2]for i in range(1,len(e),2)]
```
[Answer]
# SmileBASIC, 144 bytes
```
DEF R C,I,O
C[0]="&H
A=R+G+B
RGBREAD VAL(C)OUT VAR(I[1]),VAR(I[3]),VAR(I[5]),VAR(I[7])?"#";RGB(VAR(O[1]),VAR(O[3]),VAR(O[5]),VAR(O[7]))END
```
[Answer]
# [Red](http://www.red-lang.org), 154 120 114 bytes
```
func[c o t][g: func[q][parse q[skip collect 4 keep 2 skip]]
prin"#"foreach p g t[prin pick g c index? find g o p]]
```
[Try it online!](https://tio.run/##ZYzLCoMwFET3fsUQv6BqH7gpSbXusw1ZSEysKBofhULpt9v42JSu7pzhzB10MXNdCOmZeDbPVgmFDpMUZYwVeylsPowavRjrykJ1TaPVhAi11hYBllZKzw5VS3xiukHn6gGLEpNYSthK1Y4UqrbQryuMu447uNlsQPxDEEbH0/lCXOY8yxijdMmUbkTW5xPeH2/VacDCW5T864xlGee7vttJShOWpvefhy5vO2fPXw "Red – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 102 bytes
```
lambda x,a,b:['#']+[[x[i:i+2]for i in range(1,len(x),2)][i]for i in[a[1::2].index(i)for i in b[1::2]]]
```
[Try it online!](https://tio.run/##bY7BasMwEETP9VcIcpBERInlJC2CHKTa9d3X7RLkRm4XEiXYPrhf78Y1uBR6WRjmzezcvvrPa8zG5vA2nv2lPnk2KK9qA3zFcQ0wABlaa2yuLSNGkbU@fgSRqnOIYpBKSwRaXPCQGqPxkeIpDILkEqtnA3HsQ9cf330XOnZgcP@T6my72z89c8X4qqrK0jlrf4S1s@SoJs5ql71s8/8458qyqmYuL2zuiuL1b8VdzIkJwyRJlmm/g0zycGsp9qIRBBtUBOl0NEo5fgM "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ẹÐ€Qị⁵
```
[Try it online!](https://tio.run/##y0rNyan8///hrp2HJzxqWhP4cHf3o8at////V1cOCnJ3d3JydFQHsh0dnZzc3YOCQGxDRyMnY2cTF3UA "Jelly – Try It Online")
Full program.
Argument 1: Original
Argument 2: Target
Argument 3: Color
[Answer]
# [C (clang)](http://clang.llvm.org/), 89 bytes
```
char *a,b[10],*i,*o;f(x,y){*b=*a;for(x=1;x<8;b[x++]=a[y=index(i,o[x])-i],b[x++]=a[y+1]);}
```
[Try it online!](https://tio.run/##dU/RboIwFH3vVzSQJVDrFHTTpGLSCvLOK@OhomATVxbUBGP8dlboBLZkSXNz77nnnHuajtMTl3ltCpmervvD6nzZi@L1uAYDpBQyV1CdHnkJEce72JkmGAmMCpJZFb7Zd7TzECdZUVqV55BqtSS7uBqNEo/HN0/I/aGyBC7iKrHHIsH9buQkNnnUuWXDO/hShy6ZZbycoX7jNTQw5BgKDAubgMxSpWd9SEPjDwAUBj@5kK0R4J5hOu5s/va@WBoECjVGURgyRqkaCzVSqgGDgLxx1RLqstlm7v8nYSwMo@iXxA@oz4Jg@yPpbVuJ1g8k5eFyLSWcqnaCQJcRw@6Yap8mzf/NxVKTQJfuL1mnaslzf7ZxmUNBl2tgp9pnnpbcrBsaQBPwqL8B "C (clang) – Try It Online")
Takes input value in `a`, in format in `i` and out format in `o`. Returns out value in `b`
Minor cheat: storing result in `b` instead of printing to save bytes. Question doesn't disallow it.
# [C (clang)](http://clang.llvm.org/), 100 bytes
```
char *a,b[10],*i,*o;f(x,y){*b=*a;for(x=1;x<8;b[x]=a[y=index(i,o[x])-i],b[x+1]=a[y+1],x+=2);puts(b);}
```
[Try it online!](https://tio.run/##dY7LbsIwFET3/goLNrExhTxakIyRbEKzzzZi4YSXJepUIZGMEN@emgRCWqkr3zt3zniycXaS@lAPlc5O1Xa3OJdblb8dl6CnFEofrFRnR1lALEmauNMNwYrgnO4dQy7oilOGJd3nhWOYS81iTtPEbJhMLkzp7c44iuRWQGO1sbgZuc3NPsSMmIfod1WenRTRW610Cb@k0g6CVwAkGwxdzw/eP2bzAYXKrnEcRUJwbtfcrpy3woCCvYPoA@Ge8FdB@B8iRBTF8S8kXPNQrNefD@QV2yAt30OKXVkVGk7tOMGg60hg95kdnyFwvITD2bw1ga7dX3PbqjEHob/yhMtB16sXZ8dnn8Z8P99tAE/Arf4B "C (clang) – Try It Online")
# [C (gcc)](https://gcc.gnu.org/), 181 bytes
```
char *a,*i,*o;c[4],x,y,z;g(x){x=x==82?0:x==71?1:x==66?2:3;}f(){a++;for(;z<2;z++){i=(z?o:i)+1;for(y=0;y<7;z?printf("%s%2X","#"+!!y,c[g(i[y])]):sscanf(a+y,"%2X",&c[g(i[y])]),y+=2);}}
```
[Try it online!](https://tio.run/##jZBRb5swFIXf/StcR10wuE2ALIniUARNxjtPlRgPnuOkljKIwJGAKL89M7CyaurUScjHl3v0@dzLHw6c30Yy48fzTqxLtZP54@vTjb@yApqMmJKYOeXJLCUVqUlDD0aFL5VXed7S8acrrQvbt1udz31n5dLr3sAXZll0nxcGbdYObSwLX6RnNH6@ktiyu07tTWm9XtDGPxUyU3sD3Zf3zgsiaISsu7ua8ORgyKROcYpXZclZtjeYVRPUmb6865La8hxMr1dw0yD4k8nMwPACwADeweH7niECD8Y4HmOiJeol7CUYY0wBmEz4UbAMlkemBPwhdFwBlSgV5KwUj5DnOwFFdRJclbBUTEkOZSaVZEfZ6CrPAODJNPV4YreH0x5uqndWe40eGzAPjWzHnX2dL5aIQqnLOI6iMAwCXea6DIL@B6JAr5OC01mVBkJtuv9AB07oPs82/0KHYRTF8QfoT8mbbbAJt9tvv8l/Unbk/pkPyYVQ5yKD03a7JhiGJ3BIp69vOPjwBEeLZW8Cwzh/m/sxOvNs4z47oR2AIeE7nL6@JevMbbu1AXMCrrdf "C (gcc) – Try It Online")
Creates a `RGBA` value in `c[]` array based on format `i`, then prints in `o` format
[Answer]
# Clojure 1.8, 156 bytes
```
(fn[c o t](reduce #(str %(val %2))""(sort-by key(reduce-kv #(let[s(clojure.string/index-of t(nth o %2))](assoc %(if(contains? % s)(inc s)s)%3)){}(vec c)))))
```
Ungolfed
```
  (fn [c o t]
    (reduce
     #(str % (val %2))
     ""
     (sort-by key
              (reduce-kv
               #(let [s (clojure.string/index-of t (nth o %2))]
                  (assoc %
                         (if (contains? % s) (inc s) s)
                         %3))
               {}
               (vec c)))))
```
Try it online does not have Clojure 1.8 support. Very strange!
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~55~~ ~~51~~ 46 bytes
```
{[~] %(@^b Z=>@^a){@^c}}o*.map(*.comb(/\w?./))
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/OrouVkFVwyEuSSHK1s4hLlGz2iEuubY2X0svN7FAQ0svOT83SUM/ptxeT19T8781V3FipYKSSryCrZ1CdZqGSrxmrZJCWn4RF6eNsqGRsYmpmbmFgnJQkLu7k5Ojo4KyoyOEbacDVuFo5GTsbOKCqsLJyd09KAiiwsXV0cXJ1dUNoVNBGaISqOI/AA "Perl 6 – Try It Online")
Takes a (color, original, target) list as input. Splits each input string into components, creates a Hash mapping source keys to color values, looks up color values in target key order, then formats the result.
]


[Question]
      [
Given a positive integer *N* ("virality"), your program should create an ASCII-art drawing of a tree with two branches of length *N* extending downwards and/or rightwards from the top-left corner.
The direction taken by each branch *after the first asterisk* can be either rightwards or downwards, and this choice should be made *randomly*1 at every next step.
For example, given an input of 5, the output might look like:
```
***
* ***
**
 **
```
The two branches are allowed to touch (be on adjacent cells), but not overlap (be on the same cell), so the following would not be allowed:
```
***
* *
*****
  *
  *
```
## Examples
For input `1`, the only possible output is:
```
**
*
```
(This will be present in all valid outputs, since having the two branches take the same path would cause them to overlap.)
Possible outputs for an input of `3` include:
```
***
* *
**
```
```
**
***
*
*
```
For input `7`:
```
****
*  **
*   **
*
***
  *
```
For input `10`:
```
****
*  *
*********
  *
  *****
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest valid answer (in bytes) wins.
1. This should uniformly random (i.e. a 50/50 chance of each direction),
 or as close to uniformly random as you can get on normal hardware.

[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~58~~ 51 bytes
```
[TT]{_2_m*\f.+{:-},mR}ri*]ee{~\)S*\{'*t}/}%::a:.+N*
```
[Try it online!](https://tio.run/##S85KzP3/PzokJLY63ig@VysmTU@72kq3Vic3qLYoUys2NbW6LkYzWCumWl2rpFa/VtXKKtFKT9tP6/9/QwMDAA "CJam – Try It Online")
The basic idea is that we start with `[0 0]` and then repeatedly add either 0 or 1 to each element (making sure that they are never equal except at the start to avoid overlap), collecting all intermediate results.
```
[[0 0] [0 1] [0 2] [0 2] [1 3]]
```
We then create a large array of arrays where each subarray contains `*` at indices given by the corresponding pair in the original array and spaces everywhere else.
```
["*"
 "**"
 "* *"
 "* * "
 " * * "]
```
This yields diagonal slices of the output matrix (where moving left to right corresponds to moving top-right to bottom-left in the actual matrix).
We can then use `::a:.+` to "de-diagonalize" and get the resulting lines:
```
[ "**** "
  "*  *"
  "** "
  " *"
  ""     ]
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~31~~ 24 bytes
```
Ｆ²«Ｊ⁰¦⁰Ｆ⊕θ«¿ι*↓*≔‽²ι¿ＫＫ↗
```
[Try it online!](https://tio.run/##LY2xDoIwFEVn@hUvTK8GE3SEycRFExNC9ANIeUBjabFUHAzfXkvjes7NuWJorDCN8r4zFvDI4cuS63uc7gbzDHJesiSaixaWRtKOWnzxOEtkByg5VFZqh@ku5SWQmukPirP56AwiD@PTPMteY93o1ozhKAMZ@RapiJ4YojezEBaPqZb94Da7stX7Q@73i/oB "Charcoal – Try It Online") Link is to verbose version of code. Originally I thought it would be easier to make the first step random but it turned out to be golfier to make the first branch predictable. Explanation:
```
Ｆ²«
```
Loop twice, using index variable `i`. (This actually iterates over an implicit list, so it's safe to mutate `i` inside the loop.)
```
Ｊ⁰¦⁰
```
Jump to the origin of the canvas.
```
Ｆ⊕θ«
```
Loop `N+1` times.
```
¿ι*↓*
```
Print a `*`, but leave the cursor either to the right or below the cursor depending on the value of `i`.
```
‽²ι
```
Randomise the value of `i` for the next iteration of the inner loop.
```
¿ＫＫ↗
```
If the current character is a `*`, this means that we're the second branch and we went down instead of right, so move up right to correct that.
 (The first branch always starts downwards so the second branch will always be above it, meaning that we only need to check for a vertical collision.)
[Answer]
# Java 10, ~~273~~ ~~272~~ ~~268~~ 239 bytes
```
n->{var c=new char[++n][n];for(var d:c)java.util.Arrays.fill(d,' ');for(int i=0,j=0,k=0,l=0,r=0,s=0,t=0,u=0;n-->0;){c[i+=r][j+=s]=c[k+=t][l+=u]=42;do{r=t=2;r*=Math.random();t*=Math.random();s=r^1;u=t^1;}while(i+r==k+t&j+s==l+u);}return c;}
```
Try it online [here](https://tio.run/##nVLBjtMwED2nX@ETtfE2agtcMF6JI4e9sBKXYCTjpK1d11mNJ1lWVb692MnShaWAxGE80vjN8/ObcbrXC1fvT3fdV28NMV7HSG60DeQ4K2zABjbaNOSTBe1zqTA7DZWqFOlziSYICUzMimFWPHJE1JhS39qaHBITvUWwYZtaNGwjG1kmvpGCSHIKi@tjr4EYGZp7Mj7BeVBVUGLTAs1X9VvDXFJbdmh9@R5AP8RyY72n9dWczNkIzGqsXF65FPsUPgWkiCkwRSeXIiwW10vBjqayXIKqHJdRSVPtuURVeS47JV@vRd0eQaJcC3gpbzTuStChbg@UCXxeiBK@rEQnMZ3D/c76hloOUu45vnA8Sul5x8QADXYQiBHDqSiSY8VdsgXpaEI5ubli2cri9iFicyjbDssR4wOdfw5zdrlp/T9Nr/7d9OT2x/GnBNKo8nyeX9ARfvY/oZYipXdklTPn08gviIAyNN/wQ6q@WTL@@Pm/ahqmRQPba2x@2bSJ/bydZnr0gihT@iZscfeztB8wN8FchlVWnZEuITPuN200wyqn/qj8SfVQnL4D).
Thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen%20Kevin%20Cruijssen) for golfing 29 bytes.
Ungolfed version:
```
n -> { // lambda taking an int as argument
    var c = new char[++n][n]; // the output; increment the virality since the root does not count
    for(var d : c) // for every line
        java.util.Arrays.fill(d,' '); // initialize it with spaces
    for(int i = 0, j = 0, // coordinates of the first branch
            k = 0, l = 0, // coordinates of the second branch
            r = 0, s = 0, // offsets for the first branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
            t = 0, u = 0; // offsets for the second branch, one will be 0 and the other 1 always except for the first '*' where the two branches overlap
        n-- > 0; ) { // decrement virality and repeat as many times
        c[i+=r][j+=s] = c[k+=t][l+=u] = 42; // move according to offsets and place an '*' for each branch, 42 is ASCII code
        do { // randomly pick offsets for both branches
            r = t = 2; // Math.random() provides results in [0,1)
            r *= Math.random(); // flip a coin for the first branch
            t *= Math.random(); // flip another coin for the second
            s = r^1; // set s to 0 if r=1, to 1 if r=0
            u = t^1; // set u to 0 if t=1, to 1 if t=0
        } while(i+r==k+t&j+s==l+u); // repeat if the branches overlap
    }
    return c; // return the output
}
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~208~~ ~~124~~ ~~122~~ 118 bytes
118 bytes without newlines, indentation and comments. Takes *N* from stdin:
```
@b=1..2;                            #number of branches is 2
for(1..<>){                         #add length <> (the input) to each branch
  ($x,$y)=@$_                       #get where current branch has its tip now
 ,.5>rand?$x++:$y++                 #increase either x or y
 ,$o[$y][$x]++&&redo                #try again if that place is already occupied
 ,$_=[$x,$y]                        #register new tip of current branch
   for@b                            #...and do all that for each branch
}
say map$_||!$i++?'*':$",@$_ for@o;  #output the branches
```
[Try it online!](https://tio.run/##HYzdCoIwGEBfxerDn74xUpTANd17jCGKBkE12Sgc2bOv2d25OOfMk7lX/mWn6F3R/MQO1vTPMT1nzIuB55QW7KpNGuDSZJ8UFgIu4wI6QqtmU1tYEGtwiAS0BKckLAoxjs00agIdl/9GhYsYvrZ30aOfoVvXHdwQ2@SY1LAnYRhthmbel@UP "Perl 5 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 204 bytes
```
from random import*
N=input()
s=eval(`[[' ']*-~N]*-~N`)
s[0][0]='*'
I=x,y=1,0
J=X,Y=0,1
exec"s[y][x]=s[Y][X]='*';i,j,k,l=choice((J+I,I+I,I+J,J+J)[x-2<X:]);x+=i;y+=j;X+=k;Y+=l;"*N
for i in s:print`i`[2::5]
```
[Try it online!](https://tio.run/##HYrLDoIwFET3/YrGDY9eEyRxQ70fQBesIU0TDGK8ii0paMrGX0dCMnNmcWZc5oez@brevXtzf7W3beg9Oj@nrEKy42eOEzZh/70Ocat1xCOTHn/VjnYzOjNbMEojVmKABU@QMYU1NJjBifWh7w6TXowOBifdGF3vZ0nwhBcM2D0cdX0cK1FCuVeBEirR4Zhf6sIkMggkuQh8ylrgSzYCB3lIK3Z3nhMny6di9GTnllqdF8XZrOv5Dw "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-a`, ~~97~~ ~~96~~ ~~93~~ 92 bytes
Has no right, down or off diagonal bias.
```
#!/usr/bin/perl -a
@;=[1];map{$x=$y=0;map++(.5<rand?$x:$y)*$;[$y][$x]++&&redo,1.."@F"}1,2;say+($","*")[@$_]for@
```
[Try it online!](https://tio.run/##FcbRCsIgFADQf7lcxjadaOFLJvnUW18gEsIWBDXF9aBEv96NztPJS3loImesV8E8Y35jtdis/J@xXuhjiet8wnrANoxoPLbgsQbGuq4sc@JKCHBn@Ci@M1tsrEfgMMLgHV7DLRVHtJfflF/3tG40RZouWigp1A8 "Perl 5 – Try It Online")
[Answer]
# PHP, 118 bytes
```
for($r="*",$w=$argn+2;$argn--;$r[$q+=rand(0,$r[$q+1]<"*")?:$w]=$r)$r[$p+=rand(!$i++,1)?:$w]=$r;echo wordwrap($r,$w-1);
```
requires PHP 5.4 or later for the Elvis operator. Replace `?:` with `?1:` for older PHP.
Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/353a94382205848f7807035ce8ed711fdb5f105a).
[Answer]
# [Red](http://www.red-lang.org), 195 190 bytes
```
func[n][g: func[s][i: 0 d: s while[i < n][b/(d): #"*"until[r: 1 if 1 = random 2[r: n + 1]b/(d + r) =#" "]d: d + r
i: i + 1]]b:""loop n[loop n[append b" "]append b"^/"]b/1: #"*"g n + 2 g 2 b]
```
[Try it online!](https://tio.run/##PY29DoMwDIR3nuIUltIO/IxR@xJdo1SCJqGWwEQBxOPTEKoOts/W3edgzf60RukstGymsZytNeBpKxcabebk7lZ@K9aql0hy1ookKhiJGduHBqsId0RHV15MIZGLq1h5oUEFiRrkYnvgxKM5jowban3YowgFHrmA0BGY9iziKTl0J4UYpsmD1W@03ls26I7AX79KEWn1@bpP@AZ9rE7vPhAvcGiq/Qs "Red – Try It Online")
## Readable:
```
f: func[n][
    g: func[s][
        i: 0
        d: s
        while[i < n][
            b/(d): #"*"
            until[
                r: 1 if 1 = random 2[r: n + 1]
                b/(d + r) = #" "
            ]
            d: d + r
            i: i + 1
        ]
    ]
    b: ""
    loop n[loop n[append b " "]append b "^/"]
    b/1: #"*"
    g n + 2
    g 2
    b
]
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~50~~ ~~43~~ 41 bytes
```
2ḶẊ⁸Ð¡+\‘Ṗ
⁸ÇU;Ç¤⁻Q$¿
‘,þ`⁼€þÇS+»þ`Ị$ị⁾*
```
[Try it online!](https://tio.run/##y0rNyan8/9/o4Y5tD3d1PWrccXjCoYXaMY8aZjzcOY0LxG8PtT7cfmjJo8bdgSqH9nMBZXQO70t41LjnUdOaw/sOtwdrH9oNFHi4u0vl4e7uR437tBT@H26PBJppAAA "Jelly – Try It Online")
This was a really fun one to write. There could be some much more optimal method. There is probably some golfing to do within this method as well.
Right after I posted this I realized I could use `,þ`` instead of `aþ,""oþ`Ɗ`.
[Answer]
# [R](https://www.r-project.org/), ~~148~~ 142 bytes
```
n=scan();`~`=sample;o=r=k=1;l=c(1,n);for(i in 1:n){r=r+l~1;t=l~1;k=k+"if"(k+t-r,t,l[l!=t]);o=c(o,r,k)};write(c(" ","*")[1:n^2%in%o+1],1,n,,"")
```
[Try it online!](https://tio.run/##Fc1BCsIwEEDRq9SBwowZFxHcGOYkpdISWgiJiUwDLsRePdbNX76vrWXZ/JyR3LRPss3PV1pcEZUo1iXxaDmTW4ti6ELu7D3TR0VN2q2r8m@UaCCsgNHUi3LlNKST1JEOxmNh5Uhf99ZQF/QIHTCcgYZDelz7kPti7MjHhRmA2q39AA "R – Try It Online")
Additionally, although it won't meet the output spec, you can distinguish the two branches: [Try it online!](https://tio.run/##FczLCsIwEEbhV6lZTegsjOCmw/8kpdASWgi5KNOAgthXj3ZzFmfxaWsFu18KWZmPGfuSn2mVjLxUDW8yneHCxUoe3YSrKCKcJHhy590eSqELpXNDsR@F9ulwUnE2IvYmbIZiXwHlNKYL6sT1xDwpRzvBDbevvDTUlTL/SWZjbLu3Hw)
Explanation:
Starting from index `1`, we randomly select a right or left move for branch `r` by adding `n` or `1`, respectively. Then we select another right or left move for branch `k`, and if it would intersect where `r` is going, we select the other direction. Then we use `r` and `k` as indices into `m`, setting those values as `"*"`. Iterating `n-1` times, we then print the result.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~39~~ 38 bytes
```
ḣ2+\€Ẏ
2Rd¤ṗẊÇ⁻Q$$¿Ç0,0ṭ‘Ṭ€×þ/$€Sị⁾* Y
```
[Try it online!](https://tio.run/##AVIArf9qZWxsef//4bijMitc4oKs4bqOCjJSZMKk4bmX4bqKw4figbtRJCTCv8OHMCww4bmt4oCY4bms4oKsw5fDvi8k4oKsU@G7i@KBviogWf///zEw "Jelly – Try It Online")
Although seemingly unrelated, `d` is useful here to save a byte (over my previous approach).
[Answer]
# [Python 2](https://docs.python.org/2/), ~~191~~ ~~187~~ 176 bytes
```
from random import*
n=input()
p,q=c=1,1j;s={p,q,0}
exec'z=choice(c);q,p=p+[z,1+1j-z][p+z in s],q;s|={q};'*2*~-n
R=range(n+1)
for y in R:print''.join(' *'[y+x*1jin s]for x in R)
```
[Try it online!](https://tio.run/##Hc1LCoMwGATgfU6RXTSJpRG6acgl3IqLksYaoX8epuCj9upWXQ0DHzN@Sp2Dctva6N44PuC5h317FxNFoCz4T8py5HlQWgkuejmoZW/8uiIzGk1mpTtntcl0LgP3yrN65oKJvpib2rMZW8BDw4McvmoJqyS0pL8CUKX2s5fJgIkctS7i6ZDV3UcLiZBL7yxkBFNST2ykoj9nDjeeLt@22x8 "Python 2 – Try It Online")
Python has native support for complex numbers of the form `a+bj`; this makes some 2-D problems a bit more tractable...
]


[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]
# [Momema](https://github.com/ScratchMan544/momema), 63 bytes
```
0-9*072*0101*0108*0108*0111*044*032*087*0111*0114*0108*0100*033
```
[Try it online!](https://tio.run/##y83PTc1N/P/fQNdSy8DcSMvA0MAQRFjACEMg18REy8AYKGdhDhUwNDSBKzIAyhn//w8A "Momema – Try It Online")
This is a golfed version of the Hello World program given by TIO. The only difference is that we store the value `-9` (the cell which is memory-mapped for character-based I/O) in cell 0, and then use `*0` (the value of cell `0`) instead of `-9` everywhere. This wouldn't save bytes except that Momema will parse a leading `0` on a string literal as a separate number, so you can write e.g. `*0108` instead of `-9 108`. This saves a byte for every write.
As hinted above, the program consists of a series of writes of various codepoints to `-9` (the address which is memory-mapped to perform character-based I/O). In ungolfed form, it looks like:
```
0   -9
*0  72
*0  101
*0  108
*0  108
*0  111
*0  44
*0  32
*0  87
*0  111
*0  114
*0  108
*0  100
*0  33
```
[Answer]
## Crayon, 16 Bytes
```
"Hello, World!"q
```
[Try it online!](https://tio.run/##Sy5KrMzP@/9fySM1JydfRyE8vygnRVGp8P9/AA)
[Answer]
# [Felix](https://github.com/felix-lang/felix), 21 bytes
```
print"Hello, World!";
```
[Try it online!](https://tio.run/##S0vNyaz4/7@gKDOvRMkjNScnX0chPL8oJ0VRyfr/fwA "Felix – Try It Online")
Somebody linked to this language on PPCG and I thought it was interesting. In the interest of getting to know the language, I thought I'd write some programs in it.
The Felix docs all use `print$ x` instead of `print x` because `print` is a procedure and not a keyword, so use of the Haskell-style low-precedence application operator `$` allows a slightly more natural syntax (compare `print (1 + foo(5));` with `print$ 1 + foo(5);`. I'm not sure I agree completely with this, but it's just a convention and as I'm on PPCG I can break it without feeling guilty.
`print` is Felix's function to output something, with no trailing newline.
[Answer]
# [Brat](https://github.com/presidentbeef/brat), 17 bytes
```
p "Hello, World!"
```
[Try it online!](https://tio.run/##SypKLPn/v0BBySM1JydfRyE8vygnRVHp/38A "Brat – Try It Online")
[Answer]
## [NEUPL](https://github.com/Legend-of-iPhoenix/NEUPL), 14 bytes
```
"!dlrow ,olleH
```
[Try it online](https://legend-of-iphoenix.github.io/NEUPL/?c=%22!dlrow%20,olleH)
### Explanation:
```
"!dlrow ,olleH
"               Begin pushing characters to the stack.
 !              Push the character "!" to the stack.
  d             Push the character "d" to the stack.
   l            Push the character "l" to the stack.
    r           Push the character "r" to the stack.
     o          Push the character "o" to the stack.
      w         Push the character "w" to the stack.
                Push the character " " to the stack.
        ,       Push the character "," to the stack.
         o      Push the character "o" to the stack.
          l     Push the character "l" to the stack.
           l    Push the character "l" to the stack.
            e   Push the character "e" to the stack.
             H  Push the character "H" to the stack.
                Implicitly stop pushing characters to the stack.
                Implicitly pop and print each character in the stack.
```
[Answer]
# [Dreaderef](https://github.com/ScratchMan544/Dreaderef), 42 bytes
```
"??	?\r?0"-1"Hello, World!\n"
```
[Try it online!](https://tio.run/##SylKTUxJLUpN@/9fiVGAhdGencWe0549pojNnolRVIDRQEnXUMkjNScnX0chPL8oJ0UxJk/p/38A "Dreaderef – Try It Online") This file contains unprintables. Hexdump:
```
00000000: 2201 1004 013f 0704 3f09 3f07 5c72 063f  "....?..?.?.\r.?
00000010: 0201 1510 0130 222d 3122 4865 6c6c 6f2c  .....0"-1"Hello,
00000020: 2057 6f72 6c64 215c 6e22                  World!\n"
```
There already is a Dreaderef submission, but this uses a different approach (looping through memory rather than printing out each character directly).
Ungolfed:
```
CODE.
; Dereference the string pointer
0.  deref 16 4
; End the program if the value pointed to is zero
3.  deref ? 7
6.  bool ? 9
9.  ? 7 13 ; Black magic
12. chro ?
; Increment the string pointer
14. add 1 21 16
; Go back to the beginning
18. deref 100 -1
DATA.
21. "Hello, World!\n"
```
[Answer]
## [Reflections](https://thewastl.github.io/Reflections/), 41 bytes
```
_Hello, World!;#_#_#_#_#_#_#_#_#_#_#_#_#_
```
[Test it!](https://thewastl.github.io/Reflections/reflections.html##X0hlbGxvLCBXb3JsZCE7I18jXyNfI18jXyNfI18jXyNfI18jXyNfI1//MP81MDD/MP8=)
Explanation:
1. The `_` at (0|0) pushes my source to the stack.
2. `Hello, World!` consists of no-ops
3. `;` pops the first character.
4. 13 times `#_`:
	1. `#` redefines (0|0)
	2. `_` at (1|0) prints a character
[Answer]
# [DipDup](https://github.com/AlephAlpha/DipDup), 15 bytes
```
[Hello, World!]
```
[Try it online!](https://tio.run/##ZVRLj9owEL7nV8xGSCRi4dYLWvaCqFqpVVGp1EOUzXoTU6xN4sg2JUj973RmnFcpBzL@5pv32Cdh32VZ3m6qarRx8EO2brUXxkqz1dWbqoXTxq6@S1Hsg6AQTiDFVLCBLWxPwsAf2MGubUwQuGsjWURlQqQ0CFRtnahzCYeTvnjLy0kaGQD@LGHRFvKYLPJ0Au5AEhgmISwWHpMkhWk4sL4o65ATLRYxrCDXdS7cV9GwbhKZUr@PbBCzeyNztEdD9DNjbJ85nR1YJIuB24W6o/iyezKs1xxrz8FGeEMlPs2ewQqn7PEK0Wut3a6U1SvWl4ZxjIUtqGQivUl3kbKGKKfmzpN53Ispin3U2IflZg9hOZ0B3kAl6utYip/dwYn8HXXecrn2ADbrqFoDHwii1innieuR0EM4qZQtBwgnr5uBCstnnwmBUcvUjGbZdhvy8VxT2wdy50P@FmXfRv6iiqijol@KSJLTeKLYwvxlTqpCNf/CmYfPd/ADw42@g9cM00KMeIaIKnx@fb/5O82v6/ixVA2u4lGXRYkbxcfekfcwteYuMbgBatZqNGDKpMFYF1lyPJK7vl7531LSXhxsW7BodZ5YnQcr5nuxA4Kg0SOV5Cgbqaimlgx6PvyfAY4HT9DGvU8ju60wqv7lJ00S46puznSjcmElJC2@IlH7CGEYw9PS305PSUEf@RYmbUou@CWYcZ24UKTICJbGaANhQ@@WP4RBUAlVUwKfv0EU@xOOsnbSiNxhkOZ2Sz7h26cf4ac2ZfGQ/gU "Haskell – Try It Online")
[Answer]
# [MachineCode](https://github.com/aaronryank/MachineCode) on x86\_64, 125 bytes
```
4889f8c60748c6470165c647036cc647026cc647046fc647052cc6470620c6470757c647086fc6470972c6470a6cc6470b64c6470c21c6470d00c3
sbrk()
```
Requires string output via the `s` flag. [Try it online!](https://tio.run/##LctBCoAwDATAuy/RW4xpUp/TphVFVND/EyX2ssOy7JF03c6qV6lmFOO8RGUQ@pIERg7uxOpik3hxA/6dEVwJ4sa2z4Juar/M5CqObgHQqXvyvfeDmT0v)
This language works like so:
* The first line is machine code. This is translated to a C function.
* The second line is C code. It specifies the arguments to the function created in line 1.
* A command-line argument specifies how the function's return value is used.
So, the machine code is equivalent to:
```
char *a(char *s) {
    s[0]='H'; s[1]='e'; s[2]=s[3]='l'; s[4]='o'; s[5]=','; s[6]=' '; s[7]='W'; s[8]='o'; s[9]='r'; s[10]='l'; s[11]='d'; s[12]='!'; s[13]=0;
    return s;
}
```
I generated the machine code via my [C lambda script](https://gist.github.com/aaronryank/c6fd96d543658b19ed9268a3844d0657).
[Answer]
# [QUARK](https://github.com/moonheart08/quark-interp), 46 bytes
```
33 100^8+^6+^3−87 32 44 111^3−^^7−72›I
```
Sets up the numbers in reverse order, with quick number twiddling used for the lowercase characters, as they are quite close together.
[Answer]
# [Dirty](https://github.com/Ourous/dirty), 16 bytes
```
'Hello, World!'‼
```
[Try it online!](https://tio.run/##S8ksKqn8/1/dIzUnJ19HITy/KCdFUf1Rw57//wE "Dirty – Try It Online")
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), ~~40~~ 39 [bytes](https://github.com/mudkip201/pyt/wiki/Codepage)
```
89*2ᴇ⁺Đ7+ĐĐ3+5⬡⁻2⁵9²6+Đ4!+Đ3+Đ6-2ᴇĐ₃áƇǰ
```
Explanation:
```
89*                                                  Pushes 72 ('H')
   2ᴇ⁺                                               Pushes 101 ('e')
      Đ7+                                            Duplicates 101, then adds 7 ('l')
         Đ                                           Duplicates 108 ('l')
           Đ3+                                       Duplicates 108, then adds 3 ('o')
              5⬡⁻                                   Pushes 44 (',')
                  2⁵                                 Pushes 32 (' ')
                    9²6+                             Pushes 87 ('W')
                        Đ4!+                         Duplicates 87, then adds 24 ('o')
                            Đ3+                      Duplicates 111, then adds 3 ('r')
                               Đ6-                   Duplicates 114, then subtracts 6 ('l')
                                  2ᴇ                 Pushes 100 ('d')
                                    Đ₃               Duplicates 100, then divides by 3 (Python 2-style integer division)
                                      á              Replaces the stack with an array containing the stack's contents
                                       Ƈ             Cast to unicode characters
                                        ǰ            Join strings
                                                     Implicit print
```
[Try it online!](https://tio.run/##K6gs@f/fwlLL6OGW9keNu45MMNc@MuHIBGNt80ObTHWNHjVutTy0yQwoZqKoDRI@MsFMF6T2yIRHTc2HFx5rP77h/38A)
[Answer]
# R16K1S60, ~~42~~ 40 bytes
## Program:
```
C301 000D 0001 5180 2C20 A539 0008 5100 C589 00FF 4701 0003 1000 4865 6C6C 6F2C 2057 6F72 6C64 2100
```
## Source:
```
[C301 000D] mov sp,hello ;set the stack pointer to the start of the message
[0001     ] dw 1 ;do nothing + skip next instruction
loop:
    [5180] send 0,cx ;output cx (skipped the first time)
    [2C20] pop bx ;read a value into register bx
    [A539 0008] shr bx,cx,8 ;copy bx into cx, shift bx 8 bits to the right
    [5100] send 0,bx ;output bx
    [C589 00FF] @flags and cx,0xFF ;get the lower 8 bits of cx
[4701 0003] jnz loop ;repeat if cx is not 0
[1000] hlt ;end
hello:
    [4865 6C6C 6F2C 2057 6F72 6C64 2100] db "Hello, World!" ;byte data
```
[Answer]
# [MachineCode](https://github.com/aaronryank/MachineCode), ~~68~~ 62 bytes
```
e80d00000048656c6c6f2c20576f726c6421596a015b6a0d5a6a0458cd80c3
```
Credit to [ceilingcat](https://stackoverflow.com/a/49063073/6850771) for finding this (and for the language inspiration). [Try it online!](https://tio.run/##HYdBDoAwCMC@xBAYPgeBRQ/q/09IbJMmvc3P60l/I6tSIeCHVFi8XegIPGVN7CMcvIvB4KMbbF1i9VDwreoD)
---
Here's a hacky version that isn't true machine code but works with my language.
# MachineCode, 54 bytes
```
e80d00000H656c6c6f2c20576f726c6421596a1[6adZ6a4Xcd80c3
```
Abuses the current compiler's parser. [Try it online!](https://tio.run/##y01MzsjMS03OT0n9/z/VwiDFAAQ8zEzNkoEwzSjZyMDU3CzN3AjIMzEyNLU0SzSMNktMiTJLNIlITrEwSDb@/x8A)
[Answer]
# [Jstx](https://github.com/Quantum64/Jstx), 2 [bytes](https://quantum64.github.io/Jstx/codepage)
```
₧P
```
[Try it online!](https://quantum64.github.io/Jstx/JstxGWT-1.0.2/JstxGWT.html?code=4oKnUA%3D%3D)
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/attache), 21 bytes
```
Print!"Hello, World!"
```
[Try it online!](https://tio.run/##SywpSUzOSP3/P6AoM69EUckjNScnX0chPL8oJ0VR6f9/AA "Attache – Try It Online")
[Answer]
# [Lorale](https://github.com/TheOnlyMrCat/Lorale) 37 (36) bytes
This is a language I am making. It shouldn't count as a loophole, as I *am* making this legitimately, but a hello world program requires you to pass this to the interpreter as args:
```
;Main{§vmain(){¶"Hello, world!"}};
```
Alternatively, the program could be put into the semi-IDE as:
```
Main{§vmain(){¶"Hello, world!"}};
```
making it 36, not 37 bytes.
```
Main{                                 Defines the main class
     §v                               Defines a void
       main(){                                       named main
              ¶"Hello, world!";       Prints "Hello, world!"
                              }};     Closes the main method and class
```
[Answer]
# [Beatnik](https://esolangs.org/wiki/Beatnik), 111 bytes
```
k zzzzzzzzc k xx k x k d k k k zzxa k zzzzzzzzf xw k zd z xw xo k k k x xw k zk
k zzzzzzzzzzxx qs z xo xw xj kd
```
[Try it online!](https://tio.run/##RYthCoBQCIP/d4pd7ZUFJfSIgoaXNw3hOTamfM5re85d3RVWs0BBZoQlnDJjw2A28M1VYNnYC2PddRpsvBLXnWT/4QMq7h8 "Beatnik – Try It Online")
## Non-crashing version, 117 bytes
```
k zzzc xw xw z k xx k x k d k k k zzxa k zzzzzzzzf xw k zd z xw xo k k k x xw k zk
k zzzzzzzzzzxx qs z xo xw xj kd xo
```
[Try it online!](https://tio.run/##RYtdCoBACITfO4VX27KghJZooWEub7otpI5/fDOvpZ27uZuQXARPFsUEyBbSUCaJ0scXW4JxatDpqgPD@Nv0s2GFXHeStcOHmMbu/gI "Beatnik – Try It Online")
[Answer]
## [Vala](https://wiki.gnome.org/Projects/Vala), 36 bytes
File hello.vala:
```
void main(){print("Hello, World!");}
```
...without trailing newline.
After a diet suggested by @ASCII-only.
[Try it online!](https://tio.run/##K0vMSfz/vyw/M0UhNzEzT0OzuqAoM69EQ8kjNScnX0chPL8oJ0VRSdO69v9/AA "Vala – Try It Online")
---
## [Vala](https://wiki.gnome.org/Projects/Vala), 42 bytes
Yayyyy!!! 42!!! \o/
File `hello.vala`:
```
void main(){stdout.puts("Hello, World!");}
```
...without trailing newline.
Run:
```
$ valac hello.vala
$ ./hello
Hello, World!
```
[Answer]
# [Subskin](https://github.com/TryItOnline/subskin), 47 bytes
```
48
6f
2
a
1
4
1
4
a
3
3
43
4f
18
-3
3
b
4e
```
[Try it online!](https://tio.run/##Ky5NKs7OzPv/n8vEgsssjcuIK5HLkMsEjLmAbGMg5DIx5jJJ4zK04OLSBfGTuExS//8HAA "Subskin – Try It Online")
So Ruby allows negative indices.
[Answer]
**[IO](http://iolanguage.org/), 20 Bytes**
```
"Hello, World!"print
```
**Other possibility, 21 22 Bytes**
```
write("Hello, World!")
```
[Answer]
# [BrainfuckSubstitutor](https://github.com/okx-code/BrainfuckSubstitutor), 65 bytes
```
_--!+++?>>/<<
+[_>-[?+>__-/]<_<_-]>-.>?+.?..![.>]//.!.___./-.??+.
```
Based off KSab's Brainfuck answer.
[Answer]
# [tinyBF](https://github.com/TryItOnline/brainfuck), 94 bytes
```
+|=++=>=+=|>>+>=+++++>>|>++>+++|=>=+===>>>+==>>====+++|==>=|>>>>===+++===++++++==>>+===>>>>+==
```
[Try it online!](https://tio.run/##JUs5DsAwDHoQb4DHdKjUJVOWSP67i4kHwBz7W@d5u1EEKIIlwTwnlYxWlYiUw0FLxrbvQQz/FyNSnP5w9w8 "tinyBF – Try It Online")
I noticed there wasn't a tinyBF answer here. This is based on Ksab's record-breaking [brainfuck answer](https://codegolf.stackexchange.com/a/163590/76162).
[Answer]
# [2Col](https://github.com/gunnerwolf/2col), 2 bytes
```
HW
```
Hooray, another boring answer using a Hello world builtin.
[Answer]
# [HadesLang](https://github.com/Azer0s/HadesLang), ~~20~~ 19 bytes
-1 byte thanks to [Oliver](https://codegolf.stackexchange.com/users/61613/oliver)
```
out:'Hello, World!'
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 137 bytes
```
++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++++++++++++++.------------.>+++++++++++++++.>.+++.------.--------.<<+.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGw6i7bTtgJQdlGuHkLEBAt1YOzugkJ6dth5UVA/E0LOx0UYBerpIQM9OG03WTg@hBq4UZIje//8A "brainfuck – Try It Online")
---
# Explained :
```
++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.                       H
>+.                                                                    e
+++++++..                                                             l l
+++.                                                                   o
<<++++++++++++++.                                                    comma
------------.                                                        space
>+++++++++++++++.                                                      W
>.                                                                     o
+++.                                                                   r
------.                                                                l
--------.                                                              d
<<+.                                                                   !
```
---
This can definitely be golfed. (World record is 72 bytes so I already know that)
---
[Answer]
# [Thing](https://gitlab.com/gnu-nobody/Thinglang), 37 bytes
Pushes the characters to the stack one by one (the second "l" is made with duplication, saving 1 byte), then concatenates them.
```
\!\d\l\r\o\W\ \,\o\ld\e\H++++++++++++
```
[Try it online!](https://tio.run/##K8nIzEv//z9GMSYlJiemKCY/JjxGIUYHSOekxKTGeGgjgf//AQ "Thing – Try It Online")
[Answer]
## [TapeBagel](https://esolangs.org/wiki/TapeBagel), 511 bytes
```
%% %++ %++ %++ %++ %++ %++ %++ %++ @* ## %++ %++ %++ %++ %++ @* ## %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* @* ## %++ %++ %++ %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* ## @* %++ %++ %++ %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ %++ %++ %++ @* ##  %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ @* ##
```
---
**%#** - adds one to the integer index.
**%%** - resets the integer index to zero.
**%&** - the integer that the integer index is pointing to is inputted into the program.
**#%** - sets all of the integers to one.
**##** - resets all of the integers to zero.
**&&** - pauses the program.
**&@** - clears the screen.
**%++** - adds one to the integer that the integer index is pointing to
**@[** int **]** - outputs the integer as a character (1 = A, 2 = B, ... 26 = Z)
**\*** - integer 0
[Answer]
# [Sisi](https://github.com/dloscutoff/Esolangs/tree/master/Sisi), 21 bytes
```
0print"Hello, World!"
```
[Try it online!](https://tio.run/##K84szvz/36CgKDOvRMkjNScnX0chPL8oJ0VR6f9/AA "Sisi – Try It Online")
[Answer]
# [Q#](https://docs.microsoft.com/en-us/quantum/quantum-qr-intro?view=qsharp-preview), 43 bytes
```
function H():String{return"Hello, World!";}
```
[Try it online!](https://tio.run/##bY6xTsNADIbn5ClMp0SCewAywtCBDpBKnc3FpadefKl9R1VVeXXChRImJA/279@/v5M@2CA0MfakA1qCkx5QhvI67RPb6ALDuqof2yiOP65CMQmv1uR9uIddEN/drZpxGqevTtwnyZQ0@6C9aKS@KW/TxlkJGvbRvCbkmHrTuj55nNOXNogu9tux2R6EsMuC2aIetfmHsSyG9O6dBetRFZ5/EMoi68tCY/5iAfXCFuYc2KDjqs6O2VU8BdbgyezERXpxTBWe0UVYm7fEFdMZfpH/MKu6rpt8Opa5xm8 "Q# – Try It Online")
Might as well put it out there. Q# is Microsoft's programming language for quantum computers, not that there's anything quantum happening here.
"Now hold on a moment! This isn't a complete program!"--You, probably.
Well, it's not actually possible to write a complete program in Q#. You *always* have to call it from a different language. So I'm just submitting a "function", although note that while Q# is a .NET language, the `function` keyword actually defines a class and not a method, and the submission is equivalent to the following C# code:
```
public class H : Operation<QVoid, String>, ICallable
{
    public H(IOperationFactory m) : base(m)
    {
    }
    String ICallable.Name => "H";
    String ICallable.FullName => "qsharp.H";
    public override Func<QVoid, String> Body => (__in) =>
    {
        return "Hello, World!";
    }
    ;
    public override void Init()
    {
    }
    public override IApplyData __dataIn(QVoid data) => data;
    public override IApplyData __dataOut(String data) => new QTuple<String>(data);
    public static System.Threading.Tasks.Task<String> Run(IOperationFactory __m__)
    {
        return __m__.Run<H, QVoid, String>(QVoid.Instance);
    }
}
```
You can use [this link](https://tio.run/##tZFBS8NAEIXP5leMbSEtNLupoogWL6L05sGC53UzSZZuZje7k0qt/e0xAcGrIMK80zze9@B9xLrXiuEeaiPaCOt1@vj8lPakGoxeaYQ21ir45JiclR1pNo5gM1/cvnAwVB0DchdoskFr3RJeXbDF@eTulJz6ISYpHBMySOdZNkYHF13JsnYNSkFdhSwHxE5VGH/eou0UcdeIAvdonW@QWOwMy1xciNVNfi1WV/ll5gPuDb5Lds5G2UY9ShTWQpYFLDEgaYwwm5eGin9tYM0bfEIV0EM68Gfp4m9UrcjR71lZZsh3/L3fFLg2EYZzhGAN4RIO6pAk48iDpRJ6NG1rhAoJg2Is4GEKpbHYfwE) to "disassemble" Q#.
]