Utwórz program A w taki sposób, że uruchomienie go w języku A tworzy Program B, a uruchomienie programu A w języku B tworzy program C.
Program B, gdy jest uruchamiany w języku B, tworzy Program A, a uruchomienie programu B w języku A tworzy program C.
Program C, uruchamiany w języku A lub języku B , drukuje komunikat „Zły język!”.
Program | Language | Result
--------|----------|----------
A | A | Program B
B | B | Program A
A | B | Program C
B | A | Program C
C | A | "Wrong language!"
C | B | "Wrong language!"
Twoja odpowiedź powinna korzystać z tego szablonu:
Język A / Język B, {a bytes} + {b bytes} = {total bytes} bajtów
Program A:
a code
Program B:
b code
Program C:
c code
Źródło:
# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes
Program A:
a code
Program B:
b code
Program C:
c code
- Żaden z tych programów nie powinien pobierać danych wejściowych.
- Różne wersje tego samego języka są liczone jako różne języki. (chociaż jest to odradzane, ponieważ prowadzi do nudnych rozwiązań)
- Języki A i B muszą być odrębne.
- Nie wolno czytać własnego kodu źródłowego z pliku. Programy mogą nie być puste
- Obowiązują standardowe luki.
Poradnik
- C ++ i [Python / Bash / inne
#
skomentowane języki] to dobre kombinacje, ponieważ możesz zdefiniować makra, które jeden język może ignorować
To jest golf golfowy , więc najmniejsza suma bajtów liczy wygrane Programu A i B.
code-golf
quine
code-generation
polyglot
noɥʇʎԀʎzɐɹƆ
źródło
źródło
Wrong language!
można wydrukować w dowolnej formie (tj. Wszystkie wielkie litery, wszystkie małe litery itp.)?Odpowiedzi:
Befunge-98 (PyFunge) / > <> , 123 + 123 =
Program A:266 250246 bajtówWypróbuj w Befunge-98! , Wypróbuj w> <>!
Program B:Wypróbuj w> <>! , Wypróbuj w Befunge-98!
Program C:Wypróbuj w Befunge-98! Wypróbuj w> <>!
Jak to działa:
Drugi wiersz w obu programach jest identyczny i pełni tę samą funkcję dla obu języków. Po wejściu w lewo od
<<<<
drukuje całą drugą linię. Wchodząc po prawej stronie, wydrukuj program C.Gdy pierwszy wiersz jest uruchamiany w niewłaściwym języku, przechodzi przez sekcję produkującą program C. W przeciwnym razie drukuje górną linię do tyłu z napisem z
"
przodu i wchodzi do sekcji produkującej drugą linię.Pierwsza linia
Program A: Program B:Druga linia:
Program C
źródło
JavaScript (ES6) / Python 3, 264 + 258 = 522 bajty
Program A:
Program B:
Program C:
Prawdopodobnie gra w golfa ...
Wyjaśnienie JavaScript
Program A:
Program B:
Program C:
Wyjaśnienie w języku Python
Program A:
Program B:
Program C:
źródło
Python 3 + JavaScript (Rhino), 171 + 171 = 342 bajtów
Program A (generuje program B w Pythonie 3, program C w JavaScript; zwróć uwagę na nowy wiersz):
Program B (generuje program A w JavaScript, program C w Pythonie; zwróć uwagę na nowy wiersz):
Program C (wypisuje „Wrong language!” W dowolnym języku; ma także końcowy znak nowej linii, który nie liczy się w wyniku):
Zauważ, że używam tutaj niezwykłego dialektu JavaScript. Ludzie zwykle używają implementacji przeglądarki, ale mają one problemy z wyjściem, robiąc to w dziwny sposób (używając
alert
). Korzystam z pakietu Ubuntu,rhino
który jest implementacją JavaScript „offline” z innym zestawem bibliotek zaimplementowanych w typowej przeglądarce (ma to być język skryptowy do osadzenia); jest to godne uwagi, ponieważ zapewniaprint
instrukcję w tym samym stylu, co na przykład Python 3.Jest to „prawdziwy poliglot” w tym sensie, że oba języki wykonują te same obliczenia, w tej samej kolejności, nadając im to samo znaczenie. Oba mają ten sam AST (i dość proste jest stworzenie quilu poliglotycznego Python 3 + JavaScript poprzez redukcję tego programu). Nie ma kodu specyficznego dla jednego języka, co pomogłoby mi zmniejszyć długość. Nawiasem mówiąc, musisz użyć Python 3, abyś mógł używać średników do oddzielania instrukcji (jeśli używałeś nowego wiersza, musiałbyś uciec od nowego wiersza).
Program rozpoczyna się od zdefiniowania sznurki
s
id
które posiadają pojedynczą i podwójną cytat cytat odpowiednio. Umożliwia to wypisywanie cudzysłowów bez konieczności wspominania ich później w kodzie źródłowym, unikając problemów ze zmianą znaczenia (które często wydają się stanowić problem z quinesami; głównym powodem, dla którego odpowiadam na tak wiele problemów quine w niedociążeniu, jest to, że łańcuchy zagnieżdżają się) .Sercem programu jest tablica,
r
która zawiera główną część dwóch programów używanych przez wyzwanie; jeden z programów (ten, który pojawia się jako pierwszy w programie A, a drugi w programie B) jest prawie quine, który po prostu wyprowadza oryginalny program poprzez łączenie ze sobą kawałków (pobranych głównie odr
siebie, z kilkoma literałami łańcuchowymi) oraz inne wydruki program C. Aby program nie był prawdziwym quine (co uniemożliwiłoby wykrycie, że działaliśmy w złym języku), elementyr
są drukowane w odwrotnej kolejności;r[0]
w programie A znajduje sięr[1]
w programie B i odwrotnie.Wreszcie, wszystko, co jest konieczne, to
eval
użyć odpowiedniego elementur
. Dokonuje się tego za pomocą wyrażenia,([11]+[0])[1]
które generuje inną wartość w Pythonie 3 i JavaScript. Oba języki analizują to identycznie, ale mają różne wyobrażenia o tym, co dodatek dodaje do list:Kiedy Python 3 dodaje
[11]
się[0]
, że zostanie[11, 0]
(złączenie list), a następnie biorąc drugi element listy ([1]
) daje nam całkowitą 0.Kiedy JavaScript dodaje się
[11]
do[0]
niego, otrzymuje się"110"
(łączenie reprezentacji ciągów z listami), a następnie wzięcie drugiego znaku ciągu ([1]
) daje nam ciąg"1"
, którego JavaScript z przyjemnością używa jako indeksu do listy.W związku z tym Python 3 uruchamia pierwszy element
r
w obu programach (generując prawie quinę podczas uruchamiania programu A i drukując program C podczas uruchamiania programu B); JavaScript uruchamia drugi element, a zatem traktuje program A i program B w drugą stronę.Nawiasem mówiąc, jeśli uruchomisz program A w Rubim, wydrukuje on program B, chyba że bez końcowego znaku nowej linii. Jeśli uruchomisz program B w Rubim, wydrukuje on program C, chyba że bez końcowego znaku nowej linii. Innymi słowy, to rozwiązanie prawie działa z innym zestawem języków, zamieniając Python 3 na Ruby (jedynym powodem, dla którego nie usuwam po prostu nowej linii z programu B, aby uzyskać wynik 341, jest niespójność nowej linii w programie C zdyskwalifikuje zgłoszenie).
(I was working on a "true polyglot" like this for a different reason, which I've now posted as a challenge, and realised that the techniques could be adapted to this one as well.)
źródło
<pre><code>...</code></pre>
for them to show up."a"[0]
,"a"["0"]
, and"a"[[[[[[[["0"]]]]]]]]
all accomplish the same thing.C/Python, 733 bytes + 733 bytes = 1466 bytes
Program A:
Program B:
Program C:
I used your hint of using C/C++ with Python. Not very concise, but still qualifying I suppose.
źródło
Python 2 / Retina, 550 + 645 =
1373125412211195 bytesI'm not quite sure if the
unichr
andreplace
parts can be golfed more. I tried using Python 3, but a lot is lost by having to add parentheses and handle them. I tried settingR=unicode.replace
and using that, but the output gets messed up.Note that Retina has a trailing newline in its output by default, and this is not included in the programs. If someone says I need to remove it, that can be done trivially. Also, the Python code works in repl.it, but is not guaranteed to work on Ideone.com.
Also note that leading and trailing newlines are significant in the code below.
Program A (Python 2):
638587566550 bytes (UTF-8)Python 2, Retina
Program B (Retina):
735667655645 bytes (ISO 8859-1)Retina, Python 2
Program C:
Python 2, Retina
This can actually be made shorter using
#!`W.*!
instead of the last two lines, but this makes A and B longer, because having`
in a line where there wasn't one means I need to handle it differently (because the first backtick in a line in Retina is a configuration delimiter).Explanation:
Program C:
I wrote Program C first during my first attempt and kept it mostly the same. In Python, it prints the string and ignores the comment. In Retina, it replaces nothing with
print"Wrong language!"
and then removes the parts aroundWrong language!
.To better understand the complex programs, let's look at simplified versions:
Program A (simplified):
When I started over from scratch, I used the
PYTHON
bit as a placeholder for the code that should print Program A. This simpler version made it easier to explain how both Program B and Program C would be printed.The
print
and everything inside is what prints Program B, but first, lets see how Program C is printed, because that's simple. After theprint"..."
is#|
. This trick saved LOADS of difficulty that I experienced in my first attempt. This allows Retina to replace nothing with the 2nd line, which will be Program C, except there's a#
in front. The last 2 lines remove that first#
. I used#{2}
to prevent the stage from removing all occurrences of#
. I cannot use#1`#
like I used in Program B, because it causes problems to have that backtick in the first line of Program A.Which brings me to my next task, printing Program B. You may have noticed another difference from the actual code. There aren't backticks in the actual code, since I replaced them with tabs. I had to substitute a character, because any backtick would make the earlier code a configuration string in Retina, causing the syntax to be invalid. I chose tabs because they're visible and the code point is a single digit (
9
). The code prints Program B as shown in the simplified version below.Program B:
The first two lines will replace nothing with the Python code, but with a
#
in front and some characters slightly different. This part is omitted for clarity. The next stage removes that first#
. Then, I use a Transliteration (T) stage#T`²-¹`_o`[^¹]
to undo some of thereplace
operations seen in the complete Program A. Using this stage is a way to output a literal pilcrow¶
in Retina, which might otherwise be impossible.¹ It replaces·
with¶
, and³
with²
. Occurrences of¹
will stay the same due to them being ignored with[^¹]
.Program A:
Newlines and tabs have been added for readability.
This follows the general structure of the following Python quine:
When you add things before or after, you have to put them in the string, too.
I wanted to use a triple-quoted string to make it easy to include quotation marks (avoiding the use of backslashes).
s=U(39)*3;
is the string'''
. I also used%s
instead of%r
, in order to avoid some problems with newlines or other characters being escaped with backslashes.So now, the replacements. The first replacement
.replace(U(9),U(96));
is there to replace tabs with the backticks that we see in Program B. This replacement is done before string formatting, because the tabs need to remain tabs in Program A. The other replacements are simply to avoid using certain characters in the 2nd line of Program B:These last three replacements anticipate the Transliteration stage in Program B, in order to prevent those characters from being either removed or transliterated when they shouldn't be.
The only other part of the code is the code from Program B that is essentially copied character-for-character, except for the changes due to the replacements.
¹ Thanks to Martin for his tip on how to output a literal
¶
in Retina. It made everything so much easier.źródło
Befunge/Python,
381+485259+345229+304 = 533 bytesProgram A: Try in Befunge | Try in Python
Program B: Try in Python | Try in Befunge
Program C: Try in Befunge | Try in Python
Explanation
Program C: This relies on the fact that Befunge-93 ignores unsupported instructions, so while the
p
harmlessly write a zero at 0;0, the rest of theprint
is ignored up until the<
instruction which reverse the direction. Then flowing from right to left, the+5+5
pushes a 10 (linefeed) on to the stack followed by the message string, and then a standard output sequence is executed to write out the string. In Python it's just printing two string literals that are concatenated together, but the first one (containing the Befunge code) is sliced off by the array reference at the end ([+5+5:]
).Program B: The first line is a fairly basic Befunge sequence to print out Program C. The only interesting thing is the way it generates quote characters using
50g
(i.e. reading the character from memory) which is more efficient than calculating the ASCII code. The#>
(a bridge over the direction instruction) is essentially a nop that prevents the code being seen by Python since#
is the Python comment character. The Python interpretation starts on line two and is simply printing a multiline string containing the source code of Program A.Program A: In Python the first three lines are again ignored because they start with
#
, while the last line simply prints out Program C. The Befunge code snakes back and forth across the first three lines, building up the source for Program B on the stack in reverse order. It starts with three quotes, then a sequence that makes a copy of Program A's source, and finally what is essentially a hard coded string with the openingprint """
and the first line of Befunge code. It's then just a matter of writing it out with a standard output sequence.Some points of contention:
I've been told that a quine using the
g
command is not considered a proper quine as far as this community is concerned. I'm not sure if that rule would apply to this challenge as well, but if so, this answer might not be considered a proper solution either.While I've said that Befunge-93 ignores unsupported instructions, that's not technically defined in the specification, and you'll need to use the
-q
(quiet) command line option in the reference interpreter to avoid warnings in Program C. Most other interpreters will be fine, though, but some of the flakier ones could potentially crash. Also note that Befunge-98 reflects on unsupported instructions, so a 98 interpreter will just loop indefinitely.źródło
-q
flag actually "quite", or did you mean "quiet"? Mm-yes, this flag is quite useful.r
eflect instruction and the 0 that wasp
ut in the first cellPerl/JavaScript, 176 bytes + 176 bytes = 352 bytes
Don't think I can share 52 bytes off the underlying mechanism for the bounty, but I enjoyed building this. I think what I've produced meets the criteria...
Program A:
Program B:
Program C:
Explanation
Uses my Perl/JavaScript polyquine as a basis but sets an additional variable
$P
which controls which program to generate. Uses the check that+[]
is truthy in Perl, but falsy in JavaScript.źródło