# Question
Title: This code errors on *this* and *that*, is it really written in them?
Inspired by I'm not the language you're looking for!

# Challenge

Choose two different programming languages, and write a program that prints the following line to stdout (or equivalent):

```
This program errors out in <the current language> :P

```

and then generates different kind of error in each of the two languages.

# Rules

Some rules are taken from the original challenge.

* In the output, language names should exactly follow:
    + The name listed on TIO, optionally excluding the version number and/or the implementation name (e.g. if you use `JavaScript (Node.js)` as one of your languages, you can use `JavaScript` for your language name, but not `JS` or `Javascript`.)
    + The full name on the official website (or GitHub repo) if your language of choice is not available on TIO.
* Neither program should take any input from the user.
* You may use comments in either language.
* Two different versions of the same language count as different languages.
    + If this is done, the program should output the major version number, and if running on two different minor versions, should report the minor version also.
    + You should not use prebuilt version functions (this includes variables that have already been evaluated at runtime).
* **Two different command line flags in the same language also count as different languages** as per this meta consensus, as long as the flags don't include code fragments (such as `-Dblahblah...` in C).
    + If this is done, the program should also output the flag used.
* Two errors are considered different unless both errors are generated by the same semantics (such as "division by zero", "segmentation fault", or "index out of range").
    + If a language's runtime does not exit after an error, but reports the error in some way to the user, it's a valid error.
    + If a language does not discriminate the error messages but has a known list of reasons that cause error, **you must specify the reason, not the error message.**
    An example is `><>`, which has only one error message `something smells fishy...`, but esolangs wiki page has a list of error reasons.
* Syntax error is not allowed unless it is generated by calling `eval()` or similar.
* Throwing something manually (via `throw`(JS), `raise`(Python), `die`(Perl) or similar) is allowed, but all of them are considered as one kind of error.
* Error by invalid command in 2D or golflangs is also allowed (and treated as one kind of error).

# Examples

### Python and Ruby

* Python: `This program errors out in Python :P` to stdout, then undefined identifier
* Ruby: `This program errors out in Ruby :P` to stdout, then index out of bounds

### C89 and C99

* C89: `This program errors out in C 89 :P` to stdout, then division by zero
* C99: `This program errors out in C 99 :P` to stdout, then segmentation fault

Note that the version number should *always* be separated from the language name by a space.

### Python 2.7.9 and Python 2.7.10

* Python 2.7.9: `This program errors out in Python 2.7.9 :P` to stdout, then syntax error on eval
* Python 2.7.10: `This program errors out in Python 2.7.10 :P` to stdout, then key error on dict

### Perl and Perl `-n`

* Perl: `This program errors out in Perl :P` to stdout, then invalid time format
* Perl `-n`: `This program errors out in Perl -n :P` to stdout, then try to open a file that doesn't exist

# Winning condition

This is , so the shortest code in bytes wins. But you're always encouraged to post an answer that is fun or interesting even if it isn't very short.

# Answer
# Python 2 / Python 3, 60 bytes

```
print("This program errors out in Python %d :P"%(3/2*2))*1;a

```
* Python 2 got `NameError: name 'a' is not defined`
* Python 3 got `unsupported operand type(s) for *: 'NoneType' and 'int'`

**Python 2:**

* `/` is integer division, 3 / 2 got 1; int(3 / 2 * 2) is 2.
* print is a statement, so the first statement read as `print((...)*1)`, here `*1` means repeating the string once.
* second statement referenced a non-existing variable, which caused the error.
* Try it online!

**Python 3:**

* '/' is floating number division, 3 / 2 got 1.5; int(3 / 2 * 2) is 3.
* print is a function, so the first statement read as `(print(...))*1`.
* function `print` returns `None`; Multiplication do not work on `None x int`, so it report "unsupported operand".
* Try it online!
> 41 votes

# Answer
# C and C++, ~~114~~ 101 bytes

*-13 bytes thanks to l4m2!*

```
#include<stdio.h>
main(){auto d=.5;printf("This program errors out in C%s :P",d?"++":"");2[&d]+=1/d;}

```

Segmentation fault in C++, floating point exception in C.

`auto` is defaulted to `int` in C so `(int).5` becomes `0`, so trying to divide by it is basically division by zero.

In C++ `1/d` is 2, adding it to address of `d` and trying to change that address' value throws a segfault.

Try it in C++!
Try it in C!
> 16 votes

# Answer
# JavaScript + HTML / HTML + JavaScript, 160 bytes

```
<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>
```

```
<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>
```

Not sure if this count two languages, but it is funny.
> 14 votes

# Answer
# \>\<\> and Foo, 42 bytes

```
#o<"This code errors in "p"Foo"'><>'" :P"/

```

Try it in \>\<\>!

Try it in Foo!

Foo prints everything in `"`, as is well documented, and tries to divide by zero at the end. It ignores the `'><>'`.

`><>` pushes the "Foo" to the stack, but immediately pops it using `p`. After it prints everything to the stack with `#o<` it exits when the the stack is empty with the only error message it knows, `something smells fishy...`
> 12 votes

# Answer
# Java 8 & C99, 172 bytes

```
//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

```

Based on my answer for the *'abc' and 'cba'* challenge.

Try it in Java 8 - resulting in *ArrayIndexOutOfBoundsException: 1*.
Try it in C - resulting in *Floating point exception: division by zero is undefined*.

**Explanation:**

```
//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

```

As you can see in the Java-highlighted code above, the first line is a comment due to `//`, and the C-code is a comment due to `/* ... */`, resulting in:

```
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]="";}}

```

So it prints to STDOUT, and then tries to access the second program-argument (when none given), so it produces the *ArrayIndexOutOfBoundsException*.

---

```
//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

```

Not sure how to correctly enable C-highlighting, because `lang-c` results in the same highlighting as Java.. But `//\` will comment out the next line, which is the Java-code, resulting in:

```
main(n){{n=puts("This program errors out in C99 :P")/0;}}

```

So it prins to STDOUT, and then gives a division by zero error.
> 12 votes

# Answer
# Java 8 & Whitespace, ~~439~~ ~~431~~ ~~428~~ 408 bytes

```

 interface a{static void    main(String[]a){System.out.print("This program errors out"+
" in Java 8 :P");a[0]="";}}

```

Try it in Java 8 - resulting in *ArrayIndexOutOfBoundsException: 0*.
Try it in Whitespace - resulting in *user error (Can't do Infix Plus)*.

### Explanation:

**Java 8:**

```
interface a{static void main(String[]a){System.out.print("This program errors out"+
" in Java 8 :P");a[0]="";}}

```

So it prints to STDOUT, and then tries to access the first program-argument (when none given), so it produces the *ArrayIndexOutOfBoundsException*.

---

**Whitespace:**

```
[S S T  T   T   T   T   T   N
_Push_-31_P][S S T  T   T   S T S T N
_Push_-53_:][S S T  T   S S T   T   T   T   N
_Push_-79_space][S S T  T   S T S N
_Push_-10_e][S S T  T   T   S S N
_Push_-12_c][S S T  T   T   T   S N
_Push_-14_a][S S S T    N
_Push_1_p][S S S T  S S N
_Push_4_s][S S T    T   S T S N
_Push_-10_e][S S S T    S T N
_Push_5_t][S S T    T   T   S N
_Push_-6_i][S S T   T   T   T   N
_Push_-7_h][S S T   T   T   S S S N
_Push_-24_W][S T    S S T   S T S N
_Copy_0-based_10th_(-79_space)][S S T   T   N
_Push_-1_n][S S T   T   T   S N
_Push_-6_i][S T S S T   S N
_Copy_0-based_2nd_(-79_space)][S S S T  S T N
_Push_5_t][S S S T  T   S N
_Push_6_u][S S S N
_Push_0_o][S T  S S T   T   N
_Copy_0-based_3rd_(-79_space)][S S S T  S S N
_Push_4_s][S S S T  T   N
_Push_3_r][S S S N
_Push_0_o][S S S T  T   N
_Push_3_r][S N
S _Duplicate_top_(3_r)][S S T   T   S T S N
_Push_-10_e][S T    S S T   T   S N
_Copy_0-based_6th_(-79_space)][S S T    T   S N
_Push_-2_m][S S T   T   T   T   S N
_Push_-14_a][S S S T    T   N
_Push_3_r][S S T    T   S S S N
_Push_-8_g][S S S S (_Note_the_additional_S_here)N
_Push_0_o][S S S T  T   N
_Push_3_r][S S S T  N
_Push_1_p][S T  S S T   T   T   N
_Copy_0-based_7th_(-79_space)][S S S T  S S N
_Push_4_s][S S T    T   T   S N
_Push_-6_i][S S T   T   T   T   N
_Push_-7_h][S S T   T   T   S T T   N
_Push_-27_T][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   T   N
_Push_111][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

```

Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.
`[..._some_action]` added as explanation only.

Try this highlighted version.

Whitespace is a stack-based language that ignores everything except for spaces, tabs and new-lines. Here is the same program in pseudo-code:

```
Push all unicode values of "P: ecapsetihW tuo srorre margorp sihT", minus 111
Start LOOP
  Push 111
  Add the top two stack values together
  Print as character
  Go to the next iteration of the LOOP

```

It will error as soon as it's done printing all values and the stack is empty when it tries to do the *Add* (`TSSS`), which requires two items on the stack.

I've generated the constant `111` with this Java program, which I've also used for previous ASCII-related challenges I've made in Whitespace. In addition, I've used some copies for the spaces to save bytes.

One important thing to note is the trick I've used to place the Java program within the Whitespace answer. Let me start by explaining how a number is pushed in Whitespace:

`S` at the start: Enable Stack Manipulation;
`S`: Push what follows as Number;
`S` or `T`: Positive or Negative respectively;
Some `S` and/or `T`, followed by an `N`: Number as binary, where `T=1` and `S=0`.

Here some examples:

* Pushing the value 1 will be `SSSTN`;
* Pushing the value -1 will be `SSTTN`;
* Pushing the value 111 will be `SSSTTSTTTTN`.
* Pushing the value 0 can be `SSSSN`, `SSTSN`, `SSSN`, `SSTN`, `SSSSSSSSSSSSN`, etc. (When you use `SSSN` (or `SSTN`), we don't have to specify the binary part, because it's implicitly 0 after we've stated its sign.)

So just `SSSN` is enough for pushing the value `0` (used for the letter `o` in this case). But, to place the Java program in this golfed Whitespace program, I needed an additional space, so the first two `o`s are pushed with `SSSN`, but the third one is pushed with `SSSSN`, so we have enough spaces for the sentence of the Java program.
> 12 votes

# Answer
# CBM BASIC and 6502 machine code (C64), 142 144 bytes

*Had to add 2 bytes after realizing a syntax error wasn't allowed ....*

---

Hexdump of `.prg` file:

```
01 08 50 08 00 00 8F 5A 49 52 49 41 A9 17 8D 18 D0 A2 30 BD 30 08 20 D2 FF E8
E0 4B D0 F5 A2 30 BD 05 08 20 D2 FF E8 E0 44 D0 F5 A9 0D 20 D2 FF A2 1A 4C 37
A4 22 36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0 22 20 20 20
20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22 D4 48 49 53 20 50 52
4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54 20 49 4E 20 C3 C2 CD 2D C2 C1
D3 C9 C3 20 3A D0 22 2C 58 AD 50 00 00 00

```

---

**The CBM BASIC view**, as listed in the C64's editor:

```
0 remziriastepgosubinput#new0exp0 dim.clrsavekinput#stepnew0exp<white> dim.clrsavedinput#stepstep
 dim.newl7to"6502 machine code :P"
1 poke53272,23:print"This program errors out in CBM-BASIC :P",x/p

```

**Attention**: It's impossible to correctly enter this program in the BASIC editor. Don't even **try to *edit*** this program in the BASIC editor, it will crash. Still, it's a runnable BASIC program ;)

---

**The 6502 machine code view**:

```
         01 08                          ; load address

.C:0801  50 08       BVC $080B          ; jump to real start of mc

         ; line number (00 00), REM (8F) and "ziria"
.C:0803  00 00 8F 5A 49 52 49 41

.C:080b  A9 17       LDA #$17
.C:080d  8D 18 D0    STA $D018          ; set upper/lower font
.C:0810  A2 30       LDX #$30
.C:0812  BD 30 08    LDA $0830,X
.C:0815  20 D2 FF    JSR $FFD2          ; print "This program errors ..."
.C:0818  E8          INX
.C:0819  E0 4B       CPX #$4B
.C:081b  D0 F5       BNE $0812
.C:081d  A2 30       LDX #$30
.C:081f  BD 05 08    LDA $0805,X
.C:0822  20 D2 FF    JSR $FFD2          ; print "6502 machine code :P"
.C:0825  E8          INX
.C:0826  E0 44       CPX #$44
.C:0828  D0 F5       BNE $081F
.C:082a  A9 0D       LDA #$0D
.C:082c  20 D2 FF    JSR $FFD2          ; print a newline
.C:082f  A2 1A       LDX #$1A           ; error code for "can't continue"
.C:0831  4C 37 A4    JMP $A437          ; jump to error handling routine

.C:0834  22 ; '"'

         ; "6502 machine code :P"
.C:0835  36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0

         ; '"', some spaces, and next BASIC line
.C:0849  22 20 20 20 20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22

         ; "This program errors out in CBM-BASIC :P"
.C:0860  D4 48 49 53 20 50 52 4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54
.C:0877  20 49 4E 20 C3 C2 CD 2D C2 C1 D3 C9 C3 20 3A D0

.C:0887  22 2C 58 AD 50 00 00 00

```

---

**Online demo**, type `run` to run as BASIC, `sys 2049` to run as machine code, `list` to show it interpreted as BASIC code.

Running as BASIC produces a `division by zero error in 1`, running as machine code a `can't continue error`

---

**Explanation:**

The first two bytes of a `.prg` file are the load address in little endian, this is `$0801` (decimal `2049`) here, which is the start address for BASIC programs on the C64. `run` starts this program in the BASIC interpreter, while `sys 2049` is the command to run a machine code program at address `2049`.

As you can see, the first line in the BASIC view is a comment (`rem`) containing "garbage" and part of the required output string. This is the machine code program and some filler bytes. You see some "random" BASIC commands there because CBM-BASIC programs contain the commands "tokenized" as single byte values, and some of these values are the same as opcodes used in the machine code. The machine code reuses the string present in the second line of code for its output.

The first two bytes of a line of a basic program are a pointer to the next line, here `$0850`. This is carefully chosen because `50 08` is also a 6502 branch instruction jumping over the next 8 bytes when the overflow flag is not set -- this is used to jump somewhere in the middle of this "comment" line when executed as machine code. The `50` is the opcode used here, so the second line has to start at `0850` for the trick to work. That's why you see a sequence of 5 `20` bytes (space characters) to fill up. The machine code actively jumps to the ROM error handling routine to give a "can't continue" error.

The BASIC code is pretty straightforward; as a second argument to "print", two uninitialized variables (having a value of `0` in CBM BASIC) are divided, triggering the "division by zero" error.
> 10 votes

# Answer
# C and Python, ~~126~~ 116 bytes

*-10 bytes thanks to @Bubbler!*

```
#1/*
-print("This program errors out in Python :P")
'''*/
main(c){c=puts("This program errors out in C :P")/0;}//'''

```

In Python print() is a None, so trying to get its negative doesn't make sense, so Python throws an error.

In C printf() returns an int, so dividing it by zero gives a floating point exception.

Try it in C!
Try it in Python!
> 6 votes

# Answer
# Attache \+ Wolfram Language (Mathematica), 82 bytes

```
s:="Attache"
s=" Mathematica "
Throw[Print["This program errors out in",s,":P"]-0]

```

Try Attache online! Try Mathematica online!

This pivots upon the meaning of the operator `=` in the two languages. In Attache, it compares for equality, but in Mathematica, it performs variable assignment. `:=` does variable assignment in both languages.

Now, in Attache, `Print` returns an array of strings printed, and subtraction is not possible with strings and integers (namely, `0`). So, a type error is thrown. In Mathematica, `Print` returns `Null`, and Mathematica is just fine subtracting `0` from that. But, we manually throw that null with `Throw`, giving a `nocatch` error.
> 6 votes

# Answer
# Python (2) and QB64, 82 bytes

```
1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

```

To test the Python version, you can Try it online! To test the QB64 version, you'll need to download QB64.

### What Python sees

```
1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

```

The first line is just the bare expression `1` (a no-op) followed by a comment.

The second line sets `s` to the string `"QB64"`, but the third line immediately changes it to `"Python"`. The fourth line prints the message accordingly.

The fifth line is another bare expression, but it raises a `NameError` because of the undefined name `CLS`.

### What QB64 sees

```
1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

```

The first line, numbered `1#`, defines every variable whose name starts with `S` (case-insensitive) as a string variable. This means we don't have to use `s$`, which would be a syntax error in Python.

The second line sets `s` to the string `"QB64"`. `'` starts a comment in QB64, so the third line doesn't do anything. The fourth line prints the message accordingly.

The fifth line tries to `CLS` (clear screen) with an argument of `-1`. But since `CLS` only accepts arguments of `0`, `1`, or `2`, this produces the error `Illegal function call`. The error creates a dialog box asking the user if they want to continue execution or abort. Technically, this means the error isn't fatal (in this case, you can pick "continue execution" and the program simply ends without further problems); but the OP has explicitly allowed languages that can continue after an error, so QB64's behavior should be fine.
> 5 votes

# Answer
# Jelly and , 39 bytes

```
İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ

```

Try it in Jelly!

Try it in M!

Both languages apply inverse `İ` to `0` which results in `inf` for Jelly and `zoo` for M. I don't know why `zoo` represents infinity in M. Ask Dennis.

The important difference is that Jelly's infinity is equal to itself while M's infinity is not. Thus the "is equal to itself" monad `=`` yields `1` in Jelly and `0` in M. From here:

```
İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ
İ=`                                      0 in M, 1 in Jelly
    “¢³ƥ“Ȥ¹»                             Pair of compressed strings: [' M',' Jelly']
   ị                                     Index into this list with 0 or 1
            ;“ :P”                       Concatenate with the string ' :P'
                  “¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»       Compressed string: 'This program errors in'
                                  ;      Prepend this to ' Jelly/M :P'
                                   Ȯ     Print the string and return it
                                    Ṡ    Sign. M errors with a string as input and terminates
                                         Jelly returns a list of Nones
                                     ṛ   Right argument. This prevents the list of Nones from being printed
                                      Ɠ  Read a single line from input. Since input is not allowed, this produces an EOFError

```

Jelly's error is `EOFError: EOF when reading a line`.

M's error is `TypeError: '>' not supported between instances of 'str' and 'int'`.
> 4 votes

# Answer
# C++ 14 (gcc) / C++ 17 (gcc), ~~107~~ 105 bytes

```
#include<cstdio>
int*p,c=*"??/0"/20;int
main(){*p=printf("This program errors out in C++ 1%d :P",4+c)/c;}

```

Try it online! (C++14)

Try it online! (C++17)

---

Assumes that `<cstdio>` declares `printf` in the global namespace (in addition to `std`) and that the basic execution character set uses ASCII values, which are both true using g++ on Linux.

The basic catch here is that C++17 eliminated trigraphs from the language.

In C++14, `"??/0"` contains a trigraph and is equivalent to `"\0"`. So `*"??/0"` is zero, and `c` is set to zero. The number 4 is passed as an argument to `printf`, then the division by `c` causes undefined behavior. On Linux, this happens before `*p` comes into the picture, and the program gets a `SIGFPE`.

In C++17, `"??/0"` is exactly the length 4 string it appears to be. So `*"??/0"` is `'?'` or 63, and `c` is set to 3. The number 7 is passed as an argument to `printf`, and this time the division by `c` is valid. Since `p` is a namespace member, it gets zero-initialized at the start of the program and has a null pointer value, so `*p` is undefined behavior. On Linux, because the program attempts to modify memory at address zero, the program gets a `SIGSEGV`.
> 4 votes

# Answer
# Perl 5 and JavaScript (Node.js), 96 bytes

```
eval("printf=console.log");printf("This program errors out in %s :P",("Perl","JavaScript"));$//0

```

This makes use of the fact that `(...)` is a list in Perl that `printf` will use the leftmost element of and the fact that it's the comma operator in JavaScript, which will return the rightmost argument.

Causes a division by zero error in Perl and a ReferenceError because `$` is not defined in JavaScript.

Try the Perl online!

Try the JavaScript online!
> 3 votes

# Answer
# Octave and MATLAB, 67 bytes

```
v=ver;disp(['This program errors out in ' v(1).Name ' :P']);v(--pi)

```

Try it online!

Notes: The code assumes MATLAB is installed with no toolboxes (or that the names of any toolbox that is installed don't start with letters A to M).

How it works:

The code gets the version data for the interpreter and toolboxes using `ver`. Running `v(1).Name` extracts the name of the first product, this will return either `Octave` or `MATLAB` assuming the note above holds true.

The program will then display the required string, complete with `Octave` or `MATLAB` as required.

Finally we do `v(--pi)`.

In Octave, `--` is the pre-decrement operator. As such it attempts to pre-decrement which fails as the variable `pi` doesn't exist (`pi` is actually function, not a variable).

```
This program errors out in Octave :P
error: in x-- or --x, x must be defined first

```

In MATLAB, the pre-decrement operator doesn't exist. As such the statement is interpreted as `v(-(-pi))` which is equal to just `v(pi)`. However `pi` is not an integer, so cannot be used to index into the `v` array, giving an error.

```
This program errors out in MATLAB :P
Subscript indices must either be real positive integers or logicals.

```
> 3 votes

# Answer
# Haskell, Python3, JavaScript(Node.js), 195 Bytes

```
j=1
y="This program errors out in "
--j//1;Error=print
--j;Error(y+"Python :P");eval("console.log(y+`JavaScript :P`);e");j//2;"""
1//0=do print (y++"Haskell :P");putChar$""!!1
main=1//0
--j //"""

```

Error Messages

Python - Syntax Error due to the \` in the EVAL Haskell - Index too large (""!!1) JavaScript - Reference Error (e is not defined)
> 3 votes

# Answer
# Foo / CJam, ~~51~~ 50 bytes

```
"This program errors out in ""Foo"/'C'J'a'm" :P"Li

```

This exits with a divide-by-zero error in Foo, and a `NumberFormatException` in CJam.

## To CJam:

* A string literal (between quotes) pushes itself to the stack. Items from the stack are automatically printed without a separator when the program terminates.
* `/` tries to split the string `This program errors out in`  on the substring `Foo`. Since the string does not contain the substring, this yields a singleton array containing the original string, which displayed in exactly the same way.
* `'x` is a character literal for `x`, which is printed the same way as a one-character string. This way, we can push data for CJam that is ignored by Foo (I haven't figured out how to make a loop not execute in Foo).
* `Li` tries to cast the empty string to an integer, which fails. Everything from the stack is printed.

## To Foo:

* A string literal (between quotes) prints itself.
* `/` tries to divide the current cell by the top stack element (which is an implicit `0`). For some reason, divide-by-0 errors aren't fatal in Foo, so this just prints the message
```
Only Chuck Norris can divide by zero.
```
to STDERR and keeps going.
* Unrecognized characters (`'C'J'a'm` and `Li`) are ignored.
> 2 votes

# Answer
# PHP 7+ / JavaScript, ~~90~~ 89 bytes

This uses 2 languages with very similar syntax, allowing to write this code on both languages.

The language separation is done by a property not present in JavaScript: PHP considers `[]` (empty array) to be a falsy value while it is truthy in JavaScript (because it is an object and objects are **always** truthy, even `new Boolean(false)`).

```
$X='This program errors out in %s :P';([]?console.log($X,'JavaScript'):printf($X,PHP))();
```

---

## Execution:

Will focus on the following piece of code: `([]?console.log($X,'JavaScript'):printf($X,PHP))();`.

The string attribution works the same in both languages.

This code uses the "ternary operator" (Javascript, PHP), which works mostly the same way in both languages.

### Javascript

Javascript will run the `console.log($X,'JavaScript')` piece, which returns `undefined`.

Later on, when you try to execute `(...)()`, you get an `Uncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function` (in Google Chrome).

### PHP

PHP will execute the `printf($X,PHP)` piece.

In PHP, the `printf` function returns the length of the output.

PHP has an interesting functionality: it can execute functions who's name is stored in a variable (or, since PHP7, as the result of an expression), which prevents a syntax error.

PHP then will try to run the function who's name is the result of the expression `[]? ... :printf($X,PHP)` (which is the number `33`).
But that interesting functionality has a caveat: only accepts strings (duh!).

This causes a `Fatal error: Function name must be a string`, because `33` is an `int`.

---

Thanks to Shieru Asakoto for saving me 1 byte!
> 2 votes

# Answer
# Perl 5 and Perl 6, 55 bytes

```
say('This program errors out in Perl ',5-~-1,' :P').a/0

```

Try Perl 5 online! (Illegal division by zero)

Try Perl 6 online! (No such method)

Prefix `~` is stringification in Perl 6 and essentially a no-op in the program above. In Perl 5, it's bitwise not, converting -1 to 0.

`.` is method call syntax in Perl 6 and concatenation in Perl 5.
> 2 votes

# Answer
# Java and C# ~~242~~ 235

```
/**\u002f/*/using System;/**/class G{public static void/**\u002fmain/*/Main/**/(String[]a){String s="This program errors out in ";/**\u002fSystem.out.print(s+"Java :P");/*/Console.Write(s+"C# :P")/**/;s=/**\u002f(1/0)+""/*/a[-1]/**/;}}

```

Abusing different escape handling between java and C# (unicode escapes are parsed before code parsing in java and not in c#) as a sort of preprocessor, thats the job of the `\u0027` magic, rest are some "toggle-comments"

Edit: Golfed off 8 bytes thanks to a pointer of @KevinCruijssen

Edit: Rule derp fixed
> 2 votes

# Answer
# Python and Lua, ~~111~~ ~~110~~ ~~102~~ ~~98~~ ~~95~~ 85 bytes

```
x="This program errors out in ",#[[
print(x[0]+"Python :P")
a#]]z=#print(x.."Lua :P")

```

Errors: Python 3:

```
Traceback (most recent call last):
  File ".code.tio", line 3, in <module>
    a#]]z=#print(x.."Lua :P")
NameError: name 'a' is not defined

```

Lua:

```
lua: .code.tio:3: attempt to get length of a nil value
stack traceback:
    .code.tio:3: in main chunk
    [C]: in ?

```

Clearly distinct.

Abuses multiple differences:

* `<var>=<a>,<b>,...` creates a tuple in Python, but in Lua it creates an argument list, from which only the first member is taken.
* `#` starts a comment in Python, but is the length operator in Lua. Extra props to Python for allowing tuples to end in a comma.
* `[[...]]` is Lua's multiline string syntax, meaning it doesn't even see Python's print function; this is necessary due to Lua using `..` for string concatenation and not `+`.
* Python errors after seeing `a`, an undefined variable; Lua after `z=#print(x.."Lua :P")`. Using just `#print(x.."Lua :P")` for Lua doesn't work, as that raises an error before the code is even executed.

Edits:

* No need to use `"".join` in Python, -1 byte
* Make `x` a string in both languages and place `Python` in a string literal in the print function, -8 bytes
* Using `#[[]]` is shorter than `#""` and `--[[]]`, -4 bytes
* No need to use `#1` as a table key, -3 bytes
* Jo King did this, -9 bytes
* Taking the length of the return value of `print(x.."Lua :P")` works, apparently; -1 byte
> 2 votes

# Answer
# AutoHotKey / C#, ~~155~~ ~~133~~ ~~128~~ 122 bytes

Syntax highlighting explains it better than I could:

**C#** RuntimeBinderException: 'Cannot invoke a non-delegate type'

```
;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

```

**AutoHotkey** Error: An exception was thrown.

```
;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

```

## Edits:

1. removed a var
2. -5 bytes thanks to milk
> 2 votes

# Answer
# C (gcc)/Stax, 109 bytes

```
AA=~1;
	char* s;main(){*(int*)(printf("%s C :P",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

```

Try it online! (C (gcc))

Try it online! (Stax) or Run and debug it! (Stax)

Segfault in C. Invalid operation in Stax. I love how everything that is not a comment is actually used in Stax.

## C

This is how C sees it. The first line is no-op. The second line prints the message with `printf` and then segfaults due to the `=0`.

```
AA=~1;
	char* s;main(){*(int*)(printf("%s C :P\n",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

```

## Stax

Stax program terminates whenever it tries to pop or peek from empty stack. This makes it a little bit tricky and we have to prepare a stack that is not empty. `AA=~1;` does this while remaining a valid statement in C.

```
AA=~1;
AA=       10=10, returns a 1
   ~      Put it on the input stack
    1     Pushes a 1 to main stack (*)
     ;    Peek from the input stack (**)

```

What is really useful is the `~`, it prepares a non-empty input stack so that the `;` can be executed without exiting the program. However, the two `1`s on the main stack are also used later.

The second line begins with a tab and starts a line comment in Stax.

```
"...";;;/*dp`UGYC\`Q*/
"..."                     "This program errors out in"
     ;;;                  Peek the stack three times so that we have enough operands for the next two operations
        /                 Divide, this consumes one element of the main stack
         *                Multiply, this consumes another element
          d               Discard the result, now the TOS is the string
           p              Pop and print without newline
            `UGYC\`       Compressed string literal for " Stax :P"
                   Q      Print and keep the string as TOS
                    *     Duplicate string specific times
                          Since the element under the top of stack is `1` that was prepared in (**), this does nothing
                     /    Invalid operation error

```

The invalid operation is trying to perform `/` operation for a string as the TOS (2nd operand) and the number `1` from (\*) as the 1st operand, which is invalid.

If the two operands are swapped, it would be a valid operation in Stax.
> 2 votes

# Answer
# 05AB1E and Python 3, 89 bytes

```
print("\"}\"This program errors out in Python :P\""[3:-1]);'")н”±¸ :P\”"05AB1E :P":,õι';a

```

Try it online! (05AB1E)

Try it online! (Python 3)

## 05AB1E

```
print("\"}\"This program errors out in Python :P\""[3:-1]);'")н”±¸ :P\”"05AB1E :P":,õι';a  # full program
print("\"}\                                                                                # a bunch of nops
           "This program errors out in Python :P\"                                         # push literal (in 05AB1E, backslashes are not escape characters)
                                                  "[3:-1]);'"                              # push literal
                                                                                :        # replace all instances of...
                                                               ”±¸ :P\”                    # "Python :P\"
                                                                                :        # in...
                                                              н                            # first element of...
                                                             )                             # stack as a list (left of list is bottom of stack)...
                                                                                :        # with...
                                                                       "05AB1E :P"         # literal
                                                                                ,       # output explicitly to prevent the error from stopping implicit output
                                                                                ι     # attempt to use...
                                                                                õ      # empty string...
                                                                                ι     # as index "step" value in uninterleave, resulting in an error

```

## Error

```
** (RuntimeError) Could not convert  to integer.
    (osabie) lib/interp/functions.ex:101: Interp.Functions.to_integer!/1
    (osabie) lib/interp/commands/special_interp.ex:113: Interp.SpecialInterp.interp_step/3
    (osabie) lib/interp/interpreter.ex:127: Interp.Interpreter.interp/3
    (osabie) lib/osabie.ex:62: Osabie.CLI.main/1
    (elixir) lib/kernel/cli.ex:105: anonymous fn/3 in Kernel.CLI.exec_fun/2

```

## Python 3

```
print("\"}\"This program errors out in Python :P\""[3:-1]);'")н”±¸ :P\”"05AB1E :P":,õι';a  # full program
print("\"}\"This program errors out in Python :P\""                                        # print string "}"This program errors out in Python :P" (including quotes)...
                                                   [3:-1]);                                # not including the first 3 characters and the quote at the end
                                                           '")н”±¸ :P\”"05AB1E :P":,õι';   # string literal (nop)
                                                                                a  # references an undefined variable, resulting in an error

```

## Error

```
Traceback (most recent call last):
  File ".code.tio", line 1, in <module>
    print("\"}\"This program errors out in Python :P\""[3:-1]);'")”±¸ :P\”"05AB1E :P":,õι';a
NameError: name 'a' is not defined

```
> 2 votes

# Answer
# Forth (gforth) and Vim, 76 bytes

```
.( This program errors out in Forth :P ) <esc>0iThi<esc>:s/F.*/Vim :P<cr>:!a

```

Try it in Forth!

Try it in Vim!

In Forth, `.( This program errors out in Forth )` prints the necessary message and the rest just makes it blow up because it's an undefined word.

In Vim, that first part writes `s program errors out in Forth :P )`  to the buffer, `0iThi` puts `Thi` at the start of the line, and `:s/F.*/Vim` turns that last part into `Vim :P` instead of `Forth :P )`. `:!a` simply tries to run a command named `a` and errors because it doesn't exist.
> 2 votes

# Answer
# Perl 5 and C, 95 bytes

```
//;$_='
main(){puts(puts("This program errors out in C :P"));}//';/T.*n /;print$&,"perl :P";die

```

`//;` is basically a NOP in perl, and is a comment in C.

So the C program is effectively:

```
main(){puts(puts("This program errors out in C :P"));}

```

Which prints the required string, then tries to run `puts(32)`. This is technically undefined behavior in C, but it causes a segmentation fault on TIO and every system I have access to.

The perl program treats the whole C program as a string, uses the regex `/T.*n /` to match `This program errors out in`  and then prints that and `perl :P`. `die` causes the program to crash with the error `Died at script_name line 2`.

If you don't like that as an error, `1/0` is the same length and crashes with an `Illegal division by zero` error. I just like `die` more ;)

Try it online! (C)

Try it online! (Perl)
> 1 votes

# Answer
## VBScript, JScript, 72 bytes

```
x="VB"
'';x='J'
WScript.echo("This program errors out in "+x+"Script")
y
```

VBScript will print "Microsoft VBScript runtime error: Type mismatch: 'y'"
JScript will print "Microsoft JScript runtime error: 'y' is undefined"
> 1 votes

# Answer
# Java (JDK)/JavaScript (Node.js), 154 bytes

```
class P{P(){var s="This program errors out in ";try{System.out.printf("%sJava :P",s);}finally{if(1!='1'){var a=0/0;}throw new Error(s+"JavaScript :P");}}}

```

Try it online! (Java)

Try it online! (JavaScript)

Output in Java:

```
This program errors out in Java :P
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at P.(Main.java:1)

```

Output in JavaScript (to stderr):

```
Error: This program errors out in JavaScript :P
    at P (/home/runner/.code.tio:1:185)

```

This takes advantage of JavaScript's weak typing (`1=='1'`) to detect the language, and the same keywords in Java and JavaScript (`var`,`class`), and the similar error constructors (`new Error()`) to make the polyglot.
> 1 votes

# Answer
# JavaScript & Python 3, ~~105~~ 91 bytes

Errors by `NameError: name 'console' is not defined` in Python 3

```
a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

```

Try it online!

... and by `TypeError: console.log(...) is not a function` in JavaScript.

```
a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

```

Try it online!
> 1 votes

# Answer
# PowerShell v6 and PowerShell v2, 73 bytes

```
"This errors out in PowerShell v$($PSVersionTable.PSVersion) :P"
1-shl1/0

```

Try it online!

This will throw a parsing error on v2 because `-shl` was introduced in v3. v3+ will then be able to correctly shift the value before attempting to divide it by 0, conveniently throwing a division-by-zero error. Both versions have the $PSVersionTable hashmap which contains the `PSVersion` field
> 1 votes

# Answer
# Python 3 / Befunge-98 (FBBI), 75 bytes

```
r='=,k1'"This program errors out in Befunge :P"
-print(r[4:31]+"Python :P")

```

Raises a TypeError in Python and a segmentation fault in Befunge.

Try it online! (Python)

Try it online! (Befunge)

## Python

```
r='=,k1'"This program errors out in Befunge :P"

r=                                                        #Declare variable
  '=,k1'                                                  #String literal
        "This program errors out in Befunge-98 (FBBI) :P" #Another string literal
                                                          #Concatenating string literals joins the two strings together.

-print(r[4:31]+"Python :P")

       r[4:31]                                            #Extract the relevant part of the output
              +"Python :P"                                #Change the language name to "Python"
 print(                   )                               #Print the string and return None
-                                                         #Unary negation

```

Apparently, consecutive string literals (such as `'1'"2"`) are valid in Python.

The `print` function, after printing its input (`"This program errors out in Python :P"`), returns `None`. The program attempts to negate that with `-`, which raises a TypeError:

```
Traceback (most recent call last):
  File ".code.tio", line 2, in <module>
    -print(r[4:31]+"Python :P")
TypeError: bad operand type for unary -: 'NoneType'

```

## Befunge

```
r  =,k1'"This program errors out in Befunge :P"

r                                               #Reverse direction
        "This program errors out in Befunge :P" #String literal (backwards)
      1'                                        #Push 49
     k                                          #Repeat that many (49) times:
    ,                                           #Output the last character
   =                                            #System-execute the top of the stack ("")

```

After using `'1k,` to print `"This program errors out in Befunge :P"`, the stack is empty. `=` does a system-execute call, passing the string on top of the stack (which is empty) to the interpreter. FBBI implements this using a C `system()` call, so it calls `system("")`, which leads to a segmentation fault:

```
/srv/wrappers/befunge-98: line 3:  6033 Segmentation fault      (core dumped) /opt/befunge-98/bin/fbbi .code.tio "$@" < .input.tio

```
> 1 votes

# Answer
# Vyxal / Javascript, 78 bytes

```
a=`This program errors out in `
0
0n/*_‛₴ŀ+,i#*/;console.log(a+'Javascript');g

```

Try it Online in Vyxal!

Try it online in JS!

Backticks delimit a string in both Vyxal and JS. The difference is, in Vyxal, we're pushing it to the stack, whereas in JS, we're assigning it to the variable `a`. `a=` pushes 1 to the stack in Vyxal, but this doesn't matter.

Then, we push some values (0, 0, and `n` which is 0 when not in a function) so that `/*` in Vyxal doesn't do anything to the string we have prepared. We can't use `;` at any point that is executed by Vyxal because it will throw a parse error - `;` closes structures in Vyxal, and if there's nothing to close...

`/*` is a comment in JS, so the code `‛₴ŀ+←` appends the compressed string 'Vyxal' and throws an error by indexing 0 into 1 - `i` is very finicky. `#` is a comment in Vyxal, so after the `*/`, we can run whatever we want in JS and Vyxal won't do anything about it. We simply append `'Javascript'` to `a` and output that, then error by referencing an undefined variable.
> 1 votes

# Answer
# Vyxal and JavaScript (V8), 59 bytes (Vyxal SBCS)

```
print`This program errors out in Javascript`;DD//_‛›ṅ‛₴ŀV,/

```

Try it Online! Try it online!

I'm quite proud of this one - I think I've managed to make the two parts integrate quite nicely.

In JavaScript, this simply prints "This program errors out in Javascript", then tries and fails to access the `DD` variable. the rest of the code is hidden in a comment.

In Vyxal, `print` does nothing important, then the string is pushed. The same `DD` that errors in JS lets the string survive through the `//` in Vyxal, resulting in something that gets popped leaving behind the string. Then, `Javascript` is replaced with `Vyxal`, and printed, then an error is thrown by attempting to split the remaining copy of the string into 0 chunks.
> 1 votes

# Answer
C(gcc) on Linux/C(gcc) on Mac (160)

```
#include <sys/utsname.h>
main(){struct utsname n;float g;uname(&n);printf("This program errors out in C(gcc) on %s :P\n",n.sysname);g=1/(int)gamma(1);abort();}

```

Untested on Mac; basically, John Cook pointed out (in his blog) that POSIX doesn't define gamma; Linux uses the log of the gamma function (log(gamma(1)) will return 0 which will trigger a floating point exception); OSX uses the "true" gamma function, (which is officially called tgamma per POSIX); this returns 1 which will then hit the abort statement; I tried to get it to throw a different floating point error (e.g. sqrt(-1) but I'm forgetting how to make that throw an error vs just return zero)
> 0 votes

# Answer
# Perl, Bash (78 bytes)

```
printf "This program errors out in ";eval 'echo Bash :P'||print"Perl :P
";
a()

```

Output in Perl:

```
This program errors out in Perl :P
Undefined subroutine &main::a called at /tmp/perlbash line 3.

```

Output in Bash:

```
This program errors out in Bash :P
/tmp/perlbash: line 4: syntax error: unexpected end of file

```

(Note that Bash is indeed displaying the `line 4` error, despite the fact that line 3 does not end with a line feed...)
> 0 votes

# Answer
# C and ECPP, 112 bytes

```
#ifdef ECPP
#replace "C" "ECPP"
#endif
main(){puts("This program errors out in " "C" " :P");raise(strlen("C"));}

```
> 0 votes

# Answer
# C (gcc) and Haskell, 135 bytes

```
char/*x=0-- */*
s="This program errors out in ";
int main(){--s;*s=printf("%sC :P",s+1);}//-}=0;main=mapM print[s++"Haskell :P",tail""]

```

Try it online (С)! Try it online (Haskell)!

The result is achieved by interweaving the comments, the C version being essentially this:

```
char * s = "This program errors out in ";
int main ()
{
   --s;
   *s = printf ("%sC :P", s + 1);
}

```

(Failure is achieved by writing before the beginning of the string).

Haskell version, on the other hand, reduces to the following:

```
char /* x = 0 -- a useless operator (/*) taking two arguments
s = "This program errors out in ";
int main () = 0 -- a useless function int taking two arguments
main = mapM print [s ++ "Haskell :P", tail ""]

```

(Failure is achieved by taking tail of an empty list)
> 0 votes

# Answer
# Ruby / Erlang, ~~150~~ 115 bytes

```
%w();puts r=<<X[/T.*n /]+"Ruby :P";r*=-1
main([])->io:fwrite("This program errors out in Erlang :P
"),X=1/0,Y=
X
.%

```

Try it online:

Ruby

Erlang (escrpit)

### What's happening here?

Erlang was quite easy, it's just printing out a string then performing a division by zero.

The `%` sign starts a single line comment in Erlang, so I could use that to mark Ruby code, by creating some nop and then appending valid code.

Ruby has to skip all the Erlang code, so I used the here-document syntax to read it all into a string. The delimiter is a valid variable name in Erlang, so that's no problem. Then I multiply the string by -1, which is an invalid argument and outputs the error message.

The last line marks the end of the Erlang function, and does not look too bad to the Ruby interpreter, which gets an error before having to interpret that anyway.
> 0 votes

# Answer
# 05AB1E \+ Groovy, ~~80~~ ~~75~~ 79 bytes (99 bytes UTF-8)

```
//“€Œ‚ë›í€Ä€† 05AB1E :P“=}q
1/{println'this program errors out in Groovy :P'}()

```

Try it online (05AB1E)!

Try it online (Groovy)!

---

***Results for 05AB1E:***

**Output:** `this program errors out in 05AB1E :P`

**Error:**

```
** (FunctionClauseError) no function clause matching in Interp.Stack.pop/2

    The following arguments were given to Interp.Stack.pop/2:

        # 1
        :end

        # 2
        "}"

    (osabie) lib/interp/stack.ex:12: Interp.Stack.pop/2
    (osabie) lib/osabie.ex:63: Osabie.CLI.main/1
    (elixir) lib/kernel/cli.ex:105: anonymous fn/3 in Kernel.CLI.exec_fun/2

Real time: 0.373 s
User time: 0.316 s
Sys. time: 0.114 s
CPU share: 115.03 %
Exit code: 1

```

This occurs do to a mismatched `}`, it never runs the Groovy part because of `q`.

---

***Results for Groovy:*** \- *Note, I updated the code but not the TIO links.*

**Output:** `this program errors out in Groovy :P`

**Error:**

```
groovy.lang.GroovyRuntimeException: Ambiguous method overloading for method java.lang.Integer#div.
Cannot resolve which method to invoke for [null] due to overlapping prototypes between:
    [class java.lang.Character]
    [class java.lang.Number]
    at Script1.run(Script1.groovy:3)
    at io.grpc.Context.run(Context.java:565)

```

By calling 1/null as println returns nothing.
> 0 votes

# Answer
# Swift 4/JavaScript (SpiderMonkey), 105 bytes

```
print("This program errors out in " + ([1]==[1] ?"Swift :P":"JavaScript :P"))
var b=Int.self,a=[1]
a[2]=0

```

Try it online! (Swift)

Try it online! (JavaScript)

Output in Swift:

```
This program errors out in Swift :P
Fatal error: Index out of range

```
Output in JavaScript:
```
This program errors out in JavaScript :P
.code.tio:2:5 ReferenceError: Int is not defined
```

This also uses JavaScript's type system to tell the difference between the two languages.
> 0 votes

# Answer
# Ink and Haskell, 104 bytes

```
--This program errors out in ink :P->->
main=mapM putStr["This program errors out in Haskell :P",tail""]

```

Try it online! (Ink, Haskell)

In ink, the first line gets literally printed except for the `--` at the start, until it encounters the `->->`, which means "divert back to where you entered from", and is an error here since we didn't enter from anywhere. The second line is never reached.

In haskell, the first line is a comment. The second line prints the string in question, then tries (and fails) to discard the first element of an empty list.

# More interesting variant, 110 bytes

```
--T<>
h
 ~temp a="is program errors out in "
-- <>{a}ink :P->a
main=mapM putStr["Th",h()0,"Haskell :P",tail""]

```

Try it online! (Ink, Haskell)

In Haskell, if we ignore the comments, we're left with a function `h` which takes two parameters (matching lazily due to the `~`) and returning most of the string we want to print. Then `main` prints the beginning of the string, then the part described be `h`, then the end, and then fails by trying to discard the first character of an empty string.

```
h ~temp a="is program errors out in "
main=mapM putStr["Th",h()0,"Haskell :P",tail""]

```

In ink, the `T` and `h` get printed, the third line defines a variable containing most of the string, then the fourth line prints that, then the very end of the string, then fails because it tries to divert to a variable that contains a number rather than a valid divert target.

```
Th
~temp a="is program errors out in "
<>{a}ink :P->a

```
> 0 votes

# Answer
# Rust / Python 2, ~~128~~ ~~126~~ ~~124~~ 123 bytes

```
#[cold]fn main(){panic!(print!("This program errors out in Rust :P"))}/*
print"This program errors out in Python 2 :P";k#*/

```

Try it online: Rust, Python

## More interesting variant, 124 bytes

```
#[cold]fn main(){panic!(print!(/*
r="Python 2";print str.format(#*/
"This program errors out in {} :P",r#"Rust"#))}/*
);k#*/

```

Try it online: Rust, Python

## Rust

Rust sees this:

```
#[cold]fn main(){panic!(print!(
"This program errors out in {} :P",r#"Rust"#))}

```
* A harmless attribute is applied to main.
* Unusual string literal syntax is used.
* Error:

```
thread 'main' panicked at 'Box<Any>', code.tio:1:18
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

```

## Python

Python sees this:

```
r="Python 2";print str.format(
"This program errors out in {} :P",r
);k

```

Error:

```
Traceback (most recent call last):
  File ".code.tio", line 4, in <module>
    );k#*/
NameError: name 'k' is not defined

```

## Potential improvements I don't want to make

* (-2) The `2` in `Python 2` is technically not required by the rules
* (-1) Use `#[doc]` instead of `#[cold]` \- this generates a soft error -- a warning that'll become an error in the future.
> 0 votes

# Answer
# Nim & Python 2, 104 bytes

```
#[]#var s=""
s=("This program errors out in "#[
"Python"#]#&"Nim"&
" :P")#[
print s#]#
s.echo
s[42].echo

```

Try it online in Nim! Produces `IndexError`.

Try it online in Python! Produces `AttributeError`.

Uses the fact that Nim has delimited comments `#[ ]#`, whereas Python doesn't.
> 0 votes

# Answer
# Zsh `-596X` and Zsh `-596Xr`, 44 bytes

```
<<<"This program errors out in Zsh -$- :P"
/
```

Attempt This Online! (`-596X`)

Attempt This Online! (`-596Xr`)

The first line prints the string; the special global variable `$-` contains the shell's current options. `-596X` are set by default, but I've specified that we're using Zsh with those explicitly so that the `$-` output is correct.

In Zsh `-r`, commands containing slashes are not allowed and will error with `restricted`. Otherwise, `/` is a directory and cannot be a command, so will error with `permission denied`.
> 0 votes

# Answer
# Julia and Python, 65 bytes

```
~print("This program errors out in",[" Julia ","Python"][1],":P")

```
* Julia is 1-indexed while Python is 0-indexed, allowing to chose which one to print
* Julia needs spaces around its name because Python adds spaces between arguments and Julia doesn't
* both error messages can seem similar but they are 2 different errors:
    + the Python unary `~` doesn't accept `NoneType`:
    `TypeError: bad operand type for unary ~: 'NoneType'`
    + the Julia function `~` doesn't have the method `~(::Nothing)` defined:
    `LoadError: MethodError: no method matching ~(::Nothing)`

Try it online! (Julia)

Try it online! (Python)
> 0 votes

---
Tags: code-golf, polyglot
---


title: Convert Alpha-3 to Alpha-2

text:
# Question
Title: Convert Alpha-3 to Alpha-2
I've been developing some programs involving me fetching a vector from a url using Alpha-2 country codes (such as `GET /jp.svg` for Japan). Except, oh no! All the country data on my computer uses Alpha-3! That just won't do...
The task is simple: Take an Alpha-3 country code (e.g. `UKR`) and return its Alpha-2 equivalent (e.g. `UA`). And because my hard drive is smaller than the Vatican (and because this is ), the program must be as small as possible.
Codes can be found here
and below.

```
[["AFG", "AF"],["ALA", "AX"],["ALB", "AL"],["DZA", "DZ"],["ASM", "AS"],["AND", "AD"],["AGO", "AO"],["AIA", "AI"],["ATA", "AQ"],["ATG", "AG"],["ARG", "AR"],["ARM", "AM"],["ABW", "AW"],["AUS", "AU"],["AUT", "AT"],["AZE", "AZ"],["BHS", "BS"],["BHR", "BH"],["BGD", "BD"],["BRB", "BB"],["BLR", "BY"],["BEL", "BE"],["BLZ", "BZ"],["BEN", "BJ"],["BMU", "BM"],["BTN", "BT"],["BOL", "BO"],["BIH", "BA"],["BWA", "BW"],["BVT", "BV"],["BRA", "BR"],["VGB", "VG"],["IOT", "IO"],["BRN", "BN"],["BGR", "BG"],["BFA", "BF"],["BDI", "BI"],["KHM", "KH"],["CMR", "CM"],["CAN", "CA"],["CPV", "CV"],["CYM", "KY"],["CAF", "CF"],["TCD", "TD"],["CHL", "CL"],["CHN", "CN"],["HKG", "HK"],["MAC", "MO"],["CXR", "CX"],["CCK", "CC"],["COL", "CO"],["COM", "KM"],["COG", "CG"],["COD", "CD"],["COK", "CK"],["CRI", "CR"],["CIV", "CI"],["HRV", "HR"],["CUB", "CU"],["CYP", "CY"],["CZE", "CZ"],["DNK", "DK"],["DJI", "DJ"],["DMA", "DM"],["DOM", "DO"],["ECU", "EC"],["EGY", "EG"],["SLV", "SV"],["GNQ", "GQ"],["ERI", "ER"],["EST", "EE"],["ETH", "ET"],["FLK", "FK"],["FRO", "FO"],["FJI", "FJ"],["FIN", "FI"],["FRA", "FR"],["GUF", "GF"],["PYF", "PF"],["ATF", "TF"],["GAB", "GA"],["GMB", "GM"],["GEO", "GE"],["DEU", "DE"],["GHA", "GH"],["GIB", "GI"],["GRC", "GR"],["GRL", "GL"],["GRD", "GD"],["GLP", "GP"],["GUM", "GU"],["GTM", "GT"],["GGY", "GG"],["GIN", "GN"],["GNB", "GW"],["GUY", "GY"],["HTI", "HT"],["HMD", "HM"],["VAT", "VA"],["HND", "HN"],["HUN", "HU"],["ISL", "IS"],["IND", "IN"],["IDN", "ID"],["IRN", "IR"],["IRQ", "IQ"],["IRL", "IE"],["IMN", "IM"],["ISR", "IL"],["ITA", "IT"],["JAM", "JM"],["JPN", "JP"],["JEY", "JE"],["JOR", "JO"],["KAZ", "KZ"],["KEN", "KE"],["KIR", "KI"],["PRK", "KP"],["KOR", "KR"],["KWT", "KW"],["KGZ", "KG"],["LAO", "LA"],["LVA", "LV"],["LBN", "LB"],["LSO", "LS"],["LBR", "LR"],["LBY", "LY"],["LIE", "LI"],["LTU", "LT"],["LUX", "LU"],["MKD", "MK"],["MDG", "MG"],["MWI", "MW"],["MYS", "MY"],["MDV", "MV"],["MLI", "ML"],["MLT", "MT"],["MHL", "MH"],["MTQ", "MQ"],["MRT", "MR"],["MUS", "MU"],["MYT", "YT"],["MEX", "MX"],["FSM", "FM"],["MDA", "MD"],["MCO", "MC"],["MNG", "MN"],["MNE", "ME"],["MSR", "MS"],["MAR", "MA"],["MOZ", "MZ"],["MMR", "MM"],["NAM", "NA"],["NRU", "NR"],["NPL", "NP"],["NLD", "NL"],["ANT", "AN"],["NCL", "NC"],["NZL", "NZ"],["NIC", "NI"],["NER", "NE"],["NGA", "NG"],["NIU", "NU"],["NFK", "NF"],["MNP", "MP"],["NOR", "NO"],["OMN", "OM"],["PAK", "PK"],["PLW", "PW"],["PSE", "PS"],["PAN", "PA"],["PNG", "PG"],["PRY", "PY"],["PER", "PE"],["PHL", "PH"],["PCN", "PN"],["POL", "PL"],["PRT", "PT"],["PRI", "PR"],["QAT", "QA"],["REU", "RE"],["ROU", "RO"],["RUS", "RU"],["RWA", "RW"],["BLM", "BL"],["SHN", "SH"],["KNA", "KN"],["LCA", "LC"],["MAF", "MF"],["SPM", "PM"],["VCT", "VC"],["WSM", "WS"],["SMR", "SM"],["STP", "ST"],["SAU", "SA"],["SEN", "SN"],["SRB", "RS"],["SYC", "SC"],["SLE", "SL"],["SGP", "SG"],["SVK", "SK"],["SVN", "SI"],["SLB", "SB"],["SOM", "SO"],["ZAF", "ZA"],["SGS", "GS"],["SSD", "SS"],["ESP", "ES"],["LKA", "LK"],["SDN", "SD"],["SUR", "SR"],["SJM", "SJ"],["SWZ", "SZ"],["SWE", "SE"],["CHE", "CH"],["SYR", "SY"],["TWN", "TW"],["TJK", "TJ"],["TZA", "TZ"],["THA", "TH"],["TLS", "TL"],["TGO", "TG"],["TKL", "TK"],["TON", "TO"],["TTO", "TT"],["TUN", "TN"],["TUR", "TR"],["TKM", "TM"],["TCA", "TC"],["TUV", "TV"],["UGA", "UG"],["UKR", "UA"],["ARE", "AE"],["GBR", "GB"],["USA", "US"],["UMI", "UM"],["URY", "UY"],["UZB", "UZ"],["VUT", "VU"],["VEN", "VE"],["VNM", "VN"],["VIR", "VI"],["WLF", "WF"],["ESH", "EH"],["YEM", "YE"],["ZMB", "ZM"],["ZWE", "ZW"]]

```

## Rules

* Your answer must work with all countries and territories
* You may not fetch any data from the internet.
* Standard loopholes apply.
* This is , so the shortest code in bytes in each language wins.

Input/Output may be a string, list of characters, or list of character codes. Text case does not matter

## Test Cases

### Countries

```
USA -> US     # United States
AUS -> AU     # Australia
BIH -> BA     # Bosnia and Herzegovina
ISL -> IS     # Iceland
FSM -> FM     # Micronesia
SYC -> SC     # Seychelles

```

### Territories

```
UMI -> UM     # US Minor Outlying Islands
SPM -> PM     # Saint Pierre and Miquelon
GUF -> GF     # French Guiana
ATF -> TF     # French Southern Territories
HKG -> HK     # Hong Kong
IOT -> IO     # British Indian Ocean Territory

```

# Answer
> 13 votes
# JavaScript (Node.js), 253 bytes

*Saved 1 byte thanks to @MatthewJensen*

Expects a string in upper case. Returns an array of 2 characters.

```
s=>["TKKYKGPR"[i="ATFCOMCYMMYTPRKSGSSPMSRBALAATABLRBENBIHMACESTGNBIRLISRSVNUKR".search(s)/3]||s[0],"FMYTPSMSXQYJAOEWELIA"[i]||s[2-Buffer(`Z&:^*Wf&*/1*EKe'(1#/.534aq>HI*"#0551(C=J@75%,.I>"!G0"2#1)%)(2p#/4@!&<`).every(n=>q-=n-32,q=parseInt(s,36)*5%1601)]]

```

Try it online!

Or **250 bytes** with unprintable characters:

Try it online!

## How?

### Groups

We categorize the Alpha-2 codes into 4 groups:

1. Codes made of the first two letters of the Alpha-3 code, e.g. `AFG``AF` (156 entries).
2. Codes made of the 1st and last letters of the Alpha-3 code, e.g. `ATG``AG` (71 entries).
3. Other codes whose 1st letter is the 1st letter of the Alpha-3 code, e.g. `UKR``UA` (12 entries).
4. Codes whose 1st letter is not the 1st letter of the Alpha-3 code, e.g. `CYM``KY` (8 entries).

### Initial lookup

We first test whether the input belongs to either group 3 or group 4 by looking for its position `i` into the following lookup string (without the spaces), divided by 3:

```
ATF COM CYM MYT PRK SGS SPM SRB ALA ATA BLR BEN BIH MAC EST GNB IRL ISR SVN UKR
\_____________________________/ \_____________________________________________/
            group 4                                 group 3

```

### First letter

For the first letter, we attempt to get:

```
"TKKYKGPR"[i] // lookup string for group 4

```

If this is undefined, we use the first letter of the input.

### Second letter

For the second letter, we attempt to get:

```
"FMYTPSMSXQYJAOEWELIA"[i] // lookup string for groups 4 and 3

```

If this is undefined, we need to figure out whether we should use the 2nd or 3rd letter of the input.

We apply the following hash function to the input string:

```
q = parseInt(s, 36) * 5 % 1601

```

and test whether we can reach exactly \\$0\\$ by subtracting the ASCII codes minus \\$32\\$ of the corresponding data string from `q`:

```
`Z&:^*Wf&*/1*EKe'(1#/.534aq>HI*"#0551(C=J@75%,.I>"!G0"2#1)%)(2p#/4@!&<`

```

This is encoding the entries that belong to group 2.

For instance, `parseInt("JAM", 36)` is \\$25006\\$, which leads to:

$$q=(25006\times 5)\bmod 1601=125030\bmod 1601=152$$

Using the first four characters `Z&:^` of the data string, we find out that this is the sum of:

$$\operatorname{ord}(\text{"Z"})-32+\operatorname{ord}(\text{"&"})-32+\operatorname{ord}(\text{":"})-32+\operatorname{ord}(\text{"^"})-32\\\=58+6+26+62$$

which means that `"JAM"` belongs to group 2 and the correct answer is `"JM"`.

# Answer
> 4 votes
# 05AB1E, ~~238~~ 219 bytes

```
¨I2ιн.•LS’αPñΔ•.•„Rà´θ≠…āñ©B—‚Ls¿ºÄ¿α>°%»^cýαƒ¸AbŒΓÝ€I†„{rʒKÓÎƶÿ}ιUƶ–ΔΓ5`Δ9Λº½P.÷ü)–\ÎÇÕ¡â"‚0’₁Ýá+_.n¯₅Èg«J¡þ&м£ñ:‡‘÷&´”тε?ʒ^÷δ“ ¥ΔàHÌAiìb0SĀ'WDî>ηOāß7|^î‘€'òê®ćM2¤γù£Œ∞Néä_}àŒ@‹Ó•3ôIlk₄%©èIнì.•TŠ+º°•2ô®èI¦)®•rá÷•₃в‹Oèu

```

Try it online or verify all test cases.

**Explanation:**

There are five possible groups:

1. Those for which the first character is removed
2. Those for which the middle character is removed
3. Those for which the last character is removed
4. Those for which the last two characters are replaced with a different character, but the first character remains unchanged
5. Those for which all three characters are replaced with two different characters

My program does three steps:

1. Generate the five possible results above (in the order 1,2,4,5,3), and put them in a list:

```
¨            # (1) Remove the last character from the (implicit) input-string
I            # (2) Push the input-string again
 2ι          # Uninterleave it into two parts: "abc" → ["ac","b"]
   н         # Only leave the first part
.•LS’αPñΔ•   # (4) Push compressed string "aaeeijloqwxy"
  ...        # See step 2 below
     è       # Modular 0-based index the result of step 2 into this string
      Iн     # Push the first character of the input-string
        ì    # Prepend it in front of the indexed character
.•TŠ+º°•     # (5) Push compressed string "kykmkprs"
        2ô   # Split it into parts of size 2: ["ky","km","kp","rs"]
          ®  # Push the index of step 2 again
           è # Modular 0-based index it into this list
I            # (3) Push the input-string again
 ¦           # Remove its first character
)            # Wrap all five results on the stack into a list

```

Try just step 1 online.

2. Check in which group the input belongs:

```
.•„Rà´θ≠…āñ©B—‚Ls¿ºÄ¿α>°%»^cýαƒ¸AbŒΓÝ€I†„{rʒKÓÎƶÿ}ιUƶ–ΔΓ5`Δ9Λº½P.÷ü)–\ÎÇÕ¡â"‚0’₁Ýá+_.n¯₅Èg«J¡þ&м£ñ:‡‘÷&´”тε?ʒ^÷δ“ ¥ΔàHÌAiìb0SĀ'WDî>ηOāß7|^î‘€'òê®ćM2¤γù£Œ∞Néä_}àŒ@‹Ó•
            "# Push compressed string "atfmytspmsgscymcomprksrbatagnbalablrbihukrestirlsvnbenisrmacabwagoandarearmatgautbdibgdbhsblzbrbbrncafchlchncodcogcokcpvdnkeshflkfrofsmginglpgnqgrdgrlgufguyirqjamkazkorlbrlbymafmdgmdvmexmltmnemnpmozmtqniupakpcnplwpngpolprtprypyfsenslbslvsursvksweswzsyctcdtkmtunturtuvurywlf"
  3ô         # Split it into parts of size 3: ["atf","myt",...,"wlf","esh"]
    I        # Push the input-string
     l       # Convert it to lowercase
      k      # Get its index in this list (or -1 if not found)
       ₄%    # Modulo-1000 to convert the -1 to 999
         ©   # Store it in variable `®` (without popping)

```

Try just step 2 online.

3. Use that to index into the quintuplet of possible results:

```
®            # Push the index of step 2 again
 •rá÷•       # Push compressed integer 3503691
      ₃в     # Convert it to base-95 as list: [4,8,20,91]
        ‹    # Check for each if its larger than the index
         O   # Sum to get the amount of truthy values
          è  # Use that to index into the result-quintuplet of step 1
           u # Uppercase it for the potential lowercase characters
             # (after which the result is output implicitly)

```

Try just (the first portion of) step 3 online.

---

See this 05AB1E tip of mine (sections *How to compress strings not part of the dictionary?*, *How to compress large integers?*, and *How to compress integer lists?*) to understand why `.•LS’αPñΔ•` is `"aaeeijloqwxy"`; `.•TŠ+º°•` is `"kykmkprs"`; `.•„Rà´θ≠…āñ©B—‚Ls¿ºÄ¿α>°%»^cýαƒ¸AbŒΓÝ€I†„{rʒKÓÎƶÿ}ιUƶ–ΔΓ5`Δ9Λº½P.÷ü)–\ÎÇÕ¡â"‚0’₁Ýá+_.n¯₅Èg«J¡þ&м£ñ:‡‘÷&´”тε?ʒ^÷δ“ ¥ΔàHÌAiìb0SĀ'WDî>ηOāß7|^î‘€'òê®ćM2¤γù£Œ∞Néä_}àŒ@‹Ó•` is `"atfmytspmsgscymcomprksrbatagnbalablrbihukrestirlsvnbenisrmacabwagoandarearmatgautbdibgdbhsblzbrbbrncafchlchncodcogcokcpvdnkeshflkfrofsmginglpgnqgrdgrlgufguyirqjamkazkorlbrlbymafmdgmdvmexmltmnemnpmozmtqniupakpcnplwpngpolprtprypyfsenslbslvsursvksweswzsyctcdtkmtunturtuvurywlf"`; `•rá÷•` is `3503691`; and `•rá÷•₃в` is `[4,8,20,91]`.

# Answer
> 4 votes
# Wolfram Language (Mathematica), 115 bytes (uses builtin libraries)

Turns out there's a builtin for everything! There was a restriction against using internet connectivity, so I'm not sure if the builtin data is allowed, but if so, it's the shortest.

```
If[#=="HMD"||#=="ANT"||#=="PSE",#~StringTake~2&,Association[#@"UNCode"->#@"CountryCode"&/@EntityList@"Country"]]@#&

```

This code doesn't work right on TIO due to using Mathematica's libraries. Also takes quite a while to run, but it does work for every test case, although I did have to hardcode in the three cases seen in the If statement.

(Don't) try it online!

Here's a cloud notebook with the code: https://www.wolframcloud.com/obj/romanp/Published/CountryCodeConvert

It should eventually return the correct values, but if it doesn't, you can copy the code and test it either in the cloud on a smaller test case or in a personal installation.

# Answer
> 3 votes
# Charcoal, 241 bytes

```
≔⌕⪪”$⌊σ⎚✂↔¿^Ｔ”³θη¿⊕η§⪪KYKMKPRS²η«¿№⪪”$⌊´u⪫∕γ+T”³θΦθκ«§θ⁰≔⌕⪪”$‽∧⌕¤MÀ;S¦Ｏ⪫;¦⁻\I-→mxτ9”³θη¿⊕η§XQYJAOEWELIAη§θ⊕№⪪”$⌈“ＭＯNＺ⦃§r\`>7∨M¹↘№κ➙@◨33✳¦z≕ςie�+ψΦ|Ｊ1ιν‴№²⌈o≧h⟦UE∧№›.Ｇ›dWＳ&σ∨⟧Ｊm∧‴>¦¦◧Ｄ@QＪ∧#e↨⁷*+Ｕ‴∕b✂�\6j4)τ″?⎚9∧§6ρ⮌ζσ↗.Ｂ↨$]h↓¹ＮφＸ¡¹~⮌S₂7�Ｆm;”³θ

```

Try it online! Link is to verbose version of code. Explanation (with compressed lookup tables redacted to `⪪”...”³`):

```
≔⌕⪪”...”³θη¿⊕η§⪪KYKMKPRS²η«

```

If the country is one of CYM, COM, PRK or SRB, then output KY, KM, KP or RS respectively, otherwise:

```
¿№⪪”...”³θΦθκ«

```

If the country is one of ATF, MYT, SPM or SGS, then output the second and third letters, otherwise:

```
§θ⁰

```

Output the first letter.

```
≔⌕⪪”...”³θη¿⊕η§XQYJAOEWELIAη

```

If the country is one of ALA, ATA, BLR, BEN, BIH, MAC, EST, GNB, IRL, ISR, SVN or UKR, then output the respective letter from XQYJAOEWELIA, otherwise:

```
§θ⊕№⪪”...”³θ

```

Output either the second or third letter of the input appropriately.

# Answer
> 3 votes
# \+ countrycode, ~~76~~ 74 bytes (using library)

*Edit: -2 bytes thanks to pajonk*

```
function(c)`if`(c=="ANT","AN",countrycode::countrycode(c,"iso3c","iso2c"))

```

Try it at rdrr.io

Seemingly the  'countrycode' library is more comprehensive than Mathematica's "CountryCode" builtin, although still not perfect and requiring "ANT" to be hard-coded.

# Answer
> 2 votes
# Perl 5 `-MLocale::Country -pl`, 48 bytes

```
$_=country_code2code($_,'alpha-3','alpha-2')||an

```

Try it online!

The ANT-\>AN mapping isn't in Perl's list, so it's hardcoded.

# Answer
> 1 votes
# Whython, 370 bytes

```
lambda c:"AABBBKMKETGIIKYRPSGU"[p:="ALAATABLRBENBIHCYMMACCOMESTATFGNBIRLISRPRKMYTSRBSPMSVNSGSUKR".index(c)//3]+"XQYJAYOMEFWELPTSMISA"[p]?c[0]+c[1+(c in"ATGARMAUTABWBHSBGDBRBBLZBRNBDIANDAGOCPVCAFTCDCHLCHNCOGCODCOKDNKSLVGNQFLKFROGUFPYFGRLGRDGLPGINGUYIRQJAMKAZKORLBRLBYMDGMDVMLTMTQMEXFSMMNEMOZNIUMNPPAKPLWPLPNGPRYPCNPOLPRTMAFSENSYCSVKSLBSURSWZSWETUNTURTKMTUVURYWLFESHARE")]
```

Attempt This Online!

Improvable

# Answer
> 1 votes
# Vyxal, 217 bytes

```
Ṫ⁰y_«⌐ƈḣAɾǑP««∷Þ≤¦HU¤żǑ₄°ṅ›⌐7İḊṖİAs§dĖy'ΠA‹Ḃ»&ḃO꘍∴øð∷|6@¢⌊⁰ė‟~R¨ėṁPO∨{P
∵ḊĠɾm≬¾hṁw⁰Ṫ±√≠a›λḣY꘍≥jzm2⁋]Ẇ+₆↔√„eK⟩Ǒo→ġ≬e¦ŀMEt@y≬Dḭ^₀P≤∆₌»-⇩&λƈḟf!ßǎsGʁż℅÷}yǎġ∴fǒ¥¶ẇæ¬‛C↵⟩ḃXʀ£ƒz~≤ḃuȧ⌊«3ẇ⁰ɽḟk1%:£i⁰hp«∞τjḊ§«2ẇ¥i⁰ḢW¥»?Ṫ4»₁τ<∑i⇧

```

Try it Online! or Run all the test cases or Try it on every country code

Port of 05AB1E.

## How?

```
Ṫ⁰y_«⌐ƈḣAɾǑP««∷Þ≤¦HU¤żǑ₄°ṅ›⌐7İḊṖİAs§dĖy'ΠA‹Ḃ»&ḃO꘍∴øð∷|6@¢⌊⁰ė‟~R¨ėṁPO∨{P
∵ḊĠɾm≬¾hṁw⁰Ṫ±√≠a›λḣY꘍≥jzm2⁋]Ẇ+₆↔√„eK⟩Ǒo→ġ≬e¦ŀMEt@y≬Dḭ^₀P≤∆₌»-⇩&λƈḟf!ßǎsGʁż℅÷}yǎġ∴fǒ¥¶ẇæ¬‛C↵⟩ḃXʀ£ƒz~≤ḃuȧ⌊«3ẇ⁰ɽḟk1%:£i⁰hp«∞τjḊ§«2ẇ¥i⁰ḢW¥»?Ṫ4»₁τ<∑i⇧
                # ^ full program
Ṫ               # Remove the last character of the (implicit) input
 ⁰              # Push the input again
  y             # Uninterleave, push a[::2] and a[1::2] to the stack
   _            # Pop so a[1::2] is removed. Stack: a[:-1], a[::2]
    «⌐ƈḣAɾǑP«   # Push compressed string "aaeeijloqwxy"
«∷Þ≤¦HU¤żǑ₄°ṅ›⌐7İḊṖİAs§dĖy'ΠA‹Ḃ»&ḃO꘍∴øð∷|6@¢⌊⁰ė‟~R¨ėṁPO∨{P
∵ḊĠɾm≬¾hṁw⁰Ṫ±√≠a›λḣY꘍≥jzm2⁋]Ẇ+₆↔√„eK⟩Ǒo→ġ≬e¦ŀMEt@y≬Dḭ^₀P≤∆₌»-⇩&λƈḟf!ßǎsGʁż℅÷}yǎġ∴fǒ¥¶ẇæ¬‛C↵⟩ḃXʀ£ƒz~≤ḃuȧ⌊«
                # Push compressed string "atfmytspmsgscymcomprksrbatagnbalablrbihukrestirlsvnbenisrmacabwagoandarearmatgautbdibgdbhsblzbrbbrncafchlchncodcogcokcpvdnkeshflkfrofsmginglpgnqgrdgrlgufguyirqjamkazkorlbrlbymafmdgmdvmexmltmnemnpmozmtqniupakpcnplwpngpolprtprypyfsenslbslvsursvksweswzsyctcdtkmtunturtuvurywlf"
3ẇ              # Split into chunks of 3: ["atf", "myt", "spm", ..., "ury", "wlf"]
  ⁰ɽ            # Push the input and lowercase it
    ḟ           # Find its index in the list (-1 if not found)
     k1%        # Modulo 1000 to convert -1 to 999
        :£      # Store in the register without popping
          i     # Index this into the string pushed earlier ("aaeeijloqwxy")
           ⁰h   # Push the first character of the input
             p  # Prepend it
«∞τjḊ§«         # Push compressed string "kykmkprs"
       2ẇ       # Split into chunks of two
         ¥      # Push the contents of the register
          i     # Index this into the list
           ⁰Ḣ   # Push the input without the first character
W               # Wrap these five values on the stack into a list
 ¥              # Push the contents of the register
  »?Ṫ4»         # Push compressed integer 4082091
       ₁τ       # Convert to base 100 list: [4, 8, 20, 91]
         <      # For each item, is the register (pushed earlier) less than it?
          ∑     # Sum this to get the amount of integers that the register is less than
           i    # Index this into the list pushed earlier
            ⇧   # Uppercase

```

---
Tags: code-golf, string, kolmogorov-complexity
---


title: Random Pixels Image Compression

text:
# Question
Title: Random Pixels Image Compression
## Challenge:

Given an integer \\$n\\$, guaranteed to be \\$\geq2\\$ and a power of 2, we are going to draw multiply boards either side-by-side or below one another, where the first has dimensions of \\$n\\$ by \\$n\\$; the second \\$\frac{n}{2}\\$ by \\$\frac{n}{2}\\$; the third \\$\frac{n}{4}\\$ by \\$\frac{n}{4}\\$; etc.; until the final \\$1\\$ by \\$1\\$ pixel.

The first \\$n\\$ by \\$n\\$ board will have its pixels uniformly randomly generated with black (`rgb(0,0,0)`/`#000000`) and white (`rgb(255,255,255)`/`#FFFFFF`) pixels. The next \\$\frac{n}{2}\\$ by \\$\frac{n}{2}\\$ compressed image will have each 2x2 block of pixels reduced to the color with the most pixels in that block (thus if a 2x2 block has four or three pixels of the same color, it becomes that color; and if both colors have two pixels each, we again choose one uniformly randomly).

It must be clear how the boards of each iteration are separated.

## Challenge rules:

* Output is flexible, but must be a . So it can be drawn and shown in a frame/canvas; output to an image-file on disk; drawn in a graph; generated as black/white Minecraft Wool blocks; generated as colored MS Excel cells; etc.
* As mentioned, it should be clear how the boards of each iteration are separated. This can for example be done by using a non-white and non-black color: setting a background of your canvas with a single pixel delimiter between boards or surrounding each board with a border. Alternatively you can output each board separately, in its own image-file or own canvas tab/window perhaps.
* The iterations can be drawn both horizontally or vertically, and alignment is irrelevant (e.g. vertical output with right aligned blocks is fine).
* The size of the individual blocks doesn't necessarily have to be a single pixel, as long as they are all the same size and squares.

**Example:**

Input: \\$8\\$
Potential output - horizontal; bottom-aligned; red background as separator:

Same example output, but vertical, right-aligned, with a blue border as separator instead:

## General rules:

* This is , so the shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* Standard rules apply for your answer with default input rules and graphical output rules.
* Default Loopholes are forbidden.
* If possible, please add a link with a test for your code, and if not, please include an example screenshot of the output.
* Also, adding an explanation for your answer is highly recommended.

# Answer
## JavaScript (browser), 334 bytes

```
f=
n=>[...n.toString(2)].map((_,i)=>(c=document.createElement`canvas`,c.height=c.width=s=n>>i,c.getContext`2d`.putImageData(new ImageData(new Uint8ClampedArray(Int32Array.from([].concat(...a=[...Array(s)].map((_,x,t)=>t.map((_,y)=>Math.random()<(i?a[x][y+=y]+a[x+1][y]+a[x][++y]+a[x+1][y]-1.5:.5),x+=x))),b=>-1<<b*24).buffer),s),0,0),c))
;g=n=>{m.value=0;m.max=n;a=f(1<<n);h(0);};h=n=>o.replaceChildren(a[n]);g(8)
```

```
canvas{width:256px;height:256px;image-rendering:pixelated;}
```

```
log<sub>2</sub>n: <input id=n type=number size=1 min=0 max=8 value=8><input type=button value=Go! onclick=g(+n.value)><input id=m type=number size=1 min=0 max=8 value=0 oninput=h(+this.value)><div id=o>
```

Viewer takes input of `log₂n`. To use the viewer, choose `n`, click `Go!`, then use the second input to select which of the output canvases to insert into the DOM. Because the CSS is fixed at `256` pixels, this limits the inputs to `8`; the browser's actual limit is `15`.
> 3 votes

# Answer
# C (GCC), 296 bytes

```
#define f(I,J,d)for(i=0;i<I;i+=d)for(j=0;j<J;j+=d)
main(N,n,i,j,c){scanf("%d",&N);char m[N][N];f(N,N,1)m[i][j]=rand()&2;printf("P5 %d %d 2 ",N,N*2+(int)log(N));for(n=N;n;n/=2){f(n+1,N,1)putchar(j<n&i<n?m[i][j]:1);f(n,n,2)m[i/2][j/2]=(c=m[i][j]+m[i+1][j]+m[i][j+1]+m[i+1][j+1])-4?c/5*2:rand()&2;}}
```

Attempt This Online!

Outpus a PGM image.

Since PGM stands for "Portable Gray Map", the output is a grayscale image. The `2` in `printf("P5 %d %d 2 "` is the maximum gray value, hence there are three possible colors: `0` (black), `1` (50% gray), and `2` (white).

Whit the instruction `m[i][j]=rand()&2;`, each element of the matrix is assigned a random value (with \\$p(X=0)=0.5\\$ and \\$p(X=2)=0.5\\$), hence the pixels are uniformly randomly generated with black and white pixels.

In the compression phase, the `(c=m[i][j]+m[i+1][j]+m[i][j+1]+m[i+1][j+1])-4?` expression is false if two of the four pixels have value `2` (that is, they are white, and the other two are black).

The value `1` is used only for the background pixels.
> 2 votes

# Answer
# , 91 bytes

```
load'viewmat'
[:viewmat[:,.~/[:>:&>(,:~2 2)0:`(?@2)`1:@.(1+_2*@++/@,);._3&.:>^:a:[:<,~?@$2:

```

Try it online!

Output from the above is show below, since TIO won't produce images.

However, here is a TIO link that outputs the raw matrix data, which is where all the logic is. The image is produced simply by calling `viewmat` on that.

f 16:
> 2 votes

# Answer
# Wolfram Language (Mathematica), 93 bytes

```
Image/@NestList[BlockMap[Boole[#~Total~2+r[]>2]&,#,{2,2}]&,r=RandomInteger;1~r~{#,#},Log2@#]&

```

Try it online!

This is a function that takes an input `n` and returns a list of images. TIO can't display the images, but both the Notebook interface and @wolframtap supports graphical output.
> 2 votes

# Answer
# Yabasic, 196 bytes

Program that takes input \\$n\\$ from STDIN and outputs to a 'grafic' window.

```
Input n
Open Window 5*n,3*n
Color 0,0,99
Fill Circle 0,0,6*n
While n>.5
For x=1To n
For y=1To n
Color 0,0,0
If ran(2)>1Color 255,255,255
Box 2*x+o-1,2*y-1,2*x+o,2*y
Next
Next
o=o+2*n+2
n=n/2
Wend

```

### Commented

```
Input n                       rem   take input
Open Window 5*n,3*n           rem   open a graphics window
Color 0,0,99                  rem   set brush color to blue
Fill Circle 0,0,9*n           rem   fill background
While n>.5                    rem   iter across subimages
For x=1To n                   rem   iter across subimage's x
For y=1To n                   rem   iter across subimage's y
Color 0,0,0                   rem   set brush color to black
If ran(2)>1Color 255,255,255  rem   50% to set brush color to white
                              rem   draw a rectangle for the current cell
                              rem     of the subimage. Uses the 1px
Box 2*x+o-1,2*y-1,2*x+o,2*y   rem     border to draw each 2px X 2px cell
Next                          rem   loop
Next                          rem   loop
o=o+2*n+2                     rem   update offset for next subimage
n=n/2                         rem   decrement n by base 2 order of magnitude
Wend                          rem   loop

```

# Example Output (\\$n=256\\$)
> 0 votes

---
Tags: code-golf, graphical-output, random, image-processing, compression
---