Czy to nie denerwujące, gdy znajdziesz kawałek kodu i nie wiesz, w jakim języku został napisany? To wyzwanie próbuje nieco rozwiązać ten problem.

Wyzwanie

Będziesz musiał napisać program, który po uruchomieniu w dwóch różnych językach wyświetli ciąg znaków:

This program wasn't written in <language program compiled/interpreted in>, it was built for <other language the program can be run in>!

• W danych wyjściowych nazwy języków powinny mieć oficjalne wielkie litery. np .: CJam, C ++

• Żaden program nie powinien pobierać żadnych danych wejściowych od użytkownika.

• W przypadku uruchamiania w obu językach, wyjście powinno być standardowe lub równoważne.

• W żadnym programie nie powinno być wyjścia do stderr.

• Możesz używać komentarzy w dowolnym języku.

• Dwie różne wersje tego samego języka liczą się jako różne języki.

  • Jeśli tak się stanie, program powinien wypisać główny numer wersji, a jeśli działa na dwóch różnych mniejszych wersjach, powinien również zgłosić wersję mniejszą.

  • Nie należy używać wstępnie wbudowanych funkcji wersji (obejmuje to zmienne, które zostały już ocenione w czasie wykonywania).

Przykładowe dane wyjściowe:

Perl i Ruby:

• Perl: This program wasn't written in Perl, it was built for Ruby!

• Rubin: This program wasn't written in Ruby, it was built for Perl!

Python i C:

• Pyton: This program wasn't written in Python, it was built for C!

• DO: This program wasn't written in C, it was built for Python!

Python 2 i Python 3:

• Python 2: This program wasn't written in Python 2, it was built for Python 3!

• Python 3: This program wasn't written in Python 3, it was built for Python 2!

Python 2.4 i Python 2.7:

• Python 2.4: This program wasn't written in Python 2.4, it was built for Python 2.7!

• Python 2.7: This program wasn't written in Python 2.7, it was built for Python 2.4!

To jest kod golfowy, więc wygrywa najkrótszy kod w bajtach.

Foo / CJam, 70 bajtów

"This program wasn't written in ""Foo"", it was built for ""CJam"\@"!"

W Foo, jak wielu się dowiedziało, po prostu drukuje wszystko w podwójnych cudzysłowach i ignoruje większość innych znaków lub robi coś, co nie wpływa na wynik w większości przypadków. Krótko mówiąc, \@nic nie robi, a wszystkie ciągi znaków są drukowane w niezmienionej postaci.

W CJam \zamienia dwa górne elementy i @przenosi trzeci element na górę, które układają łańcuchy we właściwej kolejności. A po zakończeniu programu wszystko, co pozostało na stosie, jest automatycznie drukowane.

C89 / C99, 171 152 136 114 111 107 105 bajtów

Dzięki za @Hurkyls, @Qwertiys, @ jimmy23013 i @MD XF za podpowiedzi.

wersja golfowa:

c;main(){c=-4.5//**/
-4.5;printf("This program wasn't written in C%d, it was built for C%d!",90-c,98+c);}

wersja bez golfa:

c;

main()
{
    c = -4.5//**/
    -4.5;
    printf("This program wasn't written in C%d, it was built for C%d!",90-c,98+c);
}

Mały opis:

Wersje C z poprzedniej wersji C99 miały po prostu taki komentarz wielowierszowy:

/*foo*/

wraz z C99 wprowadzono komentarz jednowierszowy. lubię to:

//foo

więc jeśli skompilujesz taką linię:

c =-4.5//**/
-4.5;

dla kodu związanego z kompilacją c99 byłoby:

c = -4.5 -4.5;

podczas gdy odpowiednim kodem dla kompilatora c89 byłoby:

(ponieważ pierwszy /nie jest częścią komentarza i nie traktuje go jak operatora)

c = -4.5 / -4.5;

JavaScript / Ruby, 170 bajtów

Może być tylko 2.0, nie działa przynajmniej w wersji 2.1.5 ... Edytuj: Aktualizacje zgodnie z radą @Jordan, mam nadzieję, że działa teraz w kilku innych wersjach!

a='1';c=console=console||eval('def c.log s;$><<s end;c');c.log("This program wasn't written in "+(d=['JavaScript','Ruby'])[b= ~(a=~/1/)]+', it was built for '+d[b+1]+'!')

Nadużywa ~operatora, ponieważ Ruby będzie traktować =~jako dopasowanie wyrażenia regularnego zwracając pozycję pierwszego dopasowania w ciągu ( 0), ale JavaScript będzie traktować to, = ~/1/co jest -1(ponieważ /1/jest konwertowane NaNna operacje liczbowe, które mają 0wartość).

Python 2 / Python 3, 92

Używa „standardowego” sprawdzania wersji Pythona (liczba całkowita vs. dzielenie zmiennoprzecinkowe).

print("This program wasn't written in Python %d, it was built for Python %d!"%(3/2*2,4-3/2))

Wędkarstwo / > <> 233 217 bajtów

v++C-CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+CCCCCCC-CCCCCCCCCCCCCCCCCCC+CCCCCC
\   "This program wasn't written in ""><>"  ", it was built for Fishing!"
>r!`ol?!;32.                         Fishing                     ><>!`N

Wędkarstwo jest językiem opartym na wędrującym rybaku łowącym ryby. Aby stworzyć program w tym języku, który najpierw musi zdefiniować dok, po którym chodzi. Stacja dokująca zapewnia tylko sterowanie przepływem do programu. Stacja dokująca w tym programie to:

v++C-CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+CCCCCCC-CCCCCCCCCCCCCCCCCCC+CCCCCC

Za każdym razem, gdy Cpolecenie zostanie znalezione, rybak rzuca swoją linię, aby złapać instrukcję. +I -instrukcje zmniejszyć lub zwiększyć długość jego linii odpowiednio. vzmienia kierunek rzucania w dół. Ryby, które łapie w tym programie to:

`This program wasn't written in Fishing, it was built for ><>!`N

> <> to język oparty na rybach poruszających się w wodzie. vPolecenie uruchamia ryby ruchu w dół, gdzie jest ona następnie odbija w prawo z \polecenia. Wszystko między cudzysłowami jest wypychane na stos. Po popchnięciu sznurka na stos, ryba owija się na drugą stronę, gdzie odbija się w dół \. Następnie drukuje zawartość stosu za pomocą:

>r!`ol?!;32.

23 / Malbolge, 5688 bajtów

                    bCBA@?>=<;:987
                                                                                        6543210/.-,+*)
                                                                                          ('&%$#"!~}|{zy
                                                                                               xwvutsrqponmlk
                                                                                                  jihgfedcba`_^]
                                                                                     \[ZYXWVUTSRQPO
                                                                                               NMLKJIHGFEDCBA
                                                                                    @?>=<;:9y76543
                                                                210/(L,l*)(!E}
                   |B"!~}|{zyxwvu
                                                                                                     tsrqponmlkjiha
                                                                                                  fed]#a`_^]?zZY
                                                                                         XWVUTSRQ3ONMLK
                   JIHGFEDCBA:^>=
                                                                                                       <;:98705.R21q/
                                                                                               .-,+*#G'&%${"!
                                                                                            x>|{zyxwYutm3k
                                                                                                        ponmlkjihg`&^c
                                                                                     ba`_^]\[ZYXWVO
                   sSRQPONMLEi,HG
                                                                                                      FEDCBA@?>=6Z:9
                                                                                    y76543210/.-,+
                                                                                                          *)('&%$#"y?w|u
                   ;sxwvutm3qSonm
                                                                                                       fkjiha'edcba`_
                                                                                            ^]\[ZYXWVUTSRQ
                   PONM/EiIHGFEDC
                               BA@?>7[;:987w5
                                      432+O/o-,%I)('
                                     &}$#z@~}|{zsxw
                   vutsrqponmlkji
                                                                                                 ha'&dFba`_^]\U
                                                                                            yYXWVUTMRQPONM
                   LKDhH*F?DCBA@?
                                                                                                 8\<;:98765432r
                                                                                        0/.-&J*)('&f$#
                                                                                                       "!~}|{zyxwvuts
                                                                                                       rqj0nmOkjihaf_
                                                                                            %cE[!_^]\[=SwW
                                                                                                     VU7SLpPONMLEJI
                                                                                                          HAeEDC%A@?>=<;
                   :9876543210/.-
                                                                                                       ,+$H('&}${A!xw
                          ={]yxwvutsrk1o
                                                                                                 nmOejib(fedcE"
                                                                                                      `_^]?[ZYRvVUT6
                                                                                     RKo2HMLKJIHAe
                                                                                                           EDCBA@?>=<;:9
                    87w5432+O/.-,
                                                                                                 +*)('&%e#"y?w
                                                                                     |{zs9wvun4rqp
                                                                                                      onmlNjib(fedc
                                                                                           ba`_^]\[ZYXWV
                                                                                                   8TMqKPONMLKDh
                                                                                                      +GFEDCB;_?>=<
                                                                                                    ;:9y7654321*N
                    .-,+*)('&f|{A
                                                                                                       !~}|{]yxwvo5s
                                                                                             rqpinmlkjihg`
                                                                                            &dcbD`_^]\[Tx
                                                                        ;WVUTMRQJnN0F
                                                 KDhH*FEDC<A@?
     >=<5Y92765.R?

Zauważ, że program wymaga końcowego podawania linii. Żadna linia nie zawiera końcowych białych znaków, więc kopiowanie / wklejanie powinno działać dobrze.

Weryfikacja

Aby przetestować kod Malbolge w tym internetowym tłumaczu , wklej go w obszarze Kod Malbolge i kliknij Load/Reset, a następnie Execute.

Aby przetestować kod 23 w tym internetowym tłumaczu , wklej go w obszarze Źródło , naciśnij, Enteraby wstawić końcowe podawanie wiersza, wpisz 23w obszarze Konsoli (aby przełączyć z domyślnej notacji 23.dezsy na automatyczne wykrywanie) i kliknij Run Interpreter!.

Lua / C - 182 164 bajtów

#if 0
print"This program wasn't written in Lua, it was built for C!"--[[
#endif
main(){printf("This program wasn't written in C, it was built for Lua!\n");}/*]]--*/

Korzysta z funkcji, w której Lua traktuje znak krzyżyka w pierwszym wierszu jako komentarz, aby uwzględnić uniksowe shebangi. W przeciwnym razie otacza komentarze drugiego języka własnymi komentarzami.

Aby golić bajty, polegam na zachowaniu niejawnym, które emituje tylko ostrzeżenia w GCC i Clang: niejawna deklaracja int dla głównej i niejawnej definicji printf.

JavaScript / Haskell, 158 bajtów 147 bajtów

Ogólny pomysł: przekradnij składnię komentarza każdego do drugiego.

W jednej linii:

u="This program wasn't written in ";v=", it was built for ";j="JavaScript";h="Haskell";{-console.log(u+j+v+h+"!")}//-}main=putStrLn$u++h++v++j++"!"

Jak to wygląda dla Haskell:

-- some variable definitions
u = "This program wasn't written in "
v = ", it was built for "
j = "JavaScript"
h = "Haskell"

-- a comment
{-console.log(u+j+v+h+"!")}//-}

-- the main method that does the dirty deed
main = putStrLn $ u ++ h ++ v ++ j ++ "!"

Jak to wygląda w JavaScript:

/* variables can be declared without `var` */
u = "This program wasn't written in ";
v = ", it was built for ";
j = "JavaScript";
h = "Haskell";

/* hey look, an anonymous block! */
{ 
  /* we negate the `undefined` that comes out of console.log */
  -console.log(u+j+v+h+"!")
} 
/* there are two automatic semicolon insertions here:
   one before `}` and one before EOF. */

/* a one-line comment. */
//-}main=putStrLn$u++h++v++j++"!"

Brainfuck / Foo, 769 bajtów

-[--->+<]>-.[---->+++++<]>-.+.++++++++++.+[---->+<]>+++.[-->+++++++<]>.++.---.--------.+++++++++++.+++[->+++<]>++.++++++++++++.[->+++++<]>-.--[->++++<]>-.-[->+++<]>-.--[--->+<]>--.-----.[++>---<]>++.[->+++<]>-.[---->+<]>+++.--[->++++<]>-.-----.---------.+++++++++++..+++[->+++<]>.+++++++++.-[->+++++<]>-.-[--->++<]>-.+++++.-[->+++++<]>-.+[->++<]>.---[----->+<]>-.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.+++[----->++<]>.------------.-[--->++<]>-.+++++++++++.[---->+<]>+++.--[->++++<]>-.-[->+++<]>-.--[--->+<]>--.+[---->+<]>+++.[->+++<]>++.[--->+<]>-.------------.+++.++++++++.[---->+<]>+++.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.+++[->++<]>.+[--->+<]>++..[--->+<]>----."This program wasn't written in Foo, it was built for Brainfuck!"

Niezwykle skomplikowana i złożona odpowiedź ... czy nie.

C / Python, 238 znaków

To nie drukuje w 100% dokładnie tego, co jest wymagane, ale dość blisko.
Ponowne uruchomienie mojej karty walentynkowej .

#define def main(){0?
#define print printf(
#define return 0)));}
#define pass 0);

def main():
    print "This program wasn't written in ",
    pass
    print "Python",
    print ", it was built for ",
    print "C",
    return

main();

C / C ++, 136

#include<stdio.h>
int main(){
char*a="++",z=sizeof'c'/2;
printf("This program wasn't written in C%s, it was built for C%s!\n",a+z,a+2-z);
}

Dodano nowe linie do formatowania. Wypróbuj w C lub C ++ .

Befunge / > <> , 141 138 134 133 130 130 bajtów

3 bajty zapisane dzięki @Cole .

Mówiąc dokładniej, używam Befunge-98.

\"!><> rof tliub saw ti ,egnufeB"   >" rof nettirw t'nsaw margorp sih"'T>:#,_@'~~~~~~
>l?v"!egnufeB rof tliub saw ti ,><>"^
?!;>ol

Wykorzystując fakty, które:

• \ jest lustrem w> <> i zamienia się w Befunge
• 'string'jest ciągiem w> <> i 'cjest znakiem w Befunge

PHP / MySQL, 147 bajtów

-- $argc;die("This program wasn't written in PHP, it was built for MySQL!");
SELECT("This program wasn't written in MySQL, it was built for PHP!");

Python 3 / > <> , 177 173 172 167 bajtów

Dzięki @mathmandan za zgolenie 5 bajtów!

Cóż, to było doświadczenie, które też było trudne. Wszelkie sugestie dotyczące golfa są mile widziane, ponieważ jest to dość długi czas. Starałem się jak najlepiej wykorzystywać tekst, ale było to dość trudne.

Technicznie rzecz biorąc, to Python 3 powinien wypisać ten program (i mógłbym to zmienić, gdybym nie spełniał specyfikacji - ale w przykładzie wyjście Python / C Python wymieniono ).

aa=" ni nettirw t'nsaw margorp sihT\"\""
v="><>!"                 #v   "><>"r~/
a=", it was built for "+v#\a
print(aa[-3::-1]+"Pytho" +"n"+a)
#  .4b;!?lor"!nohtyP r"~/

Wypróbuj go w internetowym> <> tłumaczu i w Pythonie 3 ( interpreter > <> wymaga ręcznego wprowadzenia kodu)

Zwroty

This program wasn't written in ><>, it was built for Python!

w> <> i

This program wasn't written in Python, it was built for ><>!

w Pythonie.

Wyjaśnienie (Python)

Po stronie Pythona jest to dość proste. Oto kod, na którym nam zależy (w zasadzie kod bez komentarzy, które są oznaczone przez #w Pythonie). Zwróć uwagę, że w Pythonie \jest to znak ucieczki, gdy jest używany w ciągach, więc \"zwraca wartość "w ciągu.

aa=" ni nettirw t'nsaw margorp sihT\"\""
v="><>!"
a=", it was built for "+v
print(aa[-3::-1]+"Pytho" +"n"+a)

Najważniejsze są tutaj operacje wykonywane na zmiennej aa:

aa[-3::-1]: reverses the string and chops off the quotation marks (thanks to @mathmandan)

Instrukcja print ocenia w ten sposób

"This program wasn't written in " + "Pytho" + "n" + ", it was built for ><>!"

Objaśnienie (> <>)

Teraz przechodzimy do trudniejszej części. Jeszcze raz oto kod z usuniętymi niepotrzebnymi bitami.

aa=" ni nettirw t'nsaw margorp sihT\"\
                          v   "><>"r~/
a=", it was built for "+v \a

   .4b;!?lor"!nohtyP r"~/

Linia 1:

aa=" ni nettirw t'nsaw margorp sihT\"\

aa=         pushes 1 onto the stack (evaluates 10==10, basically)
" ni ... \" pushes the first part plus a \ onto the stack.
\           deflects the pointer downwards

Stos w tej chwili (jeśli jest wydrukowany): \This program wasn't written in

Linia 2:

Zauważ, że linia 2 zaczyna się z /powodu pozycji wskaźnika od linii 1 i przesuwa się od prawej do lewej.

v   "><>"r~/

/     deflects the pointer leftwards
~r    pops the / off the stack and then reverses it
"><>" pushes ><> onto the stack
v     deflects the pointer downwards

Stos w tej chwili: ><> ni nettirw t'nsaw margorp sihT

Wiersz 3:

Podobnie jak poprzednia linia, ta zaczyna się od \, czyli tam, gdzie linia 2 wysyła wskaźnik. Zauważ, że ponieważ wskaźnik owija się wokół linii, gdy osiągnie pierwszą a, będę pisać wyjaśnienie w kolejności, w której idzie wskaźnik (a więc co jest wykonywane)

a=", it was built for "+v \a

\aa=       deflect and push 1 onto the stack
", i ... " push the string onto the stack
+v         sum the last two values pushed and deflect

Stos w tej chwili ( xto postać utworzona przez dodanie „r” i spacji. - to nie jest rzeczywista postać, tylko symbol zastępczy ode mnie):

xof tliub saw ti ,><> ni nettirw t'nsaw margorp sihT

Wiersz 4:

Wskaźnik po prostu przesuwa się w dół, więc linia ta nie wymaga dalszych wyjaśnień.

Wiersz 5:

Zaczynając od /lewej strony.

.4b;!?lor"!nohtyP r"~/

~"r Python!" pops x off and adds back r and a space
r            reverses the stack
o            pops and prints a character
l?!;         pushes the length of the stack and stops if it's 0
b4.          pushes 11 then 4 then moves to that location (where o is)

Stos w tej chwili (wyjście odwrócone):

!nohtyP rof tliub saw ti ,><> ni nettirw t'nsaw margorp sihT

I to powinno być na wyjaśnienie. Daj mi znać, jeśli istnieje jakaś niespójność między wyjaśnieniem / kodem lub jeśli zrobiłem coś złego; Grałem trochę w golfa, gdy byłem w trakcie pisania objaśnienia, więc mogłem mieszać fragmenty starego i nowego kodu.

Plik wsadowy .BAT / Plik wsadowy .CMD, 194 185 bajtów

@ECHO OFF
SET a=BAT
SET b=CMD
CALL :F&&GOTO :C||GOTO :O
:C
SET a=CMD
SET b=BAT
:O
ECHO This program wasn't written for %a% File, it was built for %b% File!
GOTO :EOF
:F
md;2>nul
SET v=1

_{Edycja: Zapisano 9 bajtów i poprawiono brakujące !dzięki DLosc}

Tak, istnieją różnice między plikami BAT i CMD. Odniesienie. Zasadniczo CMD ustawia ERRORLEVELsię na SETkomendę, a BAT nie, co oznacza, że w tym przypadku ERRORLEVELzestaw przez zniekształconego mdpolecenia zostanie wyczyszczone przez SET v=1w jednej wersji, ale nie innych. Ten skrypt jest oparty na przykładzie podanym przez „Ritchie” w tym wątku grupy dyskusyjnej.

Zauważ, że powyższy skrócony skrypt zakłada ENABLEEXTENSIONSsię ON(jest domyślnie na każdej platformie). Rozszerzony skrypt poniżej wyraźnie go ustawia, aby zagwarantować poprawną funkcjonalność. Bez tego SETpolecenie polecenia CMD nie zezwala na wszystkie rozszerzenia i (w niektórych systemach, być może) może nie ustawićERRORLEVEL odpowiednio.

Rozszerzony i zauważony

@ECHO OFF
setlocal ENABLEEXTENSIONS

REM Call the :FUNC subroutine and branch based on the resulting errorlevel
CALL :FUNC&&GOTO :CMD||GOTO :BAT

REM Just in case. If we reach this, though, hoo-boy ...
GOTO :EOF

:BAT
REM We're a BAT file, so set variables and goto output
SET a=BAT
SET b=CMD
GOTO :OUTPUT

:CMD
REM We're a CMD file, so set variables and goto output
SET a=CMD
SET b=BAT
GOTO :OUTPUT

:OUTPUT
REM Print out the result, then go to end of file
ECHO This program wasn't written for %a% File, it was built for %b% File!
GOTO :EOF

:FUNC
REM Simple subroutine to set the ERRORLEVEL appropriately
md;2>nul
REM Right now, ERRORLEVEL on both CMD and BAT is 1
SET v=1
REM Right now, ERRORLEVEL on CMD is 0, but BAT is still 1

JavaScript / C, 148 146 143 znaków

//\
alert/*
main(){puts/**/("This program wasn't written in "//\
+"Javascript"+/*
"C"/**/", it was built for "//\
+"C!")/*
"Javascript!");}/**/

C: http://codepad.org/u8UimGLc http://codepad.org/Y80M5jpc http://codepad.org/m4DB2Ndd
Javascript: po prostu skopiuj kod do konsoli przeglądarki

CJam / GolfScript, 81 78 bajtów

"This program wasn't written in "o"GolfScript"", it was built for ""CJam"oo"!"

Oryginalna 81-bajtowa wersja:

"This program wasn't written in "["CJam"", it was built for ""GolfScript"]-1a%"!"

PHP / Perl, 98 96 bajtów

$a="HP";$b="erl";
//;$a=$b;$b=HP;
print"This code wasn't written in P$a, it was built for P$b!";

Nie wiem, czy to oszustwo, czy nie, ponieważ o ile mogę powiedzieć, jedynym sposobem na uruchomienie PHP bez otwierającego <?tagu jest coś takiego php -r $(cat codefile.php). Ale zakładanie, że jest to zgodne z prawem ... //jest komentarzem PHP, ale w Perlu jest wyrażeniem regularnym (które samo w sobie nic nie robi). Reszta powinna być dość oczywista.

Edycja: Teraz używa słowa bez słów w części tylko dla Perla. Chciałem używać ich przede wszystkim dla obu języków, ale PHP wyświetla ostrzeżenie, gdy to robisz, w przeciwieństwie do „Stderr nie powinien generować żadnych danych wyjściowych”.

Ruby / Python, 105 znaków

a=["Ruby","Python"];a.sort();print("This program wasn't written in "+a[0]+", it was built for "+a[1]+"!")

JavaScript 1.8 / JavaScript 1.7, 89 bajtów

a=![].reduce;`This program wasn't written in JS 1.${8-a}, it was built for JS 1.${7+a}!`

Ponieważ Array.prototype.reduce jest nowy w wersji 1.8

EDYCJA: Wyodrębniono 7 bajtów, bezpośrednio inicjując azamiast używaćreverse()

EDYCJA: JavaScriptmożna zapisać jakoJS , oszczędzając 8 bajtów

EDYTOWAĆ: Dzięki Hedi za wskazanie, że mogę zaoszczędzić 3 więcej bajtów, jeśli nie użyć zmiennej bwięcej

EDYCJA: Wyodrębniono 6 bajtów, obliczając 7+ai8-a , a=1jeśli zdefiniowano redukcję (JS 1.8) i a=0jeśli nie jest zdefiniowana (JS 1.7)

EDYCJA: Hedi odłożył jeszcze 6 bajtów, co sugeruje użycie ciągu szablonu

EDYCJA: ETHprodukcje sugerowały 2 bajtya=!![].reduce; zamiasta=[].reduce?1:0;

EDYCJA: no1xsyzy zagrał jeszcze jeden bajt, sugerując odwrócenie czeku boolowskiego

SWI-Prolog 6 / SWI-Prolog 7, 156 bajtów

P='SWI-Prolog ',A=6,B=7,(is_list(""),N=A,M=B;N=B,M=A),atomic_list_concat(['This program wasn\'t written in ',P,N,', it was built for ',P,M,'!'],W),write(W).

Wykorzystuje fakt, że podwójne cudzysłowy ""są kodami ciągów (tj. Listą kodów znaków) w wersjach SWI-Prolog starszych niż 7 i są poprawnym typem Łańcuchów w wersji 7. W is_list("")związku z tym w wersji 7 będą fałszywe, a we wcześniejszych wersjach prawdziwe.

BF / SPL, 5342 bajtów

Jestem prawie pewien, że jest to pierwszy poliglot Szekspira w tej witrynie.

Prawdopodobnie nie wygra żadnych nagród. Działa poprzez przekradanie kodu BF do tytułów akt / sceny / programu. Kod SPL używa wykrzykników zamiast kropek, z wyjątkiem kilku przypadków. Programy nie powinny pobierać danych wejściowych, więc przecinki w deklaracjach znaków są „komentowane” przez zerowanie komórek i umieszczanie nawiasów kwadratowych wokół przecinków. Ta sama procedura obowiązuje w przypadku ukrywania nawiasów kwadratowych wokół instrukcji enter / exeunt.

[-][.
Ford,.
Page,.
Act I:]+++++++++[>+++++++++<-]>+++.
Scene I:>[.
[Enter Ford and Page]
Ford:
You is sum of bad bad bad bad bad bad day and sum of bad bad bad bad day and bad bad day!Speak thy mind!
Scene II:]<<++[>++++++++++<-]>.
Page:
You is sum of bad bad bad bad bad bad day and sum of bad bad bad bad bad day and bad bad bad day!Speak thy mind!
Scene III:+.
Page:
You is sum of thyself and day!Speak thy mind!
Scene IV:++++++++++.
Page:
You is sum of thyself and sum of bad bad bad day and bad day!Speak thy mind!
Scene V:>++++[>++++++++<-]>.
Ford:
You is fat fat fat fat fat cat!Speak thy mind!
Scene VI:[-<+>]<<---.
Page:
You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene VII:++.
Page:
You is sum of thyself and fat cat!Speak thy mind!
Scene VIII:---.
Page:
You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene IX:--------.
Page:
You is sum of thyself and big big big pig!Speak thy mind!
Scene X:+++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XI:<++++[->----<]>-.
Page:
You is sum of thyself and sum of big big big big pig and pig!Speak thy mind!
Scene XII:++++++++++++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and big big pig!Speak thy mind!
Scene XIII:>.
Ford:
Speak thy mind!
Scene XIV:<++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XV:<++++[->-----<]>--.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XVI:<++++[>++++<-]>++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and fat cat!Speak thy mind!
Scene XVII:-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XVIII:>+++++++.
Ford:
You is sum of thyself and sum of fat fat fat cat and pig!Speak thy mind!
Scene XIX:<++++++.
Page:
You is sum of thyself and sum of fat fat cat and fat cat!Speak thy mind!
Scene XX:>-------.
Ford:
You is sum of thyself and sum of big big big pig and cat!Speak thy mind!
Scene XXI:<+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XXII:-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XXIII:---------.
Page:
You is sum of thyself and sum of big big big pig and pig!Speak thy mind!
Scene XXIV:+++++++++++.
Page:
You is sum of thyself and sum of cat and sum of fat cat and fat fat fat cat.Speak thy mind!Speak thy mind!
Scene XXV:<+++[>-----<-]>.
Page:
You is sum of thyself and sum of big big big big pig and cat!Speak thy mind!
Scene XXVI:+++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and cat!Speak thy mind!
Scene XXVII:>.
Ford:
Speak thy mind!
Scene XXVIII:<-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XXIX:+++++.
Page:
You is sum of thyself and sum of fat fat cat and cat!Speak thy mind!
Scene XXX:>.
Ford:
Speak thy mind!
Scene XXXI:[->++<]>++.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat cat and cat!Speak thy mind!You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene XXXII:++++.
Page:
You is sum of thyself and big red hog!Speak thy mind!
Scene XXXIII:<+++++[>-----<-]>-.
Page:
You is sum of thyself and big big big big big pig!Speak thy mind!
Scene XXXIV:[-<+>]<------------.
Ford:
Speak thy mind!
Scene XXXV:<-----.
Page:
You is sum of thyself and sum of fat fat fat fat fat fat cat and sum of big pig and pig!Speak thy mind!
Scene XXXVI:+++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XXXVII:>.
Ford:
Speak thy mind!
Scene XXXVIII:<+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XXXIX:<++++[->-----<]>--.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XL:<++++[>++++<-]>++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and fat cat!Speak thy mind!
Scene XLI:>.
Ford:
Speak thy mind!
Scene XLII:<<++++[>----<-]>-.
Page:
You is sum of thyself and sum of big big big big pig and pig!Speak thy mind!
Scene XLIII:<+++++[>++++<-]>-.
Page:
You is sum of thyself and sum of fat fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XLIV:------------.
Page:
You is sum of thyself and sum of big big big big pig and fat fat cat!Speak thy mind!
Scene XLV:+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XLVI:++++++++.
Page:
You is sum of thyself and fat fat fat cat!Speak thy mind!
Scene XLVII:>.
Ford:
Speak thy mind!
Scene XLVIII:<--------------.
Page:
You is sum of thyself and sum of big big big big pig and fat cat!Speak thy mind!
Scene XLIX:+++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and cat!Speak thy mind!
Scene L:+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene LI:>.
Ford:
Speak thy mind!
Scene LII:>+++++++[<+++++++>-]<++.
Page:
You is sum of thyself and sum of big big big big big pig and big big big big pig!Speak thy mind!
Scene LIII:---.
Page:
You is sum of thyself and fat fat cat!Speak thy mind!
Scene LIV:----.
Ford:
You is sum of thyself and cat!Speak thy mind!
Scene LV:>+++++++[<------>-]<-.
Ford:
You is cat!
Scene LVI:>[.
[Exeunt]

Przetestuj BF na https://repl.it/E8Hh/23 .

Kod SPL został przetestowany w kompilatorze znalezionym tutaj: https://github.com/drsam94/Spl/ .

Ruby 1.8 / Ruby 1.9, 87

puts"This program wasn't written in Ruby 1.#{?9%49}, it was built for Ruby 1.#{?8%47}!"

W Ruby 1.8 ?9jest wartością ASCII „9”, czyli 8 modulo 49. W Ruby 1.9 jest to ciąg „9” i %49jest operacją formatowania, która nic nie robi, ponieważ „9” nie zawiera żadnych ciągów formatujących to.

Python 2.7.9 / Python 2.7.10, 127 bajtów

Mieliśmy kilka postów, które wykorzystywały pomniejsze wersje, ale żadne nie przeszło na wyższy poziom niżej ...

import types
n=len(dir(types))
print"This program wasn't written in Python 2.7.%d, it was made for Python 2.7.%d!"%(n%33,-n%52)

Wypróbuj na Ideone (Python 2.7.10) i repl.it (technicznie Python 2.7.2, ale powinien dać taki sam wynik jak 2.7.9).

Python 2.7.10, zgodnie z dziennikiem zmian :

Dodano __all__do typesmodułu.

Liczba ta wzrosła len(dir(types))z 42 do 43, dając liczbową różnicę, którą możemy wykorzystać do wygenerowania pożądanego wyniku.

Python / QBasic, 160 142 bajtów

Testowane z Python 3 i QBasic 1.1 . Nie będzie działać w Pythonie 2 bez dodawania from __future__ import print_functiondo wiersza 4.

1# DEFSTR A-B
a = "QBasic"
b = "Python"
'';a,b=b,a;PRINT=print
PRINT ("This program wasn't written in " + a + ", it was built for " + b + "!")

• W Pythonie 1#jest to wyrażenie1 (no-op), po którym następuje komentarz. W QBasic jest to numer linii (z sufiksem typu oznaczającym go jako a DOUBLE). DEFSTROświadczenie mówi QBasic że wszystkie zmienne, których nazwy zaczynają się Alub B(wielkość liter) są zmienne znakowe. W ten sposób możemy wywoływać nasze zmienne ai bzamiast a$i b$(które nie działałyby w Pythonie).
• W QBasic 'rozpoczyna komentarz. W Pythonie ''jest pusty ciąg (no-op). Następnie zamieniamy nazwy języków i definiujemy alias dla printfunkcji (ponieważ słowa kluczowe QBasic są automatycznie formatowane wielkimi literami).
• Nawiasy w ostatnim wierszu nie są konieczne w QBasic, ale też niczego nie krzywdzą.

Jeśli mogę wyłączyć autoformatter (który jest opcją w QB64 , choć nie w oryginalnym QBasic), mogę sprowadzić go do 114 bajtów za pomocą Pythona 2 :

1#DEFSTR A-B
a="QBasic"
b="Python"
'';a,b=b,a
print"This program wasn't written in "+a+", it was built for "+b+"!"

Perl / Ruby, 129 bajtów

0&&eval('def sort a,b;[b,a] end');printf"This program wasn't written in %s, it was built for %s!",(@a=sort"Perl","Ruby")[0],@a[1]

Żadnych nadużyć wyrażeń regularnych w tym, po prostu wykorzystując fakt, że 0 jest zgodne z Ruby evalw definicji sort(która faktycznie reversejest) i printfing. Ruby nie lubiła używać listy jako argumentów, więc musiałem zrobić każdy z osobna.

/// i Retina , 95 + 3 = 98 bajtów

/
//

This program wasn't written in \/\/\/, it was built for Retina!
/?./....(.*)(R.*)!
$2$1///!

+3 bajty dla -sflagi w Retina.

Wyjaśnienie dla ///

Pierwsza instrukcja to

/
//

usuwa wszystkie znaki nowej linii z pozostałej części kodu, co powoduje

This program wasn't written in \/\/\/, it was built for Retina!/?./....(.*)(R.*)!$2$1///!

Wszystko do tego !jest dosłowne i drukowane do STDOUT. Następna instrukcja to

/?./....(.*)(R.*)!$2$1/

Ale ?.nie można znaleźć szukanego ciągu, więc nic się nie dzieje. Następnie pozostały kod jest //!niekompletną instrukcją, więc program kończy działanie, po wydrukowaniu poprawnego ciągu.

Wyjaśnienie dotyczące siatkówki

/
//

Mówi siatkówka do zastąpienia /z //. Ale dane wejściowe są puste, więc nic nie pasuje.

<empty>
This program wasn't written in \/\/\/, it was built for Retina!

To zastępuje dane wejściowe ciągiem w drugim wierszu.

/?./....(.*)(R.*)!
$2$1///!

Dopasowuje ciąg \/\/\/, it was built for Retina!i zastępuje go, Retina, it was built for ///!aby dać poprawny wynik.

sed / Hexagony 251 Bytes

/$/cThis program wasn't written in sed, it was built for Hexagony!
#...>32;p;r;o;g;r;\+/;a;w;23+;m;a<.;.>s;n;+39;t;+32\s/;n;e;;t;i;r;w;<. |.>+32;i;n;+32;H;e\ ;/4+;y;n;o;g;a;x;< i>4;+32;i;t;+32;\;/u;b;23+;s;a;w<h>;i;l;t;+32;f\;/;s;23+;r;o;< T>e;d;+33;@

sed: Wypróbuj online!
Heksagonia: Wypróbuj online!

W sed drukuje prawidłowy ciąg znaków, jeśli pasuje do pustego ciągu na końcu (zawsze). Drugi wiersz to komentarz. Wymaga to ciągu znaków na STDIN, ale może być pusty ( dozwolone na podstawie tego konsensusu ).

Przykład:

echo '' | sed -f whatLanguage.sed

W Hexagony pierwsze /przekierowuje na lewy dolny róg, podąża za lewą stroną do miejsca, w którym zaczyna się część sed, a następnie po prostu owija od lewej do prawej, wzdłuż linii, od prawej do lewej, wzdłuż linii i tak dalej. Rozwinięty hex wygląda następująco:

         / $ / c T h i s p r 
        o g r a m w a s n ' t 
       w r i t t e n i n s e d 
      , i t w a s b u i l t f o 
     r H e x a g o n y ! # . . . 
    > 3 2 ; p ; r ; o ; g ; r ; \
   + / ; a ; w ; 2 3 + ; m ; a < .
  ; . > s ; n ; + 3 9 ; t ; + 3 2 \
 s / ; n ; e ; ; t ; i ; r ; w ; < . 
| . > + 3 2 ; i ; n ; + 3 2 ; H ; e \ 
 ; / 4 + ; y ; n ; o ; g ; a ; x ; < 
  i > 4 ; + 3 2 ; i ; t ; + 3 2 ; \
   ; / u ; b ; 2 3 + ; s ; a ; w <
    h > ; i ; l ; t ; + 3 2 ; f \
     ; / ; s ; 2 3 + ; r ; o ; < 
      T > e ; d ; @ . . . . . .
       . . . . . . . . . . . .
        . . . . . . . . . . .
         . . . . . . . . . .

Python / Retina, 133 120 119 117 115 bajtów

Teraz, gdy wiem więcej o Retinie i wyrażeniach regularnych, grałem w nią trochę dłużej. Teraz też działa.

#?.*
print"This program wasn't written in Python, it was built for Retina!"
#?.*t"

#?(\w+)(,.* )(.+)!"
#$3$2$1!
#

Python po prostu drukuje instrukcję. Retina zastępuje wszystko poleceniem print Pythona, a następnie usuwa printcudzysłowy. Potem zamienić Pythona Retinai usunąć #.

Spróbuj w Pythonie | Spróbuj w siatkówce

JavaScript / CoffeeScript, 125 124 bajtów

console.log("This program wasn't written in",(a=['Coffee','Java'])[+(b=0=='0')]+"Script, it was built for",a[b^1]+"Script!")

W CoffeeScript a==bjest kompilowany do a===b, co powoduje, że warunek pośredni jest fałszywy. Użyłem odrobiny magii, aby przekonwertować wartość logiczną na liczbę całkowitą.

Zaoszczędzono 1 bajt dzięki @DomHastings!

Wersja 125-bajtowa:

console.log("This program wasn't written in",(a=['Coffee','Java'])[(b=0=='0')+0]+"Script, it was built for",a[b^1]+"Script!")