वाक्यांश को प्रिंट करें "और उसने कहा, 'लेकिन यह उसका है।" "केवल वर्णमाला का उपयोग करके


50

And she said, 'But that's his.'केवल निम्नलिखित वर्णों का उपयोग करके वाक्यांश प्रिंट करें : abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ कोई विराम चिह्न या गैर-वर्णनात्मक वर्ण जो भी हो। आप जो भी प्रोग्रामिंग भाषा चाहते हैं उसका उपयोग कर सकते हैं। व्हॉट्सएप को पूरी तरह से अनुमति है। सबसे छोटा कार्यक्रम जीतता है।


आउटपुट में व्हाट्सएप के बारे में क्या? (अग्रणी / अनुगामी?)
अत्तिनत

2
डार, मेरा एसोलंग पूरा नहीं हो सकता क्योंकि केवल उत्पादन के साथ उत्पादन करने की कोई क्षमता नहीं है a-zA-Z। सिद्धांत रूप में मैं आवश्यक निर्देशों को बनाने के लिए wसंस्कार और Eघाटी का उपयोग कर सकता था , लेकिन +-*,%'"(कम से कम) एक का उपयोग किए बिना किसी का निर्माण नहीं किया जा सकता है +-*,%'"0-9
ड्रेको १18

10
(programmer-of (language 'lisp))यह नापसंद है।
मैथ्यूॉक

4
स्वीकार करना है, मुझे नहीं लगता कि यह पहली बार में विशेष रूप से दिलचस्प था, लेकिन दोहराया और अद्वितीय पात्रों के संयोजन ने वास्तव में इसे अनुकूलित करने के लिए कुछ मजेदार बना दिया (विशेष रूप से स्टैक भाषा पर!)। बहुत अच्छा।
ब्रूफ़ल

1
क्या आप स्पष्ट कर सकते हैं कि आउटपुट में अतिरिक्त व्हाट्सएप की अनुमति है? अतिरिक्त अनुगामी newlines की तरह? या स्रोत में केवल व्हाट्सएप , प्लस वर्णमाला वर्ण। एक Befunge उत्तर है जो अतिरिक्त ट्रेलिंग न्यूलाइन के साथ प्रिंट करता है।
पीटर कॉर्ड्स

जवाबों:


75

व्हॉट्सएप , 417 414 349 265 बाइट्स

265 बाइट्स केविन क्रूज़सेन की बदौलत

  							
  				   
   		 	
   		
   	 
  		   		 
 	  		
 	  		 
   			 
  		 	
   	 
 	  	 
 	  		 
 	  	
   				
  		  	  
  							
 	  	  
  				 	 
  		 
   		
  		 	
   		 	
 	  	 	
  		
   	 
 	  		
 	  		
  		 
   	   
  		  	 	

  
   		  		 
	   	
  
 


इसे ऑनलाइन आज़माएं!

व्याख्या की:

[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बाहर निकलने के लिए अनुगामी हटा सकते हैं , क्योंकि यह पहले से ही एक त्रुटि के साथ बंद हो जाता है जब आप प्रिंट_चार से पहले ऐड कर रहे होते हैं, तो यह जंप_टाउनबेल के बाद भी नहीं आएगा। इसके अलावा, 63शुरुआत में क्यों स्टोर करें और इसे लूप में पुनः प्राप्त करें? इसके बजाय आप इसे जोड़ने से पहले धक्का दे सकते हैं। और, लेबल-एनआर क्यों है TTSSSSTN? एक लेबल भी खाली हो सकता है, इसलिए केवल NSSNलेबल बनाने के लिए और लेबल NSNNपर कूदने के लिए पर्याप्त है जब आप केवल एक लेबल का उपयोग कर रहे हैं।
केविन क्रूज़सेन

1
मेरे द्वारा प्रस्तावित परिवर्तनों के साथ 318 बाइट्सयहाँ जोड़ा हाइलाइटिंग के साथ एक ही कार्यक्रम है। और आपने निरंतर मूल्य कैसे घटाया 63? मैं 100% निश्चित नहीं हूं कि यह यहां सबसे कम संभव है। यदि ऐसा है, तो मेरे निरंतर सृजन कार्यक्रम के साथ कुछ गलत है जो मैंने पहले की चुनौती के लिए लिखा था। :)
केविन क्रूज़सेन

1
हां, मैं सही था। लगातार 102सबसे कुशल है: 281 बाइट्स (या यहां हाइलाइटिंग के साथ )। (नोट: मैंने बीच की जगह के लिए 4 बाइट्स को बचाने के लिए एक कॉपी का उपयोग किया है ehs dnA( बीच की जगह से कॉपी किया गया है dias ehs)।
केविन क्रूज़सेन

3
ठीक है, अब मैं कर रहा हूँ। :) 265 बाइट्स (या यहां हाइलाइटिंग के साथ )। कुछ अतिरिक्त प्रतियां जोड़ी गईं। ( यहां प्रासंगिक
व्हॉट्सएप

62

पर्ल 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 chop। यह के अंतिम चरित्र को हटाता है $_, इसकी कीकोड लेता है, इसे अष्टाध्यायी के रूप में व्याख्या करता है, और इसे एक चरित्र में परिवर्तित करता है। उदाहरण के लिए, j→ 106 → 70 → 56 → 46 → .

प्रतिस्थापन के काम करने के तरीके के कारण, प्रतिस्थापन का $_मूल्यांकन करते समय होने वाले संशोधन खो जाते हैं, इसलिए $_अब यह है And she said, 'But that's his.'GjGGf

y qGjfqqd

सभी को नष्ट कर देता है G, jऔर fमें $_


26
पर्ल को न जानते हुए, ऐसा लगता है कि आपने केवल वाक्य टाइप करने की कोशिश की, लेकिन इस प्रक्रिया में आपकी बिल्ली के साथ कई झगड़े हुए
popctrl

2
यह कोड का सबसे सुंदर टुकड़ा हो सकता है, जिसे मैंने कभी इस वेबसाइट पर लिखा देखा है, और मैं कहता हूं कि किसी ऐसे व्यक्ति के रूप में जो पर्ल को जानता है।
सिल्वियो मेयोलो

1
संबंधित, लेकिन आप -2 पात्रों के printसाथ बदल सकते हैं say। वर्तमान मेटा सर्वसम्मति कहती है कि कमांड लाइन के झंडे -M5.010बाइट की गिनती की तरह नहीं हैं।
सिल्वियो मेयोलो

34

> <> , 916 915 903 बाइट्स

पहले तो मुझे लगा कि> <> में एक समाधान असंभव है, लेकिन तब मुझे एहसास हुआ ... किसे सशर्त या तर्क नियंत्रण की आवश्यकता है? : डी

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

इसे ऑनलाइन आज़माएं

मैं बार-बार संख्याओं (संख्या 15) को ढेर में धकेलता हूं, फिर ढेर की लंबाई को धक्का देता हूं और उस ASCII मान के साथ चरित्र को प्रिंट करता हूं। यदि मुझे स्टैक की लंबाई को सिकोड़ने की आवश्यकता है, तो मैं एक बार में तीन मानों का उपयोग करके pया एक बार gलक्ष्य के तीन के भीतर होने पर स्टैक को सिकोड़ता हूं। प्रोग्राम कॉलिंग i(इनपुट) द्वारा समाप्त होता है , जो तब से धक्का देता है -1जब कोई इनपुट नहीं होता है, तो यह एक त्रुटि का कारण बनता है।

यह पायथन 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 अंक हैं।)
नाइट्रोडॉन

असल में, आप का दुरुपयोग कर सकते हैं lऔर p(10,10) में कई उपयोगी पात्रों डाल करने के लिए - साथ (15,15) आयत, तो पुनः प्राप्त उन्हें gजहां इसकी और अधिक सुविधाजनक।
नाइट्रोडॉन

यह वास्तव में एक अच्छा विचार है। इस तरह से सोचना मुश्किल है> <>। यह BF के साथ कोडिंग की तरह है
mbomb007

मैंने अपना जवाब पोस्ट किया: codegolf.stackexchange.com/a/186916/69059
नाइट्रोडन

28

आईबीएम पीसी पर 8086 विधानसभा, 1463 845 664 बाइट्स

स्पष्टीकरण: वास्तविक असेंबली भाषा स्रोत प्रविष्टि है, न कि उत्पन्न मशीन कोड।

कठिनाई यह है कि अधिकांश x86 निर्देशों (जैसे कि ADD, SUB, JMP, सशर्त कूदता है, मेमोरी एक्सेस) के दो तर्क हैं और इस तरह अल्पविराम की आवश्यकता होती है, या स्मृति पते की आवश्यकता होती है। इसलिए, हम इसके अलावा, घटाव, ifs, या लूप का उपयोग नहीं कर सकते हैं!

अपने पहले प्रयास के दौरान मैं वेतन वृद्धि, वेतन वृद्धि, गुणा, भाग, बाइट-ट्रिक्स और अस्पष्ट बीसीडी निर्देशों (जैसे AAA, DAS) के संयोजन का उपयोग करके "निर्माण" करने में सक्षम था। उसके बाद, मुझे एहसास हुआ कि इस विचार का उपयोग आत्म-निरीक्षण और आत्म-संशोधन कोड बनाने के लिए किया जा सकता है।

  • प्रयास 1. (1463 बाइट्स)

    एएससीआईआई कोड और स्क्रीन बफर के 0xb800 पते के निर्माण के लिए उपलब्ध निर्देशों का उपयोग किया। अनुक्रम में प्रत्येक वर्ण की गणना हाथ से गढ़ी गई थी।

  • प्रयास किया गया 2. पूरा नहीं ()

    एहसास हुआ कि 0x40-0x5f रेंज में हर पूर्णांक के लिए एक ओपकोड है। इस श्रेणी में AZ शामिल हैं। इसलिए उदाहरण के लिए INC CX 0x41 = 'A' से मेल खाता है। (यह ओपकोड तालिका बहुत उपयोगी है।)

    मैंने 3 "डेटा" स्ट्रिंग्स के निर्माण का प्रयास किया, और उन्हें एक दूसरे के ऊपर परत किया। पहला जैसा है (अपरकेस), दूसरा "0x60-0x7f ज़ोन (लोअरकेस) में" शिफ्ट "और आखिरी" शिफ्ट "0x20-0x3f ज़ोन (विराम चिह्न) में।

    स्व-संशोधित कोड डेटा पर पुनरावृत्ति करने के लिए एक लूप या तीन का उत्पादन करेगा।

  • प्रयास 3. (845 बाइट्स)

    पिछले दृष्टिकोण की तरह लेकिन डेटा में कटौती करने के लिए, स्ट्रिंग को केवल एक बार एन्कोड किया जाएगा, जिसमें कैरेक्टर सेट को स्विच करने के लिए "कंट्रोल कैरेक्टर" मिलाया जाएगा।

  • प्रयास 4. (664 बाइट्स)

    नियंत्रण पात्रों से छुटकारा पाने के लिए कैसे ब्रांचिंग से निपटने के लिए पूरे ढेर सारे निर्देशों की आवश्यकता होती है? यह देखते हुए कि केवल दो अपरकेस अक्षरों का उपयोग किया जाता है, मुझे आश्चर्य हुआ कि क्या मैं 0x40-0x4f रेंज और 0x90-0x9f रेंज (0xc0 से घटाकर) का उपयोग करके विराम चिह्न को एनकोड करने के लिए opcode तालिका को "फ्लिप" कर सकता हूं। "ए" और "बी" अलग से डाल सकते हैं।

    हालाँकि 0x90-0x9f रेंज में केवल आधे opcodes उपयोग करने योग्य हैं और वे आवश्यक लोगों के साथ लाइन में नहीं थे। तब मुझे लगा कि शायद मैं एक XOR का उपयोग करके उन्हें फेरबदल कर सकता हूं, और मुझे एक काम मिला। और यहाँ यह है।

golfed:

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

के साथ इकट्ठा

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 से होती है। संपादित करें - एनवीएम में अंतर पाया गया: टिप्पणी की गई संस्करण में लाइन 117 है, INC AXजबकि अधूरा है INC AL
गैस्ट्रोपनर

1
मैं इसके बजाय एक पूरी तरह से अल्फाबेटिक बाइनरी देखना चाहता हूं। :-)
पीटर फेर्री

1
यदि आप एनएएसएम को पसंद के कोडांतरक के रूप में बंद कर रहे हैं, तो आप label1 dbअपनी स्वयं की लाइन पर लेबल बना सकते हैं । यह एक चेतावनी देगा, लेकिन कोई त्रुटि नहीं।
गैस्ट्रोपनर

1
@gastropner अच्छी तरह से जो इसे बहुत आसान बना देगा। : पी उस के बारे में पता नहीं था, धन्यवाद! हो सकता है कि मुझे अपनी भाषा का नाम बदलकर "कुछ आप DEBUG.COM में फीड कर सकते हैं" के रूप में करना चाहिए। किस संयोग से मैं इस पर बहस करता था। xD
आर्टिलियस

1
@PeterCordes अब यह स्व-संशोधन है!
आर्टिलियस

23

पर्ल 6 , 1299 1272 1220 1215 बाइट्स

-27 बाइट्स के लिए ग्रिमी के लिए धन्यवाद।

-52 बाइट्स क्योंकि हमें पहले स्थान पर खरगोश के कानों की आवश्यकता नहीं थी।

-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को a से बदलें print। तुम भी रिक्त स्थान के साथ स्रोत में newlines बदल सकते हैं।

व्याख्या

यह कोड वर्ण द्वारा स्ट्रिंग वर्ण को प्रिंट करता है। प्रत्येक वर्ण chrफ़ंक्शन में उपयुक्त वर्ण कोड खिलाकर और lcयदि आवश्यक हो तो इसे कम करके बनाया जाता है।

वर्तमान में, सभी मान इसमें सही वर्णों की एक स्ट्रिंग उत्पन्न करके उत्पन्न होते हैं; कुछ मामलों में, वर्णों की संख्या लक्ष्य वर्ण कोड का उल्टा है। गणितीय कार्यों जैसे कि logऔर expसीधे उपयोग करना सैद्धांतिक रूप से संभव होना चाहिए , लेकिन मुझे उन का उपयोग करना बहुत आसान नहीं लगा।

संख्या के रूप में उपयोग के लिए, हमारे पास e, piऔर tau; के सही पक्ष में xया xx, वे परोक्ष फिदा कर रहे हैं। उनके स्ट्रिंग प्रतिनिधित्व में सभी 17 वर्ण हैं, इसलिए हम eन्यूनतम वर्ण गणना के लिए उपयोग करते हैं। हमारे पास i(4 वर्ण), False(5 वर्ण) और NaN(3 वर्ण) भी हैं। हम स्ट्रिंग की लंबाई के साथ गुणा कर सकते हैं x; xxदाएं हाथ की ओर से एक से अधिक लंबाई गुणा और एक जोड़ता है। chopयदि हम लक्ष्य से एक दूर हैं, तो स्ट्रिंग से एक वर्ण निकाल देता है।

प्रिंट स्टेटमेंट का उपयोग करके एक साथ जंजीर लगाई जाती है and, जिसमें काफी कम पूर्वता होती है। यह लगभग एक चमत्कार है जो मौजूद है; अन्यथा, हमें अवैध अर्धविरामों का उपयोग करना होगा।

मुझे हाथ से पात्रों के लिए भाव मिले। यह छोटे भावों को खोजने के लिए प्रोग्रामेटिक रूप से उन्हें खोजने लायक हो सकता है।



वैसे, @JoKing, क्या आपने हाथ से छोटी अभिव्यक्तियों की खोज की या आपने मदद करने के लिए किसी प्रोग्राम का उपयोग किया?
बीबी94

1
हाथ से मुझे डर लगता है। एक एल्गोरिथम तरीका शायद बहुत कठिन नहीं होगा
जो किंग


@ जिमी चालाक, लेकिन दुर्भाग्य से केवल संभव है क्योंकि शून्य चौड़ाई अंतरिक्ष आप उपयोग कर रहे हैं एक व्हाट्सएप चरित्र नहीं है
जो किंग

17

चौड़ाई , 66 64 बाइट्स

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

इसे ऑनलाइन आज़माएं!

डीबग करने के लिए प्रिंट। स्टडआउट में प्रिंट करने के लिए, wwकोड के अंत में संलग्न करें, जो स्टैक के शीर्ष पर पॉप और आउटपुट करता है।

व्याख्या

चौड़ाई में, प्रत्येक अक्षर एक संख्या से संबंधित है, जो इस तालिका के अनुसार "व्यापक" है, इसके आधार पर । यह प्रत्येक अक्षर को 0 से 9 तक एक संख्या प्रदान करता है। फिर, उन संख्याओं का उपयोग वास्तव में कोड निष्पादित करने के लिए किया जाता है।

विशेष रूप से, मैचों की तुलना में एक पत्र 7एक स्ट्रिंग शाब्दिक शुरू करेगा। यह दो अक्षरों के सेट को एक बार में पढ़ेगा, जब तक कि वह मूल पत्र को फिर से नहीं पढ़ता। दो अक्षरों के प्रत्येक सेट को उनकी चौड़ाई संख्या में बदल दिया जाएगा, 0 और 99 के बीच एक दशमलव संख्या के रूप में पढ़ा जाता है, और उनके बराबर वर्ण निम्न स्ट्रिंग में उनका सूचकांक होगा:

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

उदाहरण के लिए, का सूचकांक !1 है, इसलिए 01सही चौड़ाई संख्या होगी। इस प्रकार, if, iI, jt, आदि सब एक स्ट्रिंग का शाब्दिक से सहसम्बन्धित हो जाएगा !

इस मामले में, मैंने 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*

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 में एक नॉन-ब्रेकिंग स्पेस से मेल खाती है। नियमों पर थोड़ा खिंचाव, लेकिन अन्यथा मुझे लगता है कि यह कार्य असंभव है ...

असेंबली सोर्स कोड, सी प्रोग्राम के साथ मिलकर जो इसे चलाता है (विजुअल स्टूडियो सिंटैक्स का उपयोग करता है):

#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सामान बाहर फैक्टर किया जा सकता है।
कोडी ग्रे

आपका प्रयास करने के लिए स्वागत है। यह सबसे अच्छा मैं कर सकता है; मुझे एक अलग दृष्टिकोण देखकर खुशी होगी। मैंने छोरों के विचार को छोड़ने का फैसला किया जब मैंने देखा कि उन्हें एक नकारात्मक कूद ऑफसेट की आवश्यकता है। शायद इस प्रतिबंध को रचनात्मक तरीके से हल किया जा सकता है - मुझे नहीं पता कि कैसे।
अनातोली

1
@anatolyg यह नीचे आ सकता है कि आत्म-संशोधन कोड पर आपके परीक्षण वातावरण का क्या रुख है। या स्टैक पर आपके द्वारा बनाए गए कोड को निष्पादित करने पर इसकी राय।
गैस्ट्रोपनर

क्या 0xff"कोई विराम चिह्न या गैर-वर्णनात्मक वर्ण" का उल्लंघन नहीं करता है ?
वैल


13

पोस्टस्क्रिप्ट, 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। लक्ष्य स्ट्रिंग के सभी चार्ट उन पूर्णांकों पर संचालन के साथ प्राप्त किए जा सकते हैं, स्टैक क्रम में: उदाहरण के लिए, 'ए' (एएससीआईआई 65) 89 है - (25 & (20 + 6))। पूर्णांक के कई 4-टुपल्स में यह संपत्ति है; यह इसलिए चुना गया क्योंकि वे विशेष रूप से उत्पन्न करने में आसान हैं।

currentflat string dup rrand

फ्लैट 1 के लिए चूक, इसलिए यह लंबाई 1 (आरंभिक \0) की एक स्ट्रिंग बनाता है । dupएक गहरी प्रतिलिपि नहीं है: यह उसी स्ट्रिंग के लिए दूसरा संदर्भ बनाता है। रैंड यादृच्छिक बीज को धक्का देता है, जो कि 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

शीर्ष चार पूर्णांकों से एक चारकोड की गणना करें, इसे स्ट्रिंग के सूचकांक 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वर्ग परिभाषा निकाय के भीतर कॉल करके मुद्रित किया जा सकता है।

अन्य शब्दों को उस नाम के साथ तरीकों को परिभाषित करके प्रदर्शित किया जा सकता है, जो एक प्रतीक देता है, फिर अग्रणी बृहदान्त्र को हटाने के लिए एक स्ट्रिंग पर कास्टिंग करता है।

अन्य पात्रों putcको उनके ASCII कोड पर कॉल करके प्रदर्शित किया जा सकता है । हम String defएक स्ट्रिंग प्राप्त करने के लिए चाल का पुन: उपयोग करके उचित संख्याओं को उत्पन्न कर सकते हैं , फिर इसके आकार द्वारा निर्धारित मापांक का उपयोग करके इसकी बाइट्स की राशि ले सकते हैं । दुर्भाग्यवश, हमारे पास उस ऑब्जेक्ट की वर्ग परिभाषा के भीतर से किसी ऑब्जेक्ट पर कॉल करने का कोई तरीका नहीं है, जिससे तर्क में पारित करना मुश्किल हो जाता है। इसलिए अंतिम हैक को फिर से परिभाषित करना है String#inspect, जिसे स्ट्रींग को pविधि में पास करते समय अंतर्निहित रूप से कहा जाता है , ताकि यह त्रुटि को उठाने से पहले एक उचित प्रभाव के रूप में उपयुक्त चरित्र की गणना और आउटपुट करता है, ताकि pवास्तव में निष्पादन समाप्त न हो और प्रिंट हो सके नई पंक्ति। फिर हमें मुख्य कोड में त्रुटि को बचाने की आवश्यकता है।

संपादित करें: जॉर्डन ने बाइट की गिनती बहुत कम की, अहम, कुछ चतुर नियंत्रण प्रवाह गोल्फिंग के साथ उच्च, और मैंने raiseएक-अक्षर के साथ कोई भी गैर-कॉल विधि द्वारा प्रतिस्थापित करके कुछ और बाइट्स काट दिया है , जो NameError को बढ़ाता है।

संपादित करें 2: ध्यान दिया जाता है कि print Stringएक विधि में निकाले जाने के साथ , यह केवल क्लास डेफिनिशन ट्रिक का उपयोग करने की तुलना में विधि परिभाषा के साथ उपयोग करने के लिए सस्ता है, क्योंकि विधियों को शीर्षक आवरण होने की अनुमति है।


सुंदर .... मुझे समझ में नहीं आता कि sum sizeयोग का आकार कैसे बदल जाता है, लेकिन बाकी सब कुछ जांचता है!
मान स्याही

मैंने कहा कि थोड़ा सा आलसी, यह वास्तव में स्ट्रिंग के आकार में गुजर रहा है जो कि सम विधि के वैकल्पिक तर्क के रूप में है ।
हिस्टोक्रेट

11

> <> , 233 122 बाइट्स

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

इसे ऑनलाइन आज़माएं!

यह एमबॉम्ब के उत्तर के एक गोल्फ के रूप में शुरू हुआ , लेकिन मैंने एक मौलिक पारी की खोज की जो बड़ी संख्या में बाइट्स को बचाता है, इसलिए मैं इसे अपने स्वयं के उत्तर के रूप में पोस्ट कर रहा हूं।

आउटपुट के लिए गैर-अल्फाबेटिक वर्णों को उत्पन्न lकरना स्टैक की लंबाई को पुश करने के लिए बार-बार मानों को धक्का देकर किया जाता है । हालांकि, इसे तुरंत आउटपुट करने की आवश्यकता नहीं है: उपयोग करते हुए p, इस चरित्र को किसी भी सेल में रखा जा सकता है, जिनके निर्देशांक 10 और 15 समावेशी दोनों के बीच हैं, जिन्हें बाद में पुनः प्राप्त किया जा सकता है g। इसी तरह, वर्णमाला वर्णों को प्रारंभिक स्रोत कोड में रखा जा सकता है और इस तरह से पढ़ा जा सकता है: चूंकि इनपुट में उच्चतम गैर-अल्फाबेटिक वर्ण कोड 46 ( .) है, इसका मतलब है कि स्टैक को स्टोर करने के लिए आवश्यक 62 से अधिक धकेलने की आवश्यकता नहीं है। आउटपुट के सभी 31 वर्ण।

इसके अतिरिक्त, vकॉलम 7. को कोड में रखा गया है। जब निर्देश सूचक चारों ओर घूमता है और हिट करता है v, तो अनुक्रम goको धक्का दिए गए निर्देशांक से पढ़ने और संबंधित वर्णों को आउटपुट करने के लिए बार-बार निष्पादित किया जाता है। आखिरकार, स्टैक खाली हो जाता है, और gप्रोग्राम को एक त्रुटि के साथ समाप्त करता है।

कोड के पहले 7 बाइट्स का पुन: उपयोग किया जाता है क्योंकि पहले 7 और अंतिम 7 निर्देशांक दोनों को धक्का दिया गया था। vकॉलम 9 में रखने से सैद्धांतिक रूप से दो और बाइट्स बच जाते, लेकिन Ainsvकोड में वर्णों को 2x2 वर्ग में मजबूर कर दिया होता , जो कि असंभव है। पहले के संस्करण में कॉलम 15 का उपयोग किया गया था, लेकिन इसके लिए स्रोत कोड में एक अतिरिक्त लाइन की आवश्यकता थी और छह बाइट्स लंबे समय तक समाप्त हो गए।


आगे के विचार के बाद, मुझे लगता है कि मैं rजहां चाहूं वहां संरेखण को स्थानांतरित करने के लिए एक बाइट खर्च करके कॉलम 9 का काम कर सकता हूं। हालांकि, इस कार्यक्रम को गोल्फ करने से मेरे दिमाग को थोड़ा दर्द होता है।
नाइट्रोडॉन

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एक्स * वाई की गणना) करने के लिए भी किया जा सकता है । इसके अलावा, कभी-कभी अपरकेस कोडपॉइंट का निर्माण करना आसान होता है, जिस स्थिति में हम elपरिणामी चरित्र पर (लोअरकेस में कन्वर्ट) का उपयोग कर सकते हैं ।

मैं अब भी कुछ लोगों से संतुष्ट नहीं हूँ। ओह अच्छा।

व्याख्या

यह आउटपुट का चरित्र-दर-वर्ण स्पष्टीकरण है। शुरू करने से पहले, मैं संख्या बनाने के लिए कुछ छोटे तरीके बता रहा हूँ:

  • 0, 1, 2, 3 चर में शामिल हैं T, X, Y, Zक्रमशः।
  • 20 के माध्यम से नंबर 10 चर में निहित हैं Aके माध्यम से K
  • 32 का उपयोग करके बनाया जा सकता है Sci( Sएक स्ट्रिंग को शामिल करता है, जिसमें एक स्पेस होता है, cइस स्ट्रिंग का पहला कैरेक्टर मिलता है, और iउस कैरेक्टर को उसके कोड पॉइंट में कनवर्ट करता है)। Sका उपयोग रिक्त स्थान के लिए भी किया जाता है।
  • 4 द्वारा दिया जाता है GmQ(16 का पूर्णांक वर्गमूल)।
  • 5 द्वारा दिया जाता है AZbYb(10 को आधार 3 में बदलें [1 0 1], उपज , और परिणामी संख्या को आधार 2 में परिवर्तित करें, 5 उपज)।
  • 7 द्वारा दिया गया है Ymei(गणना ऍक्स्प (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
नाइट्रोडॉन

7

डेडफिश ~ , 943 बाइट्स

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

इसे ऑनलाइन आज़माएं!

कोई छोरों की अनुमति नहीं है :(




6

MATL , 187 158 बाइट्स

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

इसे ऑनलाइन आज़माएं!

अधिक पठनीय संस्करण: इसे ऑनलाइन आज़माएं! स्ट्रिंग के निर्माण में मैनुअल प्रयास। सुविधाजनक चनों में स्ट्रिंग को काटकर, उपयोग करके Pऔर hएक स्ट्रिंग बनाने और बनाने के लिए गोल्फ के लिए बहुत जगह है । मुझे उम्मीद है कि कोई मुझे चुनौती देने की कोशिश करेगा। मुख्य चुनौती यह है कि आप उपयोग नहीं कर सकते +या -, इसलिए मूल अंकगणित अक्सर संभव नहीं है।

मुख्य विशेषताएं:

  • KQthpYq: 25 वाँ ( KQthp) अभाज्य Yq97 है, अक्षर के अनुरूप a। अक्षर s(115) 30 वें अभाज्य संख्या 113 से समान रूप से उत्पन्न होता है। यह तब क्लिपबोर्ड में बड़े पैमाने पर फिर से उपयोग किया जाता है J
  • hishक्लिपबोर्ड में पहले से स्टोर करके छोटा किया गया है J। चूंकि वह पहले संग्रहीत था s, हम hisरिवर्स में निर्माण करते हैं इसलिए हम अभी भी हाल के sउपयोग को पुनः प्राप्त कर सकते हैं y, और उपयोग करने के बाद इसे फ्लिप कर सकते हैं P
  • बाइट्स की एक बड़ी संख्या लुइस Mendo के लिए धन्यवाद बचाया (ज्यादातर के एक झुंड को बदलने के द्वारा hकरने के लिए vle)

हुह - मैं वास्तव में सोचा था vकि hमैं पहले था के साथ खिलवाड़ करेंगे । मुझे लगता है कि सिर्फ संभालने के बजाय होना चाहिए। इसके अलावा, हेड-अप के लिए धन्यवाद, अति हर्षजनक विलोपन हुआ। मैं यह देखने के लिए उत्सुक हूं कि क्या आप इससे बेहतर कर सकते हैं ...
Sanchises

मैं कोशिश करना चाहूंगा, लेकिन इसके लिए इंतजार करना होगा। इसका उत्तर देते हुए बहुत समय लगता है!
लुइस मेंडो

1
@LuisMendo युप। इसे बनाने के लिए मुझे एक घंटे का समय दिया गया, और इसमें केवल बहुत स्थानीय अनुकूलन शामिल हैं। मुझे यकीन है कि कोई चीज़ों पर वैश्विक नज़र से थोड़ा और बेहतर कर सकता है।
संभल

मेरा प्रयास । मैं तुम्हारी तरफ नहीं देखा, इसलिए दृष्टिकोण उम्मीद से अलग हैं
लुइस मेंडो

@LuisMendo मैं पूरी तरह से भूल गया कि Uइसका मतलब है ^2, कि मुझे काफी कुछ बाइट्स बचा सकता है ...
Sanchises

6

MATL , 118 बाइट्स

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

इसे ऑनलाइन आज़माएं!

अधिक पठनीय संस्करण (प्रत्येक पंक्ति एक चरित्र से मेल खाती है, स्टैक-पुनर्व्यवस्थित संचालन को छोड़कर)।

व्याख्या

कार्यक्रम स्वतंत्र वर्णों के रूप में आवश्यक वर्णों के कोड बिंदुओं का उत्पादन करता है। अंत में उन सभी नंबरों को एक कॉलम वेक्टर में बदल दिया जाता है, एक पंक्ति वेक्टर के रूप में आकार दिया जाता है, और वर्णों में परिवर्तित किया जाता है। परिणाम स्पष्ट रूप से प्रदर्शित होता है।

उपयोग किए गए कुछ ट्रिक्स:

  • 32 से नीचे के अधिकांश कोड बिंदु अंतरिक्ष के रूप में प्रदर्शित किए जाते हैं। इसलिए 0अधिकांश स्थानों के लिए उपयोग किया जाता है, क्योंकि यह केवल एक बाइट ( O) खर्च करता है ।
  • पहली जगह के लिए, हालांकि, 15इसका उपयोग (के रूप में उत्पन्न KUq) किया जाता है , क्योंकि इसे 100(( 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
  • जिस क्रम में नंबर उत्पन्न होते हैं, उसे कभी-कभी सुविधा के लिए बदल दिया जाता है; और फिर उन्हें स्टैक-रीक्रेंजिंग फ़ंक्शन द्वारा स्वैप किया जाता है: स्वैप ( w), बबल अप b)।

1
बहुत अच्छा! रिक्त स्थान के Oबजाय चतुर स्पर्श का उपयोग करना KWE। और आपने मेरे संदेह की पुष्टि की कि शायद एक और क्लिपबोर्ड का त्याग करना बेहतर है H
संभल

5

डीसी , 240 222 209 बाइट्स

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

इसे ऑनलाइन आज़माएं!

मेरा पहला विचार @seshoumara के समान था, बस सभी पात्रों के ASCII मूल्यों को उत्पन्न करने के लिए स्टैक पर पर्याप्त सामान धक्का दें। तो यह मेरे लिए हुआ है कि के बाद से +, -और *एकल चरित्र ऑपरेटर हैं, मैं सिर्फ उन्हें फिर से और गणित का उपयोग करने की क्षमता है सकते हैं! निश्चित रूप से यह छोटा होगा! और, मुझे आश्चर्य नहीं होगा यदि मैं किसी भी अधिक बाइट को बंद करने में सक्षम हूं, लेकिन अभी के लिए ... इस दृढ़ दृष्टिकोण ने भोले (ईश) को बांधने में कामयाबी हासिल की है।

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdदृष्टिकोण का हिस्सा है जो @ seshoumara के समान है, लेकिन हम केवल 46 तक जाते हैं, जो है .। हम ऐसा इसलिए करते हैं क्योंकि हमें 45 तक जाने की आवश्यकता होती है -, और हमें अपनी स्ट्रिंग में भी एक अवधि की आवश्यकता होती है, इसलिए केवल एक अवधि के लिए आगे जाना (मुझे लगता है) सबसे सस्ता है। रास्ते के साथ, हम कुछ मूल्यों को संग्रहीत करते हैं: 5, 32, 39 सभी बाद में काम में आते हैं। उपयोगितावादी चीजों के लिए 5, उनके ASCII मूल्यों के लिए 32 और 39। मूल रूप से मैंने 1-5 किया था, लेकिन यह महंगा था, और मैं केवल 4 का उपयोग करने से बचने में सक्षम था; Zउन मानों के लिए तीन-, दो- या एक-अंकों की संख्या पर उपयोग (एक मान पॉप करें , उसके पास अंकों की संख्या को धक्का दें)। 42, 43, और 45 में, हम तार करने के लिए इन कन्वर्ट ( *, +, और -क्रमशः) और (मैक्रो के रूप में उन्हें स्टोर B, AऔरCक्रमशः)। इसका मतलब है कि पात्रों का उपयोग किए बिना *+-, हम अब उन ऑपरेटरों का उपयोग कर सकते हैं।

यहां से हम मूल रूप से सरासर संचय के बजाय गणित की शक्ति का उपयोग करके एएससीआईआई मूल्यों को उत्पन्न करना शुरू करते हैं, रास्ते में कुछ दोहराते हैं। 100, 105 और 115 पर्याप्त हैं जो उन्हें (रजिस्टरों में या अन्यथा) संग्रहीत करते हैं। मूल रूप से, मैंने 10s से भरे हुए स्टैक को छोड़ दिया और 100s बनाने के लिए इनका उपयोग किया; यह 32 के साथ स्टैक को भरने और बाद में रिक्त स्थान के रूप में उन का उपयोग करने के लिए बाइट्स की बचत को समाप्त करता है। 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; फिर 1s उत्पन्न करने के लिए और 2s उत्पन्न KZकरने के लिए बदलना पड़ा ।IZOZKZ

32 के साथ स्टैक को बाढ़ करके 13 और बाइट्स को बंद कर दिया; 39 को सटीक सेट करना; 116 से बचने के लिए स्टैक हेरफेर का उपयोग करना; कुछ दोहरे काम काटने से मैं गलती से अंदर चला गया।


+1 अच्छा विचार aउन ऑपरेटरों को फिर से बनाने के लिए उपयोग करने के लिए, फिर उन्हें कॉल करने के लिए x। यह dc का डेटा-ए-कोड व्यवहार दिखाता है। जब मेरे पास समय होगा तो मैं आपके नवीनतम डेटा को रजिस्टरों के बजाय मापदंडों में संग्रहीत करने की नवीनतम चाल लागू करूँगा। क्या आपको लगता है कि जिस तरह से हम एक ही समय में केवल हेक्स का उपयोग करके आवश्यक विशाल संख्या में इनपुट करने के लिए भाग्यशाली हैं, तो पी जिस तरह से अधिक पत्र मुद्रित करने के लिए काम करता है, हम एक और भी छोटा डीसी समाधान प्राप्त कर सकते हैं?
शेषमारा

@ शीशमौरा यह संभव है, हालांकि अन्य चुनौतियों के साथ करने के मेरे प्रयासों से पता चलता है कि यह केवल इसलिए संभव नहीं है क्योंकि वे मूल्य जल्दी से बड़े हो जाते हैं। बस पहले दो अक्षर, 'ए' प्राप्त करने के लिए, हमें P16750 या 0x416E की आवश्यकता है । यदि हम सिर्फ भाग्यशाली पाने के लिए हुए हैं और सबस्ट्रिंग में से एक को विशेष रूप से एएफ के मूल्यों से युक्त किया गया है, तो हो सकता है कि हमें एक शॉर्टकट मिल जाए। यह कुछ भाग्य होगा, हालांकि! अन्यथा हम या तो बड़ी संख्या में किसी भी तरह से इनपुट कर रहे होंगे, किसी तरह उनके साथ आ रहे होंगे, या बहुत सारे जोड़ और गुणा करके 256 कर देंगे P
ब्रफल

5

जाप , 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

दूसरी लाइन 2वेरिएबल को असाइन करती है V

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 में काम नहीं करता है, लेकिन रेड दुभाषिया में काम करता है।

लाल सांत्वना

स्पष्टीकरण:

शब्द तुच्छ हैं - मैं उन्हें (बिना न्यूलाइन के प्रिंट के साथ) शाब्दिक के रूप में छापता हूं quoteलाल में अंतरिक्ष के लिए एक अंतर्निहित शब्द है - और spसाथ ही । और अधिक दिलचस्प: मैं उन लोगों से एक अंतरिक्ष को घटा कर prin और क्रमश: एक शाब्दिक से शुरू और , साथ स्ट्रिंग के लिए उन्हें पहली परिवर्तित करने के लिए और फिर चरित्र को wtih (आदेश उन पर घटाव का उपयोग करने के) ( लाल प्रोटोटाइप द्वारा रूपांतरण है - कन्वर्ट स्ट्रिंग के प्रकार के लिए , जो चरित्र है)।commadot"'BGBGmoldto spsp


1
प्रश्न स्पष्ट किया गया था; उन्होंने इसमें से दिलचस्प हिस्सा हटा दिया।
अनातोली

@anatolyg धन्यवाद, मुझे इसकी आवश्यकता है ', इसलिए 272 बाइट्स समाधान समान है।
गैलेन इवानोव

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

पेपे , 266 बाइट्स

मैं आर स्टैक को खाली रखता हूं, और आर स्टैक पर 'एस' है

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) से बचाया जाए, बचत ( sX) स्टैक के आकार ( z) को कस्टम रजिस्टरों में रखा जाए जब यह प्रत्येक अद्वितीय ASCII कोड से मेल खाता हो। मुद्रण ( P) भर में किया जाता है।

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

इसे ऑनलाइन आज़माएं!

मैंने कुछ अनुकूलन किया, जैसे किसी पत्र को सहेजना नहीं अगर उसके बाद इसका उपयोग नहीं किया जाता है, जैसे कि dएक बाइट को बचाने के लिए स्टैक पर डुप्लिकेट ( ) एक अक्षर, जैसे टी, याद करने के बाद से ( lX) 2 बाइट्स है।


मैं एक dc समाधान के साथ आया था जो कि +, -, और * के लिए मैक्रोज़ बनाकर अंकगणित का उपयोग करता है। यह 262 बाइट्स है। मैं प्रतिस्पर्धी पाने की कोशिश करने के लिए इसे अनुकूलित करने का प्रयास करता रहूंगा, लेकिन मुझे कहना होगा कि मैं निराश हूं कि यह (अपेक्षाकृत) भोले समाधान की तुलना में बहुत अधिक है।
ब्रुह

@brhfl हाँ, डीसी बहुत तेजी से क्रिया हो जाता है। फिर भी, मुझे आपका समाधान देखना बहुत पसंद है, इसलिए इसे पोस्ट करें! इस बीच, मैं भी या तो वर्तमान विधि को और अधिक गोल्फ बनाने की सोच रहा हूं, एक प्रोग्राम का उपयोग कर रहा हूं, या डीसी के लिए एक और विचार के साथ आ रहा हूं।
शीशमारा

मैं 240 टाई करने में कामयाब रहा! और मुझे आश्चर्य नहीं होगा अगर मैं एक या दो और बाइट्स को गोल्फ से बाहर करने में सक्षम था, लेकिन ... यह बहुत कम / कोई लाभ नहीं के लिए बहुत अधिक अप्रिय दृष्टिकोण है। वैसे भी, मैंने इसे वहीं कहीं पोस्ट कर दिया ...
brhfl

मैं अपने कुछ सबसे सामान्य रजिस्टरों w / इनपुट / आउटपुट मूलांक और परिशुद्धता की जगह ले कर 222 पर आ गया; दुकान पर एक बाइट और हर भार पर एक बाइट बचाता है ... चूंकि संख्याएं सारहीन हैं, यह कुछ भी प्रभावित नहीं करता है ... आप अपने लाभ के लिए भी इसका उपयोग करने में सक्षम हो सकते हैं!
ब्रुफ

3

80186+ मशीन कोड, MS-DOS .COM प्रारूप, 822 787 बाइट्स

अक्षरों के अतिरिक्त केवल टैब और रिक्त स्थान का उपयोग किया जाता है। यह देखते हुए कि अनुमत सीमा में अधिकांश opcodes कुछ वृद्धि, decrements, धक्का, चबूतरे, और रजिस्टर-अप्रत्यक्ष ANDs और ORs हैं, 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

यह असेंबली नहीं है, यह मशीन कोड है ...
आर्टेलियस

@ आर्टेलियस मेला काफी मैंने विवरण अपडेट कर दिया है।
एरिकएफ

3

बेगुंजे -98 (FBBI) , 125 124 121 बाइट्स

wab









And she said   But that s his












wakekekaayyeapwayyaayybyapayybyapcyabcyaayycayyba
a



b
wayapapoq

इसे ऑनलाइन आज़माएं! नाम की एक फ़ाइल में आउटपुट\n (एक नई पंक्ति)। अपनी स्क्रिप्ट के लिए जो किंग को धन्यवाद ।

आउटपुट में 10 अनुगामी newlines शामिल हैं।

निम्नलिखित पंक्ति को बदलकर केवल एक अनुगामी न्यूलाइन, +1 बाइट के लिए :

wakekekaayyeapwayydayybyapayybyapycyabcyaayycayyba

इसे ऑनलाइन आज़माएं!


स्पष्टीकरण:

निर्देश सूचक निम्नानुसार चलता है:आईपी ​​पथ

प्रोग्राम उस लाइन को फ़ाइल में आउटपुट करने से पहले, गैर-अक्षर वर्णों को स्थिति में रखता है।

Befunge-98 में निर्देश शामिल हैं a... f, जो स्टैक के लिए संबंधित हेक्साडेसिमल मान को धक्का देते हैं। अन्य संख्याओं को उत्पन्न करने के लिए, यह उन मूल्यों को y("SysInfo") को प्राप्त करने के लिए तर्क के रूप में पास करता है:

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

23* stack size

कोड के थोक को y = 23 पर रखकर, ayyढेर आकार तक बार-बार पहुंच के लिए उपयोग किया जा सकता है, जो तब वर्ण कोड उत्पन्न करने के लिए उपयोग किया जाता है।


क्या केवल एक अनुगामी न्यूलाइन की अनुमति नहीं है?
Delioth

पोस्ट में कहा गया है "व्हॉट्सएप पूरी तरह से अनुमति है"। मुझे लगता है कि नई कहानियों को सही ठहराने के लिए इस शब्द का दुरुपयोग करना अच्छा है!
एनाटोलिग

2

पायथ , 210 बाइट्स

pChyCdpCyhyhlGpCyytlGpdpChFhTyylGpCyylGpChyytlGpdpChFhTyylGpCtytytlGpChyylGpCyytlGpCyyhTpdpCtyyTpCyhCdpCtFyyCdhTpCyhFlGCdpdpCyhFlGCdpCyylGpCtytytlGpCyhFlGCdpCtyyTpChFhTyylGpdpCyylGpChyylGpChFhTyylGpCyhyhTpCtyyT

इसे ऑनलाइन आज़माएं!

मुझे कुछ संख्याएँ मिलीं जिन्हें केवल अक्षरों का उपयोग करके व्यक्त किया जा सकता था (जैसे T= 10, Z= 0, lG= लंबाई (वर्णमाला) = 26, Cd= चारकोड (स्थान) = 32), और कुछ कार्य जो केवल अक्षरों का उपयोग करके किए जा सकते हैं (जैसे t= decrement, h= increment , = increment का 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 के माध्यम से ले जाया जा सकता है (SP को POP नहीं कर सकता क्योंकि यह वर्णनात्मक नहीं है);

  • डॉस कॉल को भेजने के निर्देश का निर्माण करता है (एल्गोरिथ्म क्योंकि यह अल्फाबेटिक नहीं है);

  • गैर-अक्षर वर्णों का निर्माण करता है;

  • स्टैक पर स्ट्रिंग रखता है;

  • स्टैक पर प्रेषण निर्देश को कोड के सटीक छोर पर रखता है, ताकि निष्पादन सीधे उस निर्देश पर बह जाए;

  • एक स्ट्रिंग मुद्रित करने के निर्देश का निर्माण करता है;

  • स्ट्रिंग प्रदर्शित करता है और उन्हें तुरंत क्रैश करता है। : - / (एक सुंदर निकास अधिक कोड की आवश्यकता होगी)




0

80186 मशीन कोड + डॉस, 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. डॉस को कॉल करता है

विधानसभा कोड (इसके साथ संकलित किया जा सकता है 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कि एक निषिद्ध opcode है)।

बाइट्स टू पैच के पते 0x100 ... 0x160 की सीमा में हैं। भाग्य से, उन्हें अनुमत मूल्यों के साथ 3 बाइट्स के योग के रूप में दर्शाया जा सकता है:

  • में 0x7a bp
  • 0x7a या 0x67 में siयाdi
  • तत्काल मूल्य

संदेश में बाइट्स का ORपैच 0x20 (स्पेस कैरेक्टर) और एक छोटे से स्थिरांक (4, 7, 12 या 14) पर लॉजिकल काम करता है । छोटा स्थिरांक 9 cxऔर dx(टैब वर्ण) को इनिशियलाइज़ करके और आवश्यकतानुसार INCया प्राप्त किया DECजाता है।

कोड का पैचिंग IMULनिर्देश का उपयोग करता है । मुझे जानवर-बल खोज का उपयोग करने के लिए 16-बिट स्थिरांक की आवश्यकता थी।

अंत में, संदेश का पता (0x13b) गुणन द्वारा प्राप्त किया जाता है। अंतरिक्ष को बचाने के लिए, मैंने निर्देशकों में से एक निर्देश से एक लिया, जिसमें एक तत्काल मूल्य शामिल है 0x96d। यहां 9भाग एक डॉस प्रिंट फ़ंक्शन चुनता है, और यह 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
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.