Program A'yı, A dilinde çalıştırmanın Program B'yi ürettiğini ve program A'yı B dilinde çalıştırmanın C programını yaratmasını sağlayın.

B dilinde çalıştırıldığında, B programı, Program A'yı, B dilinde ise program A'yı C programında çalıştırır.

C dilinde, A dilinde veya B dilinde çalıştırıldığında , "Yanlış dil!" Yazıyor.

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!" 

Cevabınız bu şablonu kullanmalıdır:

Dil A / Dil B, {a bayt} + {b bayt} = {toplam bayt} bayt

Program A:

a code

Program B:

b code

Program C:

c code 

Kaynak:

# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Bu programların hiçbiri giriş almamalıdır.
• Aynı dilin farklı sürümleri farklı diller olarak sayılır. (bu cesareti kırılmış olmasına rağmen, sıkıcı çözümlere yol açtığı için)
• A ve B dilleri farklı olmalıdır.
• Kendi kaynak kodunuzu bir dosyadan okumamalısınız. Programlar boş olmayabilir
• Standart boşluklar uygulanır.

İpuçları

• C ++ ve [Python / Bash / #yorumlanan diğer diller] iyi kombinasyonlarıdır, çünkü bir dilin yoksayabileceği makroları tanımlayabilirsiniz

Bu kod-golf , yani baytın en küçük toplamı, Program A ve B'nin kazandığı sayılır.

Befunge-98 (PyFunge) / > <> , 123 + 123 = 266 250 246 bayt

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Befunge-98'de dene! , Deneyin> <>!

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Deneyin> <>!, Befunge-98'de dene!

"a0!#.pek,@f[>o<!egaugnal gnorW

Befunge-98'de dene! Deneyin> <>!

Nasıl çalışır:

Her iki programdaki ikinci satır aynıdır ve her iki dil için de aynı işlevi görür. Sola doğru sola girildiğinde<<<< ikinci satırın tamamını yazdırır. Bunların sağına girerken, C programını yazdır.

İlk satır yanlış dilde çalıştırıldığında, C programlama programına girer. Aksi takdirde, üst çizgiyi arkaya doğru" ön tarafta ve ikinci satır üretim bölümüne girer.

İlk satır

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00

><>:
" Wrapping string literal over the first line
 81!#.  Jumps the pointer to the Program C producer

Befunge-98:
" Wrapping string literal
 81!#.  Pushes 8,0 (! inverts number, # skips over .)
      #v Skip over the exit
        p00g Pops the excess 8,0 and space and gets the " from 0,0
            >:#,_ Classic print until stack is empty
       v         j+4< Skips back to the exit and goes to the second line

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18

><>:
" Wrapping string literal
 00g!# Gets the " from 0,0
      o!v5l1=. Print until the stack is empty and jump to the second line

Befunge-98:

" Wrapping string literal
 00g Gets the " from 0,0
    !#o!v Skip the instruction o and go to Program C producer

İkinci çizgi:

g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# $$00gff+k,@,k*9aa$$ #o#!a"

><>: Second line producer
g00<<<<< Get the " from cell 0,0
        ......      " Wrapping string literal over the stack
               #o#!a  Print newline and the stack and exit
Program C producer:
       >0!#[        Clear stack
            f8+1!#. Jump to cell 22,1
                   .....'...'   Push program C to the stack
                             00g Get " from cell 0,0
                                !#o# Print stack until empty

Befunge-98: Second line producer

g00<<<<< Get the " from cell 0,0
        ......              " Wrapping string literal
                       #o#!a  Skip over instruction o
                     $$       Pop the excess characters
                  90a Push a newline and 90
               @,k      Execute , instruction (print) 90+1 times, printing second line

Program C producer:
        >0!#[ Push 1 and skip [
             f8+1!#. Push 22, 0 and skip .
                    48*k'...' Execute ' instruction 32 times, pushing program C
                         ...'00g!#o# Push 0 and skip the instruction o
                                     \! Convert excess values to two 0s
                                       g Get " from cell 0,0
                                          ff+ Push 30
                                             k, Execute , 30+1 times, printing program C
                                               @ Exit program

Program C

"a0!#.pek,@f[>o<!egaugnal gnorW

><>:
" Wrapping string literal
 a0!#. Jump to cell 10,0
           f[ Create a new stack with only the top 15 elements
             >o< Print stack

Befunge-98:
" Wrapping string literal
 a0!#. Push 10,1
      p Pop 10,1 and excess space
       ek,@ Push 14 and execute , 14+1 times and exit the program

JavaScript (ES6) / Python 3, 264 + 258 = 522 bayt

Program A:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;print(c);'''
console.log(b,...[a,b,c].map(uneval))//'''

Program B:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;'''
print=_=>console.log(c)//'''
print(a%(a,b,c))

Program C:

1//2;alert=print
alert('Wrong language!')

Muhtemelen golf oynamak ...

JavaScript açıklaması

Program A:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;print(c);'''

// Print the Python program (b), replacing the "%s"s with the raw forms of a, b, and c:
console.log(b,...[a,b,c].map(uneval))//'''

Program B:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;'''

// Define a function `print` which prints `c` (the "Wrong language!" program):
print=_=>console.log(c)//'''

// Call `print`, ignoring the argument (which is NaN):
print(a%(a,b,c))

Program C:

// Ignore this line:
1//2;alert=print

// Alert "Wrong language!":
alert('Wrong language!')

Python açıklaması

Program A:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Print `c` (the "Wrong language!" program):
1//2;print(c);

# Ignore this part:
'''
console.log(b,...[a,b,c].map(uneval))//'''

Program B:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Ignore this part:
1//2;'''
print=_=>console.log(c)//'''

# Print the JS program (a), replacing the "%r"s with the raw forms of a, b, and c:
print(a%(a,b,c))

Program C:

# Set `alert` to the function `print`:
1//2;alert=print

# Call this function on "Wrong language!":
alert('Wrong language!')

Python 3 + JavaScript (Rhino), 171 + 171 = 342 bayt

Program A (Python 3'te B programını, JavaScript'te C programını gösterir; izleyen yeni satırı not edin):

s="'";d='"';r=['print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")','print("print("+d+"Wrong language!"+d+")")'];eval(r[([11]+[0])[1]])

B Programı (JavaScript'te A programını, Python'da C programını çıkarır; not son satırını not eder):

s="'";d='"';r=['print("print("+d+"Wrong language!"+d+")")','print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")'];eval(r[([11]+[0])[1]])

Program C (her iki dilde de "Yanlış dil!" İfadesi verilir; puanda sayılmayan yeni bir satır da vardır):

print("Wrong language!")

Burada alışılmadık bir JavaScript lehçesi kullandığımı unutmayın. İnsanlar normalde tarayıcı uygulamalarını kullanırlar, ancak çıktılarında sorun vardır, bunu garip bir şekilde yaparlar (kullanarak alert). rhinoTipik bir tarayıcıya (gömülebilir bir komut dosyası dili olarak tasarlanmıştır) farklı bir kitaplık kümesiyle "çevrimdışı" bir JavaScript uygulaması olan Ubuntu paketini kullanıyorum ; bu sağlayan bir dikkate değerprint örneğin Python 3 ile aynı tarzda ifade .

Bu, her iki dilin de aynı hesaplamaları aynı sırayla çalıştırıp aynı anlama geldiklerini ifade eden "gerçek bir çok dilli" dir. Her ikisi de aynı AST'ye sahiptir (ve bu programı azaltarak bir Python 3 + JavaScript polyglot keki oluşturmak için oldukça önemlidir). Bir dile özgü kod yok, bu da uzunluğu düşürmeme yardımcı oluyor. Bu arada, Python 3'ü kullanmanız gerekir; böylece ifadeleri ayırmak için noktalı virgül kullanabilirsiniz (eğer yeni satırlar kullandıysanız, yeni satırlardan kaçmak zorunda kalırsınız).

Program dizeleri tanımlayarak başlar sved hangi sırayla tek tırnak ve çift tırnak tutun. Bu, daha sonra kaynak kodda belirtmeden alıntıların çıktısını almayı mümkün kılar, kaçış sorunlarından kaçınır (sık sık sorgularla ilgili bir sorun gibi görünüyor; Underload'da çok fazla soru sormamın asıl nedeni dizgelerin yuvaları olmasıdır) .

Programın kalbi r, meydan okuma tarafından kullanılan iki programın ana gövdesini tutan dizidir ; programlardan biri (A programında birincisi ve B programında birincisi ile gelen program) orijinal programı bir araya getirerek parçaları birleştirerek (çoğunlukla rbirkaç dize değişmezi ile) diğer program C programlarını yazdırır. Programın gerçek bir yazıya dönüştürülmemesi için (yanlış dilde çalıştığımızın tespitini imkansız kılacaktı), elemanları rters sırayla basılır; r[0]programda A, r[1]programda B'dir ve bunun tersi de geçerlidir.

Sonunda, gereken tek şey eval, doğru unsurunu kullanmaktır r. Bu, ([11]+[0])[1]Python 3 ve JavaScript'te farklı bir değer üreten ifade kullanılarak gerçekleştirilir . Her iki dil de aynı şekilde ayrıştırsa da, listelemelere ne eklenmesi konusunda farklı fikirleri vardır:

• Python 3 eklediğinde [11]için [0], bu olur [11, 0](listeleri bitiştirmek) ve ardından (listenin ikinci elemanını alarak [1]bize tamsayı 0 verir).

• JavaScript eklediğinde [11]için [0], bu olur "110"(bitiştirmek dize halinde temsilini listeleri) ve ardından (dizenin ikinci karakterini alarak [1]) bize dizeyi verir "1"JavaScript listesi dizin olarak kullanmak oldukça mutlu olduğunu.

Bu nedenle, Python 3 rher iki programın da ilk elemanını çalıştırır (A programını çalıştırırken neredeyse bir sıra üretmek ve B programını çalıştırırken C programını yazdırmak); JavaScript ikinci elemanı çalıştırır ve böylece program A ile program B'yi tersi yönde ele alır.

Bu arada, eğer A programını Ruby'de çalıştırırsanız, izleyen bir yeni satır olmadan B programını basar. B programını Ruby'de çalıştırırsanız, izleyen yeni satırlar dışında C programını basar. Başka bir deyişle, bu çözüm neredeyse Python 3'ü Ruby için değiştirerek, farklı bir dil grubuyla neredeyse çalışıyor. teslimi diskalifiye edecekti).

(Farklı bir nedenden dolayı bunun gibi bir "gerçek poliglot" üzerinde çalışıyordum, şimdi bir meydan okuma olarak belirttim ve tekniklerin de buna adapte edilebileceğini fark ettim.)

C / Python, 733 bayt + 733 bayt = 1466 bayt

Program A:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}
print(c%(13,34,34))

Program B:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(c,13,34,34);};
print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))

Program C:

#define print(a) main(){puts(a);}
print("Wrong language!")

Python ile C / C ++ kullanma ipucunu kullandım. Çok özlü değil, ama yine de kalifiye sanırım.

Python 2 / Retina, 550 + 645 = 1373 1254 1221 1195 bayt

Ben eğer emin değilim unichrve replaceparçalar daha golfed edilebilir. Python 3'ü kullanmaya çalıştım, ancak parantez ekleyip bunları kullanmak zorunda kaldıkça çok şey kayboluyor. Ayarlamayı R=unicode.replaceve kullanmayı denedim , ancak çıktı karışık.

Retina varsayılan olarak kendi çıkışında bir eğik yeni satır vardır ve bu unutmayın olmayan programlara dahil. Birisi onu kaldırmam gerektiğini söylüyorsa, bu önemsiz yapılabilir. Ayrıca, Python kodu repl.it dosyasında çalışır, ancak Ideone.com'da çalışması garanti edilmez.

Ayrıca, yeni ve önde gelen yeni satırların aşağıdaki kodda önemli olduğunu unutmayın.

Program A (Python 2): 638 587 566 550 bayt (UTF-8)

Python 2 , Retina

U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶\n#1 #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

B Programı (Retina): 735 667 655 645 bayt (ISO 8859-1)

Retina , Python 2

#U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|·#¸print"Wrong language!"¸#?.*t|"¸·#{2}|^.·\n#1   #\n\n#T ³-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

Program C:

Python 2 , Retina

Bu aslında #!`W.*!son iki satır yerine daha kısa yapılabilir , ancak bu A ve B'yi daha uzun kılar, çünkü `tek bir hattın olmadığı bir çizgiye sahip olmak , onu farklı şekilde ele almam gerekir (çünkü Retina'daki bir çizgideki ilk geri dönüş hareketi bir yapılandırma sınırlayıcısıdır).

print"Wrong language!"
#?.*t|"

Açıklama:

Program C:

                        # Retina: replace nothing with the Python code string
print"Wrong language!"  # >> code is executed if run in Python
#?.*t|"                 # Comment w/ '?' for Retina to skip, then replace up to the 't',
                        #    as well as any quotation marks, with nothing

İlk girişimimde önce C Programını yazdım ve çoğunlukla aynı tuttum. Python'da dizgeyi yazdırır ve yorumu yok sayar. Retina'da hiçbir şey ile yer değiştirmezprint"Wrong language!" ve etrafındaki parçaları çıkarır Wrong language!.

Karmaşık programları daha iyi anlamak için, basitleştirilmiş sürümlere bakalım:

Program A (basitleştirilmiş):

print"\n#PYTHON\n#1`#\n\n#T`²-¹`_o`[^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n"#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Sıfırdan başladığımda, PYTHONbit'i Program A'yı yazdırması gereken kod için bir yer tutucu olarak kullandım . Bu basit sürüm, hem Program B hem de Program C'nin nasıl yazdırılacağını açıklamayı kolaylaştırdı.

Ve printiçindeki her şey, Program B'yi basan şeydir, ancak önce Program C'nin nasıl yazdırıldığını görmenizi sağlar, çünkü bu basit. Sonra print"..."ise #|. Bu numara, ilk denememde karşılaştığım LOADS zorluklarını kurtardı. Bu, Retina'nın #, önünde bir tane olması dışında, Program C olacak olan 2. satırla hiçbir şeyi değiştirmesini sağlar . Son 2 satır ilk önce onu kaldırır #. Kullandığım #{2}kaldırmasını sahne önlemek için tüm tekrarlarını #. #1`#B Programında kullandığım gibi kullanamıyorum , çünkü Program A'nın ilk satırında bu geri tepme sorunlarına neden oluyor.

Bu beni bir sonraki görevime getiriyor, Program B'yi yazdırmak. Gerçek koddan başka bir fark fark etmiş olabilirsiniz. Onları sekmeyle değiştirdiğim için gerçek kodda geri tepme yok. Herhangi bir backtick, önceki kodu Retina'da bir yapılandırma dizesi yaparak sözdiziminin geçersiz olmasına neden olacak şekilde değiştirmem gerekiyordu. Sekmeleri seçtim çünkü görünürler ve kod noktası tek bir rakam ( 9). Kod, aşağıdaki sadeleştirilmiş sürümde gösterildiği gibi Program B'yi yazdırır.

Program B:

#PYTHON
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

İlk iki satır Python koduyla hiçbir şeyin yerini almaz, ancak #önünde ve bazı karakterlerde biraz farklı olur. Bu bölüm netlik için ihmal edilmiştir. Bir sonraki aşama, ilk önce onu kaldırır #. Sonra, bir çevirisi (T) sahne kullanmak #T`²-¹`_o`[^¹]bazı geri almak için replacebu aşamada kullanılması komple Programı A'da görülen operasyonlar çıktı bulunmak için bir hazır Pilcrow olduğunu ¶aksi O değiştirir impossible.¹ olabilir Retina içinde, ·birlikte ¶ve ³birlikte ². Olmadığı durumlar ¹, göz ardı edilmeleri nedeniyle aynı kalacak [^¹].

Program A:

Okunabilirlik için yeni satırlar ve sekmeler eklendi.

U=unichr;s=U(39)*3;

_=u'''
    \n#U=unichr;s=U(39)*3;

    _=u%s.replace(U(9),U(96));

    print _%%(s+_+s)
    .replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
    .replace(U(183),U(184)).replace(U(182),U(183))#|

    ¶#·print"Wrong language!"·#?.*t|"·
    ¶#{2}|^.
    ¶

    \n#1    #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''

.replace(U(9),U(96));

print _%(s+_+s)
.replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
.replace(U(183),U(184)).replace(U(182),U(183))#|

#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Bu, aşağıdaki Python sırasının genel yapısını izler:

_='_=%r;print _%%_';print _%_

Önce veya sonra bir şeyler eklediğinizde, bunları da dizgeye yerleştirmeniz gerekir.

U=unichr;_='U=unichr;_=%r;print(_%%_).replace('','')';print(_%_).replace('','')

Tırnak işaretlerini eklemeyi kolaylaştırmak için üçlü tırnaklı bir dize kullanmak istedim (ters eğik çizgi kullanmaktan kaçının). s=U(39)*3;dizedir '''. Bunun %syerine, %ryeni satırlarda veya diğer karakterlerde ters eğik çizgiyle kaçan sorunlardan kaçınmak için de kullandım .

U=unichr;s=U(39)*3;_='''U=unichr;s=U(39)*3;_=%s;print(s+_%%_+s).replace('','')''';print(s+_%_+s).replace('','')

Yani şimdi, değiştirmeleri. İlk değiştirme .replace(U(9),U(96));, Sekmeleri Program B'de gördüğümüz arka tırnaklarla değiştirmek için oradadır. Bu değiştirme, dizenin biçimlendirilmesinden önce yapılır , çünkü sekmelerin Program A'daki sekmelerde kalması gerekir. B Programının hattı:

.replace(U(10),U(92)+'n')   # Replace newlines with a backslash and 'n', for B to print A.
.replace(U(96),U(9))        # Replace backticks with tabs for the first part of B.
.replace(U(178),U(179))     # Replace '²' with '³', which will be undone with B's T stage
.replace(U(183),U(184))     # Replace '·' with '¸', which will be undone with B's T stage
.replace(U(182),U(183))     # Replace '¶' with '·', which will be undone with B's T stage

Bu son üç değişiklik, bu karakterlerin olmaması gerektiğinde kaldırılmasını veya çevrilmesini önlemek için B Programındaki Harf çevirisi aşamasını öngörmektedir.

Kodun diğer tek kısmı, yerine getirilen değişikliklerin haricinde, karakter B karakterinden kopyalanan Program B kodudur.

İna Martin'e ¶, Retina'da bir hazır bilgiyi nasıl yazacağına ilişkin ipucu için teşekkür ederiz . Her şeyi çok daha kolaylaştırdı.

Befunge / Python, 381 + 485 259 + 345 229 + 304 = 533 bayt

Program A: Befunge'de Deneyin | Python'da deneyin

#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''

B Programı: Python'da Deneyin | Befunge'de dene

#>55+"]:5+5+["50g"!egaugnal gnorW"50g"'<:#>!#,_@<'tnirp">:#,_@
print """#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''"""

Program C: Befunge'de Deneyin | Python'da deneyin

print'<@_,#!>#:<'"Wrong language!"[+5+5:]

açıklama

C Programı: Bu yüzden ederken, Befunge-93 desteklenmeyen talimatları görmezden gerçeğine dayanır p; 0, geri kalanı zararsız bir sıfır 0 yazma printkadar göz ardı edilir <yönünü tersine talimat. Sonra sağdan sola doğru akarken +5+5, istif üzerine 10 (satır besleme) ardından mesaj dizgisini iter ve dizgiyi yazmak için standart bir çıktı dizisi yürütülür. Python'da sadece bir araya getirilmiş iki dize değişmezi yazdırılıyor, ancak birincisi (Befunge kodunu içeren) sonunda ( [+5+5:]) sonunda başvuru referansı ile kesiliyor .

Program B: İlk satır, Program C'yi yazdırmak için oldukça basit bir Befunge dizisidir. Tek ilginç şey, 50gASCII kodunu hesaplamaktan daha verimli olan (örneğin bellekten gelen karakteri okuyarak) alıntı karakterleri üretme biçimidir . #>(Yön talimatı üzerine bir köprü) esasen beri Python tarafından görülmesini kodu engelleyen bir nop olan #Python açıklama karakteridir. Python yorumu ikinci satırda başlar ve yalnızca Program A'nın kaynak kodunu içeren çok satırlı bir dizge yazdırır.

Program A: Python'da ilk üç satır tekrar göz ardı edilir çünkü #son satır basitçe C Programını yazdırır. Befunge kodu ilk üç satır boyunca ileri geri sallanır ve Yığın B Programının kaynağını oluşturur. ters sırada. Üç alıntı ile başlar, sonra Program A'nın kaynağının bir kopyasını yapan bir dizi ve sonunda print """Befunge kodunun açılması ve ilk satırında esas olarak kodlanmış bir dizedir . Bu sadece standart bir çıktı dizisi ile yazması meselesi.

Bazı çekişme noktaları:

1. gKomutu kullanan bir kinin , bu topluluk söz konusu olduğunda uygun bir kine olarak kabul edilmediği söylendi . Bu kuralın bu zorluğa da uygulanıp uygulanmayacağından emin değilim, ancak öyleyse, bu cevabın da uygun bir çözüm olduğu düşünülmeyebilir.

2. Befunge-93'ün desteklenmeyen talimatları göz ardı ettiğini söylesem de, teknik şartnamede teknik olarak tanımlanmamıştır ve -qProgram C'deki uyarıları önlemek için referans tercümandaki (sessiz) komut satırı seçeneğini kullanmanız gerekir. Yine de iyi olun, ama daha ateşli olanlardan bazıları çökebilir. Ayrıca, Befunge-98'in desteklenmeyen talimatlara yansıdığına dikkat edin, 98 tercüman sadece süresiz olarak döngü yapacaktır.

Perl / JavaScript, 176 bayt + 176 bayt = 352 bayt

Ödülün altında yatan mekanizmayı 52 byte paylaşabileceğimi sanmıyorum ama bunu yapmaktan zevk aldım. Sanırım ürettiğim kriterleri karşıladı ...

Program A:

$P=1;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Program B:

$P=2;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Program C:

$P=0;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

açıklama

Perl / JavaScript polikinimi temel olarak kullanır, ancak $Phangi programın oluşturulacağını kontrol eden ek bir değişken ayarlar . +[]Perl’de truthy olan ancak JavaScript’te sahte olan kontrolü kullanır .