仅使用字母打印短语“她说,'但那是他的。'”


50

And she said, 'But that's his.'仅使用以下字符打印该短语:abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 不得使用标点符号或任何非字母字符。您可以使用所需的任何编程语言。完全允许使用空格。最短的程序获胜。


输出中的空白呢?(领先/追踪?)
attinat

2
达恩,我的esolang无法完成,因为没有能力只用来产生输出a-zA-Z。从理论上讲,我可以使用write和Eval来创建必要的指令,但是+-*,%'"如果不使用(至少)其中之一,则无法构造其中的任何一个+-*,%'"0-9
Draco18s

10
(programmer-of (language 'lisp))不喜欢这个。
MatthewRock

4
必须承认,起初我并不觉得这特别有趣,但是重复字符和独特字符的组合确实使优化变得很有趣(尤其是在堆栈语言上!)。非常好。
brhfl

1
您能否澄清输出中是否允许多余的空格?喜欢额外的尾随换行符吗?或源中仅包含空格,再加上字母字符。有一个Befunge答案,上面印有结尾的换行符。
彼得·科德斯

Answers:


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.我看你从字面上看。
本杰明·厄克特

3
你打败我了。尽管有很多东西可以打高尔夫球。:)您可以删除结尾的尾部NNN,因为在进行print_char之前的添加时,尾部已因错误而停止,因此甚至在Jump_to_Label之后也不会出现。另外,为什么还要63在开始时存储并在循环中进行检索?您可以在添加之前先推动它。而且,为什么是Label-nr TTSSSSTN?一个Label甚至可以是空的,因此当您仅使用一个Label时,仅NSSN创建标签并NSNN跳转到该标签就足够了。
凯文·克鲁伊森

1
318字节,其中包含我上面建议的更改。这是具有突出显示功能的相同程序。您如何扣除常数值63?我不确定100%是否是这里可能的最短常量。如果是的话,我为先前的挑战编写的常量生成程序出了点问题。:)
Kevin Cruijssen

1
是的,我是对的。常量102是最有效的:281个字节(或者在此处带有高亮显示)。(注:我也用一个副本保存4个字节之间的空间ehs dnA(从之间的空间复制dias ehs)。
凯文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

在线尝试!

说明:

$_默认情况下,正则表达式,打印和印章均适用于该变量。

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 chop。这将删除的最后一个字符$_,获取其键码,将其解释为八进制三次,然后将其转换回字符。例如,j→106→70→56→46→ .

由于替换的工作方式,$_在评估替换时所做的修改丢失了,$_现在也是如此And she said, 'But that's his.'GjGGf

y qGjfqqd

删除所有Gj以及f$_


26
不知道Perl,似乎您只是尝试输入句子,但是在此过程中与您的猫打了很多仗
popctrl

2
这可能是我在该网站上见过的最漂亮的代码,我以熟悉Perl的人的身份说。
Silvio Mayolo

1
相关,但可以更换printsay为-2个字符。当前的元共识说,命令行标记(例如)-M5.010不计入字节数。
Silvio Mayolo

34

> <> 916个 915 903字节

起初我以为>>中的解决方案是不可能的,但是后来我意识到...谁需要条件或逻辑控制?:D

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

在线尝试

我反复将数字(数字15)压入堆栈,然后压入堆栈的长度并用该ASCII值打印字符。如果我需要缩小栈的长度,我缩在堆栈使用在同一时间三个值p使用,或一次一个g,如果我有三个目标之内。该程序以调用i(输入)结束,-1由于没有输入,该操作会推送a ,然后打印它会导致错误。

一旦想到如何,这就是我用来创建解决方案的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,我也很感激生成程序……
Francesco

可以通过谨慎使用完全删除最后一部分p:在堆栈中从空间向上移动到sin 时创建一个59 said,然后将其放置在代码中,从下d到下,。(请注意,(15,15)此时有15。)
Nitrodon

实际上,您可以滥用lp在(10,10)-(15,15)矩形中放置几个​​有用的字符,然后g在更方便的位置检索它们。
Nitrodon

真是个好主意。以这种方式很难想到> <>。就像用BF编码
mbomb007

我发布了自己的答案:codegolf.stackexchange.com/a/186916/69059
Nitrodon

28

IBM PC上的8086汇编,1463 845 664字节

说明:实际的汇编语言源是条目,而不是生成的机器代码。

困难在于大多数x86指令(例如ADD,SUB,JMP,条件跳转,内存访问)具有两个参数,因此需要逗号或内存地址。因此,我们不能使用加法,减法,ifs或循环!

在我的第一次尝试中,我能够使用增量,减量,乘法,除法,字节提示和晦涩的BCD指令(如AAA,DAS)的组合来“构造”数字。之后,我意识到这个想法可以用来创建自我检查和自我修改的代码。

  • 尝试1.(1463字节)

    使用可用的指令来构造ASCII代码和屏幕缓冲区的0xb800地址。序列中每个角色的计算都是手工进行的。

  • 尝试2。(未完成)

    意识到对于0x40-0x5f范围内的每个整数都有一个操作码。此范围包括AZ。因此,例如INC CX对应于0x41 ='A'。(此操作码表非常方便。)

    我试图构造3个“数据”字符串,并将它们彼此层叠。第一个原样(大写),第二个“移位”到0x60-0x7f区域(小写),最后一个“移位”到0x20-0x3f区域(标点)。

    自修改代码将产生一个或三个循环来遍历数据。

  • 尝试3。(845字节)

    像以前的方法一样,但是为了减少数据,该字符串只能被编码一次,并且要混合“控制字符”来切换字符集。

  • 尝试4.(664字节)

    如何摆脱那些需要大量修补指令来处理分支的控制字符?假设仅使用两个大写字母,我想知道是否可以“翻转”操作码表以使用0x40-0x4f范围和使用0x90-0x9f范围(通过从0xc0减去)来标点编码。“ A”和“ B”可以分别放入。

    但是,在0x90-0x9f范围内只有一半的操作码可用,并且它们与所需的操作码不一致。然后我想也许我可以使用XOR将它们改组,然后发现一个可行的方法。在这里。

打高尔夫球:

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文件,它们从偏移量0x3e开始。Edit-Nvm发现了区别:注释版本中的117行为,INC AX而未注释版本为INC AL
gastropner

1
我想查看一个完全按字母顺序排列的二进制文件。:-)
彼得·费里

1
如果您愿意将NASM锁定为首选的汇编器,则可以通过label1 db自己行来创建标签。它将发出警告,但没有错误。
gastropner

1
@gastropner很好,这太容易了。:P不知道,谢谢!也许我应该将语言重命名为“您可以输入DEBUG.COM的内容”。顺便说一下,我曾经用来调试它。xD
Artelius

1
@PeterCordes现在这个是自我修改的!
阿特柳斯

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,但是我发现使用它们并不容易。

对于使用数字,我们有epitau; 在x或的右侧xx,它们是隐式铺地的。它们的字符串表示形式都有17个字符,因此我们使用e了最少的字符数。我们还有i(4个字符),False(5个字符)和NaN(3个字符)。我们可以将字符串长度乘以x; xx将一乘以字符串长度乘以右侧,再加一。chop如果我们离目标一个字符,则从字符串中删除一个字符。

print语句使用链接在一起and,优先级较低。它几乎是一个奇迹。否则,我们将不得不使用非法的分号。

我手工找到了人物的表情。以编程方式搜索它们以查找较短的表达式可能值得。



顺便说一句,@ JoKing,您是手动搜索较短的表达式还是使用某个程序提供帮助?
bb94

1
用手恐怕。一种算法方法可能不会太难
Jo King


@Grimy Clever,但不幸的是,只有这样,因为您使用的零宽度空间不是空格字符
Jo King

17

宽度66 64字节

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

在线尝试!

打印进行调试。要打印到标准输出,请追加ww到代码的末尾,这将弹出并输出堆栈的顶部。

说明

根据此表,在宽度中,每个字母都与一个数字相关联,具体取决于数字的“宽度” 。这将为每个字母分配一个从0到9的数字。然后,这些数字将用于实际执行代码。

特别是,字母比匹配7将以字符串文字开头。它将一次读取两个字母的集合,直到再次读取原始字母。每组两个字母将被转换为其宽度数字,读取为0到99之间的十进制数字,它们相等的字符将成为它们在以下字符串中的索引:

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

例如,索引!为1,因此01将为正确的宽度数字。因此,ifiIjt,等都会关联到一个字符串的!

在这种情况下,我使用Q引号将所需输出的31个字符转换为适当的字母。程序完成时,将打印堆栈顶部以进行调试。


这是最短的一个。我想你可以赢!
蓝鬃鹰

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*

十六进制转储:

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 imm8push imm16push imm32,然后pop生成常量。ah当推入一个字节(imm8)时,也会产生零(in )。
  • and [ecx+32], ah-假设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。目标字符串的所有字符代码都可以通过对这些整数的操作以堆栈顺序获得:例如,“ A”(ASCII 65)为89-(25&(20 + 6))。许多4元整数具有此属性。之所以选择该代码,是因为它们特别容易生成。

currentflat string dup rrand

Flat默认为1,因此这将创建一个长度为1的字符串(初始化为\0)。dup不是深层副本:它创建对同一字符串的第二个引用。rrand推送随机种子,默认为0。Stack现在为["\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

从前四个整数计算一个字符码,将其写入字符串的索引0,然后打印该字符串。

quit

禁止显示默认提示。


11

红宝石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在类定义主体中调用,可以打印以大写字母开头的单词。

通过定义具有该名称的方法可以显示其他单词,该方法返回Symbol,然后将其强制转换为String以删除前导冒号。

可以通过调用其他字符putc的ASCII代码来显示其他字符。我们可以通过重用String def技巧来获取字符串,然后使用由其大小确定的模量来获取其字节总和,从而生成适当的数字。不幸的是,除了从对象的类定义内部调用之外,我们没有任何其他方法可以调用该对象上的方法,这使传递参数变得困难。因此,最后的技巧是重新定义String#inspect,在将String传递给p方法时会隐式调用该方法,以便它在产生错误之前计算并输出适当的字符作为副作用,从而导致p实际上无法完成执行并打印新队。然后,我们需要挽救主代码中的错误。

编辑:Jordan通过一些巧妙的控制流高尔夫使字节数少了很多,而现在又增加了,我还raise用一个字母的不存在的方法调用替换了更多的字节,这引发了NameError。

编辑2:注意,将其print String提取到方法中后,仅将其与方法定义一起使用比使用类定义技巧便宜,因为允许对方法进行标题区分大小写。


美丽的....我不知道如何sum size获取和模的大小,但一切检查出来!
值墨水

我有点懒惰地说,它实际上是将字符串的大小作为sum方法的可选参数传入。
历史学家

11

> <> 233个 122字节

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

在线尝试!

起初为了解决mbomb的问题,但我发现了一个根本的转变,即节省了大量字节,因此我将其发布为我自己的答案。

通过重复将值推入堆栈,然后使用l来推压堆栈长度来生成非字母字符以输出。但是,这不需要立即输出:使用p,可以将该字符放在坐标都在10到15之间(包括10和15)之间的任何单元中,稍后使用检索g。同样,可以将字母字符放在初始源代码中并以这种方式读取:由于输入中最高的非字母字符代码为46(.),因此这意味着堆栈不需要推到高于存储所需的62位置输出的所有31个字符。

此外,将a v放置在第7列的代码中。当指令指针回绕并命中该指针时v,将go重复执行该序列以从推送的坐标中读取并输出相应的字符。最终,堆栈变为空,并g以错误终止程序。

代码的前7个字节在前7个和后7个坐标同时被重用。v从理论上讲,将第9列中的in 放置可以节省两个字节,但是Ainsv在代码中将这些字符强制为2x2正方形,这是不可能的。较早的版本使用第15列,但在源代码中需要额外的一行,并最终增加了6个字节。


经过进一步的思考,我认为我可以使第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名称空间包含许多高级数学运算,并且有许多预定义为有用数字的变量。

最后,我大量使用了平方根(mQmq),指数函数me和基转换(b),它们也可以用于模拟乘法([X 0] Yb计算X * Y)。另外,有时更容易构造大写代码点,在这种情况下,我们可以el对结果字符使用(转换为小写)。

我对某些更长的时间仍然不满意。那好吧。

说明

这是输出的逐个字符的说明。在开始之前,这里有一些简短的方法可以得出数字:

  • 0,1,2,3被包含在变量TXYZ分别。
  • 数字10到20包含在A到中的变量中K
  • 可以使用32来实现SciS将包含空格的字符串压入,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
你可以用数字基地转换通常范围的基础,比如外HYbYCtYbcHYbXAtYbcHYbXBtYbc
Nitrodon

7

死鱼〜,943字节

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

在线尝试!

不允许循环 :(


7

邪恶的 198字节

aeeeannkhhwzuuuuuueaeuekwuuuuuuuuuunkhwzaeeeeehknwgueeywguuuuuuhhknnwuuuwhgwpwnngheeuwguuuuuwngwzaeeeaaaeeeeeewhhgwnguuuueewnngawpaawuwnngwpawhgwhhgeeuwpawhguuuueewpwhgwhgwawpwnngaaaaaaeeeewguuuueew

在线尝试!

这很有趣。



6

MATL187个 158字节

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

在线尝试!

可读性更高的版本:在线尝试!手动尝试构建字符串。通过将细绳切成方便的小块,使用Ph翻转并构建细绳,可能有很多打高尔夫球的空间。我希望有人能够接受挑战以超越我。主要挑战是您不能使用+-,因此通常无法进行基本算术运算。

强调:

  • KQthpYq:第25(KQthp)个质数Yq是97,对应于字母a。字母s(115)类似地从第30个质数113生成。然后在剪贴板中广泛使用它J
  • his通过将hfrom之前的内容存储在剪贴板中来缩短J。由于先前已存储该文件shis因此我们进行了反向构建,因此我们仍然可以检索最近s使用的文件y,并在使用之后翻转它P
  • 路易斯·门多(Luis Mendo)节省了大量字节(主要是将更h改为vle

呵呵-我真的以为使用v会与h以前的方式搞混。猜猜我应该这样做,而不仅仅是假设。另外,感谢您的单挑,删除操作过分热心。我很好奇您是否能做得更好……
Sanchises

我想尝试,但必须等待。回答这个问题似乎需要很多时间!
Luis Mendo

1
@LuisMendo是的。花了我一个小时左右的时间,这只包括非常本地化的优化。我敢肯定,对事物有更多的全球视野可以做得更好。
桑契斯

我的尝试。我没看你的,所以方法可能有所不同
Luis Mendo

@LuisMendo我完全忘记了这U意味着^2,它可以为我节省很多字节……
Sanchises

6

MATL,118字节

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

在线尝试!

可读性更高的版本(每行对应一个字符,但堆栈重新排列操作除外)。

说明

该程序将所需字符的代码点作为独立数字产生。最后,所有这些数字都被连接到列向量中,重新整形为行向量,然后转换为字符。结果隐式显示。

使用的一些技巧:

  • 低于32的大多数代码点都显示为空格。因此0适用于大多数空格,因为它仅占用一个字节(O)。
  • 但是,对于第一个空格,15使用(生成为KUq),因为随后可以通过将其添加到100(char d)以给出115s)来重用。另一种情况5是将其用于空间(生成为KQ),因此以后可以从44,)中减去以得出39')。
  • 剪贴板J用于存储要重复的字符:首先s,然后是'。同样,剪贴板H存储100d对于生成其他字符很有用。
  • 广泛使用函数Q(加1),q(减1),E(乘以2)和U(平方)以及剪贴板I3)和K4)中的预定义文字。
  • 任意加法和减法是通过将向量串联起来h并计算其和(s)或连续差(d)来完成的。
  • 100d)生成为4二进制,并解释为十进制数。
  • 110n)是通过将65A)转换为字符串('65':代码点[54 53]),将其添加1到代码点([55 54]),将它们加在一起并相加而得到的1
  • 为了方便起见,有时会更改数字生成的顺序;然后通过堆栈重排函数对其进行重新排序:swap(w),冒泡b)。

1
非常好!巧妙地使用O代替KWE空格。您证实了我的怀疑,最好牺牲另一个剪贴板H
桑契斯

5

直流240个 222 209字节

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

在线尝试!

我的第一个想法与@seshoumara相同,只是将足够多的东西压入堆栈以生成所有字符的ASCII值。然后我想到,由于+-*是单字符运算符,因此我可以重新创建它们并具有使用算术的能力!肯定会更小!而且,如果我能够打出更多的字节,我也不会感到惊讶,但是就目前而言……这种复杂的方法已经成功地将幼稚的东西联系起来了。

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsd是该方法的一部分,类似于@seshoumara的方法,但我们最多只能使用46,即.。之所以这样做,是因为我们需要将值增加到45,-并且我们还需要在字符串中加上一个句点,因此(我认为)最短的时间是最便宜的。在此过程中,我们存储一些值:5、32、39稍后都将派上用场。5代表实用,32和39代表ASCII值。最初我做1-5,但是那很贵,我可以简单地避免使用4。Z在这些数字的三位数,两位数或一位数上使用(弹出一个值,将其拥有的位数推入)。在42,43,45,我们把这些为字符串(*+,和-分别),并将它们存储为宏(BA,和C分别)。这意味着无需使用字符*+-,我们现在可以使用这些运算符。

从这里开始,我们基本上开始使用数学的能力而不是纯粹的累加来生成ASCII值,并在此过程中存储一些重复。100、105和115足以显示它们(以寄存器或其他方式存储)是有意义的。最初,我将堆放满10s,然后用它们堆成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是输出基数,而不是寄存器;然后不得不改变KZ,以IZ产生1和OZ,以KZ产生2秒。

通过以32s充斥堆栈来减少13个字节;将精度设置为39;使用堆栈操作以避免存储116;删掉一些我不小心留下的双重工作。


+1好主意,可a用于重新创建这些运算符,然后使用调用它们x。这显示了dc的数据编码行为。有空的时候,我将运用您最新的技巧将数据存储到参数中,而不是寄存器中。如果我们幸运地仅使用十六进制输入所需的大量数字,您认为我们可以通过滥用P一次打印更多字母的方式来获得更短的dc解决方案吗?
seshoumara

@seshoumara有可能,尽管我尝试通过其他挑战来做到这一点表明,这不太可能仅仅是因为这些价值观迅速变大。为了获得前两个字母“ An”,我们需要输入P16750或0x416E。如果我们碰巧很幸运,并且其中一个子字符串仅由值AF组成,那么可能会为我们提供捷径。不过,那会有些运气!否则,我们要么以某种方式输入大量数字,以某种方式提出它们,要么进行大量的256乘加运算。这似乎比一堆Ps 更大。
brhfl

5

Japt,87字节

Bs g caA
HzG
Ts caV
iWisiiihiSisiUitiaihitiSitiuibu iUiSiWcaV idiiiaisiSieihisiSidiniau

试试吧

说明

第一行生成',并将其分配给variable U

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

第二行分配2给variable V

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

第三行生成.并将其分配给variable 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中不起作用,但在Red解释器中起作用。

红色控制台

说明:

这些单词很琐碎-我将它们(不带换行符的打印)作为原义带quote红色有一个内置的空格- sp,以及commadot"'更有趣的:我从减去空间首席他们BG分别从文字开始B,并G首先将它们转换为字符串mold,然后以字符(为了使用减法他们)wtih to sp红色具有通过原型转换-转换类型为的字符串sp(即字符)。


1
这个问题已经澄清。他们从中删除了有趣的部分。
anatolyg

@anatolyg谢谢,我仍然需要它',所以272字节的解决方案是相同的。
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重新定义为一个字母的单词,因为这将需要使用:and ;(例如: C CHAR ;)或'(例如' CHAR ALIAS C

实际上,如果我可以定义单词,那么我可以做: P CHAR EMIT ;然后做P xprint x。那好吧。

我什至无法创建缓冲区,将char序列写入该缓冲区,然后将其用作输入,因为写入内存需要使用!C!


3

的Alpha-Beta180个177 175 163字节

cccaaggtFgDILrFigggDLjDLCLigggggDLjhDLhhhDLCLiggggDLjjggDLihhDLhhhhhDLcaaCLdbbCLcbbbCLHgDLiiiiigDLhDLdaaaCLDLjhhDLjgggDLiihDLcbbbCLhDLdaaaCLjhDLgDLiDLcaaaaCLdaaaCL

在线尝试!

在制品


3

佩佩,266字节

我将r堆栈保持为空,并在R堆栈上放置's'

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

直流,240字节

主要思想是使堆栈连续增加1(K),并在与每个唯一的ASCII码匹配时sX将堆栈(z)的大小保存()到自定义寄存器中。P整个打印()。

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

在线尝试!

我做了一些优化,例如不保存字母(如果此后不使用的话),例如复制(d的字母,例如在堆栈上)t等字母以保存一个字节,因为调用(lX)是2个字节。


我想出了一个DC解决方案,它通过为+,-和*创建宏来使用算术。它是262个字节。我将不断尝试对其进行优化以提高竞争力,但我必须说,我感到失望的是,它比(相对)简单的解决方案要胖得多。
brhfl

@brhfl是的,dc非常详细。即使这样,我还是非常想看看您的解决方案,所以发布吧!同时,我也正在考虑要么更多地使用当前方法,使用程序,要么想出另一个有关dc的想法。
seshoumara

我成功并列240!如果我能够再打出一个或两个字节,我不会感到惊讶,但是……这是一种几乎没有收益的钝性方法。无论如何,我将其张贴在某处……
brhfl

我通过替换一些最普通的寄存器(包括输入/​​输出基数和精度)降至222。在存储中保存一个字节,在每次加载时保存一个字节...由于数字是无关紧要的,因此它不会影响任何内容...您也可以利用它来发挥自己的优势!
brhfl

3

80186+机器代码,MS-DOS格式.COM,822个 787字节

除字母外,仅使用制表符和空格。假定允许范围内的大多数操作码都是一定的增量,减量,压入,弹出以及寄存器间接AND和OR,除了IMUL之外,我利用了堆栈寄存器在末尾回绕的事实段的修改反向代码!需要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

@Artelius公平。我已经更新了说明。
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= length(alphabet)= 26,Cd= charcode(space)= 32),还有一些可以只用字母执行的功能(例如t=减量,h=增量,hF=重复应用增量=加法运算),然后进行蛮力搜索以找到那些函数和数字的最短组合,从而得出我需要的每个字母。


2

16位x86汇编代码,665字节

(二进制是字母,而不是源)

我以某种方式忘记了允许空格的规则。可以肯定的是,代码可以被打高尔夫。

字节码:

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***

十六进制转储:

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 di,禁止的操作码)。

要修补的字节地址在0x100 ... 0x160范围内。幸运的是,它们可以表示为具有允许值的3个字节的总和:

  • 0x7a英寸 bp
  • 0x7a或0x67 in sidi
  • 立即价值

通过OR对0x20(空格字符)和一个小的常数(4、7、12或14)进行逻辑运算,可以在消息中修补字节。小常数由初始化获得cxdx9(制表符),并做INCDEC根据需要。

代码修补使用IMUL指令。我发现需要使用蛮力搜索相乘的16位常量。

最后,通过乘法获得消息的地址(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
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.