Drucken Sie den Ausdruck And she said, 'But that's his.'nur mit den folgenden Zeichen: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ Keine Interpunktion oder nicht alphabetische Zeichen. Sie können jede gewünschte Programmiersprache verwenden. Leerzeichen sind vollständig erlaubt. Kürzeste Sendung gewinnt.

Whitespace , 417 414 349 265 Bytes

265 Bytes dank Kevin Cruijssen

Probieren Sie es online!

Erklärt:

[S S T  T   T   T   T   T   T   N
_Push_-63_'][S S T  T   T   T   S S S N
_Push_-53_.][S S S T    T   S T N
_Push_13_s][S S S T T   N
_Push_3_i][S S S T  S N
_Push_2_h][S S T    T   S S S T T   S N
_Push_-70_space][S T    S S T   T   N
_Copy_0-based_3rd_s][S T    S S T   T   S N
_Copy_0-based_6th_'][S S S T    T   T   S N
_Push_14_t][S S T   T   S T N
_Push_-5_a][S S S T S N
_Push_2_h][S T  S S T   S N
_Copy_0-based_2nd_t][S T    S S T   T   S N
_Copy_0-based_6th_space][S T    S S T   N
_Copy_0-based_1st_t][S S S T    T   T   T   N
_Push-15_u][S S T   T   S S T   S S N
_Push_-36_B][S S T  T   T   T   T   T   T   N
_Push_-63_'][S T    S S T   S S N
_Copy_0-based_4th_space][S S T  T   T   T   S T S N
_Push_-58_,][S S T  T   S N
_Push_-2_d][S S S T T   N
_Push_3_i][S S T    T   S T N
_Push_-5_a][S S S T T   S T N
_Push-13_s][S T S S T   S T N
_Copy_0-based_3rd_space][S S T  T   N
_Push_-1_e][S S S T S N
_Push_2_h][S T  S S T   T   N
_Copy_0-based_3rd_s][S T    S S T   T   N
_Copy_0-based_3rd_space][S S T  T   S N
_Push_-2_d][S S S T S S S N
_Push_8_n][S S T    T   S S T   S T N
_Push_-37_A][N
S S N
_Create_Label_LOOP][S S S T T   S S T   T   S N
_Push_102][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Perl 5 , 133 102 95 Bytes

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

Probieren Sie es online!

Erläuterung:

Regexes, Print und Chop gelten $_standardmäßig für die Variable .

s qqAnd she saidZ ZBut thatZs hisZZGjGGfq

Ersetzt die leere Zeichenfolge durch And she saidZ ZBut thatZs hisZZGjGGf.

s qZqchr oct oct oct ord chopqge

Ersetzt jeweils Zmit dem Ergebnis der Auswertung chr oct oct oct ord chop. Dadurch wird das letzte Zeichen von entfernt $_, der Schlüsselcode übernommen, dreimal als Oktal interpretiert und wieder in ein Zeichen umgewandelt. Zum Beispiel j→ 106 → 70 → 56 → 46 → ..

Aufgrund der Art und Weise Ersatz Arbeiten, die Modifikationen $_vorkommen , dass während des Ersatzes Auswertung verloren gehen, so $_jetzt ist And she said, 'But that's his.'GjGGf.

y qGjfqqd

Löscht alle G, jund fin $_.

> <> , 916 915 903 Bytes

Zuerst dachte ich, eine Lösung in> <> sei unmöglich, aber dann wurde mir klar ... wer braucht Bedingungen oder Logiksteuerung? : D

fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffloffffffffffffffffffffffffffffffffffffffffffffflopppgloppppppppppppppppppppppggloffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppggloploppppppppppppppppppppppploffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppplofffffffflopggloppppppppppppppppppgglopppplofffffffloffffffffffffffffffffffffffflofffffffffffffffffffffffffffffffffffffffffffffffffffloglopppppppppppppppppppppppppppplofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppploppgloffffffffffffffffffflopppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflopppppppppppppppppppppppppppgglofffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflofloffffffffffloppppppppppppppppppppppploppgloio

Probieren Sie es online

Ich drücke wiederholt Zahlen (die Zahl 15) auf den Stapel, drücke dann die Länge des Stapels und drucke das Zeichen mit diesem ASCII-Wert. Wenn ich die Länge des Stapels verkleinern muss, verkleinere ich den Stapel mit jeweils drei Werten poder mit jeweils einem Wert , gwenn ich innerhalb von drei Werten des Ziels bin. Das Programm endet mit einem Aufruf i(input), der a drückt, -1da keine Eingabe vorhanden ist, und gibt es dann aus, um einen Fehler zu verursachen.

Dies ist das Python 3-Programm, mit dem ich die Lösung erstellt habe, nachdem ich mir überlegt hatte, wie es geht:

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

Probieren Sie es online

8086 Assembly auf IBM PC, 1463 845 664 Bytes

Erläuterung: Die eigentliche Assemblersprachenquelle ist der Eintrag, nicht der generierte Maschinencode.

Die Schwierigkeit besteht darin, dass die meisten x86-Befehle (wie ADD, SUB, JMP, bedingte Sprünge, Speicherzugriff) zwei Argumente haben und daher ein Komma oder eine Speicheradresse benötigen. Wir können also keine Additionen, Subtraktionen, Ifs oder Schleifen verwenden!

Bei meinem ersten Versuch war ich in der Lage, Zahlen mit einer Kombination aus Inkrement, Dekrement, Multiplikation, Division, Bytetricks und den obskuren BCD-Befehlen (wie AAA, DAS) zu "konstruieren". Danach wurde mir klar, dass diese Idee verwendet werden kann, um selbstprüfenden und selbstmodifizierenden Code zu erstellen.

• Versuch 1. (1463 Bytes)

  Verwendete die verfügbaren Anweisungen, um ASCII-Codes und die 0xb800-Adresse des Bildschirmpuffers zu erstellen. Die Berechnung jedes Zeichens in der Sequenz wurde von Hand ausgeführt.

• Versuch 2. (nicht abgeschlossen)

  Es wurde festgestellt, dass für jede Ganzzahl im Bereich 0x40-0x5f ein Opcode vorhanden ist . Dieser Bereich umfasst AZ. So entspricht beispielsweise INC CX 0x41 = 'A'. (Diese Opcode-Tabelle ist sehr praktisch.)

  Ich habe versucht, 3 "Daten" -Strings zu konstruieren und übereinander zu legen. Der erste Zustand (in Großbuchstaben), der zweite "verschoben" in die Zone 0x60-0x7f (in Kleinbuchstaben) und der letzte "verschoben" in die Zone 0x20-0x3f (Interpunktion).

  Selbstmodifizierender Code würde eine oder drei Schleifen erzeugen, um die Daten zu durchlaufen.

• Versuch 3. (845 Bytes)

  Wie beim vorherigen Ansatz, jedoch um Daten zu reduzieren, wird die Zeichenfolge nur einmal codiert, wobei "Steuerzeichen" zum Wechseln der Zeichensätze eingemischt werden.

• Versuch 4. (664 Bytes)

  Wie kann man die Steuerzeichen loswerden, die eine ganze Reihe gepatchter Anweisungen für die Verzweigung benötigen? Angesichts der Tatsache, dass nur zwei Großbuchstaben verwendet werden, fragte ich mich, ob ich die Opcode-Tabelle "umdrehen" könnte, um Kleinbuchstaben mit dem Bereich 0x40-0x4f und Interpunktion mit dem Bereich 0x90-0x9f (durch Subtrahieren von 0xc0) zu codieren. Das "A" und "B" können separat eingegeben werden.

  Es kann jedoch nur die Hälfte der Opcodes im Bereich 0x90-0x9f verwendet werden, die nicht mit den benötigten übereinstimmen. Dann dachte ich, ich könnte sie vielleicht mit einem XOR durcheinander bringen, und fand einen, der funktionierte. Und hier ist es.

Golf gespielt:

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

Zusammenbauen mit

nasm golf.asm -o golf.com

und in DOSBOX ausführen (zuerst CLS ausführen). Sieht aus wie das:

Kommentiert:

; ASSUME DS = ES = CS
; ASSUME IP = 0x0100
; true for .COM file

; We treat 0xFE as a special marker that we scan for
; This marks our patch zone and the start of our data

; We also use it as a cheap trick to get a constant 0x1f
; into CX

; 0xFE is the first byte of INC or DEC instructions
; that operate on half-word registers (AL, BL, CH etc.)
; WATCH OUT! Adding these breaks the scan


; Can't assume any register contains zero
; so use this trick to zero out CX
REP LODSB

PUSH CX ; needed later

; zero AX
PUSH CX
POP AX

INC CH
PUSH CX
POP DI ; 0x100, where our code starts

DEC AX
DEC AX ; AL = 0xFE, our marker (AH = 0xFF)

REPNE SCASB ; skip the INC CH above
REPNE SCASB ; find the DEC CH located at 0x10E

; we will later need 0xF, the char count minus the 'A'
PUSH DI ; DI = 0x10F

REPNE SCASB ; find the patch position
PUSH DI

REPNE SCASB ; find the next 0xfe; our data section
PUSH DI
POP SI ; load data from here

POP DI ; store data to the patch position
DEC DI

; patch in XOR
; XOR is 0x34, start with 0xCB
; second byte of DEC BL is 0xCB
LODSB
NOT AL
STOSB

POP CX ; get 0x0f in CX for our strlen
DEC CH

; patch in our XOR arg
; it is 0xF1 (take 0x0E and NOT it)
LODSB ; 0x0E (PUSH CS)
NOT AL
STOSB

; ADD is 0x00 (take 0xAA, apply weird AAA behaviour)
; this also zeroes AH
LODSB ; 0xAA (STOSB)
AAA
STOSB

INC DI ; skip next instruction byte

; LOOP is 0xE2
LODSB ; 0x1E PUSH DS
NEG AL
STOSB


; get b800 in ES (address of screen buffer)
; first get 0x47 in AL (INC DI)
LODSB  ; get 0x47 (INC DI)
NOT AL ; NOT 0x47 = 0xb8
; AX = 0x00b8 (bytes backwards)

PUSH AX
PUSH AX
; stack contains 0xb8 0x00 0xb8 0x00
; stack off-by-1 trick
INC SP
; now POP gives you 0xb800
POP ES
INC SP ;and clean up after ourselves

; store 0 in DI ***** PUSHED AT START OF PROGRAM ***
POP DI


LODSB ; get our magic 0xC0 (0x40 INC AX)
NOT AL
PUSH AX
POP BX

NEG AL ; NOT and +1 to get 0x41 ("A")


; charloop:
STOSB
INC DI
LODSB
DEC AL ; XOR
NEG AL ; modify this into an ADD AL, BL
DIV BH ; modify this to LOOP back to charloop

; doesn't print the last character
; but the last character turns into the address where 'B'
; is supposed to go

PUSH AX
POP DI
LODSB ; "B"
STOSB

; graceful exit this time ;)
RET


; *** DATA SECTION ***

         ; PURPOSE

DEC BL   ; 0xFE marks data section, 0xCB for XOR
PUSH CS  ; for XOR arg
STOSB    ; for ADD
PUSH DS  ; for LOOP
INC DI   ; 0x47 -> for 0xb800

INC AX   ; for magic number but also "A"


POP     SI ;n
PUSH    SP ;d
NOP        ;
INC     BP ;s
POP     AX ;h 
PUSH    DI ;e
NOP        ;
INC     BP ;s
PUSH    BX ;a
POP     BX ;i
PUSH    SP ;d
PUSHF      ;,
NOP        ;
CWD        ;'
PUSH    DX ;B
INC     DI ;u
INC     SP ;t
NOP        ;
INC     SP ;t
POP     AX ;h
PUSH    BX ;a
INC     SP ;t
CWD        ;'
INC     BP ;s
NOP        ;
POP     AX ;h
POP     BX ;i
INC     BP ;s
SAHF       ;.
CWD        ;'

SCASB     ; treated as char but turns into screen address!
INC DX    ; "B"

Perl 6 , 1299 1272 1220 1215 Bytes

Vielen Dank an Grimy für -27 Bytes.

-52 Bytes, weil wir die Hasenohren gar nicht gebraucht haben.

Danke an Jo King für -5 Bytes.

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

Probieren Sie es online!

Gibt den String mit einer nachgestellten Newline aus. Wenn Sie das nicht wollen, ersetzen Sie den letzten saydurch einen print. Sie können die Zeilenumbrüche in der Quelle auch durch Leerzeichen ersetzen.

Erläuterung

Dieser Code gibt die Zeichenfolge zeichenweise aus. Jedes Zeichen wird gebildet, indem der entsprechende Zeichencode in die chrFunktion eingegeben und bei lcBedarf mit einem niedrigeren Code versehen wird .

Derzeit werden alle Werte durch Generieren einer Zeichenfolge mit der richtigen Anzahl von Zeichen generiert. In einigen Fällen ist die Anzahl der Zeichen die Umkehrung des Zielzeichencodes. Es sollte theoretisch möglich sein, mathematische Funktionen wie logund expdirekt zu verwenden, aber ich fand es nicht sehr einfach, diese zu verwenden.

Für die Verwendung als Zahlen, haben wir e, piund tau; Auf der rechten Seite von xoder xxsind sie implizit mit Fußböden versehen. Sie haben alle 17 Zeichen in ihrer Zeichenfolgendarstellung, daher verwenden wir diese Option efür eine minimale Anzahl von Zeichen. Wir haben auch i(4 Zeichen), False(5 Zeichen) und NaN(3 Zeichen). Wir können Stringlängen mit multiplizieren x; xxmultipliziert eins plus die Stringlänge mit der rechten Seite und addiert eins. chopEntfernt ein Zeichen aus der Zeichenfolge, falls wir eins vom Ziel entfernt sind.

Die print-Anweisungen werden mit verkettet and, was eine recht geringe Priorität hat. Es ist fast ein Wunder, dass es existiert; Andernfalls müssten wir ungültige Semikolons verwenden.

Ich habe die Ausdrücke für die Charaktere von Hand gefunden. Es könnte sich lohnen, programmgesteuert nach ihnen zu suchen, um kürzere Ausdrücke zu finden.

Breite , 66 64 Bytes

QaaGmwmiimaGcwWiimawAGawmfciiiGaFmAmFiimFGcwAmFiGmaiiGcGamafFiGQ

Probieren Sie es online!

Druckt zum Debuggen. Hängen Sie wwan das Ende des Codes, der den Anfang des Stapels anzeigt und ausgibt, an, um auf stdout zu drucken .

Erläuterung

In der Breite korreliert jeder Buchstabe mit einer Zahl, basierend auf der "Breite" gemäß dieser Tabelle . Dies weist jedem Buchstaben eine Zahl von 0 bis 9 zu. Diese Zahlen werden dann verwendet, um tatsächlich Code auszuführen.

Insbesondere ein Buchstabe, der größer als ein Treffer 7ist, startet ein Zeichenkettenliteral. Es werden Sätze von zwei Buchstaben gleichzeitig gelesen, bis der ursprüngliche Buchstabe erneut gelesen wird. Jeder Satz von zwei Buchstaben wird in ihre Breitenzahlen konvertiert und als Dezimalzahl zwischen 0 und 99 gelesen. Das Zeichen, dem sie entsprechen, ist der Index in der folgenden Zeichenfolge:

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

Zum Beispiel ist der Index !1, also 01werden die Zahlen der richtigen Breite sein. So if, iI, jtusw. werden alle Korrelat zu einem Stringliteral von !.

In diesem Fall habe ich die 31 Zeichen der erforderlichen Ausgabe in die entsprechenden Buchstaben übersetzt und Qals Anführungszeichen verwendet. Die Oberseite des Stapels wird zum Debuggen gedruckt, wenn das Programm beendet ist.

x86-Computercode (32-Bit), 256 Byte

Wenn ich meinen Code auf meiner Codepage 437-Konsole drucke, wird Folgendes angezeigt:

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 

Dies enthält einige Leerzeichen, daher hier derselbe Code, wenn ich alle Tabulatorzeichen durch →und alle nicht unterbrechenden Leerzeichen (mit Code 255) durch ersetze *:

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

Einige Erklärungen zur Funktionsweise:

Nützliche Anweisungen sind:

• push imm8, push imm16und push imm32, gefolgt von popKonstanten erzeugen. Dies kann auch Null (in ah) erzeugen, wenn ein Byte ( imm8) gedrückt wird .
• and [ecx+32], ah- Angenommen, ah = 0, setzt dies das Byte auf Null. Es kommt einfach so vor, dass die Länge der Ausgabezeichenfolge 32 beträgt, sodass der Code den Puffer von Ende zu Anfang füllt.
• or [ecx+32], edx- Unter der Annahme, dass das Ausgangsbyte auf Null gesetzt ist, werden diese Kopien edx(4 Bytes) ausgegeben. Ich benutze eine Variante mit dxstatt edxnahe am Ende des Puffers, da es nicht über den Ausgabepuffer hinaus schreiben soll. Die Beschränkung des Codes macht es unmöglich, einzelne Bytes auf diese Weise zu schreiben!
• imul edx, [ecx+32], whatever- Dies ist die Hauptidee des Krieges. Mit genügend Entropie [ecx+32]und einer beliebigen Anzahl kann jede Ausgabe generiert werden. Ich benutze es, um 2 oder 3 Bytes der benötigten Werte zu generieren. Eine Komplikation ist, wenn es in die Ausgabe geschrieben wird, dass es logisch ORmit dem zu tun hat, was bereits vorhanden ist. Dies machte es manchmal erforderlich, den Speicher erneut auf Null zu setzen.
• Eine Variante eines jmpBefehls wird verwendet, um zurückzukehren. Ich habe es gewählt, weil es codiert ist 0xff, was einem nicht unterbrechenden Leerzeichen in Codepage 437 entspricht. Die Regeln sind ein wenig überstrapaziert, aber ansonsten halte ich die Aufgabe für unmöglich ...

Assembly-Quellcode zusammen mit einem C-Programm, das ihn ausführt (verwendet Visual Studio-Syntax):

#include <stdio.h>

__declspec(naked) void __fastcall doit(char* buf)
{
    __asm {
        push ' '
        pop eax

        dec ecx
        and [ecx+32], ah    // terminating 0 byte

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah

        push 98
        pop edx
        or [ecx+32], edx
        imul dx, [ecx+32], 26183
        and [ecx+32], ah
        or [ecx+32], dx    // two bytes: [.']

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 'sih '
        pop edx
        or [ecx+32], edx    // 4 bytes: [ his]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 538988610
        pop edx
        or [ecx+32], edx
        imul edx, [ecx+32], 544803081
        or [ecx+32], edx // 1 junk byte and 3 good bytes: (t's)

        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 'aht '
        pop edx
        or [ecx+32], edx    // 4 bytes: [ tha]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        push 'tuB '
        pop edx
        or [ecx+32], edx    // 1 junk byte and 3 good bytes: [But]

        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push word ptr 8309
        pop dx
        or [ecx+32], dx
        imul edx, [ecx+32], 542312807
        or [ecx+32], edx    // 1 junk byte and 3 good bytes: [, ']

        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push 'dias'
        pop edx
        or [ecx+32], edx    // 4 bytes: [said]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push ' ehs'
        pop edx
        or [ecx+32], edx    // 4 bytes: [she ]

        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        dec ecx
        and [ecx+32], ah
        push ' dnA'
        pop edx
        or [ecx+32], edx    // 4 bytes: [And ]

        push esp
        pop edx
        inc edx

        pop eax
        jmp dword ptr[edx-1]
    }
}

int main()
{
    char buf[100];
    doit(buf);
    puts(buf);
}

PostScript, 889 874 837 835 Bytes

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

Probieren Sie es online!

Dies verwendet 32 ​​Kopien der ganzen Zahlen 89 25 20 6. Alle Zeichencodes der Zielzeichenfolge können mit Operationen für diese ganzen Zahlen in Stapelreihenfolge abgerufen werden: Beispiel: 'A' (ASCII 65) ist 89 - (25 & (20 + 6)). Viele 4-Tupel von ganzen Zahlen haben diese Eigenschaft; Diese wurde ausgewählt, weil sie besonders einfach zu generieren sind.

currentflat string dup rrand

Flat ist standardmäßig 1, sodass eine Zeichenfolge mit der Länge 1 erstellt wird (initialisiert auf \0). dupist keine tiefe Kopie: Es wird ein zweiter Verweis auf dieselbe Zeichenfolge erstellt. rrand schiebt den zufälligen Startwert, der standardmäßig 0 ist ["\0", "\0", 0]. Stack is now .

count dup count count mul mul xor

count Legt die Anzahl der Elemente im Stapel fest, sodass 3 ^ (3 * (5 * 6)) = 89 berechnet wird.

count count mul count dup mul exch count

4 * 5 = 20, 5 * 5 = 25, 6 = 6. Der Stapel ist jetzt ["\0", "\0", 0, 89, 25, 20, 6].

count copy count copy count copy count copy count copy

Duplizieren Sie den gesamten Stapel fünfmal. So haben wir am Ende 32 Kopien unseres ursprünglichen 7-Elemente-Stapels. Wir brauchen nur 31 Kopien, da die Zielzeichenfolge 31 Zeichen lang ist, aber die zusätzliche Kopie tut nicht weh.

add and sub put print

Berechnen Sie einen Zeichencode aus den ersten vier Ganzzahlen, schreiben Sie ihn an den Index 0 der Zeichenfolge und drucken Sie die Zeichenfolge aus.

quit

Unterdrückt die Standardeingabeaufforderung.

Ruby , 420 354 338 Bytes

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

Probieren Sie es online!

In aufsteigender Reihenfolge der Jankiness:

Wörter, die mit einem Großbuchstaben beginnen, können gedruckt werden, indem eine Klasse mit diesem Namen definiert und displayim Klassendefinitionshauptteil aufgerufen wird.

Andere Wörter können angezeigt werden, indem Sie Methoden mit diesem Namen definieren, die ein Symbol zurückgeben, und dieses dann in einen String umwandeln, um den führenden Doppelpunkt zu entfernen.

Andere Zeichen können durch Aufrufen putcihres ASCII-Codes angezeigt werden . Wir können die entsprechenden Zahlen erzeugen, indem wir den String defTrick erneut verwenden, um einen String zu erhalten, und dann die Summe seiner Bytes unter Verwendung eines durch seine Größe bestimmten Moduls nehmen . Leider haben wir keine Möglichkeit, Methoden für ein Objekt aufzurufen, das nicht in der Klassendefinition dieses Objekts enthalten ist, was die Übergabe von Argumenten erschwert. Der letzte Hack ist also die Neudefinition String#inspect, die implizit aufgerufen wird, wenn ein String an die pMethode übergeben wird, so dass das entsprechende Zeichen als Nebeneffekt berechnet und ausgegeben wird, bevor ein Fehler ausgelöst wird, sodass die pAusführung und der Ausdruck von a nicht abgeschlossen werden können Neue Zeile. Dann müssen wir den Fehler im Hauptcode beheben.

Bearbeiten: Jordan hat die Anzahl der Bytes deutlich verringert, ähm, hoch mit einigen cleveren Kontrollabläufen, und ich habe ein paar Bytes mehr gespart, indem ich sie raisedurch einen aus einem Buchstaben bestehenden Methodenaufruf ersetzt habe, der einen NameError auslöst.

Bearbeiten 2: Es wurde bemerkt, dass es bei der print StringExtraktion in eine Methode billiger ist, diese Methode nur mit einer Methodendefinition zu verwenden, als den Klassendefinitionstrick, da Methoden mit einem Titel versehen werden dürfen.

> <> , 233 122 Bytes

cdacaabbglccgpcbfbbcaacdebbafbebbcebdbealbcpcdbcccdlcdpacbbalccpaalacpbcfafbaab









       g  sandBe
       o  Aviuth

Probieren Sie es online!

Dies begann als Antwort von mbomb , aber ich entdeckte eine grundlegende Verschiebung, die eine große Anzahl von Bytes spart, also poste ich sie als meine eigene Antwort.

Das Generieren nicht-alphabetischer Zeichen zur Ausgabe erfolgt durch wiederholtes Verschieben von Werten in den Stapel und anschließendes lVerschieben der Stapellänge. Dies muss jedoch nicht sofort ausgegeben werden: Mit pkann dieses Zeichen in jede Zelle eingefügt werden, deren Koordinaten zwischen 10 und 15 liegen, um später mit abgerufen zu werden g. In ähnlicher Weise können alphabetische Zeichen in den ursprünglichen Quellcode eingefügt und folgendermaßen gelesen werden: Da der höchste nicht-alphabetische Zeichencode in der Eingabe 46 ( .) beträgt , muss der Stapel nicht höher als die 62 verschoben werden, die zum Speichern benötigt werden alle 31 Zeichen der Ausgabe.

Zusätzlich wird a vin den Code in Spalte 7 eingefügt. Wenn der Anweisungszeiger das umschließt und trifft, vwird die Sequenz gowiederholt ausgeführt, um die übertragenen Koordinaten zu lesen und die entsprechenden Zeichen auszugeben. Schließlich wird der Stapel leer und gbeendet das Programm mit einem Fehler.

Die ersten 7 Byte des Codes werden als die ersten 7 und die letzten 7 übertragenen Koordinaten wiederverwendet. Das Platzieren der vin Spalte 9 hätte theoretisch zwei weitere Bytes gespart, die Zeichen jedoch Ainsvzu einem 2x2-Quadrat im Code gezwungen , was unmöglich ist. In einer früheren Version wurde Spalte 15 verwendet, für die jedoch eine zusätzliche Zeile im Quellcode erforderlich war und die sechs Byte länger endete.

CJam , 262 Bytes

  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

Probieren Sie es online! Zeilenumbrüche werden hier nur zur Verdeutlichung angezeigt. Jede Zeile steht für ein Zeichen.

Puh, das hat Spaß gemacht. Die Beschränkung auf alphabetische Befehle birgt einige interessante Herausforderungen:

• Ohne {und }gibt es praktisch keine Möglichkeit für den Kontrollfluss (außer f, dass ich keine Möglichkeit gefunden habe, dies zu nutzen).
• Ohne \, _, ;, oder $, wir haben keine Mittel zur Stapelmanipulation.

Dies bedeutet, dass das Hauptziel darin besteht, die relevanten Codepunkte auf den Stapel zu bekommen und sie dann in Zeichen mit umzuwandeln c.

Das Problem ist, dass uns auch die meisten grundlegenden arithmetischen Befehle sowie ganzzahlige Literale fehlen. Dies ist jedoch in Ordnung, da der mNamespace zahlreiche erweiterte mathematische Operationen enthält und viele Variablen für nützliche Zahlen vordefiniert sind.

Am Ende habe ich Quadratwurzeln ( mQund mq), die Exponentialfunktion meund die Basisumwandlung ( b) verwendet, die auch zum Emulieren der Multiplikation verwendet werden können ( [X 0] YbBerechnet X * Y). Außerdem ist es manchmal einfacher, den Codepunkt in Großbuchstaben zu erstellen. In diesem Fall können Sie eldas resultierende Zeichen in Kleinbuchstaben umwandeln.

Mit einigen längeren bin ich immer noch nicht zufrieden. Naja.

Erläuterung

Dies ist eine zeichenweise Erläuterung der Ausgabe. Bevor ich anfange, sind hier ein paar kurze Möglichkeiten, um Zahlen zu machen:

• 0, 1, 2, 3 sind in Variablen enthalten T, X, Y, Zbzw..
• Die Nummern 10 bis 20 sind in den Variablen Abis enthalten K.
• 32 kann mit gemacht werden Sci( Sdrückt eine Zeichenkette, die ein Leerzeichen enthält, cholt das erste Zeichen dieser Zeichenkette und ikonvertiert dieses Zeichen in seinen Codepunkt). Swird auch für Leerzeichen verwendet.
• 4 ist gegeben durch GmQ(ganze Quadratwurzel von 16).
• 5 ist gegeben durch AZbYb(konvertiere 10 zu Base 3, was ergibt [1 0 1], und konvertiere das resultierende Zahlenarray zu Base 2, was ergibt, 5).
• 7 ist gegeben durch Ymei(berechne exp (2) und konvertiere in eine ganze Zahl).

A

K           - push 20                        | 20
 Ab         - convert to base 10             | [2 0]
   Scib     - convert from base 32           | 64
       Cmh  - hypot(TOS, 12)                 | 65.115
          c - round down and convert to char | 'A

n

C      - push 12            | 12
 Zb    - convert to base 3  | [1 1 0]
   s   - convert to string  | "110"
    i  - convert to integer | 110
     c - convert to char    | 'n

d

GmQ      - push 4             | 4
   Yb    - convert to base 2  | [1 0 0]
     s   - convert to string  | "100"
      i  - convert to integer | 100
       c - convert to char    | 'd

s

C         - push 12         | 12
 mf       - factors         | [2 2 3]
   Ymeib  - base 7          | 115
        c - convert to char | 's

h

I           - push 18                        | 18
 mq         - sqrt                           | 4.242
   me       - exp                            | 69.591
     Kmh    - hypot(TOS, 20)                 | 72.408
        c   - round down and convert to char | 'H
         el - lowercase                      | 'h

e

A      - push 10              | 10
 Zb    - convert to base 3    | [1 0 1]
   Ab  - convert from base 10 | 101
     c - convert to char      | 'c

a

KAbScibCmhc   - push 'A (see above) | 'A
           el - lowercase           | 'a

i

I              - push 18         | 18
 mq            - square root     | 4.242
   me          - exp             | 69.591
     Kmh       - hypot(TOS, 20)  | 72.408
        Amh    - hypot(TOS, 10)  | 73.095
           c   - convert to char | 'I
            el - lowercase       | 'i

,

K          - push 20              | 20
 AZbYbb    - convert to base 5    | [4 0]
       Bb  - convert from base 11 | 44
         c - convert to char      | ',

'

C        - push 12              | 12
 GmQb    - convert to base 4    | [3 0]
     Db  - convert from base 13 | 39
       c - convert to char      | ''

B

E         - push 14               | 14
 Yb       - convert to base 2     | [1 1 1 0]
   TYt    - replace elem 0 with 2 | [2 1 1 0]
      Zb  - convert from base 3   | 66
        c - convert to char       | 'B

u

F          - push 15             | 15
 Yb        - convert to base 2   | [1 1 1 1]
   GmQb    - convert from base 4 | 85
       c   - convert to char     | 'U
        el - lowercase           | 'u

t

E          - push 14             | 14
 Yb        - convert to base 2   | [1 1 1 0]
   GmQb    - convert from base 4 | 85
       c   - convert to char     | 'T
        el - lowercase           | 't

.

P          - push pi                        | 3.141
 Ymh       - hypot(TOS, 2)                  | 3.724
    me     - exp                            | 41.437
      Kmh  - hypot(TOS, 20)                 | 46.011
         c - round down and convert to char | '.

Deadfish ~ , 943 Bytes

iiisdsiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicddddddddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcdddddddddddcdddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsddddddcddddddddddddddddddciiiiiiiicdddddcddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddciiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiicdcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddddddddddddddddsdddddcddddddddddddcdddddddciiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddddddddsddddddcdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddddddddddddsiiiiciciiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcdddddddc

Probieren Sie es online!

Keine Schleifen erlaubt :(

Böse , 198 Bytes

aeeeannkhhwzuuuuuueaeuekwuuuuuuuuuunkhwzaeeeeehknwgueeywguuuuuuhhknnwuuuwhgwpwnngheeuwguuuuuwngwzaeeeaaaeeeeeewhhgwnguuuueewnngawpaawuwnngwpawhgwhhgeeuwpawhguuuueewpwhgwhgwawpwnngaaaaaaeeeewguuuueew

Probieren Sie es online!

Das hat sehr viel Spaß gemacht.

Stax , 133 95 84 79 Bytes

AHHvcAvSVvNvXvsrDhYcvxvZLcHxVahyvxxZVvHVChAHHvVAHhvZAJyVahxvVvDhZyvxvAJZcASVAhL

Führen Sie es aus und debuggen Sie es

MATL , 187 158 Bytes

IEWQKEtqhpEqqKQHhthpKWEyQKWEqqYqQQXJwtQQQwKWEJKQthpYqKQHhthptQQQQQwIIhKQhpqKWEIWKQhpqIEWQQJQQtqKWEyIIhIhpYqQXJyKQthpYqwIWKQhpqyqKWEyJtQwhhPIIhKQhpQIWKQhpqvlec

Probieren Sie es online!

Mehr lesbare Version: Probieren Sie es online! Manueller Versuch, die Zeichenfolge zu erstellen. Es gibt wahrscheinlich viel Platz zum Golfen, indem man die Saite in bequeme Stücke schneidet Pund hmit und eine Saite dreht und baut. Ich hoffe, jemand wird die Herausforderung annehmen, um mich zu übertreffen. Die größte Herausforderung besteht darin , dass Sie nicht verwenden können , +oder -, so Grundrechen ist oft nicht möglich.

Höhepunkte:

• KQthpYq: das 25. ( KQthp) Yqist 97, entsprechend dem Buchstaben a. Der Buchstabe s(115) wird auf ähnliche Weise aus 113, der 30. Primzahl, erzeugt. Es wird dann ausgiebig in der Zwischenablage wiederverwendet J.
• hiswird verkürzt, indem das hVorherige in der Zwischenablage gespeichert wird J. Da die zuvor gespeicherten s, bauen wir hisin umgekehrter Reihenfolge , so dass wir immer noch die letzte abrufen sverwenden y, und drehen Sie nach dem Gebrauch P.
• Eine große Anzahl von Bytes, die dank Luis Mendo gespeichert wurden (hauptsächlich durch Ändern einer Menge von hin vle)

MATL , 118 Bytes

KEUQtVQsQKBFZAXHKUqyyhsXJyyhdQtQQQwOJIUEyhdtKEhsHKQYqEEKQyywhdXJKEUQQHKUhstQwOytHKhsKYqyhdbJyqOHKhstQHKUqhsKUqYqqJvlec

Probieren Sie es online!

Lesbarere Version (jede Zeile entspricht einem Zeichen, mit Ausnahme von Stapel-Neuanordnungsoperationen).

Erläuterung

Das Programm erzeugt die Codepunkte der erforderlichen Zeichen als unabhängige Zahlen. Am Ende werden alle diese Zahlen zu einem Spaltenvektor verkettet, in einen Zeilenvektor umgewandelt und in Zeichen umgewandelt. Das Ergebnis wird implizit angezeigt.

Einige der verwendeten Tricks:

• Die meisten Codepunkte unter 32 werden als Leerzeichen angezeigt. Wird 0also für die meisten Leerzeichen verwendet, da es nur ein Byte kostet ( O).
• Für den ersten Raum, jedoch 15verwendet wird (erzeugt wie KUq), weil es dann durch Zugabe zu wiederverwendet werden kann 100(char d) zu geben 115( s). Bei einer anderen Gelegenheit 5für Raum (erzeugt wie verwendet wird KQ), so kann er später aus abgezogen werden 44( ,) zu erhalten 39( ').
• Die Zwischenablage Jwird zum Speichern von Zeichen verwendet, die wiederholt werden: zuerst sdann '. In ähnlicher Weise Hspeichert 100die Zwischenablage , was nützlich ist, um dandere Zeichen zu erzeugen.
• Die Funktionen Q(addieren 1), q(subtrahieren 1), E(multiplizieren mit 2) und U(quadratisch) werden zusammen mit den vordefinierten Literalen in den Zwischenablagen I( 3) und K( 4) ausführlich verwendet .
• Die willkürliche Addition und Subtraktion erfolgt durch Verketten in einen Vektor ( h) und Berechnen seiner Summe ( s) oder aufeinanderfolgender Differenzen ( d).
• 100( d) wird als 4Binärzahl generiert und als Dezimalzahl interpretiert.
• 110( n) wird aus 65( A) erhalten, indem in einen String ( '65': Codepunkte ) konvertiert [54 53], 1zu den Codepunkten ( [55 54]) addiert, summiert und addiert wird 1.
• Die Reihenfolge, in der die Nummern generiert werden, wird manchmal der Einfachheit halber geändert. und sie werden dann durch Stapel-Umordnungsfunktionen umgeordnet: swap ( w), bubble up b).

dc , 240 222 209 bytes

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdOOlAxlAxPOBlBxdIlAxoPAdlBxddsrIlAxssPPOPlsIZlCxddspPOZlCxPPOPlrdZlCxPlsPlrPlcPPKPdZlBxdZlAxPOAZlAxdPIZlCxdPrPdPlpPlrdZlCxPPKPOPPlpPlsPOPldPKP

Probieren Sie es online!

Mein erster Gedanke war derselbe wie bei @seshoumara, schiebe einfach genug Zeug auf den Stapel, um alle ASCII-Werte der Zeichen zu generieren. Dann kam mir der Gedanke, dass ich seitdem +, -und *als Einzelzeichenoperatoren, diese einfach neu erstellen und arithmetisch verwenden kann! Das wäre doch kleiner! Und ich wäre nicht überrascht, wenn ich noch mehr Bytes abwerfen könnte, aber fürs Erste ... hat dieser verschlungene Ansatz es geschafft, den naiven (ish) zu binden.

OOOOOziOOOOOOOOOOOOOOOOOOOOOOOOOOOzddddddzkdddzasBdzasAdzscdzdasCzsdist der Teil des Ansatzes, der @ seshoumara ähnelt, aber wir gehen nur auf 46, das ist .. Wir tun dies, weil wir auf 45 steigen müssen -, und wir brauchen auch eine Periode in unserer Saite, also ist es (glaube ich) am billigsten, wenn wir für diese Periode nur eine weiter gehen. Unterwegs speichern wir einige Werte: 5, 32, 39, die sich alle später als nützlich erweisen. 5 für nützliche Dinge, 32 und 39 für ihre ASCII-Werte. Ursprünglich habe ich 1-5 gemacht, aber das war teuer, und ich konnte einfach vermeiden, 4 zu verwenden; Verwenden ZSie für diese Werte eine dreistellige, zweistellige oder einstellige Zahl (geben Sie einen Wert ein und geben Sie die Anzahl der Stellen ein). Mit 42, 43 und 45 wandeln wir diese Strings ( *, +, und -jeweils) und speichert sie als Makros ( B, A, undCbeziehungsweise). Dies bedeutet, dass *+-wir diese Operatoren jetzt verwenden können , ohne die Zeichen zu verwenden.

Ab hier generieren wir im Grunde genommen die ASCII-Werte mithilfe der Potenz der Mathematik anstelle der bloßen Akkumulation und speichern dabei einige der Wiederholungen. 100, 105 und 115 sind ausreichend, um sie (in Registern oder auf andere Weise) sinnvoll zu speichern. Ursprünglich habe ich den Stapel mit 10s gefüllt und daraus 100s gemacht; Es endete damit, Bytes zu sparen, um den Stapel mit 32s zu füllen und diese später als Leerzeichen zu verwenden. Eine etwas besser lesbare Version des ASCII - Abschnitt: 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 Bytes gespart durch: Speichern der Nummer 5 als Eingabegrundlinie anstelle eines Registers; die Zahl 32 als Genauigkeit anstelle eines Registers; die Zahl 115 als Ausgangsradix anstelle eines Registers; dann ändern mußte , KZum IZ1s zu erzeugen und OZzu KZ2s zu erzeugen.

13 weitere Bytes wurden durch Überfluten des Stapels mit 32s entfernt. Einstellgenauigkeit auf 39; Verwenden einer Stapelmanipulation, um ein Speichern 116 zu vermeiden; Ich habe versehentlich Doppelarbeit weggelassen.

Japt , 87 Bytes

Bs g caA
HzG
Ts caV
iWisiiihiSisiUitiaihitiSitiuibu iUiSiWcaV idiiiaisiSieihisiSidiniau

Versuch es

Erläuterung

Die erste Zeile generiert die 'und ordnet sie der Variablen zu U.

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

Die zweite Zeile ist der 2Variable zugeordnet V.

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

In der dritten Zeile wird die .Variable generiert und zugewiesen W.

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

In der letzten Zeile wird die Zeichenfolge dann zeichenweise in umgekehrter Reihenfolge erstellt.

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

Rot , 272 Bytes

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

Wenn die doppelten Anführungszeichen erforderlich sind:

Rot , 344 Bytes

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

Funktioniert nicht in TIO, aber im Red Interpreter.

Erläuterung:

Die Wörter sind trivial - ich drucke sie (drucke ohne Zeilenvorschub) als Literale mit quote. Rot hat ein eingebautes Wort für Raum - sp, sowie commaund dot. "und 'interessanter: I prin sie durch einen Raum , aus dem Subtrahieren Bund Gjeweils ausgehend von einer Literal Bund G, sie zuerst Zeichenfolge mit der Umwandlung moldund dann Zeichen (zu verwenden , um auf sie Subtraktion) Wtih to sp( Red hat die Umstellung von Prototyp - konvertiert die Zeichenkette auf den Typ von sp(das ist das Zeichen).

Forth (Gforth), 351

CHAR A DUP EMIT
CHAR n EMIT
CHAR d EMIT
SPACE
CHAR s DUP EMIT
CHAR h EMIT
CHAR e EMIT
SPACE
EMIT
CHAR a EMIT
CHAR i EMIT
CHAR d EMIT
DUP CHAR m XOR EMIT
SPACE
CHAR f XOR DUP EMIT
CHAR B EMIT
CHAR u EMIT
CHAR t DUP EMIT
SPACE
DUP EMIT
CHAR h EMIT
CHAR a EMIT
EMIT
DUP EMIT
CHAR s EMIT
SPACE
CHAR h EMIT
CHAR i DUP EMIT
CHAR s EMIT
CHAR G XOR EMIT
EMIT

Schade, dass ich CHAR oder EMIT nicht in Ein-Buchstaben-Wörtern definieren kann, da dies die Verwendung von entweder :und ;(zB : C CHAR ;) oder '(zB ' CHAR ALIAS C) erfordern würde.

In der Tat, wenn ich Wörter definieren könnte, könnte ich tun : P CHAR EMIT ;und dann tun, um P xzu drucken x. Naja.

Ich kann nicht einmal einen Puffer erstellen, diese Zeichenfolge dort schreiben und dann als Eingabe verwenden, da das Schreiben in den Speicher die Verwendung von !oder erfordertC!

AlphaBeta , 180 177 175 163 Bytes

cccaaggtFgDILrFigggDLjDLCLigggggDLjhDLhhhDLCLiggggDLjjggDLihhDLhhhhhDLcaaCLdbbCLcbbbCLHgDLiiiiigDLhDLdaaaCLDLjhhDLjgggDLiihDLcbbbCLhDLdaaaCLjhDLgDLiDLcaaaaCLdaaaCL

Probieren Sie es online!

WIP

Pepe , 266 Bytes

Ich halte den R-Stapel leer und habe 's' auf dem R-Stapel

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

Dies ist nicht auf TIO, aber Sie können es hier versuchen

dc , 240 Bytes

Die Hauptidee besteht darin, den Stapel kontinuierlich um 1 ( K) zu vergrößern und die sXGröße des Stapels ( z) in benutzerdefinierten Registern zu speichern, wenn er mit jedem eindeutigen ASCII-Code übereinstimmt. Das Drucken ( P) erfolgt durchgehend.

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsSKKzsQKKKKKzsqKKKKKzsCKKzsDKKKKKKKKKKKKKKKKKKKzPKzsBKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKzsaKKKzsdKzseKKKzshKzsiKKKKKzPldPlSPKKKKKzsszPlhPlePlSPlsPlaPliPldPlCPlSPlqPlBPKzdstzPdPlSPdPlhPlaPPlqPlsdPlSPlhPliPPlDPlqP

Probieren Sie es online!

Ich habe einige Optimierungen vorgenommen, z. B. einen Buchstaben nicht zu speichern, wenn er danach nicht verwendet wird d, z. B. das Duplizieren ( ) eines Buchstabens, z lX.

80186+ Computercode, MS-DOS .COM-Format, 822 787 Byte

Neben Buchstaben werden nur Tabulatoren und Leerzeichen verwendet. Da die meisten Opcodes im zulässigen Bereich bestimmte Inkremente, Dekremente, Pushs, Pops und registerindirekte ANDs und ORs sind, nutze ich zusätzlich zu IMUL die Tatsache, dass das Stapelregister einen Zeilenumbruch ausführt, wenn es das Ende erreicht des Segments, um den Code in umgekehrter Reihenfolge zu ändern! 80186+ Assembly ist erforderlich, da ich sofort Werte pushe.

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

Kommentierte Quelle (TASM-Format):

IDEAL
P186

MODEL   TINY
CODESEG
ORG 100H

MAIN:   
REPT 582
    POP AX  ; Set up stack to end of string
ENDM

    PUSH 68H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],59H ; 68H*59H=2428H
    DEC CX ; -1=2427H
    PUSH CX

    PUSH BX
    POP AX
    AND [BX+58H],AL
    PUSH 64H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],77H ; 64H*77H=2E7CH
REPT 9
    DEC CX ; -9=2E73H
ENDM
    PUSH CX

    PUSH 6968H
    PUSH 2073H

    IMUL CX,[BX+58H],65H ; 64H*65H=2774H
    PUSH CX

    PUSH 6920H
    PUSH 7475H

    PUSH BX
    POP AX
    DEC AX
    OR [BX+58H],AX ; FFFFH
REPT 6
    DEC AX
ENDM
    AND [BX+58H],AL ; FFF9H
    PUSH BX
    POP AX
    AND [BX+59H],AL ; 00F9H
    IMUL CX,[BX+58H],44H ; 0F9H*44H=4224H
REPT 3
    INC CX ; +3=4227H
ENDM
    PUSH CX

    PUSH BX
    POP AX
    AND [BX+58H],AL
    PUSH 47H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],74H ; 47H*74H=202CH
    PUSH CX

    PUSH 6469H
    PUSH 6173H
    PUSH 2065H
    PUSH 6873H
    PUSH 2064H
    PUSH 6E41H

;; CODE STARTS:
;; PUSH 0909H
;; POP AX
;; PUSH 046CH
;; POP DX
;; INT 21H
;; INT 20H

    PUSH BX
    POP AX
    AND [BX+58H],AL
    PUSH 54H
    POP AX
    OR [BX+58H],AX
    IMUL CX,[BX+58H],64H ; 54H*64H=20D0H
REPT 3
    DEC CX ; -3=20CDH
ENDM
    PUSH CX

    IMUL CX,[BX+58H],67H ; 54H*67H=21CCH
    INC CX ; 21CDH
    PUSH CX

    PUSH BX
    POP AX
    AND [BX+58H],AL
REPT 21
    DEC AX
ENDM
    OR [BX+58H],AX ; 0FFEBH
    PUSH BX
    POP AX
    AND [BX+59H],AL ; 0EBH
    IMUL CX,[BX+58H],62H ; 0EBH*62H=59F6H
REPT 14
    INC CX ; +14=5A04H
ENDM
    PUSH CX

    PUSH 6C68H
    PUSH 5809H
    PUSH 0968H

    JNO $+4FH

END MAIN
ENDS

Befunge-98 (FBBI) , 125 124 121 Bytes

wab









And she said   But that s his












wakekekaayyeapwayyaayybyapayybyapcyabcyaayycayyba
a



b
wayapapoq

Probieren Sie es online! Ausgabe in eine Datei mit dem Namen \n(eine einzelne Zeile). Vielen Dank an Jo King für sein Drehbuch.

Die Ausgabe enthält 10 nachgestellte Zeilenumbrüche.

Bei nur einer nachgestellten Zeile +1 Byte durch Ändern der folgenden Zeile:

wakekekaayyeapwayydayybyapayybyapycyabcyaayycayyba

Probieren Sie es online!

Erläuterung:

Der Anweisungszeiger bewegt sich wie folgt:

Das Programm setzt die nicht alphabetischen Zeichen in Position, bevor diese Zeile in eine Datei ausgegeben wird.

Befunge-98 enthält Anweisungen a... f, die den entsprechenden Hexadezimalwert auf den Stapel schreiben . Um andere Zahlen zu generieren, werden diese Werte yals Argumente an ("Get SysInfo") übergeben, um Folgendes zu erhalten:

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

23* stack size

Indem Sie den Großteil des Codes auf y = 23 setzen, ayykönnen Sie wiederholt auf die Stapelgröße zugreifen, die dann zum Generieren von Zeichencodes verwendet wird.

Pyth , 210 Bytes

pChyCdpCyhyhlGpCyytlGpdpChFhTyylGpCyylGpChyytlGpdpChFhTyylGpCtytytlGpChyylGpCyytlGpCyyhTpdpCtyyTpCyhCdpCtFyyCdhTpCyhFlGCdpdpCyhFlGCdpCyylGpCtytytlGpCyhFlGCdpCtyyTpChFhTyylGpdpCyylGpChyylGpChFhTyylGpCyhyhTpCtyyT

Probieren Sie es online!

Ich fand einige Zahlen, die nur mit Buchstaben ausgedrückt werden konnten (wie T= 10, Z= 0, lG= Länge (Alphabet) = 26, Cd= Zeichencode (Leerzeichen) = 32), und einige Funktionen, die nur mit Buchstaben ausgeführt werden konnten (wie t= Dekrementieren, h= Inkrementieren, hF= wiederholtes Anwenden von Inkrementieren = Addieren) und dann einfach eine Brute-Force-Suche durchgeführt, um die kürzesten Kombinationen dieser Funktionen und Zahlen zu finden, die zu jedem der von mir benötigten Buchstaben führten.

16-Bit-x86-Assemblycode, 665 Byte

Ich habe irgendwie vergessen, dass Leerzeichen erlaubt sind. Sicherlich kann der Code dadurch golfen werden.

Bytecode:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXsBFVKZPFFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPFPXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXkLAFQQZJJJRkDCGPLXDPDJRkDBEPZJJRLZDRDZAAAQPLYDQDYXXDQhishZhDRDhZsDQDhaththRDhuthZBDQDRhidhsaRDhhehZsDRDhndhZADTZPiDEFY

Quelle:

    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

Es funktioniert so:

• Bewegt den Stapelzeiger über POP AX an das Ende des Codes (POP SP ist nicht möglich, da es nicht alphabetisch ist).

• erstellt die Anweisung zum Senden eines DOS-Aufrufs (algorithmisch, da er nicht alphabetisch ist);

• konstruiert die nicht-alphabetischen Zeichen;

• legt den String auf den Stapel;

• Platziert die Dispatch-Anweisung auf dem Stapel genau am Ende des Codes, sodass die Ausführung direkt zu dieser Anweisung fließt.

• erstellt die Anweisung zum Drucken einer Zeichenfolge;

• zeigt die Zeichenfolge an und sie stürzt sofort ab. : - / (Ein ordnungsgemäßer Exit würde mehr Code erfordern)

Japt , 74 Bytes

HdEz
iHdE isiiihiSisiUitiaihitiSitiuibu iUiSiHdC idiiiaisiSieihisiSidiniau

Versuch es

05AB1E , 145 121 109 Bytes

TnVYTOUXZxNJTZXTZZZXYTYxMNYTTMNNNYRYNNYNNNNYTXZMNNYxXRZZZXTYXRZZXZYxTRMRNXRMRMXNNYxYMRNTYxTRYNTZMYXRXXXTZJCXB

Probieren Sie es online!

80186 Maschinencode + DOS, 91 Bytes

Textversion:

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

Textversion mit Tabulatoren (Code 9) 9und Leerzeichen (Code 32) ersetzt durch *:

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

Der Maschinencode wird in einer Datei mit der Erweiterung angezeigt .com. Wenn ich es ausführe, druckt es die erforderliche Nachricht und hängt dann (zufällige Daten werden ausgeführt).

Erklärung auf hoher Ebene, was es tut:

1. Initialisiert Register mit konstanten Werten
2. Ersetzt Leerzeichen in der Nachricht durch die erforderlichen Sonderzeichen ( ,'.$)
3. Korrigiert den Code, um die int 21Anweisung zu generieren , die die Nachricht druckt
4. Ruft DOS auf

Assembler-Code (kann mit kompiliert werden 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

Es benutzt den popaBefehl, um alle Register zu popfüllen , da regular nicht alle benötigten Register füllen kann (zB pop diist ein verbotener Opcode).

Die Adressen der zu patchenden Bytes liegen im Bereich von 0x100 ... 0x160. Glücklicherweise können sie als Summe von 3 Bytes mit zulässigen Werten dargestellt werden:

• 0x7a in bp
• 0x7a oder 0x67 in sioderdi
• Sofortiger Wert

Das Patchen von Bytes in der Nachricht erfolgt logisch ORmit 0x20 (Leerzeichen) und einer kleinen Konstante (4, 7, 12 oder 14). Die kleine Konstante wird durch Initialisieren von cxund dxauf 9 (Tabulatorzeichen) und Ausführen INCoder DECnach Bedarf erhalten.

Das Patchen von Code verwendet die IMULAnweisung. Ich habe die benötigten 16-Bit-Konstanten gefunden, um sie mithilfe der Brute-Force-Suche zu multiplizieren.

Schließlich wird die Adresse der Nachricht (0x13b) durch Multiplikation erhalten. Um Platz zu sparen, habe ich eine der Konstanten aus einer der Anweisungen genommen, die einen unmittelbaren Wert enthält 0x96d. Hier 9wählt der Teil eine DOS-Druckfunktion und der 6dTeil ist ein freier Parameter. Es stellt sich heraus, dass dies 6ddie einzige Möglichkeit ist, die nach der Multiplikation 0x13b ergeben kann.

Demontage des Codeteils:

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)

Unterhaltsame Tatsache: Normalerweise würde ich offset messageanstelle der 13bhhartcodierten verwenden, aber in diesem Fall generiert tasm, da zum Zeitpunkt der Analyse die Adresse unbekannt ist, einen sofortigen 16-Bit-Offset und verschwendet 1 Codebyte:

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