In cụm từ And she said, 'But that's his.'chỉ sử dụng các ký tự sau: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ Không có dấu chấm câu hoặc ký tự không chữ cái nào. Bạn có thể sử dụng bất cứ ngôn ngữ lập trình nào bạn muốn. Khoảng trắng là hoàn toàn được phép. Chương trình ngắn nhất sẽ thắng.

Khoảng trắng , 417 414 349 265 byte

265 byte nhờ Kevin Cruijssen

Hãy thử trực tuyến!

Giải thích:

[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

Hãy thử trực tuyến!

Giải trình:

$_Theo mặc định , in và cắt tất cả áp dụng cho biến .

s qqAnd she saidZ ZBut thatZs hisZZGjGGfq

Thay thế chuỗi rỗng bằng And she saidZ ZBut thatZs hisZZGjGGf.

s qZqchr oct oct oct ord chopqge

Thay thế từng cái Zvới kết quả của việc trốn tránh chr oct oct oct ord chop. Điều này loại bỏ ký tự cuối cùng của $_, lấy mã khóa của nó, diễn giải nó thành ba lần bát phân và chuyển đổi nó trở lại thành một ký tự. Ví dụ: j→ 106 → 70 → 56 → 46 → ..

Do cách thức thay thế hoạt động, các sửa đổi cho $_điều đó xảy ra trong khi đánh giá thay thế bị mất, vì vậy $_bây giờ And she said, 'But that's his.'GjGGf.

y qGjfqqd

Xóa tất cả G, jvà ftrong $_.

> <> , 916 915 903 byte

Lúc đầu, tôi nghĩ rằng một giải pháp trong> <> là không thể, nhưng sau đó tôi nhận ra ... ai cần điều kiện hay điều khiển logic? :CƯỜI MỞ MIỆNG

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

Dùng thử trực tuyến

Tôi liên tục đẩy các số (số 15) vào ngăn xếp, sau đó đẩy chiều dài của ngăn xếp và in ký tự có giá trị ASCII đó. Nếu tôi cần thu nhỏ chiều dài của ngăn xếp, tôi thu nhỏ ba giá trị của ngăn xếp tại một thời điểm bằng cách sử dụng phoặc mỗi lần sử dụng gnếu tôi nằm trong ba mục tiêu. Chương trình kết thúc bằng cách gọi i(đầu vào), đẩy một -1vì không có đầu vào, sau đó in ra để gây ra lỗi.

Đây là chương trình Python 3 tôi đã sử dụng để tạo ra giải pháp một khi tôi nghĩ về cách thực hiện:

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

Dùng thử trực tuyến

8086 hội trên IBM PC, 1463 845 664 byte

Làm rõ: Nguồn ngôn ngữ lắp ráp thực tế là mục nhập, không phải mã máy được tạo.

Khó khăn là hầu hết các hướng dẫn x86 (như ADD, SUB, JMP, nhảy có điều kiện, truy cập bộ nhớ) có hai đối số và do đó cần một dấu phẩy hoặc cần một địa chỉ bộ nhớ. Vì vậy, chúng ta không thể sử dụng phép cộng, phép trừ, if hoặc vòng lặp!

Trong nỗ lực đầu tiên của tôi, tôi đã có thể "xây dựng" các số bằng cách sử dụng kết hợp tăng, giảm, nhân, chia, thủ thuật byte và các lệnh BCD tối nghĩa (như AAA, DAS). Sau đó, tôi nhận ra rằng ý tưởng này có thể được sử dụng để tạo mã tự kiểm tra và tự sửa đổi.

• Cố gắng 1. (1463 byte)

  Đã sử dụng các hướng dẫn có sẵn để xây dựng mã ASCII và địa chỉ 0xb800 của bộ đệm màn hình. Việc tính toán từng nhân vật trong chuỗi được chơi bằng tay.

• Cố gắng 2. (không hoàn thành)

  Nhận ra rằng có một opcode cho mọi số nguyên trong phạm vi 0x40-0x5f. Phạm vi này bao gồm AZ. Vì vậy, ví dụ INC CX tương ứng với 0x41 = 'A'. ( Bảng opcode này rất tiện dụng.)

  Tôi đã cố gắng xây dựng 3 chuỗi "dữ liệu" và xếp chúng lên nhau. Chữ cái đầu tiên (chữ hoa), chữ "thứ hai" chuyển sang vùng 0x60-0x7f (chữ thường) và chữ "cuối" chuyển sang vùng 0x20-0x3f (dấu chấm câu).

  Mã tự sửa đổi sẽ tạo ra một vòng lặp hoặc ba để lặp lại dữ liệu.

• Cố gắng 3. (845 byte)

  Giống như cách tiếp cận trước đây nhưng để cắt giảm dữ liệu, chuỗi sẽ chỉ được mã hóa một lần, với "ký tự điều khiển" được trộn lẫn để chuyển đổi bộ ký tự.

• Cố gắng 4. (664 byte)

  Làm thế nào để thoát khỏi các ký tự điều khiển đòi hỏi rất nhiều hướng dẫn được vá để xử lý phân nhánh? Cho rằng chỉ có hai chữ cái viết hoa được sử dụng, tôi tự hỏi liệu tôi có thể "lật" bảng opcode để mã hóa các chữ cái thường bằng cách sử dụng phạm vi 0x40-0x4f và chấm câu bằng cách sử dụng phạm vi 0x90-0x9f (bằng cách trừ từ 0xc0). "A" và "B" có thể được đặt riêng.

  Tuy nhiên, chỉ một nửa số opcodes trong phạm vi 0x90-0x9f là có thể sử dụng được và chúng không phù hợp với những cái cần thiết. Sau đó tôi nghĩ có lẽ tôi có thể xáo trộn chúng xung quanh bằng XOR và tôi đã tìm thấy một cái có hiệu quả. Và đây rồi.

Chơi gôn

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

Lắp ráp với

nasm golf.asm -o golf.com

và chạy trong DOSBOX (chạy CLS trước). Trông như thế này:

Đã bình luận:

; 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

Cảm ơn Grimy cho -27 byte.

-52 byte bởi vì chúng tôi không cần tai thỏ ở nơi đầu tiên.

Cảm ơn Jo King cho -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

Hãy thử trực tuyến!

Xuất ra chuỗi với một dòng mới. Nếu bạn không muốn điều đó, thì hãy thay thế cuối cùng saybằng a print. Bạn cũng có thể thay thế các dòng mới trong nguồn bằng dấu cách.

Giải trình

Mã này in ký tự chuỗi theo ký tự. Mỗi ký tự được hình thành bằng cách cung cấp mã ký tự phù hợp vào chrhàm và hạ thấp nó lcnếu cần.

Hiện tại, tất cả các giá trị được tạo bằng cách tạo một chuỗi có số ký tự chính xác trong đó; trong một số trường hợp, số lượng ký tự là đảo ngược của mã ký tự đích. Về mặt lý thuyết có thể sử dụng các hàm toán học như logvà exptrực tiếp, nhưng tôi không thấy nó rất dễ sử dụng.

Để sử dụng như số, chúng tôi có e, pivà tau; ở phía bên phải của xhoặc xx, chúng được thả nổi. Tất cả chúng có 17 ký tự trong biểu diễn chuỗi của chúng, vì vậy chúng tôi sử dụng echo số lượng ký tự tối thiểu. Chúng tôi cũng có i(4 ký tự), False(5 ký tự) và NaN(3 ký tự). Chúng ta có thể nhân độ dài chuỗi với x; xxnhân một cộng với độ dài chuỗi bằng phía bên tay phải và thêm một. chopxóa một ký tự khỏi chuỗi trong trường hợp chúng ta cách xa mục tiêu.

Các báo cáo in được kết nối với nhau bằng cách sử dụng and, có độ ưu tiên khá thấp. Nó gần như là một phép lạ nó tồn tại; nếu không, chúng ta sẽ phải sử dụng dấu chấm phẩy bất hợp pháp.

Tôi tìm thấy các biểu thức cho các nhân vật bằng tay. Có thể đáng để tìm kiếm chúng theo chương trình để tìm các biểu thức ngắn hơn.

Chiều rộng , 66 64 byte

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

Hãy thử trực tuyến!

In để gỡ lỗi. Để in ra thiết bị xuất chuẩn, nối wwvào cuối mã, sẽ bật và xuất ra đầu ngăn xếp.

Giải trình

Theo chiều rộng, mỗi chữ cái tương quan với một số, dựa trên mức độ "rộng" của nó, theo bảng này . Điều này gán cho mỗi chữ cái một số từ 0 đến 9. Sau đó, những số đó được sử dụng để thực sự thực thi mã.

Cụ thể, một chữ cái phù hợp hơn 7sẽ bắt đầu một chuỗi bằng chữ. Nó sẽ đọc bộ hai chữ cái cùng một lúc, cho đến khi nó đọc lại chữ cái gốc. Mỗi bộ gồm hai chữ cái sẽ được chuyển đổi thành số chiều rộng của chúng, được đọc dưới dạng số thập phân trong khoảng từ 0 đến 99 và ký tự chúng bằng nhau sẽ là chỉ mục của chúng trong chuỗi sau:

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

Ví dụ: chỉ số !là 1, vì vậy 01sẽ là số có chiều rộng phù hợp. Do đó, if, iI, jt, vv tất cả sẽ tương quan với một literal chuỗi !.

Trong trường hợp này, tôi đã dịch 31 ký tự của đầu ra cần thiết thành các chữ cái thích hợp, sử dụng Qlàm dấu ngoặc kép. Phần trên cùng của ngăn xếp được in để gỡ lỗi khi chương trình kết thúc.

Mã máy x86 (32 bit), 256 byte

Khi tôi in mã của mình trên bảng điều khiển codepage 437, tôi thấy như sau:

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 

Điều này chứa một số ký tự khoảng trắng, vì vậy đây là cùng một mã khi tôi thay thế tất cả các ký tự tab bằng →và tất cả các ký tự khoảng trắng không phá vỡ (với mã 255) bằng *:

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

Một số giải thích về cách thức hoạt động:

Hướng dẫn hữu ích là:

• push imm8, push imm16Và push imm32, tiếp theo là poptạo ra hằng số. Điều này cũng có thể tạo ra số không (in ah) khi đẩy một byte ( imm8).
• and [ecx+32], ah- giả sử ah = 0, điều này đặt byte thành 0. Nó chỉ xảy ra khi độ dài của chuỗi đầu ra là 32, do đó mã sẽ điền vào bộ đệm từ đầu đến đầu.
• or [ecx+32], edx- giả sử byte đầu ra được đặt thành 0, bản sao này edx(4 byte) thành đầu ra. Tôi sử dụng một biến thể với dxthay vì edxgần cuối bộ đệm, vì nó không nên ghi ngoài bộ đệm đầu ra. Hạn chế về mã làm cho không thể viết các byte đơn theo cách này!
• imul edx, [ecx+32], whatever- đây là ý tưởng tranh giành chính. Với đủ entropy trong [ecx+32]và bất cứ số nào, nó có thể tạo ra bất kỳ đầu ra nào. Tôi sử dụng nó để tạo 2 hoặc 3 byte giá trị cần thiết. Một số phức tạp là, khi viết nó ra đầu ra, nó phải làm logic ORvới bất cứ điều gì đã có. Điều này đôi khi làm cho nó cần thiết để bộ nhớ một lần nữa.
• Một biến thể của một jmphướng dẫn được sử dụng để trở lại. Tôi đã chọn nó bởi vì mã hóa của nó 0xff, tương ứng với một không gian không phá vỡ trong codepage 437. Một chút kéo dài về các quy tắc, nhưng nếu không thì tôi nghĩ rằng nhiệm vụ là không thể ...

Mã nguồn hội, cùng với một chương trình C chạy nó (sử dụng cú pháp 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

Hãy thử trực tuyến!

Điều này sử dụng 32 bản sao của số nguyên 89 25 20 6. Tất cả các mã của chuỗi mục tiêu có thể thu được bằng các thao tác trên các số nguyên đó, theo thứ tự ngăn xếp: ví dụ: 'A' (ASCII 65) là 89 - (25 & (20 + 6)). Nhiều số nguyên gồm 4 số nguyên có thuộc tính này; cái này được chọn vì chúng đặc biệt dễ tạo.

currentflat string dup rrand

Mặc định phẳng là 1, do đó, điều này tạo ra một chuỗi có độ dài 1 (được khởi tạo thành \0). dupkhông phải là một bản sao sâu: nó tạo ra một tham chiếu thứ hai cho cùng một chuỗi. rrand đẩy hạt giống ngẫu nhiên, mặc định là 0. Stack bây giờ ["\0", "\0", 0].

count dup count count mul mul xor

count đẩy số lượng vật phẩm trong ngăn xếp, do đó, tính toán 3 ^ (3 * (5 * 6)) = 89.

count count mul count dup mul exch count

4 * 5 = 20, 5 * 5 = 25, 6 = 6. Hiện tại ngăn xếp ["\0", "\0", 0, 89, 25, 20, 6].

count copy count copy count copy count copy count copy

Nhân đôi toàn bộ ngăn xếp, năm lần. Do đó, chúng tôi kết thúc với 32 bản sao của ngăn xếp 7 phần tử ban đầu. Chúng tôi chỉ cần 31 bản sao, vì chuỗi mục tiêu dài 31 ký tự, nhưng bản sao bổ sung không bị tổn thương.

add and sub put print

Tính toán một mã số từ bốn số nguyên hàng đầu, viết nó vào chỉ số 0 của chuỗi, sau đó in chuỗi.

quit

Bỏ qua lời nhắc mặc định.

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

Hãy thử trực tuyến!

Theo thứ tự tăng dần của jankiness:

Các từ bắt đầu bằng chữ in hoa có thể được in bằng cách định nghĩa một lớp có tên đó và gọi displaytrong thân định nghĩa lớp.

Các từ khác có thể được hiển thị bằng cách xác định các phương thức có tên đó, trả về một Biểu tượng, sau đó chuyển nó thành Chuỗi để loại bỏ dấu hai chấm đầu.

Các ký tự khác có thể được hiển thị bằng cách gọi putcmã ASCII của chúng. Chúng ta có thể tạo ra các số thích hợp bằng cách sử dụng lại String defthủ thuật để có được một chuỗi, sau đó lấy tổng số byte của nó bằng cách sử dụng một mô-đun được xác định bởi kích thước của nó. Thật không may, chúng ta không có cách nào để gọi các phương thức trên một đối tượng khác ngoài định nghĩa lớp của đối tượng đó, điều này gây khó khăn cho việc chuyển qua các đối số. Vì vậy, lần hack cuối cùng là xác định lại String#inspect, được gọi là ngầm khi truyền Chuỗi vào pphương thức, để nó tính toán và đưa ra ký tự phù hợp làm hiệu ứng phụ, trước khi đưa ra lỗi để pthực sự không thể hoàn thành việc thực thi và in dòng mới. Sau đó, chúng ta cần cứu lỗi trong mã chính.

Chỉnh sửa: Jordan đã tạo ra số byte ít hơn nhiều, ahem, cao với một số thao tác chơi gôn điều khiển thông minh và tôi đã cắt thêm một vài byte bằng cách thay thế raisebằng một cuộc gọi phương thức không tồn tại một chữ cái, làm tăng NameError.

Chỉnh sửa 2: Lưu ý rằng với print Stringtrích xuất vào một phương thức, sẽ rẻ hơn nếu chỉ sử dụng phương thức đó với định nghĩa phương thức so với sử dụng thủ thuật định nghĩa lớp, vì các phương thức được phép đặt tiêu đề.

> <> , 233 122 byte

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

Hãy thử trực tuyến!

Điều này bắt đầu như một câu trả lời của mbomb , nhưng tôi đã phát hiện ra một sự thay đổi cơ bản giúp tiết kiệm một số lượng lớn byte, vì vậy tôi đang đăng nó dưới dạng câu trả lời của riêng tôi.

Việc tạo các ký tự không phải là chữ cái cho đầu ra được thực hiện bằng cách liên tục đẩy các giá trị vào ngăn xếp, sau đó sử dụng lđể đẩy chiều dài ngăn xếp. Tuy nhiên, điều này không cần phải được xuất ngay lập tức: bằng cách sử dụng p, ký tự này có thể được đặt trong bất kỳ ô nào có tọa độ nằm trong khoảng từ 10 đến 15, để được lấy sau g. Tương tự, các ký tự chữ cái có thể được đặt trong mã nguồn ban đầu và đọc theo cách này: vì mã ký tự không chữ cái cao nhất trong đầu vào là 46 ( .), điều này có nghĩa là ngăn xếp không cần phải được đẩy lên cao hơn 62 cần thiết để lưu trữ tất cả 31 ký tự của đầu ra.

Ngoài ra, a vđược đặt trong mã ở cột 7. Khi con trỏ lệnh quấn quanh và chạm vào đó v, chuỗi gođược thực hiện liên tục để đọc từ tọa độ đẩy và xuất các ký tự tương ứng. Cuối cùng, ngăn xếp trở nên trống rỗng và gchấm dứt chương trình với một lỗi.

7 byte mã đầu tiên được sử dụng lại khi cả hai tọa độ 7 đầu tiên và 7 cuối cùng được đẩy. Đặt vvào cột 9 về mặt lý thuyết sẽ lưu thêm hai byte, nhưng sẽ buộc các ký tự Ainsvthành một hình vuông 2x2 trong mã, điều này là không thể. Một phiên bản trước đó đã sử dụng cột 15, nhưng yêu cầu thêm một dòng trong mã nguồn và kết thúc dài hơn sáu 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

Hãy thử trực tuyến! Dòng mới chỉ được hiển thị ở đây cho rõ ràng; mỗi dòng đại diện cho một nhân vật.

Whew, điều này thật thú vị. Việc giới hạn bản thân với các lệnh chữ cái đặt ra một số thách thức thú vị:

• Không có {và }, hầu như không có cơ hội cho dòng kiểm soát (ngoại trừ f, tôi không tìm thấy cơ hội sử dụng).
• Nếu không có \, _, ;, hay $, chúng tôi không có phương tiện để ngăn xếp thao tác.

Điều này có nghĩa là mục tiêu chính sẽ là lấy các điểm mã có liên quan trên ngăn xếp và sau đó chuyển đổi chúng thành các ký tự c.

Vấn đề là chúng ta cũng thiếu hầu hết các lệnh số học cơ bản, cũng như các số nguyên. Mặc dù vậy, điều này cũng tốt, vì mkhông gian tên chứa nhiều hoạt động toán học tiên tiến và có nhiều biến được xác định trước cho các số hữu ích.

Cuối cùng tôi đã sử dụng rất nhiều căn bậc hai ( mQvà mq), hàm số mũ mevà chuyển đổi cơ sở ( b), cũng có thể được sử dụng để mô phỏng phép nhân ( [X 0] Ybtính X * Y). Ngoài ra, đôi khi dễ dàng hơn để xây dựng bảng mã chữ hoa, trong trường hợp đó chúng ta có thể sử dụng el(chuyển đổi thành chữ thường) trên ký tự kết quả.

Tôi vẫn chưa hài lòng với một số cái dài hơn. Ồ tốt

Giải trình

Đây là một lời giải thích theo từng ký tự của đầu ra. Trước khi tôi bắt đầu, đây là một vài cách ngắn để tạo số:

• 0, 1, 2, 3 được chứa trong các biến T, X, Y, Ztương ứng.
• Các số từ 10 đến 20 được chứa trong các biến Athông qua K.
• 32 có thể được thực hiện bằng cách sử dụng Sci( Sđẩy một chuỗi chứa khoảng trắng, clấy ký tự đầu tiên của chuỗi này và ichuyển đổi ký tự đó thành điểm mã của nó). Scũng được sử dụng cho không gian.
• 4 được cho bởi GmQ(căn bậc hai của 16).
• 5 được đưa ra bởi AZbYb(chuyển đổi 10 sang cơ sở 3 [1 0 1], thu được và chuyển đổi mảng kết quả của các số thành cơ sở 2, thu được 5).
• 7 được cho bởi Ymei(tính exp (2) và chuyển đổi thành số nguyên).

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 byte

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

Hãy thử trực tuyến!

Không cho phép vòng lặp :(

ác , 198 byte

aeeeannkhhwzuuuuuueaeuekwuuuuuuuuuunkhwzaeeeeehknwgueeywguuuuuuhhknnwuuuwhgwpwnngheeuwguuuuuwngwzaeeeaaaeeeeeewhhgwnguuuueewnngawpaawuwnngwpawhgwhhgeeuwpawhguuuueewpwhgwhgwawpwnngaaaaaaeeeewguuuueew

Hãy thử trực tuyến!

Điều này khá thú vị.

Stax , 133 95 84 79 byte

AHHvcAvSVvNvXvsrDhYcvxvZLcHxVahyvxxZVvHVChAHHvVAHhvZAJyVahxvVvDhZyvxvAJZcASVAhL

Chạy và gỡ lỗi nó

MATL , 187 158 byte

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

Hãy thử trực tuyến!

Phiên bản dễ đọc hơn: Hãy thử trực tuyến! Hướng dẫn sử dụng để xây dựng chuỗi. Có lẽ có rất nhiều chỗ để chơi gôn bằng cách cắt dây thành các đoạn tiện lợi, sử dụng Pvà hlật và xây dựng một chuỗi. Tôi hy vọng ai đó sẽ vượt qua thử thách để vượt qua tôi. Thách thức chính là bạn không thể sử dụng +hoặc -, vì vậy số học cơ bản thường không thể thực hiện được.

Điểm nổi bật:

• KQthpYq: số KQthpnguyên tố thứ 25 ( ) Yqlà 97, tương ứng với chữ cái a. Chữ cái s(115) được tạo ra tương tự từ 113, số nguyên tố thứ 30. Sau đó nó được sử dụng lại rộng rãi trong clipboard J.
• hisđược rút ngắn bằng cách lưu trữ htừ trước trong clipboard J. Vì được lưu trữ trước đó s, chúng tôi xây dựng hisngược lại để chúng tôi vẫn có thể truy xuất gần đây sbằng cách sử dụng yvà lật nó sau khi sử dụng P.
• Một số lượng lớn byte được lưu nhờ Luis Mendo (chủ yếu bằng cách thay đổi một bó hthành vle)

MATL , 118 byte

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

Hãy thử trực tuyến!

Phiên bản dễ đọc hơn (mỗi dòng tương ứng với một ký tự, ngoại trừ các thao tác sắp xếp lại ngăn xếp).

Giải trình

Chương trình tạo ra các điểm mã của các ký tự được yêu cầu, dưới dạng các số độc lập. Cuối cùng, tất cả các số đó được nối vào một vectơ cột, được định hình lại thành một vectơ hàng và được chuyển đổi thành các ký tự. Kết quả được hiển thị ngầm.

Một số thủ thuật được sử dụng:

• Hầu hết các điểm mã dưới 32 được hiển thị dưới dạng không gian. Vì vậy, 0được sử dụng cho hầu hết các không gian, bởi vì nó chỉ tốn một byte ( O).
• Tuy nhiên, đối với không gian đầu tiên, 15được sử dụng (được tạo dưới dạng KUq), vì sau đó nó có thể được sử dụng lại bằng cách thêm nó vào 100(char d) để cho 115( s). Trong một dịp khác 5được sử dụng cho không gian (được tạo dưới dạng KQ), do đó, nó có thể được trừ sau 44( ,) để cho 39( ').
• Clipboard Jđược sử dụng để lưu trữ các ký tự sẽ được lặp lại: đầu tiên s, sau đó '. Tương tự, Hcác cửa hàng clipboard 100, hữu ích cho dvà để tạo các ký tự khác.
• Sử dụng rộng rãi được tạo thành từ các hàm Q(thêm 1), q(trừ 1), E(nhân với 2) và U(vuông), cùng với các chữ được xác định trước trong clipboards I( 3) và K( 4).
• Phép cộng và phép trừ tùy ý được thực hiện bằng cách ghép vào một vectơ ( h) và tính tổng của nó ( s) hoặc các khác biệt liên tiếp ( d).
• 100( d) được tạo như 4trong nhị phân được hiểu là số thập phân.
• 110( n) được lấy từ 65( A) bằng cách chuyển đổi thành chuỗi ( '65': điểm mã [54 53]), thêm 1vào điểm mã ( [55 54]), tổng hợp chúng lại với nhau và thêm 1.
• Thứ tự tạo số đôi khi được thay đổi để thuận tiện; và sau đó chúng được sắp xếp lại theo các chức năng sắp xếp lại ngăn xếp: hoán đổi ( w), bong bóng lên b).

dc , 240 222 209 byte

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

Hãy thử trực tuyến!

Suy nghĩ đầu tiên của tôi giống như @seshoumara, chỉ cần đẩy đủ thứ lên ngăn xếp để tạo ra tất cả các giá trị ASCII của các ký tự. Sau đó, nó xảy ra với tôi rằng kể từ +, -và *là nhà khai thác duy nhất nhân vật, tôi chỉ có thể tái tạo lại chúng và có khả năng sử dụng số học! Chắc chắn sẽ nhỏ hơn! Và, tôi sẽ không ngạc nhiên nếu tôi có thể chơi thêm bất kỳ byte nào, nhưng bây giờ ... cách tiếp cận phức tạp này đã xoay sở để buộc một cái ngây thơ (ish).

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdlà một phần của cách tiếp cận tương tự như của @ seshoumara, nhưng chúng tôi chỉ lên tới 46, tức là vậy .. Chúng tôi làm điều này bởi vì chúng tôi cần lên tới 45, -và chúng tôi cũng cần một khoảng thời gian trong chuỗi của chúng tôi, vì vậy chỉ cần đi thêm một khoảng thời gian là (tôi nghĩ) rẻ nhất. Trên đường đi, chúng tôi lưu trữ một số giá trị: 5, 32, 39 tất cả đều có ích sau này. 5 cho những thứ thực dụng, 32 và 39 cho các giá trị ASCII của chúng. Ban đầu tôi đã làm 1-5, nhưng điều đó rất tốn kém, và tôi chỉ có thể tránh sử dụng 4; sử dụng Z(bật một giá trị, đẩy số chữ số có) trên số có ba, hai hoặc một chữ số cho các giá trị đó. Tại 42, 43, và 45, chúng ta chuyển đổi các chuỗi ( *, +và -tương ứng) và lưu trữ chúng như macro ( B, A, vàCtương ứng). Điều này có nghĩa là không sử dụng các ký tự *+-, bây giờ chúng ta có thể sử dụng các toán tử đó.

Từ đây, về cơ bản chúng tôi bắt đầu tạo ra các giá trị ASCII bằng sức mạnh của toán học thay vì tích lũy tuyệt đối, lưu trữ một số lặp lại trên đường đi. 100, 105 và 115 xuất hiện đủ để lưu trữ chúng (trong sổ đăng ký hoặc cách khác) có ý nghĩa. Ban đầu, tôi rời khỏi ngăn xếp chứa đầy 10 giây và sử dụng chúng để tạo ra 100 giây; cuối cùng, nó đã lưu các byte để lấp đầy ngăn xếp với 32 giây và sử dụng chúng làm khoảng trắng sau này. Một phiên bản dễ đọc hơn một chút của phần 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.

Cạo sạch 18 byte bằng cách: lưu trữ số 5 dưới dạng cơ số đầu vào thay vì thanh ghi; số 32 là chính xác thay vì một thanh ghi; số 115 là cơ số đầu ra thay vì một thanh ghi; sau đó đã phải thay đổi KZđể IZtạo ra 1s và OZđể KZtạo ra 2s.

Cạo sạch thêm 13 byte bằng cách làm đầy stack với 32 giây; cài đặt độ chính xác đến 39; sử dụng thao tác ngăn xếp để tránh lưu trữ 116; cắt ra một số công việc gấp đôi tôi vô tình để lại.

Japt , 87 byte

Bs g caA
HzG
Ts caV
iWisiiihiSisiUitiaihitiSitiuibu iUiSiWcaV idiiiaisiSieihisiSidiniau

Thử nó

Giải trình

Dòng đầu tiên tạo 'và gán nó cho biến U.

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

Dòng thứ hai gán 2cho biến V.

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

Dòng thứ ba tạo .và gán nó cho biến W.

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

Dòng cuối cùng, sau đó, xây dựng chuỗi một ký tự tại một thời điểm ngược lại.

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

Màu đỏ , 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

Nếu dấu ngoặc kép là cần thiết:

Màu đỏ , 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

Không hoạt động trong TIO nhưng hoạt động trong trình thông dịch Đỏ.

Giải trình:

Các từ này là tầm thường - tôi viết chúng (in không có dòng mới) như nghĩa đen với quote. Màu đỏ có một từ tích hợp cho không gian - sp, cũng như commavà dot. "và 'thú vị hơn: Tôi prin chúng bằng cách trừ đi một khoảng trắng từ Bvà Gtương ứng, bắt đầu từ một chữ Bvà Gchuyển đổi chúng thành chuỗi đầu tiên moldvà sau đó thành ký tự (để sử dụng phép trừ trên chúng) wtih to sp( Red đã chuyển đổi theo nguyên mẫu - chuyển đổi chuỗi theo kiểu sp, đó là ký tự).

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

Quá tệ Tôi không thể xác định lại CHAR hoặc EMIT thành các từ một chữ cái, vì điều đó sẽ yêu cầu sử dụng một trong hai :và ;(ví dụ : C CHAR ;) hoặc '(ví dụ ' CHAR ALIAS C)

Trong thực tế, nếu tôi có thể định nghĩa các từ, tôi có thể làm : P CHAR EMIT ;và sau đó làm P xđể in x. Ồ tốt

Tôi thậm chí không thể tạo bộ đệm, ghi chuỗi char vào đó và sau đó sử dụng bộ đệm đó làm đầu vào, vì ghi vào bộ nhớ yêu cầu sử dụng !hoặcC!

AlphaBeta , 180 177 175 163 byte

cccaaggtFgDILrFigggDLjDLCLigggggDLjhDLhhhDLCLiggggDLjjggDLihhDLhhhhhDLcaaCLdbbCLcbbbCLHgDLiiiiigDLhDLdaaaCLDLjhhDLjgggDLiihDLcbbbCLhDLdaaaCLjhDLgDLiDLcaaaaCLdaaaCL

Hãy thử trực tuyến!

WIP

Pepe , 266 byte

Tôi giữ ngăn xếp r trống và có 's' trên ngăn xếp 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

Đây không phải trên TIO, nhưng bạn có thể thử ở đây

dc , 240 byte

Ý tưởng chính là liên tục tăng ngăn xếp lên 1 ( K), lưu ( sX) kích thước của ngăn xếp ( z) vào các thanh ghi tùy chỉnh khi nó khớp với từng mã ASCII duy nhất. In ( P) được thực hiện trong suốt.

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

Hãy thử trực tuyến!

Tôi đã thực hiện một số tối ưu hóa, như không lưu một chữ cái nếu nó không được sử dụng sau đó, như sao chép ( d) một chữ cái, ví dụ: trên ngăn xếp để lưu một byte, vì gọi lại ( lX) là 2 byte.

80186+ mã máy, định dạng MS-DOS .COM, 822 787 byte

Chỉ các tab và khoảng trắng được sử dụng ngoài các chữ cái. Vì hầu hết các opcodes trong phạm vi được phép là các mức tăng, giảm, đẩy, bật và đăng ký gián tiếp AND và OR, ngoài IMUL, tôi sử dụng thực tế là thanh ghi ngăn xếp kết thúc khi nó chạm đến cuối của phân đoạn để sửa đổi mã ngược lại! Cần lắp ráp 80186+ vì tôi đang đẩy các giá trị ngay lập tức.

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

Nguồn chú thích (định dạng 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

Hãy thử trực tuyến! Xuất ra một tệp có tên \n(một dòng mới). Cảm ơn Jo King cho kịch bản của mình.

Đầu ra bao gồm 10 dòng mới.

Đối với chỉ một dòng mới, +1 byte bằng cách thay đổi dòng sau:

wakekekaayyeapwayydayybyapayybyapycyabcyaayycayyba

Hãy thử trực tuyến!

Giải trình:

Con trỏ lệnh di chuyển như sau:

Chương trình đặt các ký tự không phải là chữ cái vào vị trí, trước khi xuất dòng đó thành một tệp.

Befunge-98 bao gồm các hướng dẫn a... f, giúp đẩy giá trị thập lục phân tương ứng của chúng lên ngăn xếp. Để tạo các số khác, nó chuyển các giá trị đó đến y("Nhận SysInfo") làm đối số để có được:

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

23* stack size

Bằng cách đặt phần lớn mã ở y = 23, ayycó thể được sử dụng để truy cập nhiều lần vào kích thước ngăn xếp, sau đó được sử dụng để tạo mã ký tự.

Bình thường , 210 byte

pChyCdpCyhyhlGpCyytlGpdpChFhTyylGpCyylGpChyytlGpdpChFhTyylGpCtytytlGpChyylGpCyytlGpCyyhTpdpCtyyTpCyhCdpCtFyyCdhTpCyhFlGCdpdpCyhFlGCdpCyylGpCtytytlGpCyhFlGCdpCtyyTpChFhTyylGpdpCyylGpChyylGpChFhTyylGpCyhyhTpCtyyT

Hãy thử trực tuyến!

Tôi đã tìm thấy một vài số có thể được biểu thị chỉ bằng các chữ cái (như T= 10, Z= 0, lG= length (bảng chữ cái) = 26, Cd= charcode (dấu cách) = 32) và một vài chức năng có thể được thực hiện chỉ bằng các chữ cái (như t= decrement, h= lũy tiến, hF= lặp đi lặp lại ứng dụng tăng = bổ sung), và sau đó chỉ cần chạy một tìm kiếm vũ phu để tìm ra sự kết hợp ngắn nhất của các hàm và số đó dẫn đến mỗi chữ cái tôi cần.

Mã lắp ráp x86 16 bit, 665 byte

Tôi bằng cách nào đó đã quên quy tắc cho phép khoảng trắng. Chắc chắn mã có thể được chơi golf như là kết quả.

Mã byte:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXsBFVKZPFFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXkLAFQQZJJJRkDCGPLXDPDJRkDBEPZJJRLZDRDZAAAQPLYDQDYXXDQhishZhDRDhZsDQDhaththRDhuthZBDQDRhidhsaRDhhehZsDRDhndhZADTZPiDEFY

Nguồn:

    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

Nó hoạt động theo cách này:

• di chuyển con trỏ ngăn xếp đến cuối mã, thông qua POP AX (không thể POP SP vì nó không phải là chữ cái);

• xây dựng hướng dẫn để gửi một cuộc gọi DOS (theo thuật toán vì nó không phải là chữ cái);

• xây dựng các ký tự không chữ cái;

• đặt chuỗi trên ngăn xếp;

• đặt lệnh điều phối trên ngăn xếp ở cuối mã chính xác, để việc thực thi chảy trực tiếp vào lệnh đó;

• xây dựng hướng dẫn để in một chuỗi;

• hiển thị chuỗi và chúng kịp thời gặp sự cố. : - / (Một lối thoát duyên dáng sẽ cần nhiều mã hơn)

Japt , 74 byte

HdEz
iHdE isiiihiSisiUitiaihitiSitiuibu iUiSiHdC idiiiaisiSieihisiSidiniau

Thử nó

05AB1E , 145 121 109 byte

TnVYTOUXZxNJTZXTZZZXYTYxMNYTTMNNNYRYNNYNNNNYTXZMNNYxXRZZZXTYXRZZXZYxTRMRNXRMRMXNNYxYMRNTYxTRYNTZMYXRXXXTZJCXB

Hãy thử trực tuyến!

Mã máy 80186 + DOS, 91 byte

Phiên bản văn bản:

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

Phiên bản văn bản, với các tab (mã 9) được thay thế bằng 9và khoảng trắng (mã 32) được thay thế bằng *:

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

Mã máy xuất hiện trong một tệp có phần mở rộng .com. Khi tôi chạy nó, nó sẽ in thông báo cần thiết và sau đó bị treo (thực thi dữ liệu ngẫu nhiên).

Giải thích cấp cao về những gì nó làm:

1. Khởi tạo các thanh ghi với các giá trị không đổi
2. Thay thế khoảng trắng trong tin nhắn bằng các ký hiệu đặc biệt cần thiết ( ,'.$)
3. Vá mã để tạo int 21hướng dẫn, in thông báo
4. Gọi cho DOS

Mã hội (có thể được biên dịch với 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

Nó sử dụng popahướng dẫn để bật tất cả các thanh ghi, bởi vì thông thường popkhông thể điền vào tất cả các thanh ghi cần thiết (ví dụ như pop dimột opcode bị cấm).

Địa chỉ của các byte cần vá nằm trong phạm vi 0x100 ... 0x160. May mắn thay, chúng có thể được biểu diễn dưới dạng tổng của 3 byte với các giá trị được phép:

• 0x7a trong bp
• 0x7a hoặc 0x67 trong sihoặcdi
• Giá trị trước mắt

Việc vá các byte trong thông điệp hoạt động bằng cách thực hiện logic ORtrên 0x20 (ký tự khoảng trắng) và một hằng số nhỏ (4, 7, 12 hoặc 14). Hằng số nhỏ có được bằng cách khởi tạo cxvà dxđến 9 (ký tự tab) và thực hiện INChoặc DECkhi cần thiết.

Vá mã sử dụng IMULhướng dẫn. Tôi tìm thấy các hằng số 16 bit cần thiết để nhân lên bằng cách sử dụng tìm kiếm brute-force.

Cuối cùng, địa chỉ của tin nhắn (0x13b) có được bằng cách nhân. Để tiết kiệm không gian, tôi lấy một trong các hằng số từ một trong các hướng dẫn, trong đó có giá trị ngay lập tức 0x96d. Ở đây 9phần chọn chức năng in DOS và 6dphần này là tham số miễn phí. Hóa ra đó 6dlà khả năng duy nhất có thể cho 0x13b sau khi nhân.

Tháo gỡ phần mã:

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)

Sự thật thú vị: Thông thường, tôi sẽ sử dụng offset messagethay vì mã hóa cứng 13bh, nhưng trong trường hợp này, vì tại thời điểm phân tích địa chỉ của nó không xác định, tasm tạo ra bù 16 bit ngay lập tức, lãng phí 1 byte mã:

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