您的任务很简单，编写一个代码段，当以一种语言执行时仅输出字符串，'abc'而以另一种语言执行时仅输出字符串'cba'。该程序不应该输入。

这是一个代码高尔夫挑战。

05AB1E / Pyth，5个字节

_"abc

在线尝试05AB1E！

在线尝试Pyth！

这也适用于Pyke，输出cba。

这也适用于Recursiva，输出cba。

MATLAB /八度，41字节

disp(flip('abc',size(randsample(2,2),2)))

在MATLAB中randsample(2,2)给出2×1向量，因此size(...,2)是1。因此flip沿第一个维度（即单例）应用，因此'abc'显示了原始字符串：

在八度randsample(2,2)给出了一个1×2矢量，所以size(...,2)是2。因此flip沿第二维应用，即字符串从左向右翻转：

25字节

print(1/2and'cba'or'abc')

在线尝试！（Python 2）

在线尝试！（Python 3）

空白和Bash，57个字节

   		    	
 
 	
     	
	    
 	
     	
	   	
echo  cba

在线尝试！

-1字节（如果==0写入），>0但这已经是另一个答案

Python 2，26个字节

print('acbbca'[1/2==0::2])

在线尝试！

Python 3，26个字节

print('acbbca'[1/2==0::2])

在线尝试！

1/20在Python 2中给出（floordiv），在Python 3中给出（truediv）0.5。因此，1/2==0在Python 3中给出1，在Python 2中给出0（实际上是布尔值，但它们只是整数），因此'acbbca'[1::2] => 'cba'对于Python 3 'acbbca'[0::2] => 'abc'给出并且对于Python给出2。

Excel / Google表格，_{41 28 27} 24字节

匿名工作表公式，无需输入即可输出"ABC"到Excel "CBA"中的调用单元格和Google表格中的调用单元格

=IfError(M("CBA"),"ABC")

在Google表格中，M(...)是的别名，并自动格式化为T(...)（的缩写Text()）。此调用返回传递的变量的文本值"CBA"。"CBA"没有被捕获为错误，因此"CBA"由返回IfError(...,"ABC")

在Excel中，没有M(...)函数，M(...)也不是别名，因此M("CBA")返回公式未找到错误#NAME?。它被捕获IfError(...,"ABC")，然后又返回"ABC"。

以前的版本，27，28，41字节

参见编辑以获取解释

=If(IsErr(A()),"ABC","CBA")

=If(IsErr(GT()),"ABC","CBA")

=IfError(If(Info("NUMFILE"),"ABC"),"CBA")

CJam / 05AB1E，6个字节

"abc"R

在线尝试：

• 贾姆 ;
• 05AB1E。

它如何在CJam中工作

"abc"    Push this string
R        Push variable R, predefined to the empty string
         Implicitly display stack

它如何在05AB1E中工作

"abc"    Push this string
R        Reverse
         Implicitly display top of the stack

向@HyperNeutrino道歉，因为他窃取了他的大部分答案（我还不敢发表评论）

Python 2，25个字节

print('acbbca'[1/2>0::2])

在线尝试！

Python 3，25个字节

print('acbbca'[1/2>0::2])

在线尝试！

Vim / Notepad.exe，10个字节

cbaabc<esc><backspace><backspace><backspace>

JavaScript（NodeJS）和PHP，46字节

<!--
strrev=console.log//--><?=
strrev("abc");

abc用JS和cbaPHP 打印。

在线尝试JS！

在线尝试PHP！（请注意，TIO不会隐藏HTML注释（<!--... -->）

Python / Befunge，20 18字节

@karhell节省了2个字节

print("abc")# ,,,@

在线尝试！对于Python

print("abc")然后，Python看到一条注释。

在线尝试！对于Befunge

Befunge，删除所有空指令和无用的指令看到"abc",,,@这使a，b并c在堆栈上，然后打印它们（后进-先出）。

Python 2 and Python 3, 42 bytes

try:exec("print'abc'")
except:print('cba')

Try it online! (Python 2)

Try it online! (Python 3)

Thought I'd try something different...

Excel/Google Sheets, 28 bytes

Inspired by @TaylorScott, who used a function that only exists in Excel, I found an even shorter function that only exists in Google Sheets. Conveniently, it is designed to return strings:

=iferror(join(,"cba"),"abc")

How it works

In Google Sheets, join([arg1], arg2, arg3,...argk) will concatenate arg2 -> argk, optionally using the separator specified in arg1. In this case, it successfully returns "cba."

Excel has no join function, so iferror sees a problem and returns "abc"

CJam and Gaia, 8 bytes

'c'b'a]$

Try it in CJam!

Try it in Gaia!

Explanation

In both languages this defines a list of characters.

In CJam, $ is sort, so it becomes abc.

In Gaia, $ joins the list into one string, giving cba.

Java 8 & C, 95 bytes

//\
interface a{static void main(String[]s){System.out.print("abc"/*
main(){{puts("cba"/**/);}}

Try it in Java 8 - resulting in "abc".
Try it in C - resulting in "cba".

Explanation:

//\
interface a{static void main(String[]s){System.out.print("abc"/*
main(){{puts("cba"/**/);}}

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[]s){System.out.print("abc");}}

//\
interface a{static void main(String[]s){System.out.print("abc"/*
main(){{puts("cba"/**/);}}

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(){{puts("cba");}}

Python 2 / Python 3, 28 bytes

print('abc'[::int(1/2*4)-1])

In Python 2 int(1/2*4)-1 evaluates to -1 and so prints cba. - TiO

In Python 3 it evaluates 1 so prints abc. - TiO

C and C++, 115, 78, 58, 56 bytes

#include<stdio.h>
main(){puts(sizeof('x')>1?"abc":"cba");}

78 bytes, thanks to challenger5.

58 bytes, thanks to aschepler.

56 bytes, thanks to hvd

Try it - C++!

Try it - C!

R/Cubix, 20 bytes

cat("abc")#u@o;o;o(;

R - Try it online!

Cubix - Try it online!

For R, cat("abc") then shameless abuse of comments. For Cubix

    c a
    t (
" a b c " ) # u
@ o ; o ; o ( ;
    . .
    . .

• "abc" Pushs a, b ad c onto the stack
• )# Increment the c, pushs number of element in stack
• u U-turn to the right
• ;( Remove the count, Decrement the c
• o;o;o@ Output cba and exit

Pushs the number on in stack

Python 3, 26 bytes

print('abc'[::-(1/2>0)|1])

Try it online!

Python 2, 26 bytes

print('abc'[::-(1/2>0)|1])

Try it online!

25-byte version with exit instead, which outputs to STDERR instead.

This is basically the same as print('abc'[::[1,-1][1/2>0]]), just that it's golfed.

Python 2 and Foo, 16 bytes

print"abc"[::-1]

Python 2

print"abc"[::-1]

Try Python 2 online!

Explanation

print"abc"[::-1]

print             # print... (duh)
     "abc"        # the string "abc"...
          [::-1]  # backwards

Foo

"abc"

Try Foo online!

Explanation

"abc"

"abc"               print the string "abc"

C (gcc) C++ (g++), 59 bytes

#include<stdio.h>
main(){puts("abc\0cba"+(sizeof(' ')&4));}

Fission / ><> , 11 bytes

!R"abc"ooo;

Try Fission Online

In Fission, a particle starts at R and prints abc.

Try ><> Online

In ><>, the IP starts at the top-left. ! skips the next instruction, and "abc" pushes [a,b,c] on the stack. ooo then pops and prints three times, giving cba.

Both programs end at ;

Ly / ><>, 20 19 bytes

"abc"&&ov
;     oo<

Try it with ><>!

Try it with Ly!

These languages are very similar, as Ly is based off ><>. However, Ly does not have 2D execution and interprets & differently, which I took advantage of here.

Both languages will start by pushing abc to the stack.

For ><>, the & instruction moves values to and fro the register. Two in a row will push a value to the register and then take it straight back, essentially a NOP.

For Ly, & is a modifier that makes an instruction perform its function on the entire stack.

o means the same thing for both languages, but since it is modified by & in Ly, it will print the whole stack, outputting abc. In ><>, it will only output c (as it is printed from the top down)

v is a NOP in Ly, which skips it and goes straight to ;, ending execution. ><> will instead treat it as a pointer, sending the IP downwards.

It then hits another arrow, sending the IP left. Here, it meets two o signs, outputting b and a.

EDIT: Saved a byte (and fixed ><> crashing)

Japt 2.0/JavaScript, 11 10 bytes

"abc"
//Uw

Japt 2.0 outputs cba

JavaScript outputs abc

J/K (Kona), 30 bytes

NB. :`0:"ABC"
{}[] /.echo'CBA'

TIO - J & TIO - K kona

05AB1E and 2sable, 6 bytes

…CBAžR

Prints ABC (OP said it was allowed) in 05AB1E and CBA in 2sable, using the fact that 2sable was similar to 05AB1E but the žR was added to 05AB1E after 2sable was abandoned.

Try it online! (05AB1E)

Try it online! (2sable)

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!

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)

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

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!