Cetak frasa And she said, 'But that's his.'hanya menggunakan karakter berikut: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ Tidak ada tanda baca atau karakter non-alfabet apa pun. Anda dapat menggunakan bahasa pemrograman apa pun yang Anda inginkan. Ruang kosong sepenuhnya diizinkan. Kemenangan program terpendek.

Ruang putih , 417 414 349 265 byte

265 byte berkat Kevin Cruijssen

Cobalah online!

Dijelaskan:

[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 byte

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

Cobalah online!

Penjelasan:

Regex, cetak, dan potong semua berlaku untuk variabel $_secara default.

s qqAnd she saidZ ZBut thatZs hisZZGjGGfq

Mengganti string kosong dengan And she saidZ ZBut thatZs hisZZGjGGf.

s qZqchr oct oct oct ord chopqge

Ganti masing Z- masing dengan hasil evaling chr oct oct oct ord chop. Ini menghilangkan karakter terakhir $_, mengambil kode kunci, menafsirkannya sebagai oktal tiga kali, dan mengubahnya kembali menjadi karakter. Misalnya, j→ 106 → 70 → 56 → 46 → ..

Karena cara penggantian bekerja, modifikasi $_yang terjadi saat mengevaluasi penggantian hilang, begitu $_juga sekarang And she said, 'But that's his.'GjGGf.

y qGjfqqd

Menghapus semua G, jdan fdi $_.

> <> , 916 915 903 byte

Pada awalnya saya pikir solusi di> <> tidak mungkin, tetapi kemudian saya menyadari ... siapa yang butuh kontrol kondisional atau logika? : D

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

Cobalah secara Online

Saya berulang kali mendorong angka (angka 15) ke tumpukan, lalu mendorong panjang tumpukan dan mencetak karakter dengan nilai ASCII itu. Jika saya perlu mengecilkan panjang tumpukan, saya mengecilkan tumpukan tiga nilai sekaligus p, atau satu per satu menggunakan gjika saya berada dalam tiga target. Program diakhiri dengan memanggil i(input), yang mendorong -1karena tidak ada input, kemudian mencetaknya untuk menyebabkan kesalahan.

Ini adalah program Python 3 yang saya gunakan untuk membuat solusi begitu saya memikirkan cara melakukannya:

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')

Cobalah secara Online

8086 Unit pada IBM PC, 1463 845 664 byte

Klarifikasi: Sumber bahasa rakitan yang sebenarnya adalah entri, bukan kode mesin yang dihasilkan.

Kesulitannya adalah sebagian besar instruksi x86 (seperti ADD, SUB, JMP, lompatan bersyarat, akses memori) memiliki dua argumen dan karenanya memerlukan koma, atau memerlukan alamat memori. Jadi, kita tidak bisa menggunakan penjumlahan, pengurangan, ifs, atau loop!

Selama upaya pertama saya, saya dapat "membangun" angka menggunakan kombinasi kenaikan, penurunan, perkalian, pembagian, trik-byte, dan instruksi BCD yang tidak jelas (seperti AAA, DAS). Setelah itu, saya menyadari bahwa ide ini dapat digunakan untuk membuat kode inspeksi dan modifikasi diri.

• Percobaan 1. (1463 bytes)

  Menggunakan instruksi yang tersedia untuk membuat kode ASCII dan alamat 0xb800 dari buffer layar. Perhitungan setiap karakter dalam urutan itu golf dengan tangan.

• Percobaan 2. (tidak lengkap)

  Menyadari bahwa ada opcode untuk setiap bilangan bulat di kisaran 0x40-0x5f. Kisaran ini termasuk AZ. Jadi misalnya INC CX berhubungan dengan 0x41 = 'A'. ( Tabel opcode ini sangat berguna.)

  Saya mencoba membuat 3 "data" string, dan melapisi mereka di atas satu sama lain. As-is pertama (huruf besar), yang kedua "bergeser" ke zona 0x60-0x7f (huruf kecil) dan yang terakhir "bergeser" ke zona 0x20-0x3f (tanda baca).

  Kode modifikasi diri akan menghasilkan satu atau tiga lingkaran untuk beralih pada data.

• Percobaan 3. (845 bytes)

  Seperti pendekatan sebelumnya tetapi untuk mengurangi data, string hanya akan dikodekan sekali, dengan "karakter kontrol" dicampur untuk beralih set karakter.

• Percobaan 4. (664 bytes)

  Bagaimana cara menghilangkan karakter kontrol yang memerlukan banyak instruksi yang ditambal untuk menangani percabangan? Mengingat bahwa hanya dua huruf besar yang digunakan, saya bertanya-tanya apakah saya bisa "membalik" tabel opcode untuk menyandikan huruf kecil menggunakan rentang 0x40-0x4f dan tanda baca menggunakan rentang 0x90-0x9f (dengan mengurangi dari 0xc0). "A" dan "B" dapat dimasukkan secara terpisah.

  Namun hanya separuh dari opcodes dalam rentang 0x90-0x9f yang dapat digunakan dan mereka tidak sejalan dengan yang diperlukan. Lalu saya pikir mungkin saya bisa mengocok mereka menggunakan XOR, dan saya menemukan yang berhasil. Dan ini dia.

Golf:

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

Berkumpul dengan

nasm golf.asm -o golf.com

dan jalankan di DOSBOX (jalankan CLS pertama). Terlihat seperti ini:

Berkomentar:

; 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 byte

Terima kasih kepada Grimy untuk -27 byte.

-52 byte karena kita tidak membutuhkan telinga kelinci sejak awal.

Terima kasih kepada Jo King untuk -5 byte.

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

Cobalah online!

Menghasilkan string dengan baris baru tambahan. Jika Anda tidak menginginkannya, ganti yang terakhir saydengan a print. Anda juga dapat mengganti baris baru di sumber dengan spasi.

Penjelasan

Kode ini mencetak karakter string dengan karakter. Setiap karakter dibentuk dengan memasukkan kode karakter yang sesuai ke dalam chrfungsi dan menurunkannya lcjika diperlukan.

Saat ini, semua nilai dihasilkan dengan membuat string dengan jumlah karakter yang benar di dalamnya; dalam beberapa kasus, jumlah karakter adalah kebalikan dari kode karakter target. Seharusnya secara teori dimungkinkan untuk menggunakan fungsi matematika seperti logdan explangsung, tetapi saya tidak merasa sangat mudah untuk menggunakannya.

Untuk digunakan sebagai angka, kami memiliki e, pidan tau; di sisi kanan xatau xx, mereka secara implisit lantai. Mereka semua memiliki 17 karakter dalam representasi string mereka, jadi kami gunakan euntuk jumlah karakter minimal. Kami juga memiliki i(4 karakter), False(5 karakter) dan NaN(3 karakter). Kita bisa mengalikan panjang string dengan x; xxmengalikan satu ditambah panjang string di sisi kanan dan menambahkan satu. chopmenghapus satu karakter dari string jika kita jauh dari target.

Pernyataan cetak dirangkai bersama-sama menggunakan and, yang memiliki prioritas yang sangat rendah. Itu hampir keajaiban itu ada; jika tidak, kita harus menggunakan titik koma ilegal.

Saya menemukan ekspresi untuk karakter dengan tangan. Mungkin perlu mencari mereka secara terprogram untuk menemukan ekspresi yang lebih pendek.

Lebar , 66 64 byte

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

Cobalah online!

Mencetak ke debug. Untuk mencetak ke stdout, tambahkan wwke akhir kode, yang muncul dan mengeluarkan bagian atas tumpukan.

Penjelasan

Dalam Lebar, setiap huruf berkorelasi dengan angka, berdasarkan pada seberapa "lebar" itu, menurut tabel ini . Ini memberikan setiap huruf satu angka dari 0 hingga 9. Kemudian, angka-angka itu digunakan untuk benar-benar mengeksekusi kode.

Secara khusus, surat daripada pertandingan 7akan memulai string literal. Ini akan membaca set dua huruf sekaligus, sampai membaca huruf aslinya lagi. Setiap set dua huruf akan dikonversi ke angka lebarnya, dibaca sebagai angka desimal antara 0 dan 99, dan karakter yang mereka sediakan akan menjadi indeks mereka dalam string berikut:

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

Misalnya, indeks !adalah 1, sehingga 01akan menjadi angka lebar yang tepat. Dengan demikian, if, iI, jt, dll semua akan berkorelasi dengan literal string !.

Dalam hal ini, saya menerjemahkan 31 karakter dari output yang diperlukan ke huruf yang sesuai, menggunakan Qsebagai tanda kutip. Bagian atas tumpukan dicetak untuk debug ketika program selesai.

kode mesin x86 (32-bit), 256 byte

Ketika saya mencetak kode saya di konsol codepage 437 saya, saya melihat yang berikut:

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 

Ini berisi beberapa karakter spasi putih, jadi di sini adalah kode yang sama ketika saya mengganti semua karakter tab dengan →dan semua karakter spasi nonbreaking (dengan kode 255) dengan *:

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

Beberapa penjelasan tentang cara kerjanya:

Instruksi yang berguna adalah:

• push imm8, push imm16dan push imm32, diikuti oleh popmenghasilkan konstanta. Ini juga dapat menghasilkan nol (dalam ah) saat mendorong byte ( imm8).
• and [ecx+32], ah- dengan asumsi ah = 0, ini menetapkan byte ke nol. Kebetulan panjang string output adalah 32, sehingga kode mengisi buffer dari ujung ke awal.
• or [ecx+32], edx- dengan asumsi byte output diatur ke nol, salinan ini edx(4 byte) ke output. Saya menggunakan varian dengan dxbukannya edxmendekati akhir buffer, karena seharusnya tidak menulis di luar buffer output. Pembatasan kode membuatnya tidak mungkin untuk menulis byte tunggal dengan cara ini!
• imul edx, [ecx+32], whatever- ini adalah ide pengacakan utama. Dengan cukup entropi [ecx+32]dan angka apa pun , itu dapat menghasilkan output apa pun. Saya menggunakannya untuk menghasilkan 2 atau 3 byte dari nilai yang dibutuhkan. Beberapa komplikasi adalah, ketika menuliskannya ke output, itu harus dilakukan secara logis ORdengan apa pun yang sudah ada. Ini kadang-kadang membuatnya perlu untuk nol memori sekali lagi.
• Varian jmpinstruksi digunakan untuk kembali. Saya memilihnya karena penyandiannya 0xff, yang sesuai dengan ruang bebas-melanggar dalam codepage 437. Sedikit peregangan pada aturan, tetapi kalau tidak saya pikir tugasnya tidak mungkin ...

Susun kode sumber, bersama dengan program C yang menjalankannya (menggunakan sintaks Visual Studio):

#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 byte

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

Cobalah online!

Ini menggunakan 32 salinan bilangan bulat 89 25 20 6. Semua kode dari string target dapat diperoleh dengan operasi pada bilangan bulat tersebut, dalam urutan tumpukan: misalnya, 'A' (ASCII 65) adalah 89 - (25 & (20 + 6)). Banyak 4-tupel bilangan bulat memiliki properti ini; ini dipilih karena sangat mudah dibuat.

currentflat string dup rrand

Flat default ke 1, jadi ini menciptakan string dengan panjang 1 (diinisialisasi ke \0). dupbukan salinan yang dalam: ini membuat referensi kedua ke string yang sama. rrand mendorong seed acak, yang defaultnya adalah 0. Stack sekarang ["\0", "\0", 0].

count dup count count mul mul xor

count mendorong jumlah item dalam tumpukan, jadi ini menghitung 3 ^ (3 * (5 * 6)) = 89.

count count mul count dup mul exch count

4 * 5 = 20, 5 * 5 = 25, 6 = 6. Stack sekarang ["\0", "\0", 0, 89, 25, 20, 6].

count copy count copy count copy count copy count copy

Gandakan seluruh tumpukan, lima kali. Jadi kita berakhir dengan 32 salinan tumpukan 7-elemen awal kami. Kami hanya perlu 31 salinan, karena string target adalah 31 karakter, tetapi salinan tambahan tidak sakit.

add and sub put print

Hitung charcode dari empat bilangan bulat teratas, tulis di indeks 0 dari string, lalu cetak stringnya.

quit

Menekan prompt default.

Ruby , 420 354 338 byte

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

Cobalah online!

Dalam urutan naiknya kecemburuan:

Kata-kata yang dimulai dengan huruf kapital dapat dicetak dengan mendefinisikan kelas dengan nama itu dan memanggil displaydalam badan definisi kelas.

Kata-kata lain dapat ditampilkan dengan mendefinisikan metode dengan nama itu, yang mengembalikan Simbol, kemudian melemparkannya ke String untuk menghapus titik dua utama.

Karakter lain dapat ditampilkan dengan memanggil putckode ASCII mereka. Kita dapat menghasilkan angka yang sesuai dengan menggunakan kembali String deftrik untuk mendapatkan string, kemudian mengambil jumlah byte-nya menggunakan modulus yang ditentukan oleh ukurannya. Sayangnya, kami tidak memiliki cara untuk memanggil metode pada objek selain dari dalam definisi kelas objek itu, yang membuatnya sulit untuk menyampaikan argumen. Jadi peretasan terakhir adalah mendefinisikan ulang String#inspect, yang dipanggil secara implisit ketika meneruskan sebuah String ke pmetode, sehingga ia menghitung dan mengeluarkan karakter yang sesuai sebagai efek samping, sebelum menaikkan kesalahan sehingga ptidak dapat benar-benar menyelesaikan eksekusi dan mencetak sebuah garis baru. Maka kita perlu menyelamatkan kesalahan dalam kode utama.

Sunting: Jordan membuat hitungan byte jauh lebih sedikit, ahem, tinggi dengan beberapa kontrol aliran golf yang cerdas, dan saya telah memotong beberapa byte lagi dengan mengganti raisedengan satu huruf metode panggilan tidak ada, yang menimbulkan NameError.

Sunting 2: Memperhatikan bahwa dengan print Stringdiekstraksi ke dalam metode, lebih murah hanya menggunakannya dengan definisi metode daripada menggunakan trik definisi kelas, karena metode diizinkan untuk judul judul.

> <> , 233 122 byte

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

Cobalah online!

Ini dimulai sebagai golf jawaban mbomb , tetapi saya menemukan perubahan mendasar yang menghemat banyak byte, jadi saya mempostingnya sebagai jawaban saya sendiri.

Menghasilkan karakter non-alfabetik ke output dilakukan dengan berulang kali mendorong nilai ke stack, lalu gunakan luntuk mendorong panjang stack. Namun, ini tidak perlu segera dikeluarkan: menggunakan p, karakter ini dapat ditempatkan di sel mana pun yang koordinatnya antara 10 dan 15 inklusif, untuk diambil nanti dengan g. Demikian pula, karakter alfabet dapat ditempatkan dalam kode sumber awal dan membaca dengan cara ini: karena kode karakter non-alfabet tertinggi dalam input adalah 46 ( .), ini berarti tumpukan tidak perlu didorong lebih tinggi dari 62 yang diperlukan untuk menyimpan semua 31 karakter dari output.

Selain itu, a vditempatkan dalam kode pada kolom 7. Ketika penunjuk instruksi membungkus dan mengenai itu v, urutan godieksekusi berulang kali untuk membaca dari koordinat yang didorong dan menampilkan karakter yang sesuai. Akhirnya, tumpukan menjadi kosong, dan gmengakhiri program dengan kesalahan.

7 byte kode pertama digunakan kembali ketika 7 koordinat pertama dan 7 koordinat terakhir ditekan. Menempatkan vdi kolom 9 akan secara teoritis menyimpan dua byte lagi, tetapi akan memaksa karakter Ainsvke dalam kotak 2x2 dalam kode, yang tidak mungkin. Versi sebelumnya menggunakan kolom 15, tetapi itu membutuhkan garis tambahan dalam kode sumber dan berakhir lebih lama enam byte.

CJam , 262 byte

  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

Cobalah online! Baris baru hanya ditampilkan di sini untuk kejelasan; setiap baris mewakili karakter.

Wah, ini menyenangkan. Membatasi diri dengan perintah alfabet menimbulkan beberapa tantangan menarik:

• Tanpa {dan }, hampir tidak ada peluang untuk aliran kontrol (kecuali f, yang saya tidak menemukan kesempatan untuk digunakan).
• Tanpa \, _, ;, atau $, kita tidak memiliki alat untuk manipulasi stack.

Ini berarti bahwa tujuan utama akan mendapatkan poin kode yang relevan pada stack dan kemudian mengubahnya menjadi karakter dengan c.

Masalahnya adalah kita juga tidak memiliki sebagian besar perintah aritmatika dasar, serta literal integer. Ini baik-baik saja, karena mnamespace berisi banyak operasi matematika tingkat lanjut, dan ada banyak variabel yang telah ditentukan untuk angka yang berguna.

Saya akhirnya banyak menggunakan akar kuadrat ( mQdan mq), fungsi eksponensial me, dan konversi basis ( b), yang juga dapat digunakan untuk meniru perkalian ( [X 0] Ybmenghitung X * Y). Selain itu, kadang-kadang lebih mudah untuk membangun codepoint huruf besar, dalam hal ini kita dapat menggunakan el(mengkonversi ke huruf kecil) pada karakter yang dihasilkan.

Saya masih tidak puas dengan beberapa yang lebih lama. Baiklah.

Penjelasan

Ini adalah penjelasan karakter per karakter dari output. Sebelum saya mulai, berikut adalah beberapa cara singkat untuk membuat angka:

• 0, 1, 2, 3 yang terkandung dalam variabel T, X, Y, Zmasing-masing.
• Angka 10 hingga 20 terkandung dalam variabel Athrough K.
• 32 dapat dibuat menggunakan Sci( Smendorong string yang berisi spasi, cmendapatkan karakter pertama dari string ini, dan imengonversi karakter itu ke titik kode-nya). Sjuga digunakan untuk spasi.
• 4 diberikan oleh GmQ(bilangan bulat akar 16).
• 5 diberikan oleh AZbYb(konversikan 10 ke basis 3, menghasilkan [1 0 1], dan mengonversi susunan angka yang dihasilkan menjadi basis 2, menghasilkan 5).
• 7 diberikan oleh Ymei(compute exp (2) dan convert to integer).

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 bytes

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

Cobalah online!

Tidak ada loop yang diizinkan :(

jahat , 198 byte

aeeeannkhhwzuuuuuueaeuekwuuuuuuuuuunkhwzaeeeeehknwgueeywguuuuuuhhknnwuuuwhgwpwnngheeuwguuuuuwngwzaeeeaaaeeeeeewhhgwnguuuueewnngawpaawuwnngwpawhgwhhgeeuwpawhguuuueewpwhgwhgwawpwnngaaaaaaeeeewguuuueew

Cobalah online!

Ini sangat menyenangkan.

Stax , 133 95 84 79 byte

AHHvcAvSVvNvXvsrDhYcvxvZLcHxVahyvxxZVvHVChAHHvVAHhvZAJyVahxvVvDhZyvxvAJZcASVAhL

Jalankan dan debug itu

MATL , 187 158 bytes

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

Cobalah online!

Versi yang lebih mudah dibaca: Cobalah online! Upaya manual untuk membangun string. Mungkin ada banyak ruang untuk bermain golf dengan memotong talinya menjadi chuncks yang nyaman, menggunakan Pdan huntuk membalik dan membangun string. Saya harap seseorang akan mengambil tantangan untuk mengalahkan saya. Tantangan utama adalah bahwa Anda tidak dapat menggunakan +atau -, jadi aritmatika dasar seringkali tidak memungkinkan.

Highlight:

• KQthpYq: KQthpprime 25 ( ) Yqadalah 97, sesuai dengan surat itu a. Huruf s(115) dihasilkan dengan cara yang sama dari 113, bilangan prima ke-30. Ini kemudian digunakan kembali secara luas di clipboard J.
• hisdipersingkat dengan menyimpan hdari sebelumnya di clipboard J. Karena itu sebelumnya disimpan s, kami membuat histerbalik sehingga kami masih dapat mengambil smenggunakan yang baru y, dan membaliknya setelah menggunakan P.
• Sejumlah besar byte disimpan berkat Luis Mendo (kebanyakan dengan mengubah banyak hto vle)

MATL , 118 byte

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

Cobalah online!

Versi yang lebih mudah dibaca (setiap baris sesuai dengan satu karakter, kecuali operasi penumpukan susun).

Penjelasan

Program ini menghasilkan poin kode dari karakter yang diperlukan, sebagai angka independen. Pada akhirnya semua angka-angka tersebut digabungkan menjadi vektor kolom, dibentuk kembali sebagai vektor baris, dan dikonversi menjadi karakter. Hasilnya ditampilkan secara implisit.

Beberapa trik yang digunakan:

• Sebagian besar titik kode di bawah 32 ditampilkan sebagai spasi. Jadi 0digunakan untuk sebagian besar ruang, karena hanya biaya satu byte ( O).
• Namun, untuk spasi pertama, 15digunakan (dihasilkan sebagai KUq), karena kemudian dapat digunakan kembali dengan menambahkannya ke 100(char d) untuk memberikan 115( s). Pada kesempatan lain 5digunakan untuk spasi (dihasilkan sebagai KQ), sehingga nantinya dapat dikurangkan dari 44( ,) menjadi memberi 39( ').
• Clipboard Jdigunakan untuk menyimpan karakter yang akan diulang: pertama s, lalu '. Demikian pula, Htoko clipboard 100, yang berguna untuk ddan untuk menghasilkan karakter lain.
• Penggunaan luas dibuat dari fungsi Q(tambah 1), q(kurangi 1), E(dikalikan dengan 2) dan U(kuadrat), bersama dengan literal yang telah ditentukan sebelumnya di clipboard I( 3) dan K( 4).
• Penambahan dan pengurangan sewenang-wenang dilakukan dengan menyatukan ke dalam vektor ( h) dan menghitung jumlah ( s) atau perbedaan berturut-turut ( d).
• 100( d) dihasilkan seperti 4dalam biner yang ditafsirkan sebagai angka desimal.
• 110( n) diperoleh dari 65( A) dengan mengonversi ke string ( '65': titik kode [54 53]), menambahkan 1ke titik kode ( [55 54]), menjumlahkannya bersama-sama dan menambahkan 1.
• Urutan angka yang dihasilkan terkadang diubah untuk kenyamanan; dan mereka kemudian disusun kembali oleh fungsi susunan ulang: swap ( w), bubble up b).

dc , 240 222 209 byte

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

Cobalah online!

Pikiran pertama saya sama dengan @seshoumara, cukup dorong barang-barang ke stack untuk menghasilkan semua nilai ASCII karakter. Kemudian terpikir oleh saya bahwa sejak +,, -dan *merupakan operator karakter tunggal, saya dapat membuatnya kembali dan memiliki kemampuan untuk menggunakan aritmatika! Tentunya itu akan lebih kecil! Dan, saya tidak akan terkejut jika saya bisa bermain golf lagi, tetapi untuk sekarang ... pendekatan berbelit-belit ini telah berhasil mengikat yang naif (ish).

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdadalah bagian dari pendekatan yang mirip dengan @ seshoumara, tetapi kami hanya naik ke 46, yaitu .. Kami melakukan ini karena kami perlu naik ke 45,, -dan kami juga membutuhkan periode dalam string kami, jadi hanya melangkah lebih jauh untuk periode adalah (saya pikir) termurah. Sepanjang jalan, kami menyimpan beberapa nilai: 5, 32, 39 semua berguna nanti. 5 untuk hal utilitarian, 32 dan 39 untuk nilai ASCII mereka. Awalnya saya melakukan 1-5, tapi itu mahal, dan saya hanya bisa menghindari menggunakan 4; gunakan Z(pop nilai, tekan jumlah digit yang dimilikinya) pada angka tiga, dua, atau satu digit untuk nilai-nilai tersebut. Pada 42, 43, dan 45, kita mengubah ini untuk string ( *, +, dan -masing-masing) dan menyimpannya sebagai macro ( B, A, danCmasing-masing). Ini berarti bahwa tanpa menggunakan karakter *+-, kita sekarang dapat menggunakan operator tersebut.

Dari sini kita pada dasarnya mulai menghasilkan nilai ASCII menggunakan kekuatan matematika alih-alih akumulasi belaka, menyimpan beberapa pengulangan di sepanjang jalan. 100, 105 dan 115 muncul cukup sehingga menyimpannya (dalam register atau sebaliknya) masuk akal. Awalnya, saya meninggalkan tumpukan diisi dengan 10-an dan menggunakannya untuk membuat 100-an; akhirnya menghemat byte untuk mengisi stack dengan 32-an dan menggunakannya sebagai spasi nanti. Versi yang sedikit lebih mudah dibaca dari bagian ASCII: 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.

Dipotong 18 byte dengan: menyimpan angka 5 sebagai input radix, bukan register; angka 32 lebih presisi daripada register; angka 115 sebagai output radix bukan register; kemudian harus berubah KZuntuk IZmenghasilkan 1s dan OZuntuk KZmenghasilkan 2s.

Mencukur 13 byte lagi dengan membanjiri stack dengan 32s; pengaturan presisi ke 39; menggunakan manipulasi tumpukan untuk menghindari penyimpanan 116; memotong beberapa pekerjaan ganda yang tidak sengaja saya tinggalkan.

Japt , 87 byte

Bs g caA
HzG
Ts caV
iWisiiihiSisiUitiaihitiSitiuibu iUiSiWcaV idiiiaisiSieihisiSidiniau

Cobalah

Penjelasan

Baris pertama menghasilkan 'dan menugaskannya ke variabel U.

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

Baris kedua ditugaskan 2ke variabel V.

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

Baris ketiga menghasilkan .dan menugaskannya ke variabel W.

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

Baris terakhir, kemudian, membangun string satu karakter sekaligus secara terbalik.

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

Merah , 272 byte

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

Jika kutipan ganda diperlukan:

Merah , 344 byte

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

Tidak bekerja di TIO tetapi bekerja di interpreter Merah.

Penjelasan:

Kata-katanya sepele - Saya prin mereka (cetak tanpa baris baru) sebagai literal dengan quote. Merah memiliki kata bawaan untuk ruang - sp, serta commadan dot. "dan 'lebih menarik: Saya prin mereka dengan mengurangi spasi dari Bdan Gmasing - masing, mulai dari literal Bdan G, mengubahnya pertama-tama untuk string dengan molddan kemudian ke karakter (untuk menggunakan pengurangan pada mereka) dengan to sp( Merah memiliki konversi dengan prototipe - mengkonversi string ke jenis sp, yaitu karakter).

Keempat (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

Sayang sekali saya tidak bisa mendefinisikan ulang CHAR atau EMIT menjadi kata satu huruf, karena itu akan membutuhkan penggunaan salah satu ( :dan ) misalnya ( atau );: C CHAR ;'' CHAR ALIAS C

Bahkan, jika saya bisa mendefinisikan kata-kata, saya bisa lakukan : P CHAR EMIT ;dan kemudian lakukan P xuntuk mencetak x. Baiklah.

Saya bahkan tidak dapat membuat buffer, menulis urutan char ke sana dan kemudian menggunakannya sebagai input, karena menulis ke memori memerlukan penggunaan !atauC!

AlphaBeta , 180 177 175 163 byte

cccaaggtFgDILrFigggDLjDLCLigggggDLjhDLhhhDLCLiggggDLjjggDLihhDLhhhhhDLcaaCLdbbCLcbbbCLHgDLiiiiigDLhDLdaaaCLDLjhhDLjgggDLiihDLcbbbCLhDLdaaaCLjhDLgDLiDLcaaaaCLdaaaCL

Cobalah online!

WIP

Pepe , 266 Bytes

Saya menyimpan r stack kosong, dan memiliki 's' di stack R

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

Ini bukan pada TIO, tetapi Anda dapat mencobanya di sini

dc , 240 byte

Gagasan utamanya adalah untuk terus menumbuhkan tumpukan dengan 1 ( K), menyimpan ( sX) ukuran tumpukan ( z) menjadi register khusus ketika cocok dengan masing-masing kode ASCII unik. Pencetakan ( P) dilakukan sepanjang.

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

Cobalah online!

Saya melakukan beberapa optimasi, seperti tidak menyimpan surat jika tidak digunakan setelah itu, seperti menduplikasi ( d) surat, misalnya t, pada tumpukan untuk menyimpan byte, karena recall ( lX) adalah 2 byte.

80186+ kode mesin, format MS-DOS .COM, 822 787 byte

Hanya tab dan spasi yang digunakan selain huruf. Mengingat bahwa sebagian besar opcode dalam rentang yang diizinkan adalah peningkatan tertentu, penurunan, dorongan, muncul, dan AND dan OR tidak langsung register, selain IMUL, saya menggunakan fakta bahwa register tumpukan membungkus ketika menyentuh akhir. segmen untuk mengubah kode secara terbalik! Perakitan 80186+ diperlukan karena saya mendorong nilai langsung.

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

Sumber beranotasi (format TASM):

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 byte

wab









And she said   But that s his












wakekekaayyeapwayyaayybyapayybyapcyabcyaayycayyba
a



b
wayapapoq

Cobalah online! Output ke file bernama \n(satu baris baru). Terima kasih untuk Jo King untuk skripnya.

Output mencakup 10 baris baru.

Untuk hanya satu trailing newline, +1 byte dengan mengubah baris berikut:

wakekekaayyeapwayydayybyapayybyapycyabcyaayycayyba

Cobalah online!

Penjelasan:

Penunjuk instruksi bergerak sebagai berikut:

Program ini menempatkan karakter non-alfabet pada posisinya, sebelum mengeluarkan baris itu ke file.

Befunge-98 termasuk instruksi a... f, yang mendorong nilai heksadesimal yang sesuai ke stack. Untuk menghasilkan angka lain, ini meneruskan nilai-nilai itu ke y("Dapatkan SysInfo") sebagai argumen untuk mendapatkan:

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

23* stack size

Dengan menempatkan sebagian besar kode pada y = 23, ayydapat digunakan untuk akses berulang ke ukuran tumpukan, yang kemudian digunakan untuk menghasilkan kode karakter.

Pyth , 210 byte

pChyCdpCyhyhlGpCyytlGpdpChFhTyylGpCyylGpChyytlGpdpChFhTyylGpCtytytlGpChyylGpCyytlGpCyyhTpdpCtyyTpCyhCdpCtFyyCdhTpCyhFlGCdpdpCyhFlGCdpCyylGpCtytytlGpCyhFlGCdpCtyyTpChFhTyylGpdpCyylGpChyylGpChFhTyylGpCyhyhTpCtyyT

Cobalah online!

Saya menemukan beberapa angka yang dapat diekspresikan hanya dengan huruf (seperti T= 10, Z= 0, lG= panjang (alfabet) = 26, Cd= charcode (spasi) = 32), dan beberapa fungsi yang dapat dilakukan hanya menggunakan huruf (seperti t= decrement, h= increment, hF= aplikasi peningkatan yang diulang = penambahan), dan kemudian jalankan pencarian brute force untuk menemukan kombinasi terpendek dari fungsi dan angka yang menghasilkan setiap huruf yang saya butuhkan.

Kode rakitan x86 16-bit, 665 byte

Saya entah bagaimana lupa tentang aturan yang mengizinkan spasi putih. Tentunya kodenya bisa di-golf-kan.

Bytecode:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXsBFVKZPFFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXkLAFQQZJJJRkDCGPLXDPDJRkDBEPZJJRLZDRDZAAAQPLYDQDYXXDQhishZhDRDhZsDQDhaththRDhuthZBDQDRhidhsaRDhhehZsDRDhndhZADTZPiDEFY

Sumber:

    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

Cara kerjanya seperti ini:

• memindahkan penunjuk tumpukan ke akhir kode, melalui POP AXE (tidak dapat POP SP karena itu bukan abjad);

• membangun instruksi untuk mengirim panggilan DOS (secara algoritmik karena itu bukan abjad);

• membangun karakter non-alfabet;

• menempatkan string pada tumpukan;

• menempatkan instruksi pengiriman pada tumpukan di akhir kode, sehingga eksekusi mengalir langsung ke instruksi itu;

• membuat instruksi untuk mencetak string;

• menampilkan string dan mereka segera crash. : - / (Pintu keluar yang anggun akan membutuhkan lebih banyak kode)

Japt , 74 byte

HdEz
iHdE isiiihiSisiUitiaihitiSitiuibu iUiSiHdC idiiiaisiSieihisiSidiniau

Cobalah

05AB1E , 145 121 109 byte

TnVYTOUXZxNJTZXTZZZXYTYxMNYTTMNNNYRYNNYNNNNYTXZMNNYxXRZZZXTYXRZZXZYxTRMRNXRMRMXNNYxYMRNTYxTRYNTZMYXRXXXTZJCXB

Cobalah online!

80186 kode mesin + DOS, 91 byte

Versi teks:

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

Versi teks, dengan tab (kode 9) diganti oleh 9dan spasi (kode 32) diganti oleh *:

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

Kode mesin muncul dalam file dengan ekstensi .com. Ketika saya menjalankannya, ia mencetak pesan yang diperlukan dan kemudian hang (mengeksekusi data acak).

Penjelasan tingkat tinggi tentang apa fungsinya:

1. Menginisialisasi register dengan nilai konstan
2. Mengganti spasi dalam pesan dengan simbol khusus yang diperlukan ( ,'.$)
3. Menambal kode untuk menghasilkan int 21instruksi, yang mencetak pesan
4. Panggilan DOS

Kode perakitan (dapat dikompilasi dengan 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

Ia menggunakan popainstruksi untuk mem-popup semua register, karena reguler poptidak dapat mengisi semua register yang diperlukan (misalnya pop diopcode terlarang).

Alamat byte yang akan ditambal berada dalam kisaran 0x100 ... 0x160. Untungnya, mereka dapat direpresentasikan sebagai jumlah 3 byte dengan nilai yang diizinkan:

• 0x7a dalam bp
• 0x7a atau 0x67 dalam siataudi
• Nilai segera

Penambalan byte dalam pesan berfungsi dengan melakukan logis ORpada 0x20 (karakter spasi) dan konstanta kecil (4, 7, 12 atau 14). Konstanta kecil diperoleh dengan menginisialisasi cxdan dxke 9 (karakter tab) dan melakukan INCatau DECsesuai kebutuhan.

Menambal kode menggunakan IMULinstruksi. Saya menemukan konstanta 16-bit yang diperlukan untuk berkembang biak menggunakan pencarian brute-force.

Akhirnya, alamat pesan (0x13b) diperoleh dengan perkalian. Untuk menghemat ruang, saya mengambil salah satu konstanta dari salah satu instruksi, yang berisi nilai langsung 0x96d. Di sini 9bagian memilih fungsi cetak DOS, dan 6dbagian itu adalah parameter gratis. Ternyata itu 6dadalah satu-satunya kemungkinan yang dapat memberikan 0x13b setelah perkalian.

Pembongkaran bagian kode:

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)

Fakta menyenangkan: Biasanya, saya akan menggunakan offset messagealih-alih kode-keras 13bh, tetapi dalam kasus ini, karena pada saat penguraian alamatnya tidak diketahui, tasm menghasilkan offset langsung 16-bit, membuang 1 byte kode:

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