Potansiyel olarak çok zor, ama bu siteden bazı şaşırtıcı şeyler geldiğini gördüm.

Amaç, herhangi bir dilde, istediğinizi yapan bir program yazmaktır. Yakalama, programın karakterlerin herhangi bir dairesel kaydırmasından sonra geçerli olması gerektiğidir .

Dairesel karakter kayması Dairesel Kaymaya çok benzer . Bazı örnekler benim net şeylerim.

Program için int main() { return 0; }

6 karakter sola kaydırmak şu sonuçları verir: in() { return 0; }int ma

sola 1 karakter kaydırma: nt main() { return 0; }i

sağa 10 karakter kaydırmak: eturn 0; }int main() { r

Ancak, bu program açıkça kurallara uymuyor.

kurallar

• Herhangi bir dil
• Kazanan yukarı oy sayısı ile belirlenir
• Aynı şeyi veya her rotasyon için tamamen farklı şeyleri yapan çözümler, puanlarına 100 sanal yukarı oy alacaktır.

GÜNCELLEME Bence bu yeterince uzun sürdü. En çok oyu alan (sanal oylar dahil) kazanan Mark Byers. Aferin!

Görev için doğru dili kullanın. Bu durumda, bu Befunge .

Bu dil doğal olarak dönüşlere izin verir, çünkü:

• Tüm komutlar tek bir karakterdir.
• Kumanda, programın sonuna geldiğinde baştan başlar.

Bu Befunge programı, kaç "dairesel karakter kaydırma" kullandığınıza bakılmaksızın tam olarak aynı çıktıyı ("Merhaba") yazdırır:

86*01p75*1-02p447**1-03p439**04p439**05p455**1+06p662**07p75*1-08p645**2-09p69*4+019+p57*029+p59*1-039+p555**1-049+p88*059+p86*01p75*1-02p447**1-03p439**04p439**05p455**1+06p662**07p75*1-08p645**2-09p69*4+019+p57*029+p59*1-039+p555**1-049+p88*059+p645**2-00p645**2-00p

Befungee üzerinde çalışır . Kartın artırılmasını gerektirir (varsayılan 80 karakter değil). Bu şekilde çalıştırılabilir:

python befungee.py -w400 hello.bef

Önce "Merhaba" yazdıran bir programı dinamik olarak oluşturarak ve depolayarak ve ardından yeni yazılan programa denetimi yeniden yönlendirmek için ilk baytın üzerine yazarak çalışır. Program iki kez yazılır, böylece bir bayt ilk kez doğru yazılmazsa, ikinci kez düzeltilecektir.

Fikir, herhangi bir keyfi karmaşıklık programı üretmek için genişletilebilir.

Brainf * ck

İş için doğru aracı seçin - buradaki işten daha önce hiç alakalı olmayan bir atasözü!

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+.>++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.++++++++++++++.>++++++++++.+

Burada gördüğünüz değiştirilmemiş program basitçe yazdırılıyor SHIFT(artı bir yeni satır). Her zaman altı ASCII karakteri çıkmasına rağmen, dairesel dairesel kaymalar çeşitli çıktılar üretecektir.

Commodore 64 TEMEL

?kısaltmasıdır PRINTve :bir ifade ayırıcıdır;

?1:?2:?3:          // prints 1, 2, and 3
:?1:?2:?3          // prints 1, 2, and 3
3:?1:?2:?          // adds a program line 3 :PRINT1:PRINT2:PRINT
?3:?1:?2:          // prints 3, 1, and 2
:?3:?1:?2          // prints 3, 1, and 2
2:?3:?1:?          // adds a program line 2 :PRINT3:PRINT1:PRINT
?2:?3:?1:          // prints 2, 3, and 1
:?2:?3:?1          // prints 2, 3, and 1
1:?2:?3:?          // adds a program line 1 :PRINT2:PRINT3:PRINT

Daha uzun varyasyonlar elbette mümkündür:

?1:?2:?3:?4:?5:?6:?7:?8:?9:?10:?11:

vb...

Golfscript

Bu program, programın nasıl değiştirildiğine bakılmaksızın, her zaman 2'ye kadar olan bazı basamaklar yazdırır:

10 2 base
0 2 base1
 2 base10
2 base10 
 base10 2
base10 2 
ase10 2 b
se10 2 ba
e10 2 bas

İlk satır yazdırılır 1010(ikili olarak 10), ikinci satır yazdırılır 02ve diğer tüm satırlar yazdırılır 2.

Güncelleme:

Program burada test edilebilir . Her çıktının sonuna yalnızca çıktıyı biçimlendirmek için s eklediğimi lütfen unutmayın n; bunlar kaldırılabilir ve program hala çalışır.

Muhtemelen mümkün olan en kısa çözümlerden biri olan Ruby:

p

Ve biraz daha uzun ve daha ilginç olanı:

;;p";p;";p

x86 16 bit ikili

El, bu (yardımıyla inşa 1 2 ) tablolar, nasm ve ndisasm. Bu her zaman bir çökme veya sonsuz döngü olmadan geri dönecektir, çünkü hiçbir bayt atlama değildir veya yığını değiştirir ve rether durumda tek bir bayt talimatı ile sona ermek için NOP'larla doldurulur .

Çoğu durumda bu çıktı FOOveya bunun bir alt dize olacaktır . Eğer AXkırılır, bu rastgele arayacak int 10 (bu benim testlerin birinde imlecin yanıp hızı değiştirildi), ama genellikle bir kaza yol açmaz.

Denemek için, hexdump'ı bir dosyaya koyun ve kullanın xxd -r foo.hex > foo.com, sonra bir dos ortamında çalıştırın (dosbox kullandım).

İşte bu dosyanın onaltılık dökümü:

0000000: b846 0d90 90fe c490 9090 bb05 0090 9043  .F.............C
0000010: 43cd 1090 b84f 0d90 90fe c490 9090 bb05  C....O..........
0000020: 0090 9043 43cd 1090 b84f 0d90 90fe c490  ...CC....O......
0000030: 9090 bb05 0090 9043 43cd 1090 9090 c3    .......CC......

Ve bazı ilginç sökülmüş ofsetler:

0

00000000  B8420D            mov ax,0xd42
00000003  90                nop
00000004  90                nop
00000005  FEC4              inc ah
00000007  90                nop
00000008  90                nop
00000009  90                nop
0000000A  BB0500            mov bx,0x5
0000000D  90                nop
0000000E  90                nop
0000000F  43                inc bx
00000010  43                inc bx
00000011  CD10              int 0x10
00000013  90                nop
00000014  B84F0D            mov ax,0xd4f
00000017  90                nop
00000018  90                nop
00000019  FEC4              inc ah
0000001B  90                nop
0000001C  90                nop
0000001D  90                nop
0000001E  BB0500            mov bx,0x5
00000021  90                nop
00000022  90                nop
00000023  43                inc bx
00000024  43                inc bx
00000025  CD10              int 0x10
00000027  90                nop
00000028  B84F0D            mov ax,0xd4f
0000002B  90                nop
0000002C  90                nop
0000002D  FEC4              inc ah
0000002F  90                nop
00000030  90                nop 
00000031  90                nop
00000032  BB0500            mov bx,0x5
00000035  90                nop
00000036  90                nop
00000037  43                inc bx
00000038  43                inc bx
00000039  CD10              int 0x10
0000003B  90                nop
0000003C  90                nop
0000003D  90                nop
0000003E  C3                ret

(aşağıdaki örnekler için, ikilinin geri kalanı hala geçerlidir)

+1

00000000  42                inc dx
00000001  0D9090            or ax,0x9090
00000004  FEC4              inc ah
00000006  90                nop

2

00000001  0D9090            or ax,0x9090
00000004  FEC4              inc ah
00000006  90                nop

6

00000000  C4909090          les dx,[bx+si-0x6f70]
00000004  BB0500            mov bx,0x5
00000007  90                nop
00000008  90                nop
00000009  43                inc bx
0000000A  43                inc bx
0000000B  CD10              int 0x10

11

00000000  050090            add ax,0x9000
00000003  90                nop
00000004  43                inc bx
00000005  43                inc bx
00000006  CD10              int 0x10

12

00000000  00909043          add [bx+si+0x4390],dl
00000004  43                inc bx
00000005  CD10              int 0x10

18

00000000  1090B84F          adc [bx+si+0x4fb8],dl
00000004  0D9090            or ax,0x9090
00000007  FEC4              inc ah
00000009  90                nop

(diğer ofsetler sadece yukarıdakilerin tekrarıdır)

58

00000000  10909090          adc [bx+si-0x6f70],dl
00000004  C3                ret

Tek Cevap:

000000 ... 00000

^ 44391 Sıfır

Cat programı. Nasıl döndürürseniz döndürün, aynı programdır.

PHP

İşte geçerli bir PHP programı:

Is this still funny?

Scala

İç içe bir alıntı:

""""""""""""""""""""""""""""""""

C ++ / Java / C # / Scala

Yorum Yap:

///////////////////////////////////

Boş komut:

;;;;;;;;;;;;;;;

darbe

Yorum, Whitespace ve Shell yerleşik kombinasyonu:

#

:

sed

Bağımsız geçerli komutlar:

p P n N g G d D h H

Yukarıdakilerin bir kombinasyonu:

p;P;n;N;g;G;d;D;h;H;

AWK

Dosyanın her satırını yazdırmak için:

1

veya

//

Hiçbir şey yazdırmayın:

0

Perl

abcd

J

İlk olarak, bir programın geçerli dönüşlerini kontrol eden bir komut dosyası s:

check =: 3 :'((<;(". :: (''Err''"_)))@:(y |.~]))"0 i.#y'

Örneğin, program +/1 5(toplam 1 ve 5) şunları verir:

 check '+/1 5'
┌───────┬───┐
│┌─────┐│6  │
││+/1 5││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│Err│
││/1 5+││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│Err│
││1 5+/││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│6  │
││ 5+/1││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│6  │
││5+/1 ││   │
│└─────┘│   │
└───────┴───┘

Sonra sıkıcı, geçerli bir program:

check '1x1'
┌─────┬───────┐
│┌───┐│2.71828│ NB. e^1
││1x1││       │
│└───┘│       │
├─────┼───────┤
│┌───┐│       │ NB. Value of variable x11
││x11││       │ 
│└───┘│       │
├─────┼───────┤
│┌───┐│11     │ NB. Arbitrary precision integer
││11x││       │
│└───┘│       │
└─────┴───────┘

dC

dc programları her dönüşte kolayca geçerlidir. Örneğin:

4 8 * 2 + p  # 34
8 * 2 + p 4  # stack empty / 10
...

Makine kodu

NOP için Z80 / Intel 8051 makine kodu hakkında .

Elbette İşlem Yok yapar, ancak bir veya iki döngü sürer ... istediğiniz kadar çok veya daha azına sahip olabilirsiniz.

Ve yukarıdaki Ruby cevabına katılmıyorum - sanırım tek bir bayt 00h Ruby'den daha kısa p.

k

.""

Boş bir dizeyi değerlendirir

"."

Nokta karakteri döndürür

"".

'.' İfadesinin kısmi uygulamasını döndürür. (dyanik form) boş bir karakter listesine.

sh, bash

cc
cc: no input files

Döndürülmüş cc tekrar cc'dir, ancak çok çıplak olarak adlandırılırsa çok kolay değildir.

dh 
dh: cannot read debian/control: No such file or directory
hd 

dh debhelper da çok işbirlikçi değil, hexdump sadece girdi bekliyor.

gs
sg 

Ghostscript etkileşimli modu başlatırken, anahtar grubu bir kullanım mesajı gösterir - burada geçerli bir çözüm, imho.

Ve bu tür programlar için adayları bulmak için komut dosyası:

#!/bin/bash
for name in /sbin/* /usr/sbin/* /bin/* /usr/bin/*
do 
    len=${#name}
    # len=3 => 1:2 0:1, 2:1 0:2
    # len=4 => 1:3 0:1, 2:2 0:2, 3:1 0:3
    for n in $(seq 1 $((len-1)))
    do
        init=${name:n:len-n}
        rest=${name:0:n}
        # echo $init$rest
        which /usr/bin/$init$rest 2>/dev/null >/dev/null && echo $name $init$rest $n
    done 
done

Her vardiyadan sonra geçerli olmayan (arj, jar) veya (luatex, texlua) gibi daha uzun diziler bulursa, ancak başlangıçta yanlış anladığım bazı belirli vardiyalardan sonra, ancak birkaç tane var, bu yüzden kolay elle filtrelemek için.

Önemsiz Python örneği:

"a""b""c""d""e""f""g""h""i""j""k""l""m""n""o""p""q""r""s""t""u""v""w""x""y""z""";print

Alfabeyi daha fazla ortaya çıkarmak için art arda üç karakter kaydırılabilir.

piton

123456789.0

Sadece bazı sayıları değerlendirin

dc zaten kullanılıyor, ancak rotasyon ne olursa olsun aşağıdaki program her zaman aynı çıktıyı veriyor: D

d

Çıkışlardan

dc: stack empty