And she said, 'But that's his.'Sadece şu karakterleri kullanarak ifadeyi yazdır : abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ Herhangi bir noktalama işareti veya alfabetik olmayan karakter yok. İstediğiniz programlama dilini kullanabilirsiniz. Boşluklara tamamen izin verilir. En kısa program kazanır.

Boşluk , 417 414 349 265 bayt

Kevin Cruijssen sayesinde 265 bayt

Çevrimiçi deneyin!

Açıklaması:

[S S T  T   T   T   T   T   T   N
_Push_-63_'][S S T  T   T   T   S S S N
_Push_-53_.][S S S T    T   S T N
_Push_13_s][S S S T T   N
_Push_3_i][S S S T  S N
_Push_2_h][S S T    T   S S S T T   S N
_Push_-70_space][S T    S S T   T   N
_Copy_0-based_3rd_s][S T    S S T   T   S N
_Copy_0-based_6th_'][S S S T    T   T   S N
_Push_14_t][S S T   T   S T N
_Push_-5_a][S S S T S N
_Push_2_h][S T  S S T   S N
_Copy_0-based_2nd_t][S T    S S T   T   S N
_Copy_0-based_6th_space][S T    S S T   N
_Copy_0-based_1st_t][S S S T    T   T   T   N
_Push-15_u][S S T   T   S S T   S S N
_Push_-36_B][S S T  T   T   T   T   T   T   N
_Push_-63_'][S T    S S T   S S N
_Copy_0-based_4th_space][S S T  T   T   T   S T S N
_Push_-58_,][S S T  T   S N
_Push_-2_d][S S S T T   N
_Push_3_i][S S T    T   S T N
_Push_-5_a][S S S T T   S T N
_Push-13_s][S T S S T   S T N
_Copy_0-based_3rd_space][S S T  T   N
_Push_-1_e][S S S T S N
_Push_2_h][S T  S S T   T   N
_Copy_0-based_3rd_s][S T    S S T   T   N
_Copy_0-based_3rd_space][S S T  T   S N
_Push_-2_d][S S S T S S S N
_Push_8_n][S S T    T   S S T   S T N
_Push_-37_A][N
S S N
_Create_Label_LOOP][S S S T T   S S T   T   S N
_Push_102][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Perl 5 , 133 102 95 bayt

s qqAnd she saidZ ZBut thatZs hisZZGjGGfq x
s qZqchr oct oct oct ord chopqge x
y qGjfqqdx
print

Çevrimiçi deneyin!

Açıklama:

Regexes, yazdır ve doğrama hepsi $_varsayılan olarak değişkene uygulanır .

s qqAnd she saidZ ZBut thatZs hisZZGjGGfq

Boş dizgiyi ile değiştirir And she saidZ ZBut thatZs hisZZGjGGf.

s qZqchr oct oct oct ord chopqge

Her Zbirini değerlendirme sonucu ile değiştirir chr oct oct oct ord chop. Bu, son karakterini kaldırır, $_anahtar kodunu alır, onu sekizli üçlü olarak yorumlar ve onu bir karaktere dönüştürür. Örneğin, j→ 106 → 70 → 56 → 46 → ..

Değişimin işleyiş şekli nedeniyle, değişimin $_değerlendirilmesinde yapılan değişiklikler kaybedilir, $_şimdi de öyle And she said, 'But that's his.'GjGGf.

y qGjfqqd

Bütün siler G, jve fde $_.

> <> , 916 915 903 bayt

Başta>>> bir çözümün imkansız olduğunu düşündüm, ama sonra farkettim ki ... kimin koşullu ya da mantık kontrolü gerekiyor? : D

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

Çevrimiçi Deneyin

Arka arkaya numaralar (15 numara) basıp ardından yığının uzunluğunu itiyorum ve karakteri bu ASCII değeri ile yazdırıyorum. Yığın uzunluğunu daraltmam gerekiyorsa, yığını kullanarak üç defa değeri pveya ghedefin üçünün içindeysem bir kerede bir değerini daraltırım . Program i, -1herhangi bir giriş olmadığı için zorlayan bir çağrı (giriş) yaparak sona erer , ardından bir hataya sebep olmak için yazdırır.

Bu, nasıl yapılacağını düşündüğümde çözümü oluşturmak için kullandığım Python 3 programı:

s = "And she said, 'But that's his.'"
L = [0]+[ord(c) for c in s]
#print(L)
M = L[1:]+[0]
D = [x[1]-x[0] for x in zip(L,M)]
#print(D)
while D:
	n=D.pop(0)
	if not D:print('io',end='');exit()
	if n>0:print('f'*n,end='lo')
	else:
		while n<-2:print('p',end='');n+=3
		print('g'*-n,end='lo')

Çevrimiçi Deneyin

8086 IBM PC'de derleme, 1463 845 664 bayt

Açıklama: Asıl montaj dili kaynağı, oluşturulan makine kodu değil, giriştir.

Zorluk, x86 komutlarının çoğunun (ADD, SUB, JMP, koşullu atlamalar, bellek erişimi gibi) iki argümana sahip olması ve bu nedenle virgül veya bir bellek adresine ihtiyaç duymasıdır. Bu yüzden toplama, çıkarma, ifs veya loop'ları kullanamayız!

İlk denemem sırasında bir artış, azalma, çarpma, bölme, bayt numaraları ve belirsiz BCD talimatlarını (AAA, DAS gibi) bir arada kullanarak sayıları "oluşturdum". Ondan sonra, bu fikrin kendi kendini denetleyen ve kendi kendini değiştiren kod oluşturmak için kullanılabileceğini fark ettim.

• Deneme 1. (1463 bayt)

  ASCII kodlarını ve ekran arabelleğinin 0xb800 adresini oluşturmak için mevcut talimatları kullandı. Dizideki her karakterin hesaplanması elle golf yapıldı.

• Deneme 2. (tamamlanmadı)

  0x40-0x5f aralığında her tamsayı için bir opcode olduğunu fark etti. Bu seri AZ'yi içerir. Bu nedenle, örneğin INC CX, 0x41 = 'A' değerine karşılık gelir. (Bu opcode tablosu çok kullanışlıdır.)

  3 "data" dizgisi oluşturmaya çalıştım ve onları birbirlerinin üzerine koydum. İlk olduğu gibi (büyük harf), ikincisi 0x60-0x7f bölgesine (küçük harf) ve son "0x20-0x3f bölgesine (noktalama işareti)" kaydırıldı ".

  Kendi kendini değiştiren kod, veriler üzerinde yineleme yapmak için bir döngü veya üç üretir.

• 3. girişimi (845 bayt)

  Önceki yaklaşımda olduğu gibi, ancak verileri kısmak için, karakter kümeleri arasında geçiş yapmak için "kontrol karakterleri" karıştırılarak karakter dizisi yalnızca bir kez kodlanır.

• 4. deneme (664 bayt)

  Dallanma ile baş etmek için çok sayıda yamalı talimat gerektiren kontrol karakterlerinden nasıl kurtulur? Yalnızca iki büyük harf kullanıldığı göz önüne alındığında, 0x40-0x4f aralığını kullanarak küçük harfleri kodlamak için opcode tablosunu "çevirip değiştiremeyeceğimi ve 0x90-0x9f aralığını kullanarak (0xc0'dan çıkartarak) noktalama işaretini kullanıp kullanamayacağımı merak ettim. "A" ve "B" ayrı ayrı girebilir.

  Bununla birlikte, 0x90-0x9f aralığında bulunan kodların yalnızca yarısı kullanışlıdır ve ihtiyaç duyulanlarla aynı hizada değildir. Sonra XOR kullanarak onları karıştırıp bulabileceğimi düşündüm ve işe yarayan bir tane buldum. Ve işte burada.

golfed:

REP LODSB
PUSH CX
PUSH CX
POP AX
INC CH
PUSH CX
POP DI
DEC AX
DEC AX
REPNE SCASB
REPNE SCASB
PUSH DI
REPNE SCASB
PUSH DI
REPNE SCASB
PUSH DI
POP SI
POP DI
DEC DI
LODSB
NOT AL
STOSB
POP CX
DEC CH
LODSB
NOT AL
STOSB
LODSB
AAA
STOSB
INC DI
LODSB
NEG AL
STOSB
LODSB
NOT AL
PUSH AX
PUSH AX
INC SP
POP ES
INC SP
POP DI
LODSB
NOT AL
PUSH AX
POP BX
NEG AL
STOSB
INC DI
LODSB
DEC AL
NEG AL
DIV BH
PUSH AX
POP DI
LODSB
STOSB
RET
DEC BL
PUSH CS
STOSB
PUSH DS
INC DI
INC AX
POP SI
PUSH SP
NOP
INC BP
POP AX
PUSH DI
NOP
INC BP
PUSH BX
POP BX
PUSH SP
PUSHF
NOP
CWD
PUSH DX
INC DI
INC SP
NOP
INC SP
POP AX
PUSH BX
INC SP
CWD
INC BP
NOP
POP AX
POP BX
INC BP
SAHF
CWD
SCASB
INC DX

İle birleştir

nasm golf.asm -o golf.com

ve DOSBOX'ta çalıştırın (önce CLS'yi çalıştırın). Buna benzer:

Yorumlananlar:

; ASSUME DS = ES = CS
; ASSUME IP = 0x0100
; true for .COM file

; We treat 0xFE as a special marker that we scan for
; This marks our patch zone and the start of our data

; We also use it as a cheap trick to get a constant 0x1f
; into CX

; 0xFE is the first byte of INC or DEC instructions
; that operate on half-word registers (AL, BL, CH etc.)
; WATCH OUT! Adding these breaks the scan


; Can't assume any register contains zero
; so use this trick to zero out CX
REP LODSB

PUSH CX ; needed later

; zero AX
PUSH CX
POP AX

INC CH
PUSH CX
POP DI ; 0x100, where our code starts

DEC AX
DEC AX ; AL = 0xFE, our marker (AH = 0xFF)

REPNE SCASB ; skip the INC CH above
REPNE SCASB ; find the DEC CH located at 0x10E

; we will later need 0xF, the char count minus the 'A'
PUSH DI ; DI = 0x10F

REPNE SCASB ; find the patch position
PUSH DI

REPNE SCASB ; find the next 0xfe; our data section
PUSH DI
POP SI ; load data from here

POP DI ; store data to the patch position
DEC DI

; patch in XOR
; XOR is 0x34, start with 0xCB
; second byte of DEC BL is 0xCB
LODSB
NOT AL
STOSB

POP CX ; get 0x0f in CX for our strlen
DEC CH

; patch in our XOR arg
; it is 0xF1 (take 0x0E and NOT it)
LODSB ; 0x0E (PUSH CS)
NOT AL
STOSB

; ADD is 0x00 (take 0xAA, apply weird AAA behaviour)
; this also zeroes AH
LODSB ; 0xAA (STOSB)
AAA
STOSB

INC DI ; skip next instruction byte

; LOOP is 0xE2
LODSB ; 0x1E PUSH DS
NEG AL
STOSB


; get b800 in ES (address of screen buffer)
; first get 0x47 in AL (INC DI)
LODSB  ; get 0x47 (INC DI)
NOT AL ; NOT 0x47 = 0xb8
; AX = 0x00b8 (bytes backwards)

PUSH AX
PUSH AX
; stack contains 0xb8 0x00 0xb8 0x00
; stack off-by-1 trick
INC SP
; now POP gives you 0xb800
POP ES
INC SP ;and clean up after ourselves

; store 0 in DI ***** PUSHED AT START OF PROGRAM ***
POP DI


LODSB ; get our magic 0xC0 (0x40 INC AX)
NOT AL
PUSH AX
POP BX

NEG AL ; NOT and +1 to get 0x41 ("A")


; charloop:
STOSB
INC DI
LODSB
DEC AL ; XOR
NEG AL ; modify this into an ADD AL, BL
DIV BH ; modify this to LOOP back to charloop

; doesn't print the last character
; but the last character turns into the address where 'B'
; is supposed to go

PUSH AX
POP DI
LODSB ; "B"
STOSB

; graceful exit this time ;)
RET


; *** DATA SECTION ***

         ; PURPOSE

DEC BL   ; 0xFE marks data section, 0xCB for XOR
PUSH CS  ; for XOR arg
STOSB    ; for ADD
PUSH DS  ; for LOOP
INC DI   ; 0x47 -> for 0xb800

INC AX   ; for magic number but also "A"


POP     SI ;n
PUSH    SP ;d
NOP        ;
INC     BP ;s
POP     AX ;h 
PUSH    DI ;e
NOP        ;
INC     BP ;s
PUSH    BX ;a
POP     BX ;i
PUSH    SP ;d
PUSHF      ;,
NOP        ;
CWD        ;'
PUSH    DX ;B
INC     DI ;u
INC     SP ;t
NOP        ;
INC     SP ;t
POP     AX ;h
PUSH    BX ;a
INC     SP ;t
CWD        ;'
INC     BP ;s
NOP        ;
POP     AX ;h
POP     BX ;i
INC     BP ;s
SAHF       ;.
CWD        ;'

SCASB     ; treated as char but turns into screen address!
INC DX    ; "B"

Perl 6 , 1299 1272 1220 1215 bayt

-27 bayt için Grimy'e teşekkürler.

-52 bayt çünkü ilk etapta tavşan kulağına ihtiyacımız yoktu.

Jo King'e -5 bayt için teşekkürler.

print chr flip chars i x chars i xx pi
and print lc chr chars NaN x chars cis pi
and print lc chr chars e x e x e
and print chr chars i x e x e x e
and print lc chr flip chars exp i
and print lc chr chars NaN x tau x e x e
and print chr chars chop NaN x e lcm chars e
and print chr chars i x e x e x e
and print lc chr flip chars exp i
and print lc chr flip chars i x chars i xx pi
and print chr chars False x pi x ceiling tau
and print lc chr chars e x e x e
and print chr chars i xx chars NaN x pi
and print chr chars i x e x e x e
and print chr chars chop False x e x e x e
and print chr chars chop NaN xx chars e
and print lc chr chars e x chars False
and print lc chr chars chop e x chars False
and print chr chars i x e x e x e
and print lc chr chars chop e x chars False
and print lc chr chars NaN x tau x e x e
and print lc chr flip chars i x chars i xx pi
and print lc chr chars chop e x chars False
and print chr chars chop False x e x e x e
and print lc chr flip chars exp i
and print chr chars i x e x e x e
and print lc chr chars NaN x tau x e x e
and print chr chars False x pi x ceiling tau
and print lc chr flip chars exp i
and print chr chars NaN xx tau x e
and say chr chars chop False x e x e x e

Çevrimiçi deneyin!

Dizeyi izleyen bir yeni satır ile çıkarır. Bunu istemiyorsanız, sonuncuyu a sayile değiştirin print. Kaynaktaki yeni satırları boşluklarla da değiştirebilirsiniz.

açıklama

Bu kod dize karakterini karaktere göre yazdırır. Her karakter, uygun karakter kodunu chrişlevin içine besleyerek ve gerektiğinde onu küçük harflerle oluşturarak oluşturulur lc.

Şu anda, tüm değerler, içinde doğru sayıda karakter bulunan bir dize oluşturarak üretilmektedir; Bazı durumlarda, karakter sayısı hedef karakter kodunun tam tersidir. Teorik olarak logve expdoğrudan gibi matematiksel işlevleri kullanmak mümkün olmalı , ama ben bunları kullanmayı çok kolay bulamadım.

Sayı olarak kullanım için, elimizdeki e, pive tau; xveya sağ tarafında xx, örtük olarak döşenmiştir. Hepsinin string gösterimlerinde 17 karakter var, bu yüzden eminimum karakter sayımı için kullanıyoruz . Ayrıca i(4 karakter), False(5 karakter) ve NaN(3 karakter). Dize uzunluklarını çarparak x; xxbir artı dize uzunluğunu sağ tarafla çarpar ve bir tanesini ekler. chopHedeften uzak olduğumuzda, bir karakteri dizeden kaldırır.

Basılı ifadeler and, oldukça düşük bir önceliğe sahip olan kullanılarak zincirlenmiştir . Neredeyse var olduğu bir mucize; Aksi takdirde, yasadışı noktalı virgül kullanmalıyız.

Karakterlerin ifadelerini elle buldum. Kısa ifadeleri bulmak için onları programlı olarak aramaya değebilir.

Genişlik , 66 64 bayt

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

Çevrimiçi deneyin!

Hata ayıklamak için yazdırır. Stdout'a yazdırmak için ww, yığının üstüne çıkan ve çıkan kodun sonuna ekleyin .

açıklama

Genişlikte, her harf bu tabloya göre ne kadar "geniş" olduğuna bağlı olarak bir sayı ile ilişkilendirilir . Bu, her harfe 0 ila 9 arasında bir sayı atar. Ardından, bu sayılar gerçekte kodu çalıştırmak için kullanılır.

Özellikle, eşleşmelerden 7daha büyük olan bir harf, string değişmezine başlar. Orijinal harf tekrar okuyana kadar iki harften bir kerede okuyacak. İki harften oluşan her set, genişlik numaralarına dönüştürülecek, 0 ile 99 arasında ondalık bir sayı olarak okunacak ve eşitlendikleri karakter aşağıdaki dizgede dizini olacaktır:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\n\t

Örneğin, dizini !1'dir, bu nedenle 01doğru genişlik sayıları olacaktır. Böylece if, iI, jtvb tüm edebi bir dizeye ilişkili olacaktır !.

Bu durumda, istenen çıktının 31 karakterini Qtırnak işareti olarak kullanarak uygun harflere çevirdim. Program bittiğinde yığının üstü hata ayıklamaya yazdırılır.

x86 makine kodu (32 bit), 256 bayt

Kodumu kod sayfası 437 konsolumda yazdırdığımda aşağıdakileri görüyorum:

j XI a I a I a jbZ      Q fiQ Gf a f    Q I a I a I a I a h hisZ        Q I a I a I a I a hBP  Z        Q iQ
y       Q  a I a I a I a h thaZ Q I a I a I a Ih ButZ   Q  a I a I a I a fhu fZf        Q iQ g  S       Q  a I a I a I a hsaidZ Q I a I a I a I a hshe Z        Q I a I a I a I a hAnd Z        Q TZBX b 

Bu, bazı boşluk karakterleri içeriyor; bu nedenle, tüm sekme karakterlerini →ve kırılmayan tüm boşluk karakterlerini (255 koduyla) değiştirdiğimde aynı kod *:

j XI a I a I a jbZ→Q fiQ Gf a f→Q I a I a I a I a h hisZ→Q I a I a I a I a hBP  Z→Q iQ →→y →Q  a I a I a I a h thaZ→Q I a I a I a Ih ButZ→Q  a I a I a I a fhu fZf→Q iQ g→S →Q  a I a I a I a hsaidZ→Q I a I a I a I a hshe Z→Q I a I a I a I a hAnd Z→Q TZBX*b*

HexDump:

6a 20 58 49 20 61 20 49 20 61 20 49 20 61 20 6a
62 5a 09 51 20 66 69 51 20 47 66 20 61 20 66 09
51 20 49 20 61 20 49 20 61 20 49 20 61 20 49 20
61 20 68 20 68 69 73 5a 09 51 20 49 20 61 20 49
20 61 20 49 20 61 20 49 20 61 20 68 42 50 20 20
5a 09 51 20 69 51 20 09 09 79 20 09 51 20 20 61
20 49 20 61 20 49 20 61 20 49 20 61 20 68 20 74
68 61 5a 09 51 20 49 20 61 20 49 20 61 20 49 20
61 20 49 68 20 42 75 74 5a 09 51 20 20 61 20 49
20 61 20 49 20 61 20 49 20 61 20 66 68 75 20 66
5a 66 09 51 20 69 51 20 67 09 53 20 09 51 20 20
61 20 49 20 61 20 49 20 61 20 49 20 61 20 68 73
61 69 64 5a 09 51 20 49 20 61 20 49 20 61 20 49
20 61 20 49 20 61 20 68 73 68 65 20 5a 09 51 20
49 20 61 20 49 20 61 20 49 20 61 20 49 20 61 20
68 41 6e 64 20 5a 09 51 20 54 5a 42 58 ff 62 ff

Nasıl çalıştığı hakkında bazı açıklamalar:

Yararlı talimatlar:

• push imm8, push imm16Ve push imm32, bunu takiben popsabitler üretir. Bu ayrıca ahbir byte ( imm8) basarken sıfır (in ) de üretebilir .
• and [ecx+32], ah- ah = 0 varsayalım, bu byte'ı sıfıra ayarlar. Çıktı dizgisinin uzunluğu 32'dir, kod tamponu baştan sona doldurur.
• or [ecx+32], edx- çıktı baytının sıfıra ayarlandığı varsayılarak, bu çıktıya kopyalanır edx(4 bayt). Ben bir varyantını kullanmak dxyerine edxo çıktı tamponu ötesinde yazmak gerekir, çünkü tampon sonuna yakın. Kod kısıtlaması bu şekilde tek bayt yazmayı imkansız kılar!
• imul edx, [ecx+32], whatever- Bu ana karışma fikri. Yeterli entropi [ecx+32]ve sayı ne olursa olsun , herhangi bir çıktı üretebilir. Gerekli değerleri 2 veya 3 bayt oluşturmak için kullanırım. Bazı komplikasyonlar, çıktıya yazarken OR, zaten orada olanlarla mantıklı bir şekilde çalışması gerekir . Bu bazen belleği bir kez daha sıfırlamayı gerekli kılmıştır.
• Döndürmek için bir jmpkomutun bir çeşidi kullanılır. Seçtim çünkü kodlaması, 0xffkod sayfası 437'deki ayrılmaz bir boşluğa karşılık geliyor. Kurallar üzerinde bir gerginlik biraz, ama aksi halde görevin imkansız olduğunu düşünüyorum ...

Derleme kaynak kodu, onu çalıştıran bir C programıyla birlikte (Visual Studio sözdizimini kullanır):

#include <stdio.h>

__declspec(naked) void __fastcall doit(char* buf)
{
    __asm {
        push ' '
        pop eax

        dec ecx
        and [ecx+32], ah    // terminating 0 byte

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah

        push 98
        pop edx
        or [ecx+32], edx
        imul dx, [ecx+32], 26183
        and [ecx+32], ah
        or [ecx+32], dx    // two bytes: [.']

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 'sih '
        pop edx
        or [ecx+32], edx    // 4 bytes: [ his]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 538988610
        pop edx
        or [ecx+32], edx
        imul edx, [ecx+32], 544803081
        or [ecx+32], edx // 1 junk byte and 3 good bytes: (t's)

        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 'aht '
        pop edx
        or [ecx+32], edx    // 4 bytes: [ tha]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        push 'tuB '
        pop edx
        or [ecx+32], edx    // 1 junk byte and 3 good bytes: [But]

        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push word ptr 8309
        pop dx
        or [ecx+32], dx
        imul edx, [ecx+32], 542312807
        or [ecx+32], edx    // 1 junk byte and 3 good bytes: [, ']

        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 'dias'
        pop edx
        or [ecx+32], edx    // 4 bytes: [said]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push ' ehs'
        pop edx
        or [ecx+32], edx    // 4 bytes: [she ]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push ' dnA'
        pop edx
        or [ecx+32], edx    // 4 bytes: [And ]

        push esp
        pop edx
        inc edx

        pop eax
        jmp dword ptr[edx-1]
    }
}

int main()
{
    char buf[100];
    doit(buf);
    puts(buf);
}

PostScript, 889 874 837 835 bayt

currentflat string dup rrand
count dup count count mul mul xor count count mul count dup mul exch count
count copy count copy count copy count copy count copy
add and sub put print
and sub add put print
sub sub add put print
mul or xor put print
idiv xor add put print
or xor add put print
mod idiv add put print
mul or xor put print
idiv xor add put print
sub and add put print
or and add put print
sub sub add put print
pop add sub put print
mul or xor dup copy put print
mod mul sub put print
add or xor put print
idiv add add put print
add or add put print
put print
add or add put print
or xor add put print
sub and add put print
add or add put print
mod mul sub put print
idiv xor add put print
mul or xor put print
or xor add put print
or and add put print
idiv xor add put print
xor add sub put print
mod mul sub put print
quit

Çevrimiçi deneyin!

Bu, tam sayıların 32 kopyasını kullanır 89 25 20 6. Hedef dizginin tüm karakter kodları, bu tamsayılar üzerindeki işlemlerle yığın sırasına göre elde edilebilir: örneğin, 'A' (ASCII 65) 89 - (25 & (20 + 6)) olur. Pek çok 4-tekil tam sayı bu özelliğe sahiptir; bu seçildi, çünkü üretmeleri özellikle kolaydı.

currentflat string dup rrand

Varsayılan olarak 1 varsayılandır, bu nedenle 1 uzunluğunda bir dize oluşturulur (başlangıç ​​değeri \0). dupderin bir kopya değildir: aynı dizgeye ikinci bir referans oluşturur. rrand, varsayılan olarak 0 olan rasgele tohumu iter. Yığın şimdi ["\0", "\0", 0].

count dup count count mul mul xor

count yığındaki öğe sayısını iter, bu nedenle bu 3 ^ (3 * (5 * 6)) = 89 değerini hesaplar.

count count mul count dup mul exch count

4 * 5 = 20, 5 * 5 = 25, 6 = 6. Yığın şimdi ["\0", "\0", 0, 89, 25, 20, 6].

count copy count copy count copy count copy count copy

Tüm yığını beş kez çoğaltın. Böylece ilk 7 elemanlı yığının 32 kopyasını çıkardık. Hedef dize 31 karakter uzunluğunda olduğundan yalnızca 31 kopyaya ihtiyacımız vardır, ancak ekstra kopya zarar görmez.

add and sub put print

En üstteki dört tamsayıdan bir charcode hesaplayın, dizenin 0 dizinine yazın, sonra dizeyi yazdırın.

quit

Varsayılan istemi gizler.

Ruby , 420 354 338 bayt

def P a
print String a
end
def Q a
p String a
end
class String
def inspect
putc sum size
q
end
end
def w
Q def hacked
end
rescue
end
P def And
end
w
P def she
end
w
P def said
end
Q def gadget
end rescue
w
def a
Q def afraid
end
rescue
end
a
P def But
end
w
P def that
end
a
putc String def s
end
w
P def his
end
Q def fierce
end rescue
a

Çevrimiçi deneyin!

Yükselen sarsıntı düzeninde:

Büyük harfle başlayan kelimeler, bu isimde bir sınıf tanımlanarak displayve sınıf tanım organı içinde çağrılarak yazdırılabilir .

Başka kelimeler, bir Sembol döndüren bu ada sahip yöntemleri tanımlayarak ve sonra da öndeki kolonu kaldırmak için bir Dizeye dökerek görüntülenebilir.

Diğer karakterler putcASCII kodlarını arayarak görüntülenebilir . String defBir dize elde etmek için numarayı yeniden kullanarak , ardından boyutuna göre belirlenen bir modülü kullanarak baytların toplamını alarak uygun sayıları üretebiliriz . Ne yazık ki, bu nesnenin sınıf tanımından farklı bir nesnede yöntemleri çağırmanın hiçbir yolu yoktur, bu da argümanları iletmeyi zorlaştırır. Yani nihai kesmek yeniden tanımlamaktır String#inspectiçin bir dize geçerken örtülü çağrılan hangi pbir hata artırmadan önce hesaplar ve bir yan etki olarak uygun karakteri verir, böylece, böylece yöntemin paslında yürütme ve baskı bir bitiremez Yeni hat. O zaman ana koddaki hatayı kurtarmamız gerekiyor.

Düzenleme: Ürdün , bayt sayısını daha az, bazı akıllı kontrol akışı golf ile yüksek, ahem yaptı ve raisebir NameError yükselten bir harfli varolmayan yöntem çağrısı ile değiştirerek birkaç bayt kesti .

Düzenleme 2: print StringBir yönteme ayıklanırken, yöntemlerin başlık kasasına alınmasına izin verildiğinden, yalnızca sınıf tanımı hilesini kullanmaktan çok bir yöntem tanımıyla kullanmanın daha ucuz olduğunu fark ettim .

> <> , 233 122 bayt

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

Çevrimiçi deneyin!

Bu, mbomb'un cevabının golfü olarak başladı , ancak çok sayıda bayttan tasarruf sağlayan temel bir değişim keşfettim, bu yüzden kendi cevabım olarak gönderiyorum.

Çıktıya alfabetik olmayan karakterler oluşturma, değerleri yığına tekrar tekrar lbasıp ardından yığın uzunluğunu itmek suretiyle yapılır. Bununla birlikte, bunun hemen çıkması gerekmez: kullanılarak p, bu karakter, daha sonra alınacak şekilde, her ikisi de koordinatları 10 ila 15 arasında olan herhangi bir hücreye yerleştirilebilir g. Benzer şekilde, alfabetik karakterler ilk kaynak koduna yerleştirilebilir ve şu şekilde okunur: girişteki alfabetik olmayan en yüksek karakter kodu 46 ( .) olduğundan, bu, yığının depolamak için gereken 62'den daha yüksek itilmesine gerek olmadığı anlamına gelir çıktının tüm 31 karakteri.

Ek olarak, a vsütunundaki 7 koduna yerleştirilir. Yön gösterici etrafına dolanıp çarptığında v, dizi go, basılan koordinatlardan okumak ve karşılık gelen karakterleri çıkarmak için tekrar tekrar yürütülür. Sonunda, yığın boşalır ve gprogramı bir hata ile sonlandırır.

İlk 7 bayt kod, ilk 7 ve son 7 koordinatın her ikisi de itildiği için tekrar kullanılır. v9 sütununa yerleştirmek teorik olarak iki bayt daha kaydederdi, ancak karakterleri Ainsvkodda 2x2 kareye zorlardı ki bu imkansızdır. Daha eski bir sürümde sütun 15 kullanılmış, ancak bu kaynak kodunda fazladan bir satır gerektiriyordu ve altı bayt daha uzun sürüyordu.

CJam , 262 bayt

  KAbScibCmhc  CZbsic          GmQYbsic
S CmfYmeibc    ImqmeKmhcel     AZbAbc
S CmfYmeibc    KAbScibCmhcel   ImqmeKmhAmhcel  GmQYbsic    KAZbYbbBbc
S CGmQbDbc     EYbTYtZbc       FYbGmQbcel      EYbGmQbcel
S EYbGmQbcel   ImqmeKmhcel     KAbScibCmhcel   EYbGmQbcel  CGmQbDbc    CmfYmeibc
S ImqmeKmhcel  ImqmeKmhAmhcel  CmfYmeibc       PYmhmeKmhc  CGmQbDbc

Çevrimiçi deneyin! Newlines burada sadece netlik için gösterilir; her satır bir karakteri temsil eder.

Vay, bu eğlenceliydi. Kendimizi alfabetik komutlarla sınırlandırmak bazı ilginç zorluklar doğurur:

• Olmadan {ve }neredeyse (hariç kontrol akışı için hiçbir fırsatı var fkullandığım için bir fırsat bulamadık).
• Olmadan \, _, ;ya da $biz yığın manipülasyonu için bir araca sahip.

Bu, asıl amacın yığında ilgili kod noktalarını elde etmek ve sonra bunları karakterlere dönüştürmek anlamına geliyor c.

Sorun şu ki, en basit aritmetik komutlardan ve tamsayı değişmezlerden de yoksun olmamız. Bu, mad alanı çok sayıda gelişmiş matematiksel işlem içerdiğinden ve faydalı sayılar için önceden tanımlanmış birçok değişken olduğundan, bu sorun değildir.

Çok sayıda karekök ( mQve mq), üstel fonksiyon meve üs dönüşümünü ( b) kullanmaktan da faydalandım [X 0] Yb. Ek olarak, bazen büyük harf kod noktasını oluşturmak daha kolaydır, bu durumda elortaya çıkan karakterde kullanabiliriz (küçük harfe dönüştürülebilir).

Hala daha uzun olanlardan memnun değilim. Oh iyi.

açıklama

Bu, çıkışın karakter karakterli açıklamasıdır. Başlamadan önce, sayı yapmanın birkaç kısa yolu:

• 0, 1, 2, 3 değişken içerdiği T, X, Y, Zsırasıyla.
• 20'den Numaraları 10 değişken içerdiği Ayoluyla K.
• 32 kullanılarak yapılabilir Sci( Sboşluk içeren bir dize iter c, bu dizenin ilk karakterini alır ve ibu karakteri kod noktasına dönüştürür). Sboşluklar için de kullanılır.
• 4, GmQ(16'nın tamsayılı karekökü) ile verilir.
• 5 ile verilir AZbYb(10 baz 3'e [1 0 1]dönüştürülür, elde edilir ve sonuçta elde edilen sayı dizisini baz 2'ye dönüştürülür, 5 elde edilir).
• 7, Ymei(exp (2) hesaplama ve tam sayıya dönüştürme) ile verilir.

A

K           - push 20                        | 20
 Ab         - convert to base 10             | [2 0]
   Scib     - convert from base 32           | 64
       Cmh  - hypot(TOS, 12)                 | 65.115
          c - round down and convert to char | 'A

n

C      - push 12            | 12
 Zb    - convert to base 3  | [1 1 0]
   s   - convert to string  | "110"
    i  - convert to integer | 110
     c - convert to char    | 'n

d

GmQ      - push 4             | 4
   Yb    - convert to base 2  | [1 0 0]
     s   - convert to string  | "100"
      i  - convert to integer | 100
       c - convert to char    | 'd

s

C         - push 12         | 12
 mf       - factors         | [2 2 3]
   Ymeib  - base 7          | 115
        c - convert to char | 's

h

I           - push 18                        | 18
 mq         - sqrt                           | 4.242
   me       - exp                            | 69.591
     Kmh    - hypot(TOS, 20)                 | 72.408
        c   - round down and convert to char | 'H
         el - lowercase                      | 'h

e

A      - push 10              | 10
 Zb    - convert to base 3    | [1 0 1]
   Ab  - convert from base 10 | 101
     c - convert to char      | 'c

a

KAbScibCmhc   - push 'A (see above) | 'A
           el - lowercase           | 'a

i

I              - push 18         | 18
 mq            - square root     | 4.242
   me          - exp             | 69.591
     Kmh       - hypot(TOS, 20)  | 72.408
        Amh    - hypot(TOS, 10)  | 73.095
           c   - convert to char | 'I
            el - lowercase       | 'i

,

K          - push 20              | 20
 AZbYbb    - convert to base 5    | [4 0]
       Bb  - convert from base 11 | 44
         c - convert to char      | ',

'

C        - push 12              | 12
 GmQb    - convert to base 4    | [3 0]
     Db  - convert from base 13 | 39
       c - convert to char      | ''

B

E         - push 14               | 14
 Yb       - convert to base 2     | [1 1 1 0]
   TYt    - replace elem 0 with 2 | [2 1 1 0]
      Zb  - convert from base 3   | 66
        c - convert to char       | 'B

u

F          - push 15             | 15
 Yb        - convert to base 2   | [1 1 1 1]
   GmQb    - convert from base 4 | 85
       c   - convert to char     | 'U
        el - lowercase           | 'u

t

E          - push 14             | 14
 Yb        - convert to base 2   | [1 1 1 0]
   GmQb    - convert from base 4 | 85
       c   - convert to char     | 'T
        el - lowercase           | 't

.

P          - push pi                        | 3.141
 Ymh       - hypot(TOS, 2)                  | 3.724
    me     - exp                            | 41.437
      Kmh  - hypot(TOS, 20)                 | 46.011
         c - round down and convert to char | '.

Deadfish ~ , 943 bayt

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

Çevrimiçi deneyin!

Döngü yok :(

kötülük , 198 bayt

aeeeannkhhwzuuuuuueaeuekwuuuuuuuuuunkhwzaeeeeehknwgueeywguuuuuuhhknnwuuuwhgwpwnngheeuwguuuuuwngwzaeeeaaaeeeeeewhhgwnguuuueewnngawpaawuwnngwpawhgwhhgeeuwpawhguuuueewpwhgwhgwawpwnngaaaaaaeeeewguuuueew

Çevrimiçi deneyin!

Bu oldukça eğlenceliydi.

Stax , 133 95 84 79 bayt

AHHvcAvSVvNvXvsrDhYcvxvZLcHxVahyvxxZVvHVChAHHvVAHhvZAJyVahxvVvDhZyvxvAJZcASVAhL

Koş ve hata ayıkla

MATL , 187 158 bayt

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

Çevrimiçi deneyin!

Daha okunabilir sürüm: Çevrimiçi deneyin! İpin oluşturulmasında manuel deneme. Bir ipi kullanarak Pve hçevirmek için , ipi uygun parçalara bölerek golf oynamak için yeterince yer vardır . Umarım birileri beni aşmak için mücadele eder. Asıl zorluk, kullanamamanız +ya da -temel aritmetik yapmanın mümkün olmamasıdır.

Özellikleri:

• KQthpYq: 25'inci ( KQthp) üssü Yq, mektuba karşılık gelen 97'dir a. Mektup s(115), 30. asal sayı olan 113'ten benzer şekilde üretilmiştir. Daha sonra kapsamlı bir şekilde panoda kullanılır J.
• hishPanodan önce gelenleri depolayarak kısaltılır J. Önceden depolandığından beri, geriye doğru sinşa hisediyoruz, böylece son skullanılanları hala geri alabilir ve kullandıktan ysonra çevirebiliriz P.
• Bayt sayıda (genellikle bir grup değiştirerek Luis Mendo sayesinde kaydedilen hiçin vle)

MATL , 118 bayt

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

Çevrimiçi deneyin!

Daha fazla okunabilir sürüm (her satır istif düzenleme işlemleri hariç bir karaktere karşılık gelir).

açıklama

Program, istenen karakterlerin kod noktalarını bağımsız sayılar olarak üretir. Sonunda, tüm bu sayılar bir sütun vektörüne birleştirilir, satır vektörü olarak yeniden şekillendirilir ve karakterlere dönüştürülür. Sonuç örtülü olarak görüntülenir.

Kullanılan numaralardan bazıları:

• 32'nin altındaki kod noktalarının çoğu boşluk olarak görüntülenir. Bu yüzden 0çoğu boşluk için kullanılır, çünkü yalnızca bir byte'a ( O) mal olur.
• Bununla birlikte, ilk boşluk 15için kullanılır (olarak üretilir KUq), çünkü daha sonra 100(char d) 'a 115( s) vermek için tekrar kullanılabilir . Başka bir vesileyle 5(aynı oluşturulan alan için kullanılır KQ), bu yüzden daha sonra çıkarılır edilebilir 44( ,vermek) 39( ').
• Pano J, tekrarlanacak karakterleri depolamak için kullanılır: önce s, sonra '. Benzer şekilde, panoya Hmağazaları 100için yararlıdır, dve diğer karakterleri oluşturmak için.
• Kapsamlı kullanım, Q(add 1), q(çıkarma 1), E(ile çarp 2) ve U(kare) işlevlerinin yanı sıra panolardaki I( 3) ve K( 4) önceden tanımlanmış değişmezleri içerir .
• Keyfi toplama ve çıkarma, bir vektörde ( h) birleştirme ve toplamını ( s) veya ardışık farkları ( d) hesaplayarak yapılır .
• 100( d), 4ondalık sayı olarak yorumlanan ikili sayıdaki gibi üretilir .
• 110( n) 65( A) '65'kod dizisine ( : kod noktaları [54 53]) dönüştürülerek 1kod noktalarına ( [55 54]) eklenir, toplanır ve toplanarak elde edilir 1.
• Sayıların üretilme sırası bazen kolaylık sağlamak için değiştirilir; ve daha sonra istif yeniden düzenleme fonksiyonları tarafından yeniden sıralanırlar: takas ( w), kabarcık atma b).

dc , 240 222 209 bayt

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

Çevrimiçi deneyin!

İlk düşüncem @seshoumara ile aynıydı, sadece karakterlerin ASCII değerlerini oluşturacak kadar yığının üzerine yeterince malzeme bastırdım. Sonra o yana aklıma +, -ve *tek karakterlik operatörleri, sadece bunları yeniden ve aritmetik kullanma olanağı olabilir! Elbette bu daha küçük olurdu! Ve daha fazla baytla golf oynayabilirsem şaşırmam, ama şimdilik ... bu kıvrımlı yaklaşım, naif (ish) olanı bağlamayı başardı.

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsd@ seshoumara'nınkine benzeyen yaklaşımın bir parçası, ancak biz sadece 46'ya çıkıyoruz .. Bunu yapıyoruz, çünkü 45'e çıkmamız gerekiyor -, ve aynı zamanda dizgimizde de bir zamana ihtiyacımız var, bu yüzden sadece bir süre daha gitmek, sanırım en ucuzudur. Yol boyunca bazı değerleri saklıyoruz: 5, 32, 39 hepsi daha sonra işe yarayacak. Faydacı şeyler için 5, ASCII değerleri için 32 ve 39. Başlangıçta 1-5 yaptım, ama bu pahalıydı ve 4 kullanmaktan kaçınabildim; kullanın Z(bir değer pop, sahip olduğu basamak sayısını itin) bu değerler için üç, iki veya bir basamaklı bir sayı üzerinde. 42, 43, ve 45, biz dizelerine (bu dönüştürmek *, +ve -sırasıyla) ve (makro olarak saklamak B, AveCsırasıyla). Bu, karakterleri *+-kullanmadan, şimdi bu operatörleri kullanabileceğimiz anlamına gelir .

Buradan, temelde matematiğin birikimi yerine matematiğin gücünü kullanarak ASCII değerlerini üretmeye başlıyoruz; 100, 105 ve 115, onları depolamak (sicil defterlerinde veya başka şekillerde) anlam ifade edecek kadar ortaya çıkmıştır. Başlangıçta yığını 10'larla dolu bıraktım ve bunları 100'leri yapmak için kullandım; yığını 32'lerle doldurmak ve sonradan boşluk olarak kullanmak için baytların kaydedilmesi sona erdi. ASCII bölümün Biraz daha okunabilir versiyonu: OOlAxlAxP OBlBxdIlAxoP AdlBxddsrIlAxssP P OP lsIZlCxddspP OZlCxP P OP lrdZlCxP lsP lrP lcP P KP dZlBxdZlAxP OAZlAxdP IZlCxdP rPdP lpP lrdZlCxP P KP OP P lpP lsP OP ldP KP.

18 byte tarafından traşlanır: 5 sayısının bir kayıt yerine giriş yarıçapı olarak depolanması; bir kayıt yerine hassasiyet olarak 32 sayısı; bir kayıt yerine çıktı sayı tabanı olarak 115; Daha sonra değiştirmek zorunda KZiçin IZ1'leri üretmek ve OZiçin KZ2s oluşturmak için.

Yığını 32'li suyla yıkayarak 13 bayt daha kazın; 39'a ayar hassasiyeti; 116'yı depolamaktan kaçınmak için yığın manipülasyonu kullanmak; yanlışlıkla bıraktığım çift işleri kesmek.

Japt , 87 bayt

Bs g caA
HzG
Ts caV
iWisiiihiSisiUitiaihitiSitiuibu iUiSiWcaV idiiiaisiSieihisiSidiniau

Dene

açıklama

İlk satır üretir 've onu değişkene atar U.

Bs g caA
B                            :11
 s                           :To string
   g                         :First character
     c                       :Character code
      a                      :  Absolute difference with
       A                     :  10

İkinci satır 2değişkene atar V.

HzG
H                            :32
 z                           :Floor divided by
  G                          :16

Üçüncü satır ., onu üretir ve değişkene atar W.

Ts caV
Ts                           :Convert 0 to a string
   caV                       :Absolute difference of its charcode with V (2)

Son satır, daha sonra dizgiyi, her seferinde tersine bir karakter oluşturur.

iW...ibu ...iWcaV ...iau
iW                           :Start by prepending W (.) to U (')
  ...                        :Each i prepends the literal character that follows it to the string, with S being space and U being "'"
     ibu                     :As B is the constant for 11 and it can't be quoted, here i prepends "b" to the string and u uppercases it
         ...                 :As above, each i is prepending the character/constant that follows it to the string
            iWcaV            :Gets the absolute difference of the charcode of W (.) and V (2) to get the "," and prepends that
                  ...        :Some more literals
                     iau     :And, finally, the same trick is used for the "A" as was for the "B", as A is the constant for 10

Kırmızı , 272 bayt

prin quote And prin sp prin quote she prin sp prin quote said prin comma prin sp prin subtract to sp mold quote G sp prin quote But prin sp prin quote that prin subtract to sp mold quote G sp prin quote s prin sp prin quote his prin dot prin subtract to sp mold quote G sp

Çift tırnak gerekliyse:

Kırmızı , 344 bayt

prin subtract to sp mold quote B sp prin quote And prin sp prin quote she prin sp prin quote said prin comma prin sp prin subtract to sp mold quote G sp prin quote But prin sp prin quote that prin subtract to sp mold quote G sp prin quote s prin sp prin quote his prin dot prin subtract to sp mold quote G sp prin subtract to sp mold quote B sp

TIO'da çalışmıyor, ancak Kırmızı yorumlayıcıda çalışıyor.

Açıklama:

Kelimeler önemsiz - Ben onları (yeni çizgi olmadan yazdırın) ile birlikte yazdırın quote. Kırmızı - yerleşik bir alan için kelime vardır sp, hem de commave dot. "ve 'daha ilginç: Ben bir boşluk çıkarılarak bunları prin Bve Gsırasıyla bir edebi başlayarak Bve Gbirlikte dizeye ilk dönüştürerek, moldve sonra karaktere gayrimenkulünü (onlara çıkarma kullanmak için) to sp( Kırmızı prototip tarafından dönüşüm var - dönüştürmek karakterinin türüne dize sp).

İleri (gforth), 351

CHAR A DUP EMIT
CHAR n EMIT
CHAR d EMIT
SPACE
CHAR s DUP EMIT
CHAR h EMIT
CHAR e EMIT
SPACE
EMIT
CHAR a EMIT
CHAR i EMIT
CHAR d EMIT
DUP CHAR m XOR EMIT
SPACE
CHAR f XOR DUP EMIT
CHAR B EMIT
CHAR u EMIT
CHAR t DUP EMIT
SPACE
DUP EMIT
CHAR h EMIT
CHAR a EMIT
EMIT
DUP EMIT
CHAR s EMIT
SPACE
CHAR h EMIT
CHAR i DUP EMIT
CHAR s EMIT
CHAR G XOR EMIT
EMIT

Çok kötü CHAR yeniden tanımlamak ya da kullanarak gerektirecektir beri tek harfli kelime IŞILDIYORUZ edemez :ve ;(örneğin : C CHAR ;) ya da '(örneğin ' CHAR ALIAS C)

Aslında, kelimeleri tanımlayabilseydim, yapabilirdim : P CHAR EMIT ;ve sonra P xyazdırmak için yapabilirdim x. Oh iyi.

Hatta, bir tampon oluşturmak için orada char dizisini yazıp kullanımını gerektiren belleğe yazma beri, girdi olarak kullanan değildir !ya daC!

AlphaBeta , 180 177 175 163 bayt

cccaaggtFgDILrFigggDLjDLCLigggggDLjhDLhhhDLCLiggggDLjjggDLihhDLhhhhhDLcaaCLdbbCLcbbbCLHgDLiiiiigDLhDLdaaaCLDLjhhDLjgggDLiihDLcbbbCLhDLdaaaCLjhDLgDLiDLcaaaaCLdaaaCL

Çevrimiçi deneyin!

WIP

Pepe , 266 Bayt

R yığınını boş tutuyorum ve R yığınında 'var.

reeEeeeeeE reeEEeEEEe reeEEeeEee reEe REeEEEeeEE Reee reeEEeEeee reeEEeeEeE reEe Reee reeEEeeeeE reeEEeEeeE reeEEeeEee reeeEeEEee reEe reeeEeeeEe reeEeeeeEe reeEEEeEeE reeEEEeEee reEe reeEEEeEee reeEEeEeee reeEEeeeeE reeEEEeEee reeeEeeEEE Reee reEe reeEEeEeee reeEEeEeeE Reee reeeEeEEEe reeeEeeeEe

Bu TIO'da değil, ancak burada deneyebilirsiniz

dc , 240 bayt

Ana fikir, her bir benzersiz ASCII koduyla eşleştiğinde yığını 1 ( K) ile sürekli olarak ( sX) yığının ( z) boyutunu özel kayıtlara dönüştürmektir. Baskı ( P) boyunca yapılır.

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

Çevrimiçi deneyin!

dHatırlama ( lX) 2 byte olduğundan, bir baytı kaydetmek için yığında bir mektubu, mesela t'yi kopyalamak gibi ( örneğin ondan sonra kullanılmazsa, bir mektubu kaydetmemek gibi) bazı optimizasyonlar yaptım .

80186+ makine kodu, MS-DOS .COM formatı, 822 787 bayt

Harflerin yanı sıra yalnızca sekmeler ve boşluklar kullanılır. İzin verilen aralıktaki saydamlık kodlarının çoğunun belirli artışlar, azalmalar, itmeler, patlamalar ve register-dolaylı AND'ler ve OR'ler olduğu göz önüne alındığında, IMUL'a ek olarak, yığın yazmacının sonuna geldiğinde sarıldığı gerçeğinden faydalanıyorum. Kodun tersini değiştirmek için 80186+ montaj gerekli çünkü acil değerleri zorluyorum.

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXjhX   GXkOXYIQSX GXjdX    GXkOXwIIIIIIIIIQhhihs kOXeQh ihutSXH    GXHHHHHH GXSX GYkOXDAAAQSX GXjGX    GXkOXtQhidhsahe hshhd hAnSX GXjTX   GXkOXdIIIQkOXgAQSX GXHHHHHHHHHHHHHHHHHHHHH  GXSX GYkOXbAAAAAAAAAAAAAAQhhlh  Xhh qM

Açıklamalı kaynak (TASM formatı):

IDEAL
P186

MODEL   TINY
CODESEG
ORG 100H

MAIN:   
REPT 582
    POP AX  ; Set up stack to end of string
ENDM

    PUSH 68H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],59H ; 68H*59H=2428H
    DEC CX ; -1=2427H
    PUSH CX

    PUSH BX
    POP AX
    AND [BX+58H],AL
    PUSH 64H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],77H ; 64H*77H=2E7CH
REPT 9
    DEC CX ; -9=2E73H
ENDM
    PUSH CX

    PUSH 6968H
    PUSH 2073H

    IMUL CX,[BX+58H],65H ; 64H*65H=2774H
    PUSH CX

    PUSH 6920H
    PUSH 7475H

    PUSH BX
    POP AX
    DEC AX
    OR [BX+58H],AX ; FFFFH
REPT 6
    DEC AX
ENDM
    AND [BX+58H],AL ; FFF9H
    PUSH BX
    POP AX
    AND [BX+59H],AL ; 00F9H
    IMUL CX,[BX+58H],44H ; 0F9H*44H=4224H
REPT 3
    INC CX ; +3=4227H
ENDM
    PUSH CX

    PUSH BX
    POP AX
    AND [BX+58H],AL
    PUSH 47H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],74H ; 47H*74H=202CH
    PUSH CX

    PUSH 6469H
    PUSH 6173H
    PUSH 2065H
    PUSH 6873H
    PUSH 2064H
    PUSH 6E41H

;; CODE STARTS:
;; PUSH 0909H
;; POP AX
;; PUSH 046CH
;; POP DX
;; INT 21H
;; INT 20H

    PUSH BX
    POP AX
    AND [BX+58H],AL
    PUSH 54H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],64H ; 54H*64H=20D0H
REPT 3
    DEC CX ; -3=20CDH
ENDM
    PUSH CX

    IMUL CX,[BX+58H],67H ; 54H*67H=21CCH
    INC CX ; 21CDH
    PUSH CX

    PUSH BX
    POP AX
    AND [BX+58H],AL
REPT 21
    DEC AX
ENDM
    OR [BX+58H],AX ; 0FFEBH
    PUSH BX
    POP AX
    AND [BX+59H],AL ; 0EBH
    IMUL CX,[BX+58H],62H ; 0EBH*62H=59F6H
REPT 14
    INC CX ; +14=5A04H
ENDM
    PUSH CX

    PUSH 6C68H
    PUSH 5809H
    PUSH 0968H

    JNO $+4FH

END MAIN
ENDS

Befunge-98 (FBBI) , 125 124 121 bayt

wab









And she said   But that s his












wakekekaayyeapwayyaayybyapayybyapcyabcyaayycayyba
a



b
wayapapoq

Çevrimiçi deneyin! Bir dosyaya Çıkışlar adlı \n(tek satır). Jo King'e senaryosu için teşekkürler .

Çıktıda 10 izleyen satır var.

Sadece bir son satır için, aşağıdaki satırı değiştirerek +1 bayt :

wakekekaayyeapwayydayybyapayybyapycyabcyaayycayyba

Çevrimiçi deneyin!

Açıklama:

Talimat işaretçisi aşağıdaki gibi hareket eder:

Program, alfabetik olmayan karakterleri, bu satırı bir dosyaya çıkarmadan önce konumuna getirir.

Befunge-98 talimatları içerir a... fyığına karşılık gelen onaltılık değeri itin. Başka sayılar üretmek için, bu değerleri yelde etmek için argümanlar olarak ("Get SysInfo") konumuna geçirir :

10  y-position
11  x-position
12  y-velocity (= 0)
13  x-velocity (= 1)

23* stack size

Kodun büyük kısmını y = 23'e ayyyerleştirerek yığın boyutuna tekrar tekrar erişmek için kullanılabilir, bu daha sonra karakter kodlarını üretmek için kullanılır.

Pyth , 210 bayt

pChyCdpCyhyhlGpCyytlGpdpChFhTyylGpCyylGpChyytlGpdpChFhTyylGpCtytytlGpChyylGpCyytlGpCyyhTpdpCtyyTpCyhCdpCtFyyCdhTpCyhFlGCdpdpCyhFlGCdpCyylGpCtytytlGpCyhFlGCdpCtyyTpChFhTyylGpdpCyylGpChyylGpChFhTyylGpCyhyhTpCtyyT

Çevrimiçi deneyin!

Yalnızca harfler kullanarak ifade edilebilecek birkaç sayı buldum (gibi T= 10, Z= 0, lG= uzunluk (alfabe) = 26, Cd= karakter kodu (boşluk) = 32) ve yalnızca harfler kullanarak gerçekleştirilebilecek birkaç işlev buldum. t= azaltma, h= artırma, hF= artımın tekrarlanan uygulaması = toplama), ve sonra bu işlevlerin ve sayıların, ihtiyacım olan her bir harfle sonuçlanan en kısa kombinasyonlarını bulmak için kaba bir kuvvet araması yaptı.

16 bit x86 derleme kodu, 665 bayt

Bir şekilde boşluk bırakmaya izin veren kuralı unuttum. Elbette kod sonuç olarak golf edilebilir.

Bytecode:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXsBFVKZPFFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXkLAFQQZJJJRkDCGPLXDPDJRkDBEPZJJRLZDRDZAAAQPLYDQDYXXDQhishZhDRDhZsDQDhaththRDhuthZBDQDRhidhsaRDhhehZsDRDhndhZADTZPiDEFY

Kaynak:

    db    63 dup (58h) ;pop ax
    jnb   label1
    dw    5646h      ;magic #1
    dw    5a4bh      ;magic #2
    dw    4650h      ;magic #3
    dw    (42h-6)/2 dup ("PF")

label1:
    db    416 dup (58h) ;more pop ax
    imul  cx,[si+41h],46h ;cl=24h (string sentinel)
    push  cx         ;push string sentinel
    push  cx
    pop   dx         ;dl=24h
    dec   dx
    dec   dx
    dec   dx         ;dl=21h
    push  dx         ;save for later
    imul  ax,[si+43h],47h ;al=0CDh
    push  ax         ;push xxCDh
    dec   sp         ;insert xx
    pop   ax         ;ah=0CDh
    inc   sp         ;discard xx
    push  ax         ;push 0CDxx
    inc   sp         ;discard xx
    dec   dx         ;cl=20h (space)
    push  dx
    imul  ax,[si+42h],45h ;al=2Eh (dot)
    push  ax
    pop   dx         ;dl=2Eh
    dec   dx
    dec   dx         ;dl=2Ch (comma)
    push  dx         ;push xx2Ch
    dec   sp         ;insert xx
    pop   dx         ;dl=2Ch
    inc   sp         ;discard xx
    push  dx         ;push 2Cxxh
    inc   sp         ;discard xx
    pop   dx         ;dx=202Ch
    inc   cx
    inc   cx
    inc   cx         ;cl=27h (quote)
    push  cx         ;push xx27h
    push  ax         ;push xx2Eh
    dec   sp         ;insert xx
    pop   cx         ;ch=2Eh
    inc   sp         ;discard xx
    push  cx         ;push 2Exxh
    inc   sp         ;discard xx
    pop   cx         ;cx=272Eh
    pop   ax         ;discard xxxx
    pop   ax         ;ax=0CD21h
    inc   sp         ;discard xx
    push  cx         ;push ".'"
    push  7369h      ;push "is"
    push  685ah      ;push "h"+xx
    inc   sp         ;discard xx
    push  dx         ;" "+xx
    inc   sp         ;discard xx
    push  735ah      ;push "s"+xx
    inc   sp         ;discard xx
    push  cx         ;push "'"+xx
    inc   sp         ;discard xx
    push  7461h      ;push "at"
    push  6874h      ;push "th"
    push  dx         ;push " "+xx
    inc   sp         ;discard xx
    push  7475h      ;push "ut"
    push  425ah      ;push "B"+xx
    inc   sp         ;discard xx
    push  cx         ;push "'"+xx
    inc   sp         ;discard xx
    push  dx         ;push ", "+xx
    push  6469h      ;push "id"
    push  6173h      ;push "sa"
    push  dx         ;push " "+xx
    inc   sp         ;discard xx
    push  6568h      ;push "he"
    push  735ah      ;push "s"+xx
    inc   sp         ;discard xx
    push  dx         ;push " "+xx
    inc   sp         ;discard xx
    push  646eh      ;push "nd"
    push  415ah      ;push "A"+xx
    inc   sp         ;discard xx
    push  sp
    pop   dx         ;dx=sp
    push  ax
    imul  ax,[si+45h],5946h ;ah=09h

Bu şekilde çalışır:

• yığın işaretçisini kodun sonuna hareket ettirir, POP AX ile (alfabetik olmadığı için POP SP olamaz);

• bir DOS çağrısı göndermek için yönergeyi kurar (algoritmik olarak alfabetik olmadığı için);

• alfabetik olmayan karakterleri oluşturur;

• dizeyi yığına yerleştirir;

• gönderme talimatını kodun tam ucundaki yığına yerleştirir, böylece yürütme doğrudan bu yönergeye akar;

• bir dize basma talimatını oluşturur;

• dize görüntüler ve hemen çöker. : - / (Zarif bir çıkış daha fazla kod gerektirir)

Japt , 74 bayt

HdEz
iHdE isiiihiSisiUitiaihitiSitiuibu iUiSiHdC idiiiaisiSieihisiSidiniau

Dene

05AB1E , 145 121 109 bayt

TnVYTOUXZxNJTZXTZZZXYTYxMNYTTMNNNYRYNNYNNNNYTXZMNNYxXRZZZXTYXRZZXZYxTRMRNXRMRMXNNYxYMRNTYxTRYNTZMYXRXXXTZJCXB

Çevrimiçi deneyin!

80186 makine kodu + DOS, 91 bayt

Metin sürümü:

hm  j   j   PPjzjzjgaAAA    JSJJ    RU  Sq  ReAA    JdJJJ   RfiJElK JEiS GtI And she said   But that s his   

Metin sürümü, yerine sekmeleri (kod 9) 9ve boşlukları (kod 32) değiştir *:

hm9j9j9PPjzjzjgaAAA9JSJJ9RU9Sq9ReAA9JdJJJ9RfiJElK9JEiS*GtI*And*she*said***But*that*s*his***

HexDump:

68 6D 09 6A 09 6A 09 50 50 6A 7A 6A 7A 6A 67 61
41 41 41 09 4A 53 4A 4A 09 52 55 09 53 71 09 52
65 41 41 09 4A 64 4A 4A 4A 09 52 66 69 4A 45 6C
4B 09 4A 45 69 53 20 47 74 49 20 41 6E 64 20 73
68 65 20 73 61 69 64 20 20 20 42 75 74 20 74 68
61 74 20 73 20 68 69 73 20 20 20

Makine kodu, uzantısı olan bir dosyada görünür .com. Çalıştırdığımda, gerekli mesajı yazdırıyor ve sonra kilitleniyor (rastgele veri yürütüyor).

Ne yaptığı hakkında üst düzey açıklama:

1. Sabit değerleri olan kayıtları başlatır
2. Mesajdaki boşlukları istenen özel sembollerle ( ,'.$) değiştirir
3. int 21Mesajı basacak talimatı oluşturmak için kodu yamalar.
4. DOS çağırır

Montaj kodu (ile derlenebilir tasm):

my_bp equ 7ah
my_si equ 7ah
my_di equ 67h
my_msg equ 13bh
    .model tiny
    .code
    .startup
    .186
    org 100h
    push 96dh   ; ax (ah = 0; al = don't care, but see below)
    push 9      ; cx
    push 9      ; dx
    push ax     ; bx = don't care
    push ax     ; don't care
    push my_bp
    push my_si
    push my_di
    popa
    inc cx
    inc cx
    inc cx
    or [bp+si+my_msg-my_bp-my_si+12], cx ; ,
    dec dx
    dec dx
    or [bp+si+my_msg-my_bp-my_si+14], dx ; '
    or [bp+di+my_msg-my_bp-my_di+23], dx ; '
    or [bp+si+my_msg-my_bp-my_si+30], dx ; '
    inc cx
    inc cx
    or [bp+si+my_msg-my_bp-my_si+29], cx ; .
    dec dx
    dec dx
    dec dx
    or [bp+si+my_msg-my_bp-my_si+31], dx ; $

    ; 0x2049 * 0x4b6c = 0x98301cc
    ; So this sets cx to 1cc (a temporary constant used to patch code)
    imul cx, [bp+si+my_msg-my_bp-my_si-2], 4b6ch
    ; 0x1cc | 0x2049 = 0x21cd (the instruction which calls DOS int 21)
    ; Here ah = 9 ("print" mode)
    or [bp+si+my_msg-my_bp-my_si-2], cx

    ; At address 101, there is the constant 96d, which was loaded into ax
    ; 0x96d * 0x7447 = 0x448013b
    ; So the following sets dx to 13b (adddress of the message)
    imul dx, [bp+di+101h-my_bp-my_di], 7447h

int21:
    dw 2049h

    db 'And she said   But that s his   '
    end

popaTüm kayıtları açmak için talimatı kullanır , çünkü düzenli olarak popgerekli tüm kayıtları dolduramaz (ör pop di. Yasaklanmış bir koddur).

Düzeltme yapılacak bayt adresleri 0x100 ... 0x160 aralığındadır. Şans ile, izin verilen değerlerle 3 baytlık bir toplam olarak temsil edilebilirler:

• 0x7a içinde bp
• 0x7a veya 0x67 siveyadi
• Hemen değer

İletideki baytların OReklenmesi, 0x20 (boşluk karakteri) ve küçük bir sabit (4, 7, 12 veya 14) üzerinde mantıksal olarak çalışır . Küçük sabit, ilke cxve dx9'a (sekme karakteri) basılarak ve yapılması INCveya DECgerektiği şekilde elde edilir.

Kodun eklenmesi IMULtalimatı kullanır . Kaba kuvvet arama kullanarak çarpmak için gereken 16-bit sabitleri buldum.

Son olarak, mesajın adresi (0x13b) çarpma ile elde edilir. Yer kazanmak için, sabit değerlerden birini, hemen bir değer içeren talimatlardan birinden aldım 0x96d. Burada 9parça bir DOS yazdırma işlevi seçer ve 6dparça serbest bir parametredir. 6dÇarpmadan sonra 0x13b verebilecek tek olasılık olduğu ortaya çıktı .

Kod bölümünün sökülmesi:

06BA:0100 686D09            PUSH    096D
06BA:0103 6A09              PUSH    +09
06BA:0105 6A09              PUSH    +09
06BA:0107 50                PUSH    AX
06BA:0108 50                PUSH    AX
06BA:0109 6A7A              PUSH    +7A
06BA:010B 6A7A              PUSH    +7A
06BA:010D 6A67              PUSH    +67
06BA:010F 61                POPA
06BA:0110 41                INC     CX
06BA:0111 41                INC     CX
06BA:0112 41                INC     CX
06BA:0113 094A53            OR      [BP+SI+53],CX
06BA:0116 4A                DEC     DX
06BA:0117 4A                DEC     DX
06BA:0118 095255            OR      [BP+SI+55],DX
06BA:011B 095371            OR      [BP+DI+71],DX
06BA:011E 095265            OR      [BP+SI+65],DX
06BA:0121 41                INC     CX
06BA:0122 41                INC     CX
06BA:0123 094A64            OR      [BP+SI+64],CX
06BA:0126 4A                DEC     DX
06BA:0127 4A                DEC     DX
06BA:0128 4A                DEC     DX
06BA:0129 095266            OR      [BP+SI+66],DX
06BA:012C 694A456C4B        IMUL    CX,[BP+SI+45],4B6C
06BA:0131 094A45            OR      [BP+SI+45],CX
06BA:0134 6953204774        IMUL    DX,[BP+DI+20],7447
06BA:0139 CD21              INT     21 (after the code patches itself)

Eğlenceli gerçek: Normalde, offset messagekodlanmış kod yerine kullanmak isterdim 13bh, ancak bu durumda, adresi ayrıştırma sırasında bilinmediği için, tasm 16 bitlik anında ofset oluşturur ve 1 kod boşa harcar:

06BA:0131 098A4600          OR      [BP+SI+0046],CX