'abc' and 'cba'

Question

Your task is simple, write a single code snippet that when executed in one language outputs only the string 'abc' and when executed in another language outputs only the string 'cba'. The program should take no input.

This is a code-golf challenge.

Answer 1

PHP + JavaScript, 29 28 bytes

This works because PHP interprets '0' (same as the integer number 0) as being falsy, while JavaScript assumes it is simply a non-empty string which is truthy.

'0'?alert('cba'):print(abc);

This is meant to run with -r on PHP. In Javascript, just paste it in the console.

---

Thanks to @Justin Mariner for saving me 1 byte!

Answer 2

PHP / Brainf*ck, 31 bytes

using the -r flag,

PHP sees die(abc) and a comment, and since the compiler is forgiving, it outputs abc as a string instead of an empty variable.

Brainf*ck only sees the instruction characters, and the rest is seen as comments.

die(abc);#--[----->+<]>---.-.-.

Try it online! (PHP)

Try it online! (Brainf*ck)

Answer 3

Julia and Octave/Matlab, 27 bytes

if'a'=="a""abc"else"cba"end

In Octave, both 'a' and "a" represent the same string, therefore 'a'=="a" is true. However, in Julia, 'a' is a single character while "a" is a one-character string. In Julia, "cba" is the output.

Ungolfed version:

if 'a'=="a"
  "abc"
else
  "cba"
end

Answer 4

Perl / Ruby, 18 bytes

Ruby

print'abc'.reverse

prints cba as we're calling .reverse on the string.

Try it online!

Perl

print'abc'.reverse

prints abc concatenated with the result of reverse which by default works on $_ which is empty and so makes no difference.

Try it online!

Answer 5

C / Common Lisp, 91 88 40 36 bytes

//(princ"abc")
;main(){puts("cba");}

Try it online – C

Try it online – Common Lisp

Both “normal” languages with very different syntax and semantics!

Explanation

For Common Lisp:

// is a special variable used in the Common Lisp REPL to give the result of the value preceding the previous one, initially equal to NIL. Then we prints abc. The following line starts with a semicolon, which is used to start one-line comments.

For C:

the first line is a comment, and the other is the program. Note that the semicolon before the definition of the main function is syntactically correct.

-1 byte thanks to @Zacharý

Answer 6

Python and Ruby, 30 bytes

print(['abc','cba'][(0 or 1)])

Ruby: the logical or short-circuits on 0, which is a truthy value.

Python: 0 is false, and the logical or yields 1.

Answer 7

Japt/Japt 2.0, 14 bytes

;AÊ?"abc":"cba

Japt outputs cba

Japt 2.0 outputs abc

Answer 8

MAWP / 1+, 71 bytes

1%(|"+1%+)1%()"+"+"+()();1%()"+"+"+()"+;1%()"+"+"+"+();77W2W1A!!;1M;2M;

Uses the % operator to remove all the stray 1's from the 1+ program. Rounded brackets are immediately skipped since there is no 0 in the stack for MAWP.

Try it! (MAWP)

Try it Online! (1+)

Answer 9

JavaScript (V8), 65 bytes

console.log(parseInt('abc--[----->+<]>---.-.-.',16).toString(16))

Try it online!

brainfuck, 65 bytes

console.log(parseInt('abc--[----->+<]>---.-.-.',16).toString(16))

Try it online!

Answer 10

Ruby / C, 26 20 bytes

puts(0?"abc":"cba");

-6 from Dom Hastings.

Try it online! (Ruby)

Try it online! (C)

0 is a truthy value in Ruby, so it prints "abc", and C prints "cba".

puts is a function that works in both languages.

Answer 11

Braingolf and Lean Mean Bean Machine, 35 bytes

 O
""
#a
!!
""
#b
!!
""
#c
& ,&
@U;

Braingolf: Try it online!
LMBM: Try it online!

Outputs abc in LMBM, and cba in Braingolf.

Explanation

LMBM is a 2d language, which allows us to selectively execute the code we want.
Meanwhile Braingolf is a 1d language, meaning it starts at the top left, and goes across each line, executing code. It terminates upon reaching the end of the code.

In LMBM, a marble is spawned at every uppercase O when the program starts. Each tick it drops 1 character and executes the character. LMBM terminates once all marbles are destroyed.

A double quote " in LMBM sets the marble to char mode, meaning the next character to execute is interpreted as a 1 char string literal, and the marble's value is set to the codepoint of the character.

However " begins and terminates a string in Braingolf, automatically pushing the contents to the stack. Thankfully an empty string does nothing.

! in LMBM prints the marble's value as a char, however this is the silent modifier in Braingolf. Thankfully in braingolf v1, modifiers are only held through no-ops, meaning they will be dropped when braingolf hits the empty string, which doesn't use modifiers (unlike v2 where they are held until used) so we don't have to make sure to consume that modifier before we try to print the stack.

In Braingolf # is the char literal identifier, causing the codepoint of the next char to be pushed to the stack.

After passing through all of the characters (and in LMBM's case printing the first 2) we hit the last 2 lines.
The 2nd to last line does nothing in LMBM, as it simply drops through the space, a no-op.

In Braingolf however, the ampersand & is the greedy modifier. Modifiers in Braingolf are held through no-ops such as the space, until an operator consumes them, so the first ampersand is held through the space until it hits the comma , Braingolf's flip operator. The greedy modifier is consumed here to cause Braingolf to flip the entire stack, rather than the top 2 items. Then another greedy modifier is hit.
This one is held through the newline to the at @ sign, this prints the entire stack as ASCII.

Meanwhile LMBM simply drops through the space into the U, which prints the marble's value as ASCII and destroys the marble.
The U also has a function in Braingolf, it pops the top of the stack and pushes range(0...n), but the stack is empty because we just popped and printed everything, so this does nothing.

Answer 12

Python 2, 27 bytes

print(['abc','cba'][1/2>0])

Try it online!

Python 3, 27 bytes

print(['abc','cba'][1/2>0])

Try it online!

Answer 13

Python 2, 28 bytes

print("abc"[::1/2and-1or 1])

Try it online!

Python 3, 28 bytes

print("abc"[::1/2and-1or 1])

Try it online!

Answer 14

Python 2 and Python 3, 31 bytes

print(round(.5)and"abc"or"cba")

Uses the and/or trick from Erik the Outgolfer's answer, as well as the fact that Python 3 uses banker's rounding, while Python 2 does not.

Try it - Python 2!

Try it - Python 3!

Answer 15

JavaScript (ES8 & ES6), 24 bytes

_=>"".padEnd?"abc":"cba"

Answer 16

05AB1E and MY, 22 bytes

Try it online! (05AB1E)

Hex String in Python:

'"abc"?\x8e\x01\x06\x89(\x02\x06\x89(\x80\x03\x06\x89(\x80&'

Rendered in 05AB1E's codepage:

"abc"?Žʒε‰(αε‰(€βε‰(€&

Rendered in MY's unimplemented codepage:

_RrH_⌈≡16ǵ'26ǵ'+36ǵ'+←

How?

Here is what 05AB1E sees:

"abc"?Žʒε‰(αε‰(€βε‰(€&
"abc"                   -  The string "abc"
     ?                  -  Print (no newline)
      Ž                 -  Break on empty stack
       ʒε‰(αε‰(€βε‰(€&  - Unread junk

What MY sees (I added a feature which causes errors to produce 0, in addition to fixing the r command.):

_RrH_⌈≡16ǵ'26ǵ'+36ǵ'+←
_                       Negate (0)
 R                      Convert to binary ([0])
  r                     Convert from binary (0)
   H                    Convert to hex ("0")
    _                   Negate (errors, so 0)
     ⌈                  Ceiling (0)
      ≡                 Match (0 0=>1)
       16ǵ'             'a'
           26ǵ'+        Prepend 'b'
                36ǵ'+   Prepend 'c'
                     ←  Output without a newline

I could have used …, but I don't want to divide by 0 to result in 0.

(Use the file polyglot.py)

Answer 17

C/><>, 58 bytes

#include <stdio.h>//^
int main(){puts(/*/*/"abc"//ooo;
);}

Answer 18

V/Vim, 6 bytes

iabcæ

Try it online!

V: cba

Vim: abc

V and Vim are backwards compatible, but V has many more commands mapped. In V, æ means <M-f>lip where it's meaningless in Vim.

Answer 19

JavaScript / Pascal, 40 bytes

JavaScript

Outputs "abc".

{alert`abc`/*}begin write('cba')end.{*/}

---

Pascal

Outputs "cba".

{alert`abc`/*}begin write('cba')end.{*/}

Try it online!

---

Pascal conveniently uses { } for block comments and, in JavaScript, { } are just scopes, which affect nothing in this context.

Answer 20

C and x86 DOS binary, 58 bytes

/* VX4!PZSXNN4s(D (D"5s@SCYAAA@!6cba*/main(){puts("abc");}

Answer 21

Pyth / Canvas, 14... bytes?

<4"abcｊｊｊ±" \┐

Try it in Pyth!
Try it in Canvas!

---

Pyth explanation:

<4                # All but the last 4 characters of:
  "abcｊｊｊ±"   　# String literal
               \┐ # Char literal, printing suppressed

Python 3 translation:

print("abcｊｊｊ±"[:-4])
"┐"

---

Canvas explanation:

Code               | Explanation                         | Stack
-------------------+-------------------------------------+----------------
<4"abc             | Push "<4\"abc" to the stack         | "<4\"abc"
      ｊｊｊ        |Remove first three characters of ToS | "abc"
           ±       | Reverse ToS                         | "cba"
             " \   | Push "\" \\" to stack               | "cba", "\" \\"
                 ┐ | Remove ToS                          | "cba"
                   | Print ToS (implicit)                |

Answer 22

brainfuck / Jelly, 24 bytes

-[+[>+<<]>+]>+.+.+.
“CBA

“ is encoded as 0xFE in Jelly's codepage. Jelly's codepage is backwards compatible with printable ASCII, so all other characters are encoded the same.

To brainfuck

Try it online!

-[+[>+<<]>+]> sets a cell to 64. +.+.+. increments and outputs three times, printing ABC.

To Jelly

Try it online!

The first line is parsed as valid Jelly, but is ignored.

The second line is a string literal with content CBA. The last line of the file is the main link, so this is printed.

Answer 23

Swift / JavaScript, 34 bytes

/*/*/alert`cba`// */*/print("abc")

Try it Online! (Swift)

Testing snippet (JavaScript):

/*/*/alert`cba`// */*/print("abc")

This works by abusing nested block comments in Swift. Swift interprets the code as /*/* Comment */*/print("abc") while JavaScript interprets the code as /*Comment*/alert`cba`//Comment

Answer 24

Python 3 and Batch, 24 bytes

print('abc')#|echo cba

This program just takes advantage of operators in both languages.

What Python Sees

print('abc') # This is a comment, do not run

What Batch Sees

oh noes! errors! run this -> echo cba

Answer 25

Tcl, 79 bytes

#include<stdio.h>/*
proc M {} {puts cba}
#*/
#define M main(){printf("abc");}
M

Try it online!

---

C (gcc), 79 bytes

#include<stdio.h>/*
proc M {} {puts cba}
#*/
#define M main(){printf("abc");}
M

Try it online!

Answer 26

Pxem (ぬこ's intended specification) and Pxem (pxemi.7z: his actual implementation), 16 bytes.

Filename:

.wcba.p.d.aabc.p

Content is empty.

What it does

ぬこ, the designer of Pxem, originally intended that .w should NOT get into the loop when stack is empty, but his reference implementation does not satisfy it: it gets into the loop when stack is empty. This is why none of we, implementers, have ever complied his intended specification at all.

Answer 27

JScript, VBScript, 42 bytes

rem=1;a="abc"/*
a="cba"'*/
WScript.echo(a)

Answer 28

C / ><>, 33 bytes

#//;ooo"cba"
main(){puts("abc");}

What C sees

Try it online!

#
​

Begin empty preprocessor directive.

//;ooo"cba"
​

Single-line comment.

main(){puts("abc");}

Print abc.

What ><> sees

Try it online!

#
​

Reflect the code in the other direction.

       "cba"
​

String literal. Push the character codes of abc to the stack in order.

    ooo
​

Output each of those characters. Since c is at the top of the stack, it is output first.

   ;
​

End the program.

 //
main(){puts("abc");}

Never executed.

Answer 29

><> and Underload, 14 bytes

"(abc)S"}}ooo;

To ><>:

Try it online!

"(abc)S"

String literal. Push the character codes of (abc)S to the stack.

        }}

Move the TOS to the bottom twice.

          ooo

Output three characters (cba).

             ;

Halt.

To Underload:

https://tio.run/##K81LSS3KyU9M@f9fSSMxKVkzWKm2Nj8/3/r/fwA

"

Unrecognized

 (abc)

Push the string abc.

      S

Output it.

       "}}ooo;

More unrecognized characters.

Answer 30

Add++/Whispers v2, 29 bytes

x:"abc"
O
> "cba"
>> Output 1

Try Add++ online!

Try Whispers online!

This exits with an exit code of 1 when run in Add++.

How it works

Add++

Add++ goes through each line in a linear fashion, executing as it does so. The first line

x:"abc"

sets the x variable to the string abc. Then

O

outputs that string. Next

> "cba"
>> Output 1

(the Whispers code), compares the strings abc and cba lexicographically before throwing an error at the double >> on the fourth line.

Whispers

Whispers removes any lines which don't match one of it's five regexes, all of which only match lines beginning with >, making the code processed by Whispers

> "cba"
>> Output 1

Whispers' execution model is almost the exact opposite of Add++; it begins at the bottom line, and calls the lines indicated by the numbers as arguments.

>> Output 1

calls the function stored on line 1, then outputs the result. Line 1 is

> "cba"

, a nilad line which returns a single value and takes no arguments. Here, it returns the string cba, which is then outputted by the last line.