Caso inverti il tuo quine
Scrivi un quine che tenti di invertire il caso di quanti più caratteri ASCII nel codice sorgente possibile. Ad esempio in javascript:
(x=function(y){return ('(x='+y+')(x)').toUpperCase();})(x)
Si applicano le regole standard del quine.
Il punteggio è dato dal numero di byte nel codice sorgente - numero di inversioni di maiuscole e minuscole . Ad esempio, il quine sopra ha un punteggio di 29.
Il programma con il punteggio più basso vince. Se due programmi hanno lo stesso punteggio, vince quello più breve.
Risposte
> <> , punteggio 479-479 = 0
lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllbfppllfepeeppppgglcepppbeppppppppppplfdppedpddpgglcdppbdpfcpecpggldcppllccpbcpplfbpebppldbppcbpggcbglefgpgbeglefgpgcbglefgpgggggedglefgpgccglefgpgfdglefgpgebglefgpgecglefgpggdcglefgpgceglefgpgeeglefgpgbcglefgpgfbglefgpgcdgfefgpbdgeefgpfegdefgpccgcefgpfdgbefgpdbgaefgpppddglefgpgbcglefgpgfcglefgpgdbglefgpgdcglefgpgecglefgpgddglefgpgdbglefgplffpbfgffgefgpcbgefgefgp
Provalo online!
Come funziona
Pochissime istruzioni utili in> <> sono lettere. Tuttavia, abbiamo ancora il l, spingendo la lunghezza della pila verso la pila. In quanto tale, è possibile inserire (in modo molto verboso) valori arbitrari nello stack. Pertanto, le stringhe possono essere codificate in modo simile a Brainfuck, utilizzando aper aumentare la lunghezza della pila geo pper ridurla.
Come al solito regole Quine, gnon viene utilizzato per leggere il codice stesso, invece tenuta dei registri in luoghi come bbe bc, e così via.
La stringa codificata è il prefisso:
"r&:20&3-:&?.p48*-od0l2)?.;lllll"]"
Che dopo oltre 7.000 istruzioni restituisce la stringa originale in maiuscolo.
Gol> <> , 77 75-75 = 0
urassssissezplzelssmzmzpssazmkqjmkrmbrrrrrtsuotlballsssssassmzpsssssbssmzpu
Provalo online!
Sulla base della risposta di Bubbler , questo va ancora oltre inserendo anche "il all'inizio del codice per ottenere un punteggio di 0!
Spiegazione
ur Move over one on the stack tape and reverse the stack
assssissez Push 10+16*4=74,-1+16*2=31,!(15)=0
p And put the 74 (J) at position 0,31
lz Push 0 if there is anything on the stack
e Push 14 for later
lssmzmz Push 2+16*2=34, !(-1)=0, !(-1)=0
p Put the 34 (") at position 0,0
sss Add 3*16 to the -1 from earlier
az Push !(10)=0
mkq Some no-ops
J And jump to 0,47 if the stack was initially empty
lballsssssassmzp Put T at position 0,43
sssssbssmzpu Put S at position 0,44
u Move one over on the stack again (effectively resetting the stack)
" Wrap, pushing everything to the stack
r Reverse
......... Put everything again
J But this time don't jump, since the stack is not empty
mk Copy the bottom of the stack (u)
rm Push a -1 to the bottom of the stack
brrrrr No-ops
T t Finally, loop over the stack,
Suo Capitalising then outputting everything until we get to the -1
Gol> <> , punteggio 34-33 = 1
"mrllssslssscsmzpdsmzprrrrrrtsuota
Provalo online!
Restituisce quanto segue ed esce per errore, che è ogni carattere maiuscolo eccetto il primo ".
"MRLLSSSLSSSCSMZPDSMZPRRRRRRTSUOTA
Come funziona
Le linee contrassegnate con *sono le differenze rispetto alla versione precedente.
"..." Push every char except `"`
mrl Push -1, reverse stack, push stack length (34 = `"`)
* lsss Push stack length (35) and add 16 three times (83 = S)
* lsss Push stack length (36) and add 16 three times (84 = T)
* csmzp Push 13, add 16 (29), push -1, boolean negate (0), and
replace the command at (29,0) by T
* dsmzp Push 14, add 16 (30), push -1, boolean negate (0), and
replace the command at (30,0) by S
* rrrrrr Reverse the stack 6 times;
no-op to move the positions to overwrite
TSuot Infinite uppercase-print loop; halt by error at -1
a Not executed
Gol> <> , punteggio 34-31 = 3
"mrlTSuotaaaaaaaaaaaaaaaaaaaaaaaaa
Provalo online!
Emette quanto segue ed esce per errore.
"MRLTSUOTAAAAAAAAAAAAAAAAAAAAAAAAA
Ogni lettera minuscola è maiuscola, quindi gli unici caratteri che non vengono modificati lo sono "TS.
Come funziona
"..." Start string literal, push every char in the source code (except `"`),
wrap around and end string literal
mr Push -1 and reverse the stack
(setup the chars for printing from top, and bury the trap at the bottom)
l Push length of stack, which gives 34 == `"`
T...t Infinite loop until it errors in the middle:
Su Uppercase the char at the top (errors when trying to uppercase -1)
o Pop and print as char
a... Not reached
Sospetto che 2 o meno potrebbe essere possibile.
V (vim) , punteggio 3
2i2I
Provalo online!
4 byte con 1 inversione di caso. Inserisce due volte ( 2i) la stringa 2I.
80186+ codice macchina (formato MS-DOS .COM), 115-115 = 0
E 'stato un po' difficile da fare questo, come ho avuto solo l'accesso a INC, DEC, PUSH, alcune POPvariazioni, POPA, IMUL, e alcuni salti condizionati. Fortunatamente, IMULpotrebbe fare il lavoro pesante per questa sfida!
Ho codificato il codice effettivo che esegue la stampa in una serie di valori che vengono moltiplicati insieme. Calcolo quei valori (che vengono troncati a valori a 16 bit), li memorizzo sullo stack che ho spostato appena sopra il codice, quindi salto al codice generato per stampare il codice del programma nel caso opposto.
Codice macchina:
hrXhCNhGUhnPhPwhYkhvLhKwaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaPQRjZTUVjfaiQVGARiQSCARiQPQARiQMJARiQJZARiQGuARiQDkARiQAWARpI
Fonte dell'assemblatore:
IDEAL
P186
MODEL TINY
CODESEG
ORG 100H
MAIN:
; Encoded code:
; MOV SI,100H
; MOV CX,73H
; PRINT:
; LODSB
; XOR AL,20H
; INT 29H
; NOP
; LOOP PRINT
; INT 20H
; Offset Bytes Multiplier
PUSH 5872H ; +41 BE 00 4157H
PUSH 4E43H ; +44 01 B9 416BH
PUSH 5547H ; +47 73 00 4175H
PUSH 506EH ; +4A AC 34 415AH
PUSH 7750H ; +4D 20 CD 414AH
PUSH 6B59H ; +50 29 90 4151H
PUSH 4C76H ; +53 E2 F8 4143H
PUSH 774BH ; +56 CD 20 4147H
REPT 30
POPA ; Adjust stack to point to end of generated code
ENDM
PUSH AX
PUSH CX
PUSH DX
PUSH 5AH
PUSH SP
PUSH BP
PUSH SI
PUSH 66H
POPA ; Use POPA as POP DX and POP DI are not in [A-Za-z]
IMUL DX,[BX+DI+56H],4147H
PUSH DX
IMUL DX,[BX+DI+53H],4143H
PUSH DX
IMUL DX,[BX+DI+50H],4151H
PUSH DX
IMUL DX,[BX+DI+4DH],414AH
PUSH DX
IMUL DX,[BX+DI+4AH],415AH
PUSH DX
IMUL DX,[BX+DI+47H],4175H
PUSH DX
IMUL DX,[BX+DI+44H],416BH
PUSH DX
IMUL DX,[BX+DI+41H],4157H
PUSH DX
JO $+4BH ; Jump to start of generated code
END MAIN
ENDS
05AB1E, 16 - 6 = 10
0"D34çýu"D34çýu
(nuova riga finale)
Spiegazione
0"D34çýu"D34çýu # full code
0"D34çý "D34çý # standard 05AB1E quine
u u # uppercase string in stack
# implicit print
Non è il miglior golf, ma è il mio primo golf quindi abbi pietà per favore.
Provalo online!
05AB1E (legacy), 16 - 8 = 8
0"D34çýš"D34çýš
(nuova riga finale)
Spiegazione
0"D34çýu"D34çýu # full code
0"D34çý "D34çý # standard 05AB1E quine
š š # switch case builtin
# implicit print
Grazie a Kevin Cruijssen per il punteggio di -2. Non funziona con l'attuale 05AB1E perché la funzione switch case è .šche aumenta il conteggio dei byte
Provalo online!
Ruby , punteggio 24 20 16 12
eval S="print'EVAL s=';p S.swapcase"
Provalo online!
37 byte con 25 inversioni di case. Il caso di ogni lettera viene modificato nell'output.
Perl 5 , 37 byte, 20 casi scambiati, punteggio 17
Grazie a @Dominic van Essen per -1!
eval($a=q{print uc"eval(\$a=q{$a})"})
Provalo online!
JavaScript (Node.js) , 70-38 = 32
f=x=>`f=${f}`.replace(/(.)/g,y=>y<'`'?y.toLowerCase():y.toUpperCase())
Provalo online!
BTW: Questo è il mio primo contributo e sono un po 'confuso. Mi sono assicurato di scambiare ogni personaggio possibile. L'esempio è solo maiuscolo. Se non è necessario scambiare effettivamente i casi, si può ottenere 11-0 = 11 con una variante semplificata di una risposta data sopra:
f=x=>"f="+f
Barile , punteggio 4
`④`④
Provalo online!
4 byte con 0 conversioni di case.
Il quine standard senza conversione del caso batte facilmente qualsiasi approccio di Keg che avrebbe la conversione del caso: nel momento in cui hai inserito le tecniche di conversione del caso nel mix, potresti anche aver appena scritto un quine standard senza dettagli fantasiosi.
Javascript, 27 - 13 = 14
f=x=>`f=${f}`.toUpperCase()
Provalo online!
Python 2 , punteggio 52-33 = 19
s='S=%r;PRINT S%%S.SWAPCASE()';print s%s.swapcase()
Provalo online!
Il caso inverte ogni lettera del quine.
R , punteggio = 78-53 = 25
a="a=%s;cat(toupper(sprintf(a,squote(a))))";cat(toupper(sprintf(a,sQuote(a))))
Provalo online!