พิมพ์วลี“ และเธอพูดว่า 'แต่นั่นเป็นของเขา'” ใช้ตัวอักษรเท่านั้น


50

พิมพ์วลีAnd she said, 'But that's his.'โดยใช้เฉพาะอักขระต่อไปนี้: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ไม่มีเครื่องหมายวรรคตอนหรืออักขระที่ไม่ใช่ตัวอักษรใด ๆ คุณสามารถใช้ภาษาการเขียนโปรแกรมอะไรก็ได้ที่คุณต้องการ ช่องว่างได้รับอนุญาตอย่างสมบูรณ์ โปรแกรมที่สั้นที่สุดชนะ


สิ่งที่เกี่ยวกับช่องว่างในการส่งออก? (นำหน้า / ตามหลัง?)
attinat

2
ยี้ esolang a-zA-Zของฉันไม่สามารถดำเนินการเพราะมีความสามารถในการผลิตผลผลิตที่มีเพียงไม่ ในทางทฤษฎีฉันสามารถใช้wพระราชพิธีและEVal เพื่อสร้างคำแนะนำที่จำเป็น แต่ไม่+-*,%'"สามารถสร้างได้โดยไม่ต้องใช้ (อย่างน้อย) +-*,%'"0-9หนึ่ง
Draco18s

10
(programmer-of (language 'lisp))ไม่ชอบสิ่งนี้
MatthewRock

4
ต้องยอมรับว่าฉันไม่ได้คิดว่านี่เป็นเรื่องที่น่าสนใจเป็นพิเศษในตอนแรก แต่การรวมกันของตัวละครซ้ำและตัวละครที่ไม่ซ้ำใครทำให้มันเป็นเรื่องสนุกที่จะเพิ่มประสิทธิภาพ ดีมาก.
brhfl

1
คุณสามารถชี้แจงได้หรือไม่ว่าช่องว่างพิเศษในเอาต์พุตอนุญาตหรือไม่ ชอบบรรทัดใหม่ที่ต่อท้ายหรือไม่ หรือช่องว่างเฉพาะในแหล่งที่มารวมทั้งตัวอักษร มีคำตอบ Befungeที่พิมพ์ด้วยการขึ้นบรรทัดใหม่พิเศษ
Peter Cordes

คำตอบ:


75

ช่องว่าง , 417 414 349 265 ไบต์

265 ไบต์ขอบคุณ Kevin Cruijssen

  							
  				   
   		 	
   		
   	 
  		   		 
 	  		
 	  		 
   			 
  		 	
   	 
 	  	 
 	  		 
 	  	
   				
  		  	  
  							
 	  	  
  				 	 
  		 
   		
  		 	
   		 	
 	  	 	
  		
   	 
 	  		
 	  		
  		 
   	   
  		  	 	

  
   		  		 
	   	
  
 


ลองออนไลน์!

อธิบาย:

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

100
Whitespace is completely allowed.ฉันเห็นว่าคุณได้ทำสิ่งนี้อย่างแท้จริง
Benjamin Urquhart

3
คุณชนะฉันได้ไหม .. มีบางสิ่งที่สามารถตีกอล์ฟได้ :) คุณสามารถลบส่วนท้ายNNNเพื่อออกเนื่องจากมันหยุดแล้วด้วยข้อผิดพลาดเมื่อคุณทำการเพิ่มก่อน print_char ดังนั้นมันจะไม่มาหลังจาก Jump_to_Label นอกจากนี้ทำไมต้องเก็บ63ที่จุดเริ่มต้นและดึงข้อมูลในลูป? คุณสามารถกดก่อนเพิ่มได้ และทำไม Label-nr TTSSSSTNคืออะไร? แม้กระทั่งป้ายกำกับจะว่างเปล่าดังนั้นเพียงแค่NSSNสร้างป้ายกำกับและNSNNเพื่อข้ามไปยังป้ายกำกับก็เพียงพอเมื่อคุณใช้ป้ายกำกับเดียวเท่านั้น
Kevin Cruijssen

1
ไบต์ 318กับการเปลี่ยนแปลงที่ฉันเสนอข้างต้น นี่คือโปรแกรมเดียวกันกับการเน้นที่เพิ่มเข้ามา และคุณหักค่าคงที่63อย่างไร? ฉันไม่แน่ใจ 100% ว่าเป็นค่าคงที่สั้นที่สุดที่นี่ ถ้าเป็นเช่นนั้นจะมีบางอย่างผิดปกติกับโปรแกรมสร้างค่าคงที่ที่ฉันเขียนไว้สำหรับการท้าทายครั้งก่อน :)
Kevin Cruijssen

1
ใช่ฉันพูดถูก ค่าคง102ที่มีประสิทธิภาพมากที่สุด: 281 ไบต์ (หรือที่นี่ด้วยการเน้น ) (หมายเหตุ: ฉันใช้สำเนาหนึ่งชุดเพื่อประหยัด 4 ไบต์สำหรับช่องว่างระหว่างehs dnA(คัดลอกจากช่องว่างระหว่างdias ehs)
Kevin Cruijssen

3
ตกลงตอนนี้ฉันเสร็จแล้ว :) 265 ไบต์ (หรือที่นี่ด้วยการเน้น ) เพิ่มสำเนาเพิ่มเติม ( นี่คือเคล็ดลับช่องว่างที่เกี่ยวข้อง )
Kevin Cruijssen

62

Perl 5 , 133 102 95 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

Regexes พิมพ์และสับทั้งหมดนำไปใช้กับตัวแปร$_โดยค่าเริ่มต้น

s qqAnd she saidZ ZBut thatZs hisZZGjGGfq

And she saidZ ZBut thatZs hisZZGjGGfแทนที่สตริงว่างด้วย

s qZqchr oct oct oct ord chopqge

แทนที่แต่ละZที่มีผลการ chr oct oct oct ord chopevaling สิ่งนี้จะลบอักขระตัวสุดท้ายของ$_ใช้รหัสของมันตีความมันเป็นแปดครั้งที่สามและแปลงกลับเป็นอักขระ ยกตัวอย่างเช่นj→ 106 → 70 → 56 → 46 .

เนื่องจากวิธีการทำงานแทนการปรับเปลี่ยนที่จะ$_เกิดขึ้นขณะที่การประเมินทดแทนจะหายไปเพื่อให้อยู่ในขณะนี้$_And she said, 'But that's his.'GjGGf

y qGjfqqd

ลบทั้งหมดG, jและในf$_


26
ไม่ทราบว่ามี Perl ดูเหมือนว่าคุณเพิ่งลองพิมพ์ประโยค แต่ได้ต่อสู้กับแมวของคุณหลายครั้งในกระบวนการ
popctrl

2
นี่อาจเป็นโค้ดที่สวยที่สุดเท่าที่ฉันเคยเห็นมาเขียนในเว็บไซต์นี้และฉันบอกว่าเป็นคนที่รู้จัก Perl
Silvio Mayolo

1
ที่เกี่ยวข้อง แต่คุณสามารถแทนที่printด้วยsayสำหรับ -2 ตัวอักษร ฉันทามติเมตาปัจจุบันบอกว่าแฟล็กบรรทัดคำสั่งเช่น-M5.010ไม่นับรวมเป็นจำนวนไบต์
Silvio Mayolo

34

> <> , 916 915 903 ไบต์

ตอนแรกฉันคิดว่าวิธีแก้ปัญหาใน> <> เป็นไปไม่ได้ แต่แล้วฉันก็รู้ว่า ... ใครต้องการเงื่อนไขหรือการควบคุมเชิงตรรกะ : D

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

ลองออนไลน์

ฉันดันตัวเลข (หมายเลข 15) ซ้ำไปยังสแต็กจากนั้นดันความยาวของสแต็กและพิมพ์อักขระด้วยค่า ASCII นั้น หากฉันต้องการลดขนาดความยาวของสแต็กฉันจะลดค่าสแต็กสามครั้งในการใช้pงานหรือใช้ทีละครั้งgถ้าฉันอยู่ในสามเป้าหมาย โปรแกรมสิ้นสุดโดยการโทรi(อินพุต) ซึ่งส่ง a -1เนื่องจากไม่มีอินพุตจากนั้นพิมพ์โปรแกรมเพื่อทำให้เกิดข้อผิดพลาด

นี่คือโปรแกรม Python 3 ที่ฉันใช้ในการสร้างวิธีแก้ปัญหาเมื่อฉันคิดถึงวิธีการใช้งาน:

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

ลองออนไลน์


5
นี่คือความแตกต่างที่เหมาะสมในการแก้ปัญหาช่องว่าง! มี +1 จากฉันฉันขอขอบคุณโปรแกรมสร้าง ...
ฟรานเชสโก

ส่วนสุดท้ายสามารถลบออกได้อย่างสิ้นเชิงกับใช้ความระมัดระวังของp: สร้าง 59 ในกองขณะที่การย้ายขึ้นมาจากพื้นที่ไปsในsaidแล้ววางไว้ในรหัสในทางที่ลดลงจากการd ,(โปรดทราบว่า (15,15) มี 15 ตามจุดนี้)
Nitrodon

ที่จริงแล้วคุณสามารถใช้ในทางที่ผิดlและpใส่อักขระที่มีประโยชน์หลายอย่างลงในสี่เหลี่ยม (10,10) - (15,15) จากนั้นเรียกดูด้วยgความสะดวก
Nitrodon

นั่นเป็นความคิดที่ดีจริงๆ มันยากที่จะคิด> <> ด้วยวิธีนี้ มันเหมือนกับการเขียนโปรแกรมด้วย BF
mbomb007

ฉันโพสต์คำตอบของฉันเอง: codegolf.stackexchange.com/a/186916/69059
Nitrodon

28

8086 Assembly บน IBM PC, 1463 845 664 ไบต์

การชี้แจง: แหล่งภาษาแอสเซมบลีที่แท้จริงคือรายการไม่ใช่รหัสเครื่องที่สร้างขึ้น

ปัญหาคือคำสั่ง x86 ส่วนใหญ่ (เช่น ADD, SUB, JMP, การกระโดดตามเงื่อนไข, การเข้าถึงหน่วยความจำ) มีสองอาร์กิวเมนต์และต้องมีเครื่องหมายจุลภาคหรือต้องการที่อยู่หน่วยความจำ ดังนั้นเราไม่สามารถใช้การบวกการลบ ifs หรือลูปได้!

ในความพยายามครั้งแรกของฉันฉันสามารถ "สร้าง" ตัวเลขโดยใช้การเพิ่มการลดการคูณการหารเทคนิคการติวและคำสั่ง BCD ที่คลุมเครือ (เช่น AAA, DAS) หลังจากนั้นฉันตระหนักว่าสามารถใช้ความคิดนี้เพื่อสร้างรหัสตรวจสอบตนเองและแก้ไขตัวเอง

  • ความพยายาม 1. (1463 ไบต์)

    ใช้คำแนะนำที่มีอยู่เพื่อสร้างรหัส ASCII และที่อยู่ 0xb800 ของบัฟเฟอร์หน้าจอ การคำนวณของตัวละครแต่ละตัวในลำดับถูก golfed ด้วยมือ

  • พยายาม 2. (ไม่สมบูรณ์)

    ตระหนักว่ามี opcode สำหรับจำนวนเต็มทุกตัวในช่วง 0x40-0x5f ช่วงนี้รวมถึง AZ ตัวอย่างเช่น INC CX สอดคล้องกับ 0x41 = 'A' ( ตาราง opcodeนี้มีประโยชน์มาก)

    ฉันพยายามสร้างสตริง 3 "data" และเลเยอร์มันไว้เหนือกัน อันแรกคือ (เป็นตัวพิมพ์ใหญ่) ตัวที่สอง "เลื่อน" ลงในโซน 0x60-0x7f (ตัวพิมพ์เล็ก) และ "เลื่อน" ครั้งสุดท้ายลงในโซน 0x20-0x3f (เครื่องหมายวรรคตอน)

    รหัสที่แก้ไขด้วยตนเองจะทำให้เกิดลูปหรือสามรอบเพื่อวนซ้ำข้อมูล

  • พยายาม 3. (845 ไบต์)

    เช่นเดียวกับวิธีก่อนหน้านี้ แต่เพื่อลดข้อมูลสตริงจะถูกเข้ารหัสเพียงครั้งเดียวด้วย "อักขระควบคุม" ผสมในเพื่อสลับชุดอักขระ

  • ความพยายาม 4. (664 ไบต์)

    จะกำจัดตัวควบคุมที่ต้องใช้คำสั่งปะแก้มากมายเพื่อจัดการกับการแตกแขนงได้อย่างไร? เนื่องจากมีการใช้ตัวอักษรตัวพิมพ์ใหญ่เพียงสองตัวเท่านั้นฉันสงสัยว่าฉันสามารถ "พลิก" ตาราง opcode เพื่อเข้ารหัสตัวอักษรตัวเล็กโดยใช้ช่วง 0x40-0x4f และเครื่องหมายวรรคตอนโดยใช้ช่วง 0x90-0x9f (โดยลบออกจาก 0xc0) "A" และ "B" สามารถใส่แยกกันได้

    อย่างไรก็ตามมีเพียงครึ่งหนึ่งของ opcodes ในช่วง 0x90-0x9f ที่ใช้งานได้และพวกมันไม่ได้สอดคล้องกับออพที่ต้องการ จากนั้นฉันคิดว่าบางทีฉันสามารถสับเปลี่ยนพวกเขาไปรอบ ๆ โดยใช้แฮคเกอร์และฉันก็พบว่ามันใช้งานได้ และนี่คือ

แข็งแรงเล่นกอล์ฟ:

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

ประกอบกับ

nasm golf.asm -o golf.com

และเรียกใช้ใน DOSBOX (เรียกใช้ CLS ก่อน) ดูเหมือนว่านี้:

ตัวอย่างผลลัพธ์

แสดงความคิดเห็น:

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

ฮึ่ม ฉันได้รับไฟล์. COM ที่แตกต่างจากแหล่งประกอบสองแหล่งเริ่มต้นที่ offset 0x3e แก้ไข - NVM พบความแตกต่าง: สาย 117 ในรุ่นแสดงความคิดเห็นเป็นINC AXในขณะที่ uncommented INC ALคือ
Gastropner

1
ฉันต้องการที่จะเห็นไบนารีตัวอักษรทั้งหมด :-)
peter ferrie

1
หากคุณรู้สึกสะดวกสบายที่จะล็อค NASM ในฐานะผู้ประกอบสิ่งที่คุณเลือกคุณสามารถสร้างป้ายกำกับได้โดยทำlabel1 dbเอง มันจะให้คำเตือน แต่ไม่มีข้อผิดพลาด
Gastropner

1
@Gastropner ดีที่จะทำให้มันง่ายเกินไป : P ไม่รู้เรื่องนั้นขอบคุณ! บางทีฉันควรเปลี่ยนชื่อภาษาของฉันเป็น "สิ่งที่คุณสามารถป้อนเข้าสู่ DEBUG.COM" ซึ่งบังเอิญฉันใช้ในการแก้ปัญหานี้ xD
Artelius

1
@PeterCordes ตอนนี้อันนี้แก้ไขเอง!
Artelius

23

Perl 6 , 1299 1272 1220 1215 ไบต์

ขอบคุณ Grimy สำหรับ -27 ไบต์

-52 ไบต์เพราะเราไม่ต้องการหูหูกระต่ายตั้งแต่แรก

ขอบคุณ Jo King สำหรับ -5 ไบต์

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

ลองออนไลน์!

ส่งออกสตริงที่มีบรรทัดใหม่ต่อท้าย หากคุณไม่ต้องการที่แล้วแทนที่สุดท้ายด้วยsay printนอกจากนี้คุณยังสามารถแทนที่บรรทัดใหม่ในแหล่งที่มาด้วยช่องว่าง

คำอธิบาย

รหัสนี้พิมพ์ตัวอักษรสตริงโดยตัวละคร อักขระแต่ละตัวถูกสร้างขึ้นโดยป้อนรหัสอักขระที่เหมาะสมลงในchrฟังก์ชันและลดขนาดให้เล็กลงlcหากจำเป็น

ปัจจุบันค่าทั้งหมดจะถูกสร้างขึ้นโดยการสร้างสตริงที่มีจำนวนอักขระที่ถูกต้อง ในบางกรณีจำนวนตัวอักษรเป็นสิ่งที่ตรงกันข้ามของรหัสตัวละครเป้าหมาย ในทางทฤษฎีแล้วมันเป็นไปได้ที่จะใช้ฟังก์ชั่นทางคณิตศาสตร์เช่นlogและexpโดยตรง แต่ฉันไม่คิดว่ามันจะใช้งานได้ง่ายมาก

สำหรับการใช้งานเป็นตัวเลขที่เรามีe, piและtau; ในด้านขวาของxหรือxxพวกเขาจะปูพื้นโดยปริยาย พวกเขาทั้งหมดมี 17 ตัวอักษรในการเป็นตัวแทนสตริงของพวกเขาดังนั้นเราจึงใช้eสำหรับการนับตัวละครน้อยที่สุด นอกจากนี้เรายังมีi(4 ตัวอักษร) False(5 ตัวอักษร) และNaN(3 ตัวอักษร) เราสามารถคูณความยาวของสตริงด้วยx; xxคูณหนึ่งบวกความยาวสตริงด้วยด้านขวาและเพิ่มหนึ่ง chopลบหนึ่งอักขระจากสตริงในกรณีที่เราอยู่ห่างจากเป้าหมาย

คำสั่งการพิมพ์ถูกผูกมัดด้วยกันโดยใช้andซึ่งมีความสำคัญค่อนข้างต่ำ มันเกือบจะเป็นปาฏิหาริย์ มิฉะนั้นเราจะต้องใช้อัฒภาคที่ผิดกฎหมาย

ฉันพบการแสดงออกของตัวละครด้วยมือ มันอาจจะคุ้มค่าที่จะค้นหามันแบบเป็นโปรแกรมเพื่อค้นหานิพจน์ที่สั้นลง



@JoKing คุณค้นหานิพจน์ที่สั้นกว่าด้วยมือหรือคุณใช้โปรแกรมเพื่อช่วยหรือไม่
bb94

1
ด้วยมือฉันกลัว วิธีอัลกอริทึมอาจจะไม่ยากเกินไป
โจคิง


@Grimy Clever แต่น่าเสียดายที่ทำได้เพราะ Zero Space Space ที่คุณใช้ไม่ใช่ตัวละครในช่องว่าง
Jo King

17

ความกว้าง , 66 64 ไบต์

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

ลองออนไลน์!

พิมพ์เพื่อดีบัก หากต้องการพิมพ์ไปยัง stdout ให้ต่อwwท้ายรหัสซึ่งจะปรากฏขึ้นและส่งออกด้านบนของสแต็ก

คำอธิบาย

ในความกว้างตัวอักษรแต่ละตัวมีความสัมพันธ์กับตัวเลขโดยขึ้นอยู่กับว่า "กว้าง" เป็นอย่างไรตามตารางนี้ สิ่งนี้กำหนดตัวเลขแต่ละตัวจาก 0 ถึง 9 จากนั้นตัวเลขเหล่านั้นจะถูกใช้เพื่อเรียกใช้งานโค้ดจริง

โดยเฉพาะอย่างยิ่งตัวอักษรมากกว่าการแข่งขัน7จะเริ่มต้นสตริงตัวอักษร มันจะอ่านชุดของตัวอักษรสองตัวพร้อมกันจนกว่าจะอ่านตัวอักษรเดิมอีกครั้ง แต่ละชุดของตัวอักษรสองตัวจะถูกแปลงเป็นตัวเลขความกว้างของพวกเขาอ่านเป็นเลขทศนิยมระหว่าง 0 ถึง 99 และตัวอักษรที่พวกเขาเท่ากันจะเป็นดัชนีในสตริงต่อไปนี้:

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

ตัวอย่างเช่นดัชนีของ!1 คือดังนั้น01จะเป็นตัวเลขความกว้างที่เหมาะสม ดังนั้นif, iI, jtฯลฯ !ทั้งหมดจะมีความสัมพันธ์กับสตริงที่แท้จริงของ

ในกรณีนี้ฉันแปล 31 อักขระของเอาต์พุตที่ต้องการเป็นตัวอักษรที่เหมาะสมโดยใช้Qเป็นเครื่องหมายคำพูด ด้านบนของสแต็กจะถูกพิมพ์เพื่อดีบักเมื่อโปรแกรมเสร็จสิ้น


นี่เป็นอันที่สั้นที่สุด ฉันคิดว่าคุณสามารถชนะ!
ฮอว์กสีน้ำเงิน Maned

14

รหัสเครื่อง x86 (32 บิต), 256 ไบต์

เมื่อฉันพิมพ์รหัสของฉันบนคอนโซลเพจรหัสของฉัน 437 ฉันเห็นสิ่งต่อไปนี้:

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 

สิ่งนี้มีอักขระช่องว่างบางส่วนดังนั้นนี่คือรหัสเดียวกันเมื่อฉันแทนที่อักขระแท็บทั้งหมดด้วยและอักขระช่องว่างที่ไม่แตก (ด้วยรหัส 255) โดย*:

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

คำอธิบายบางอย่างเกี่ยวกับวิธีการทำงาน:

คำแนะนำที่เป็นประโยชน์คือ:

  • push imm8, push imm16และpush imm32ตามมาด้วยการpopสร้างค่าคงที่ สิ่งนี้สามารถสร้างศูนย์ (ในah) เมื่อกดไบต์ ( imm8)
  • and [ecx+32], ah- สมมติว่าอา = 0 ชุดนี้ไบต์เป็นศูนย์ มันเพิ่งเกิดขึ้นที่ความยาวของสายอักขระออกเป็น 32 ดังนั้นโค้ดจะเติมบัฟเฟอร์ตั้งแต่ต้นจนจบ
  • or [ecx+32], edx- สมมติว่าเอาต์พุตไบต์ถูกตั้งค่าเป็นศูนย์สำเนานี้edx(4 ไบต์) เป็นเอาต์พุต ฉันใช้ตัวแปรกับdxแทนedxใกล้ถึงจุดสิ้นสุดของบัฟเฟอร์เพราะไม่ควรเขียนเกินกว่าบัฟเฟอร์เอาต์พุต ข้อ จำกัด ของโค้ดทำให้ไม่สามารถเขียนไบต์เดียวด้วยวิธีนี้!
  • imul edx, [ecx+32], whatever- นี่เป็นแนวคิดหลักในการต่อสู้ พอเอนโทรปีพอ[ecx+32]และจำนวนอะไรก็สามารถสร้างผลลัพธ์ใด ๆ ฉันใช้มันเพื่อสร้างค่าที่ต้องการ 2 หรือ 3 ไบต์ ภาวะแทรกซ้อนบางอย่างคือเมื่อเขียนไปยังเอาต์พุตมันจะต้องทำตรรกะORด้วยสิ่งที่มีอยู่แล้ว บางครั้งสิ่งนี้ทำให้มันจำเป็นต้องศูนย์ความจำอีกครั้ง
  • ตัวแปรของjmpคำสั่งถูกใช้เพื่อส่งคืน ฉันเลือกเพราะการเข้ารหัสของมันคือ0xffซึ่งสอดคล้องกับพื้นที่ไม่แตกหักในเพจรหัส 437 บิตของการยืดในกฎ แต่อย่างอื่นฉันคิดว่างานเป็นไปไม่ได้ ...

แอสเซมบลีซอร์สโค้ดพร้อมกับโปรแกรม C ที่รัน (ใช้ไวยากรณ์ 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);
}

ดูเหมือนว่าฉันจะไม่ได้เล่นกอล์ฟอย่างเต็มที่เลย แน่นอนคุณจะบันทึกหลายไบต์โดยใช้ลูปแทนที่จะทำซ้ำชุดคำสั่งที่เหมือนกัน สิ่งdec ecx+ ทั้งหมดนั้นand [ecx+32], ahสามารถแยกออกได้
โคดี้เกรย์

คุณสามารถลอง นี่คือสิ่งที่ดีที่สุดที่ฉันสามารถทำได้; ฉันยินดีที่จะเห็นวิธีการอื่น ฉันตัดสินใจที่จะละทิ้งความคิดของลูปเมื่อฉันเห็นว่าพวกเขาต้องการการข้ามทางลบ บางทีข้อ จำกัด นี้สามารถแก้ไขได้ด้วยวิธีที่สร้างสรรค์ - ฉันไม่รู้
Anatolyg

1
@anatolyg อาจเป็นเพราะท่าทางของสภาพแวดล้อมการทดสอบของคุณในการแก้ไขโค้ดด้วยตนเอง หรือความคิดเห็นเกี่ยวกับการเรียกใช้งานโค้ดที่คุณสร้างขึ้นบนสแต็ก
Gastropner

อักขระไม่0xffละเมิด "ไม่มีเครื่องหมายวรรคตอนหรือตัวอักษรที่ไม่ใช่ตัวอักษร" หรือไม่?
Val


13

PostScript, 889 874 837 835 ไบต์

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

ลองออนไลน์!

นี้ใช้ 32 89 25 20 6สำเนาของจำนวนเต็ม charcodes ทั้งหมดของสตริงเป้าหมายสามารถรับได้ด้วยการดำเนินการกับจำนวนเต็มเหล่านั้นตามลำดับสแต็ก: ตัวอย่างเช่น 'A' (ASCII 65) คือ 89 - (25 & (20 + 6)) จำนวนเต็ม 4 จำนวนเต็มมีคุณสมบัตินี้ อันนี้ถูกเลือกเพราะมันง่ายที่จะสร้าง

currentflat string dup rrand

แบนเริ่มต้นที่ 1 ดังนั้นสิ่งนี้จะสร้างสตริงที่มีความยาว 1 (เริ่มต้นได้ที่\0) dupไม่ใช่สำเนาลึก: มันสร้างการอ้างอิงที่สองไปยังสายอักขระเดียวกัน rrand ผลักดันเมล็ดสุ่มที่เริ่มต้นที่ 0 ["\0", "\0", 0]กองอยู่ในขณะนี้

count dup count count mul mul xor

count เพิ่มจำนวนของไอเท็มในสแต็กดังนั้นสิ่งนี้จะคำนวณ 3 ^ (3 * (5 * 6)) = 89

count count mul count dup mul exch count

4 * 5 = 20 5 * 5 = 25, 6 = 6 ["\0", "\0", 0, 89, 25, 20, 6]กองอยู่ในขณะนี้

count copy count copy count copy count copy count copy

ทำซ้ำสแต็กทั้งหมดห้าครั้ง ดังนั้นเราจึงสิ้นสุดด้วยชุดสำเนา 7 องค์ประกอบเริ่มต้น 32 ชุด เราต้องการเพียง 31 สำเนาเนื่องจากสตริงเป้าหมายมีความยาว 31 ตัวอักษร แต่สำเนาพิเศษไม่เจ็บ

add and sub put print

คำนวณ charcode จากจำนวนเต็มสี่อันดับแรกเขียนที่ดัชนี 0 ของสตริงจากนั้นพิมพ์สตริง

quit

ไม่แสดงพรอมต์เริ่มต้น


11

Ruby , 420 354 338 ไบต์

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

ลองออนไลน์!

ตามลำดับจากน้อยไปมาก:

คำที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่สามารถพิมพ์ได้โดยกำหนดคลาสด้วยชื่อนั้นและการโทรdisplayภายในเนื้อหาคำจำกัดความของคลาส

คำอื่น ๆ สามารถแสดงผลได้โดยการกำหนดวิธีการที่มีชื่อนั้นซึ่งจะส่งคืนสัญลักษณ์จากนั้นส่งให้กับสตริงเพื่อลบเครื่องหมายโคลอนที่อยู่ด้านหน้า

ตัวละครอื่น ๆ สามารถแสดงผลได้โดยการเรียกputcใช้รหัส ASCII เราสามารถสร้างตัวเลขที่เหมาะสมได้โดยใช้String defกลอุบายใหม่เพื่อรับสตริงจากนั้นนำผลรวมของไบต์โดยใช้โมดูลัสที่กำหนดโดยขนาดของมัน น่าเสียดายที่เราไม่มีวิธีใด ๆ ในการเรียกใช้เมธอดบนออบเจ็กต์อื่นนอกเหนือจากภายในนิยามคลาสของวัตถุนั้นซึ่งทำให้ยากที่จะผ่านการขัดแย้ง ดังนั้นการแฮ็คครั้งสุดท้ายคือการกำหนดใหม่String#inspectซึ่งถูกเรียกโดยปริยายเมื่อผ่าน String เข้าสู่pวิธีการเพื่อให้มันคำนวณและส่งออกอักขระที่เหมาะสมเป็นผลข้างเคียงก่อนที่จะเกิดข้อผิดพลาดเพื่อให้pไม่สามารถดำเนินการและพิมพ์ ขึ้นบรรทัดใหม่ จากนั้นเราต้องช่วยชีวิตข้อผิดพลาดในรหัสหลัก

แก้ไข: จอร์แดนทำให้จำนวนไบต์น้อยลง, อะแฮ่ม, สูงด้วยการควบคุมการเล่นกอล์ฟที่ชาญฉลาดและฉันได้ลดจำนวนไบต์อีกสองสามไบต์โดยแทนที่raiseด้วยการเรียกเมธอดที่ไม่มีตัวอักษรตัวเดียวซึ่งทำให้เกิด NameError

แก้ไข 2: พบว่ามีการprint Stringแยกเป็นวิธีจะถูกกว่าเพียงใช้กับคำจำกัดความวิธีกว่าใช้เคล็ดลับการกำหนดคลาสเนื่องจากวิธีการได้รับอนุญาตให้ใส่ชื่อ


สวย .... ฉันไม่เข้าใจเลยว่าsum sizeขนาดของมันจะใหญ่แค่ไหนแต่ทุกอย่างดูออกไป!
หมึกมูลค่า

ฉันใส่มันลงไปอย่างเกียจคร้านจริง ๆ แล้วมันผ่านขนาดของสตริงเป็นอาร์กิวเมนต์ที่เป็นทางเลือกสำหรับวิธีผลรวม
ชำนาญการ

11

> <> , 233 122 ไบต์

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

ลองออนไลน์!

นี่เป็นการเริ่มต้นของคำตอบของ mbombแต่ฉันค้นพบการเปลี่ยนแปลงพื้นฐานที่ช่วยประหยัดจำนวนไบต์จำนวนมากดังนั้นฉันจึงโพสต์มันเป็นคำตอบของฉันเอง

การสร้างอักขระที่ไม่ใช่ตัวอักษรไปยังเอาต์พุตทำได้โดยการกดค่าซ้ำไปยังสแต็กจากนั้นใช้lเพื่อดันความยาวสแต็ก แต่นี้ไม่จำเป็นต้องถูกขับออกทันทีโดยใช้pตัวละครนี้สามารถอยู่ในเซลล์ใด ๆ ที่มีพิกัดทั้งสองระหว่างวันที่ 10 และ 15 gรวมที่จะดึงในภายหลังด้วย ในทำนองเดียวกันตัวอักษรสามารถวางไว้ในซอร์สโค้ดเริ่มต้นและอ่านด้วยวิธีนี้: เนื่องจากรหัสอักขระที่ไม่ใช่ตัวอักษรสูงสุดในอินพุตคือ 46 ( .) หมายความว่าสแต็กไม่จำเป็นต้องถูกผลักสูงกว่า 62 ที่จำเป็นในการจัดเก็บ อักขระ 31 ตัวของเอาต์พุต

นอกจากนี้ a vจะอยู่ในรหัสที่คอลัมน์ 7 เมื่อตัวชี้คำสั่งล้อมรอบและฮิตนั้นvลำดับgoจะถูกดำเนินการซ้ำ ๆ เพื่ออ่านจากพิกัดที่ถูกพุชและส่งออกอักขระที่เกี่ยวข้อง ในที่สุดสแต็กจะว่างเปล่าและgยกเลิกโปรแกรมด้วยข้อผิดพลาด

โค้ด 7 ไบต์แรกถูกนำมาใช้ใหม่เนื่องจากทั้ง 7 พิกัดแรกและ 7 ครั้งล่าสุดที่ผลัก การวางvคอลัมน์ในคอลัมน์ 9 จะช่วยเพิ่มทางทฤษฎีได้อีกสองไบต์ แต่จะบังคับให้อักขระAinsvเป็นสี่เหลี่ยม 2x2 ในโค้ดซึ่งเป็นไปไม่ได้ เวอร์ชันก่อนหน้านี้ใช้คอลัมน์ 15 แต่จำเป็นต้องมีบรรทัดเพิ่มเติมในซอร์สโค้ดและจบลงด้วยความยาวหกไบต์


หลังจากคิดเพิ่มเติมฉันคิดว่าฉันสามารถทำให้คอลัมน์ 9 ทำงานได้โดยใช้ไบต์บนrเพื่อย้ายการจัดตำแหน่งทุกที่ที่ฉันต้องการ อย่างไรก็ตามการตีกอล์ฟโปรแกรมนี้ทำให้สมองของฉันเจ็บเล็กน้อย
Nitrodon

8

CJam , 262 ไบต์

  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

ลองออนไลน์! บรรทัดใหม่จะแสดงเฉพาะที่นี่เพื่อความชัดเจน แต่ละบรรทัดแสดงถึงอักขระ

มันสนุกดี การ จำกัด ตัวเองเป็นคำสั่งตัวอักษรทำให้เกิดความท้าทายที่น่าสนใจ:

  • หากไม่มี{และ}ก็ไม่มีโอกาสที่จะควบคุมโฟลว์ (ยกเว้นfซึ่งฉันไม่พบโอกาสที่จะใช้)
  • โดยไม่ต้อง\, _, ;หรือ$เราไม่ได้หมายความว่าสำหรับการจัดการสแต็ค

cซึ่งหมายความว่าเป้าหมายหลักเป็นไปได้ที่จะได้รับจุดรหัสที่เกี่ยวข้องในกองแล้วแปลงให้เป็นตัวอักษรที่มี

ปัญหาคือเรายังขาดคำสั่งทางคณิตศาสตร์พื้นฐานส่วนใหญ่เช่นเดียวกับตัวอักษรจำนวนเต็ม แม้ว่าจะเป็นสิ่งที่ดีเนื่องจากmเนมสเปซมีการดำเนินการทางคณิตศาสตร์ขั้นสูงจำนวนมากและมีตัวแปรจำนวนมากที่กำหนดไว้ล่วงหน้าให้กับหมายเลขที่มีประโยชน์

ฉันลงเอยด้วยการใช้ประโยชน์อย่างมากของรากที่สอง ( mQและmq), ฟังก์ชันเลขชี้กำลังmeและการแปลงฐาน ( b) ซึ่งสามารถใช้เพื่อจำลองการคูณ ( [X 0] Ybคำนวณ X * Y) นอกจากนี้บางครั้งมันง่ายกว่าที่จะสร้าง codepoint ตัวพิมพ์ใหญ่ซึ่งในกรณีนี้เราสามารถใช้el(แปลงเป็นตัวพิมพ์เล็ก) กับตัวละครที่เกิดขึ้น

ฉันยังคงไม่พอใจกับอีกต่อไป โอ้ดี

คำอธิบาย

นี่คือคำอธิบายแบบตัวอักษรต่ออักขระของเอาต์พุต ก่อนที่ฉันจะเริ่มนี่คือวิธีสั้น ๆ ในการสร้างตัวเลข:

  • 0, 1, 2, 3 มีอยู่ในตัวแปรT, X, Y, Zตามลำดับ
  • หมายเลข 10 ถึง 20 มีอยู่ในตัวแปรผ่านAK
  • 32 สามารถทำได้โดยใช้Sci( Sผลักสตริงที่มีช่องว่างcรับตัวอักษรตัวแรกของสายนี้และiแปลงตัวละครที่จุดรหัสของมัน) Sยังใช้สำหรับช่องว่าง
  • 4 มอบให้โดยGmQ(รากที่สองจำนวนเต็ม 16)
  • 5 มอบให้โดยAZbYb(แปลง 10 เป็นฐาน 3 ให้ผล[1 0 1]และแปลงอาร์เรย์ผลลัพธ์ของตัวเลขเป็นฐาน 2 ให้ผลลัพธ์ 5)
  • 7 มอบให้โดยYmei(คำนวณ exp (2) และแปลงเป็นจำนวนเต็ม)

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

1
คุณสามารถทำแปลงฐานด้วยตัวเลขนอกช่วงปกติสำหรับฐานเช่นHYbYCtYbc, และHYbXAtYbc HYbXBtYbc
Nitrodon

7

เดดฟิช ~ , 943 ไบต์

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

ลองออนไลน์!

ไม่อนุญาตให้ใช้ลูป :(




6

MATL , 187 158 ไบต์

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

ลองออนไลน์!

เวอร์ชันที่อ่านง่ายขึ้น: ลองออนไลน์! พยายามสร้างสตริงด้วยตนเอง อาจมีพื้นที่มากมายสำหรับการเล่นกอล์ฟโดยการตัดสายเป็นช่องว่างที่สะดวกใช้Pและhพลิกและสร้างสาย ฉันหวังว่าจะมีใครซักคนมาแย่งฉัน ความท้าทายหลักคือคุณไม่สามารถใช้+หรือ-ดังนั้นเลขคณิตพื้นฐานจึงไม่สามารถทำได้

ไฮไลท์:

  • KQthpYq: 25 ( KQthp) ที่สำคัญYqคือ 97 aซึ่งสอดคล้องกับตัวอักษร ตัวอักษรs(115) ถูกสร้างขึ้นในทำนองเดียวกันจาก 113 ซึ่งเป็นหมายเลขเฉพาะอันดับที่ 30 Jแล้วมันเป็นอย่างกว้างขวางอีกครั้งที่ใช้ในคลิปบอร์ด
  • hisจะสั้นลงโดยการจัดเก็บจากมาก่อนในคลิปบอร์ดh Jนับได้ว่าเก็บไว้ก่อนหน้าsเราสร้างhisในสิ่งที่ตรงกันข้ามดังนั้นเราจึงยังคงสามารถดึงข้อมูลที่ผ่านมาsใช้และพลิกมันหลังจากใช้yP
  • จำนวนมากของไบต์บันทึกขอบคุณที่หลุยส์ Mendo (ส่วนใหญ่โดยการเปลี่ยนพวงของhการvle)

อืม - ฉันคิดว่าการใช้งานจริงvจะยุ่งกับสิ่งที่hฉันมีก่อนหน้านี้ เดาว่าฉันควรจะเป็นอย่างนั้นแทนที่จะคิด นอกจากนี้ขอขอบคุณที่เฮดอัพ ฉันอยากรู้ว่าคุณสามารถทำได้ดีกว่านี้หรือไม่ ...
Sanchises

ฉันอยากจะลอง แต่มันจะต้องรอ การตอบคำถามนี้ดูเหมือนจะใช้เวลานานมาก!
Luis Mendo

1
@LuisMendo Yup ใช้เวลาหนึ่งชั่วโมงกับฉันในการทำสิ่งนี้และสิ่งนี้มีการเพิ่มประสิทธิภาพเฉพาะที่เท่านั้น ฉันแน่ใจว่าสามารถทำได้ดีกว่าโดยดูจากทั่วโลก
Sanchises

ความพยายามของฉัน ฉันไม่ได้มองคุณดังนั้นวิธีการจึงแตกต่างอย่างหวัง
หลุยส์เมนโด

@LuisMendo ฉันสมบูรณ์ลืมไปว่าUวิธีการ^2ที่จะได้บันทึกฉันค่อนข้างไม่กี่ไบต์ ...
Sanchises

6

MATL , 118 ไบต์

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

ลองออนไลน์!

เวอร์ชันที่อ่านได้ง่ายขึ้น (แต่ละบรรทัดสอดคล้องกับอักขระหนึ่งตัวยกเว้นการดำเนินการเรียงลำดับใหม่)

คำอธิบาย

โปรแกรมสร้างจุดรหัสของตัวละครที่ต้องการเป็นตัวเลขอิสระ ในตอนท้ายตัวเลขทั้งหมดเหล่านี้จะถูกตัดแบ่งเป็นเวกเตอร์คอลัมน์เปลี่ยนรูปร่างเป็นเวกเตอร์แถวและแปลงเป็นอักขระ ผลลัพธ์จะถูกแสดงโดยนัย

เทคนิคบางอย่างที่ใช้:

  • คะแนนรหัสส่วนใหญ่ต่ำกว่า 32 จะแสดงเป็นช่องว่าง ดังนั้น0จะใช้สำหรับช่องว่างส่วนใหญ่เพราะมันมีราคาเพียงไบต์ ( O)
  • อย่างไรก็ตามสำหรับพื้นที่แรกนั้น15จะถูกใช้ (สร้างเป็นKUq) เพราะสามารถนำมาใช้ซ้ำได้โดยการเพิ่มลงใน100(char d) เพื่อให้115( s) ในโอกาสอื่น5จะใช้สำหรับพื้นที่ (สร้างเป็นKQ) ดังนั้นจึงสามารถลบได้ในภายหลังจาก44( ,) เพื่อให้39( ')
  • คลิปบอร์ดJถูกนำมาใช้สำหรับการจัดเก็บอักขระที่จะต้องทำซ้ำ: ครั้งแรกแล้วs 'ในทำนองเดียวกันที่Hเก็บคลิปบอร์ด100ซึ่งมีประโยชน์สำหรับdและสำหรับการสร้างตัวละครอื่น ๆ
  • การใช้อย่างกว้างขวางนั้นทำจากฟังก์ชั่นQ(เพิ่ม1), q(ลบ1), E(คูณด้วย2) และU(สี่เหลี่ยม) พร้อมกับตัวอักษรที่กำหนดไว้ล่วงหน้าในคลิปบอร์ดI( 3) และK( 4)
  • การบวกและการลบโดยพลการกระทำโดยการต่อเวกเตอร์ ( h) เข้าด้วยกันและคำนวณผลรวม ( s) หรือผลต่างที่ต่อเนื่องกัน ( d)
  • 100( d) ถูกสร้างขึ้นเช่นเดียวกับ4ในการตีความไบนารีเป็นตัวเลขทศนิยม
  • 110( n) จะได้รับจาก65( A) โดยการแปลงสตริง ( '65': จุดรหัส[54 53]) เพิ่ม1ไปยังจุดรหัส ( [55 54]) 1ข้อสรุปพวกเขาร่วมกันและการเพิ่ม
  • ลำดับที่หมายเลขถูกสร้างขึ้นบางครั้งมีการเปลี่ยนแปลงเพื่อความสะดวก และพวกเขาจะถูกจัดลำดับใหม่โดยฟังก์ชั่นการจัดเรียงใหม่: swap ( w), เพิ่มฟองอากาศb)

1
ดีมาก! สัมผัสอย่างชาญฉลาดโดยใช้OแทนKWEการเว้นวรรค Hและคุณได้รับการยืนยันความสงสัยของผมว่ามันอาจจะดีกว่าที่จะเสียสละคลิปบอร์ดอีก
Sanchises

5

dc , 240 222 209 ไบต์

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

ลองออนไลน์!

ความคิดแรกของฉันเหมือนกับ @seshoumara เพียงแค่กดสิ่งต่าง ๆ ลงบนสแต็กเพื่อสร้างค่า ASCII ของตัวละครทั้งหมด จากนั้นก็จะเกิดขึ้นกับผมว่าตั้งแต่+, -และ*ผู้ประกอบการตัวเดียวผมก็สามารถสร้างพวกเขาและมีความสามารถในการใช้คณิตศาสตร์! แน่นอนว่ามันจะเล็กลง! และฉันจะไม่แปลกใจถ้าฉันสามารถตีไบต์ได้อีกต่อไป แต่สำหรับตอนนี้ ... วิธีการที่ซับซ้อนนี้สามารถจัดการกับnaïve (ish) ได้

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdเป็นส่วนหนึ่งของวิธีการที่คล้ายกับ @ seshoumara แต่เราเท่านั้นที่ไปถึง 46 .ซึ่งเป็น เราทำเช่นนี้เพราะเราต้องขึ้นไป 45 -และเรายังต้องการจุดในสตริงของเราดังนั้นการไปอีกหนึ่งช่วงเวลานั้นคือ (ฉันคิดว่า) ถูก ระหว่างทางเราเก็บค่าบางอย่าง: 5, 32, 39 ทั้งหมดมาในภายหลัง 5 สำหรับสิ่งที่เป็นประโยชน์ 32 และ 39 สำหรับค่า ASCII ของพวกเขา เดิมทีฉันทำ 1-5 แต่มันแพงและฉันก็สามารถหลีกเลี่ยงการใช้ 4 ได้ ใช้Z(ป็อปอัพค่ากดจำนวนหลักที่มี) กับหมายเลขสาม, สองหรือหนึ่งหลักสำหรับค่าเหล่านั้น ที่ 42, 43, และ 45 เราแปลงเหล่านี้เพื่อสตริง ( *, +และ-ตามลำดับ) และเก็บไว้เป็นแมโคร ( B, AและCตามลำดับ) ซึ่งหมายความว่าหากไม่ใช้อักขระ*+-เราสามารถใช้โอเปอเรเตอร์เหล่านั้น

จากที่นี่โดยทั่วไปเราเริ่มสร้างค่า ASCII โดยใช้พลังของคณิตศาสตร์แทนการสะสมที่แท้จริงจัดเก็บซ้ำบางส่วนไปพร้อมกัน 100, 105 และ 115 เกิดขึ้นมากพอที่จะเก็บมันไว้ แต่เดิมฉันออกจากสแต็คที่เต็มไปด้วย 10 วินาทีและใช้สิ่งเหล่านี้เพื่อสร้าง 100s; มันจบลงด้วยการบันทึกไบต์เพื่อเติมสแต็คด้วย 32s และใช้เหล่านั้นเป็นช่องว่างในภายหลัง รุ่นเล็กน้อยอ่านได้มากขึ้นของส่วน 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นี้:

ลบออกไป 18 ไบต์โดย: เก็บหมายเลข 5 เป็นค่าฐานข้อมูลแทนที่จะเป็นค่ารีจิสเตอร์ จำนวน 32 เป็นความแม่นยำแทนการลงทะเบียน; หมายเลข 115 เป็นเอาต์พุต radix แทน register จากนั้นจึงเปลี่ยนKZเป็นIZสร้าง 1s และOZเปลี่ยนKZเป็น 2 วินาที

ลบออก 13 ไบต์เพิ่มเติมโดยทำให้กองซ้อนเต็มไปด้วย 32 วินาที การตั้งค่าความแม่นยำถึง 39; ใช้การเรียงซ้อนเพื่อหลีกเลี่ยงการจัดเก็บ 116; ตัดงานซ้ำสองครั้งที่ฉันตั้งใจทิ้งไว้


1 ความคิดที่ดีที่จะใช้ในการสร้างผู้ประกอบการเหล่านั้นแล้วจะเรียกพวกเขาด้วยa xสิ่งนี้แสดงพฤติกรรม data-is-code ของ dc เมื่อฉันมีเวลาฉันจะใช้เคล็ดลับล่าสุดของการจัดเก็บข้อมูลเป็นพารามิเตอร์แทนที่จะเป็นการลงทะเบียน คุณคิดว่าเราจะได้คำตอบที่สั้นลงโดยใช้วิธีที่ P ทำงานเพื่อพิมพ์ตัวอักษรมากกว่านี้ในเวลาเดียวหรือไม่ถ้าเราโชคดีที่ได้ป้อนตัวเลขจำนวนมากที่ต้องการโดยใช้เลขฐานสิบหกเท่านั้น?
seshoumara

@seshoumara เป็นไปได้แม้ว่าความพยายามของฉันในการทำสิ่งนั้นกับความท้าทายอื่น ๆ ชี้ให้เห็นว่ามันไม่น่าเป็นไปได้เพียงเพราะคุณค่าเหล่านั้นมีขนาดใหญ่อย่างรวดเร็ว เพียงเพื่อให้ได้ตัวอักษรสองตัวแรก 'An' เราต้องP16750 หรือ 0x416E หากเราเพิ่งจะโชคดีและหนึ่งในสตริงย่อยนั้นประกอบไปด้วยค่า AF โดยเฉพาะนั่นอาจทำให้เรามีทางลัด นั่นจะเป็นโชคดี! มิฉะนั้นเราจะเป็นได้ทั้งการป้อนตัวเลขขนาดใหญ่อย่างใดขึ้นมาพร้อมกับพวกเขาอย่างใดหรือทำมากของการเพิ่มและคูณด้วย 256 ซึ่งดูเหมือนว่า ... chunkier กว่าพวงของPs
brhfl

5

Japt , 87 ไบต์

Bs g caA
HzG
Ts caV
iWisiiihiSisiUitiaihitiSitiuibu iUiSiWcaV idiiiaisiSieihisiSidiniau

ลองมัน

คำอธิบาย

บรรทัดแรกสร้างและกำหนดให้กับตัวแปร'U

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

บรรทัดที่สองกำหนดให้กับตัวแปร2V

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

บรรทัดที่สามสร้างและกำหนดให้กับตัวแปร.W

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

บรรทัดสุดท้ายจากนั้นสร้างสตริงหนึ่งตัวอักษรในเวลาย้อนกลับ

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

ทางออกที่ดี คุณสามารถบันทึกไบต์โดยแทนที่บรรทัดแรกด้วยQc dGaB
ศูนย์รวมของความไม่รู้

4

สีแดง 272 ไบต์

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

หากจำเป็นต้องใช้เครื่องหมายคำพูดคู่:

สีแดง 344 ไบต์

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

ไม่ทำงานใน TIO แต่ทำงานในล่ามสีแดง

คอนโซลสีแดง

คำอธิบาย:

คำที่มีความน่ารำคาญ - ฉัน PRIN พวกเขา (พิมพ์โดยไม่มีการขึ้นบรรทัดใหม่) quoteเป็นตัวอักษรด้วย สีแดงมีคำในตัวสำหรับพื้นที่ - spเช่นเดียวกับและcomma และน่าสนใจยิ่งขึ้น: ฉันปริญพวกเขาด้วยการลบช่องว่างจากและตามลำดับเริ่มต้นจากตัวอักษรและแปลงพวกเขาก่อนที่จะสตริงด้วยแล้วตัวละคร (เพื่อที่จะใช้การลบพวกเขา) wtih ( สีแดงมีการแปลงโดยต้นแบบ - แปลง สตริงกับประเภทของซึ่งเป็นตัวละคร)dot"'BGBGmoldto spsp


1
คำถามถูกชี้แจง พวกเขาลบส่วนที่น่าสนใจออกไป
Anatolyg

@ anatolyg ขอบคุณฉันยังคงต้องการมัน'ดังนั้น 272 bytes solution ก็เหมือนกัน
Galen Ivanov

4

ออกมา (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

น่าเสียดายที่ฉันไม่สามารถกำหนด CHAR หรือ EMIT ใหม่เป็นคำที่มีตัวอักษรเดียวเนื่องจากจะต้องใช้อย่างใดอย่างหนึ่ง:และ;(เช่น: C CHAR ;) หรือ'(เช่น' CHAR ALIAS C)

ในความเป็นจริงถ้าฉันสามารถกำหนดคำที่ฉันจะทำ: P CHAR EMIT ;แล้วทำในการพิมพ์P x xโอ้ดี

ฉันไม่สามารถสร้างบัฟเฟอร์เขียนลำดับถ่านที่นั่นแล้วใช้มันเป็นอินพุตเนื่องจากการเขียนไปยังหน่วยความจำต้องใช้!หรือC!



3

Pepe , 266 ไบต์

ฉันเก็บ r stack ว่างและมี 's' ใน 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

นี่ไม่ได้อยู่ใน TIO แต่คุณสามารถลองได้ที่นี่


3

dc , 240 ไบต์

แนวคิดหลักคือการขยายสแต็กอย่างต่อเนื่อง 1 ( K), บันทึก ( sX) ขนาดของสแต็ก ( z) เป็นการลงทะเบียนที่กำหนดเองเมื่อมันตรงกับรหัส ASCII ที่ไม่ซ้ำกันแต่ละรายการ การพิมพ์ ( P) เสร็จตลอด

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

ลองออนไลน์!

ฉันทำการเพิ่มประสิทธิภาพบางอย่างเช่นไม่บันทึกจดหมายหากไม่ได้ใช้หลังจากนั้นเช่นการทำสำเนา ( d) จดหมายเช่น t บนสแต็กเพื่อบันทึกไบต์เนื่องจากการเรียกคืน ( lX) คือ 2 ไบต์


ฉันคิดหาวิธีแก้ปัญหา dc ที่ใช้เลขคณิตด้วยการสร้างมาโครสำหรับ +, -, และ * เป็น 262 ไบต์ ฉันจะพยายามปรับมันให้เหมาะสมเพื่อพยายามแข่งขัน แต่ฉันต้องบอกว่าฉันผิดหวังมากยิ่งกว่าโซลูชันที่ค่อนข้างไร้เดียงสา
brhfl

@brhfl ใช่แล้ว dc ได้รับ verbose ค่อนข้างเร็ว ถึงกระนั้นฉันก็อยากจะเห็นวิธีการแก้ปัญหาของคุณดังนั้นโพสต์มัน! ในระหว่างนี้ฉันก็กำลังคิดว่าจะตีกอล์ฟด้วยวิธีปัจจุบันให้มากขึ้นโดยใช้โปรแกรมหรือคิดหาวิธีคิดใหม่ ๆ
seshoumara

ฉันพยายามผูก 240! และฉันจะไม่แปลกใจถ้าฉันสามารถตีลูกออกไปอีกหนึ่งหรือสองไบต์ แต่ ... มันเป็นวิธีการที่ป้านมากขึ้นเพื่อผลประโยชน์เพียงเล็กน้อย / ไม่มีเลย อย่างไรก็ตามผมโพสต์มันลงไปที่นั่นอยู่ที่ไหนสักแห่ง ...
brhfl

ฉันลงไปที่ 222 โดยแทนที่เรจิสเตอร์ทั่วไปส่วนใหญ่ของฉันด้วยเรเดียนและความแม่นยำ ช่วยประหยัดหนึ่งไบต์ในร้านค้าและหนึ่งไบต์ในทุก ๆ การโหลด ... เนื่องจากตัวเลขมีความสำคัญจึงไม่มีผลอะไรเลย ... คุณอาจใช้สิ่งนี้เพื่อผลประโยชน์ของคุณเช่นกัน!
brhfl

3

รหัสเครื่อง 80186+, รูปแบบ MS-DOS .COM, 822 787 ไบต์

เฉพาะแท็บและช่องว่างที่ใช้เพิ่มเติมจากตัวอักษร เนื่องจาก opcode ส่วนใหญ่ในช่วงที่อนุญาตคือการเพิ่มขึ้นลดลงผลักดันปรากฏและลงทะเบียนทางอ้อม AND และ ORs นอกเหนือจาก IMUL ฉันใช้ประโยชน์จากความจริงที่ว่า stack register ล้อมรอบเมื่อมันกระทบกับจุดจบ ของกลุ่มเพื่อแก้ไขรหัสในสิ่งที่ตรงกันข้าม! จำเป็นต้องมีการชุมนุม 80186+ เนื่องจากฉันกำลังผลักดันค่าทันที

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

แหล่งที่มาหมายเหตุประกอบ (รูปแบบ 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

นี่ไม่ใช่การประกอบนี่คือรหัสเครื่องจักร ...
Artelius

@Ateltel ยุติธรรมเพียงพอ ฉันอัพเดตรายละเอียดแล้ว
ErikF

3

Befunge-98 (FBBI) , 125 124 121 ไบต์

wab









And she said   But that s his












wakekekaayyeapwayyaayybyapayybyapcyabcyaayycayyba
a



b
wayapapoq

ลองออนไลน์! ส่งออกไปยังไฟล์ชื่อ\n(ขึ้นบรรทัดใหม่เดียว) ขอบคุณJo Kingสำหรับบทของเขา

เอาต์พุตประกอบด้วยบรรทัดใหม่ 10 บรรทัด

สำหรับการขึ้นบรรทัดใหม่เพียงหนึ่งบรรทัดให้+1 ไบต์โดยเปลี่ยนบรรทัดต่อไปนี้:

wakekekaayyeapwayydayybyapayybyapycyabcyaayycayyba

ลองออนไลน์!


คำอธิบาย:

ตัวชี้คำสั่งย้ายดังต่อไปนี้:เส้นทาง IP

โปรแกรมกำหนดให้อักขระที่ไม่ใช่ตัวอักษรอยู่ในตำแหน่งก่อนที่จะแสดงผลบรรทัดนั้นไปยังไฟล์

Befunge-98 มีคำแนะนำa... fซึ่งจะส่งค่าเลขฐานสิบหกที่สอดคล้องกันไปยังสแต็ก เพื่อสร้างตัวเลขอื่นมันจะส่งค่าเหล่านั้นไปที่y("Get SysInfo") เป็นอาร์กิวเมนต์เพื่อรับ:

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

23* stack size

โดยการวางโค้ดจำนวนมากที่ y = 23 ayyสามารถใช้สำหรับการเข้าถึงขนาดสแต็คซ้ำ ๆ ซึ่งจะถูกใช้เพื่อสร้างรหัสอักขระ


บรรทัดใหม่ต่อท้ายหนึ่งบรรทัดไม่ได้รับอนุญาตหรือ
Delioth

โพสต์ระบุ "ช่องว่างได้รับอนุญาตอย่างสมบูรณ์" ฉันคิดว่ามันดีที่จะใช้ถ้อยคำนี้เพื่อแสดงบรรทัดใหม่ที่ต่อท้าย!
Anatolyg

2

Pyth , 210 ไบต์

pChyCdpCyhyhlGpCyytlGpdpChFhTyylGpCyylGpChyytlGpdpChFhTyylGpCtytytlGpChyylGpCyytlGpCyyhTpdpCtyyTpCyhCdpCtFyyCdhTpCyhFlGCdpdpCyhFlGCdpCyylGpCtytytlGpCyhFlGCdpCtyyTpChFhTyylGpdpCyylGpChyylGpChFhTyylGpCyhyhTpCtyyT

ลองออนไลน์!

ฉันพบตัวเลขไม่กี่ตัวที่สามารถแสดงโดยใช้ตัวอักษรเท่านั้น (เช่นT= 10, Z= 0, lG= ความยาว (ตัวอักษร) = 26, Cd= charcode (ช่องว่าง) = 32) และฟังก์ชั่นบางอย่างที่สามารถทำได้โดยใช้ตัวอักษรเท่านั้น (เช่นt= decrement, h= increment, hF= แอปพลิเคชั่นของ increment = นอกจากนี้) จากนั้นเพียงแค่ค้นหาแรงเดรัจฉานเพื่อค้นหาชุดค่าผสมที่สั้นที่สุดของฟังก์ชันและตัวเลขเหล่านั้นที่ทำให้ตัวอักษรแต่ละตัวที่ฉันต้องการ


2

รหัสแอสเซมบลี x86 แบบ 16 บิต 665 ไบต์

(ไบนารีเป็นตัวอักษรไม่ใช่แหล่งที่มา)

ฉันลืมเกี่ยวกับกฎที่อนุญาตให้มีพื้นที่ว่าง แน่นอนรหัสสามารถ golfed เป็นผล

bytecode:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXsBFVKZPFFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXkLAFQQZJJJRkDCGPLXDPDJRkDBEPZJJRLZDRDZAAAQPLYDQDYXXDQhishZhDRDhZsDQDhaththRDhuthZBDQDRhidhsaRDhhehZsDRDhndhZADTZPiDEFY

ที่มา:

    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

มันทำงานด้วยวิธีนี้:

  • ย้ายตัวชี้สแต็กไปยังจุดสิ้นสุดของรหัสผ่าน POP AX (ไม่สามารถ POP SP ได้เนื่องจากไม่ใช่ตัวอักษร)

  • สร้างคำสั่งเพื่อส่งการเรียก DOS (อัลกอริธึมเนื่องจากไม่ใช่ตัวอักษร)

  • สร้างตัวละครที่ไม่ใช่ตัวอักษร;

  • วางสตริงบนสแต็ก

  • วางคำสั่งการแจกจ่ายในสแต็กที่จุดสิ้นสุดที่แน่นอนของรหัสเพื่อให้การดำเนินการไหลโดยตรงไปยังคำสั่งนั้น

  • สร้างคำสั่งให้พิมพ์สตริง

  • แสดงสตริงและพวกเขาล้มเหลวทันที : - / (ทางออกที่งดงามจะต้องใช้รหัสเพิ่มเติม)




0

รหัสเครื่อง 80186 + DOS, 91 ไบต์

รุ่นข้อความ:

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

เวอร์ชันข้อความที่มีแท็บ (รหัส 9) ถูกแทนที่ด้วย9และช่องว่าง (รหัส 32) แทนที่ด้วย*:

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

.comรหัสเครื่องจะปรากฏขึ้นในไฟล์ที่มีนามสกุล เมื่อฉันเรียกใช้มันจะพิมพ์ข้อความที่ต้องการแล้วจึงหยุด (เรียกใช้ข้อมูลแบบสุ่ม)

คำอธิบายระดับสูงเกี่ยวกับสิ่งที่ทำ:

  1. เริ่มต้นการลงทะเบียนด้วยค่าคงที่
  2. แทนที่ช่องว่างในข้อความด้วยสัญลักษณ์พิเศษที่ต้องการ ( ,'.$)
  3. แก้ไขรหัสเพื่อสร้างint 21คำสั่งซึ่งพิมพ์ข้อความ
  4. โทรหา DOS

รหัสการประกอบ (สามารถรวบรวมได้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

มันใช้popaคำสั่งเพื่อป๊อปอัพทะเบียนทั้งหมดเพราะปกติpopไม่สามารถกรอกลงทะเบียนที่จำเป็นทั้งหมด (เช่นpop diopcode ต้องห้าม)

ที่อยู่ของไบต์ที่จะแก้ไขอยู่ในช่วง 0x100 ... 0x160 โดยโชคพวกเขาสามารถแสดงเป็นผลรวมของ 3 ไบต์ด้วยค่าที่อนุญาต:

  • 0x7a ใน bp
  • 0x7a หรือ 0x67 ในsiหรือdi
  • มูลค่าทันที

การแพ็ตช์ไบต์ในข้อความจะทำงานโดยทำตรรกะORบน 0x20 (อักขระเว้นวรรค) และค่าคงที่ขนาดเล็ก (4, 7, 12 หรือ 14) ค่าคงที่ขนาดเล็กนั้นได้มาจากการเริ่มต้นcxและdxถึง 9 (อักขระแท็บ) และทำINCหรือDECตามที่ต้องการ

การปรับปรุงรหัสใช้IMULคำสั่ง ฉันพบค่าคงที่ 16 บิตที่ต้องการเพื่อเพิ่มจำนวนโดยใช้การค้นหาแบบ brute-force

ในที่สุดที่อยู่ของข้อความ (0x13b) จะได้รับจากการคูณ 0x96dเพื่อประหยัดพื้นที่ผมเอาหนึ่งของค่าคงที่จากหนึ่งในคำแนะนำที่มีค่าทันที นี่9เป็นส่วนหนึ่งเลือกฟังก์ชั่นการพิมพ์ DOS และ6dส่วนหนึ่งเป็นพารามิเตอร์ที่ฟรี ปรากฎว่า6dเป็นความเป็นไปได้เพียงอย่างเดียวที่สามารถให้ 0x13b หลังจากการคูณ

การถอดชิ้นส่วนรหัส:

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)

สนุกจริง: โดยปกติฉันจะใช้offset messageแทนรหัสตายตัว13bhแต่ในกรณีนี้เพราะไม่ทราบที่อยู่ของมันในขณะที่การแยกที่อยู่ Tasm สร้างออฟเซ็ต 16 บิตทันทีชดเชย 1 ไบต์เสีย:

06BA:0131 098A4600          OR      [BP+SI+0046],CX
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.