Cas inversez votre quine
Écrivez une quine qui tente d'inverser la casse du plus grand nombre possible de caractères ascii dans le code source. Par exemple en javascript:
(x=function(y){return ('(x='+y+')(x)').toUpperCase();})(x)
Les règles de quine standard s'appliquent.
Le score est donné par nombre d'octets dans le code source - nombre d'inversions de cas . Par exemple, la quine ci-dessus a un score de 29.
Le programme avec le score le plus bas l'emporte. Si deux programmes ont le même score, le plus court l'emporte.
Réponses
> <> , score 479 - 479 = 0
lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllbfppllfepeeppppgglcepppbeppppppppppplfdppedpddpgglcdppbdpfcpecpggldcppllccpbcpplfbpebppldbppcbpggcbglefgpgbeglefgpgcbglefgpgggggedglefgpgccglefgpgfdglefgpgebglefgpgecglefgpggdcglefgpgceglefgpgeeglefgpgbcglefgpgfbglefgpgcdgfefgpbdgeefgpfegdefgpccgcefgpfdgbefgpdbgaefgpppddglefgpgbcglefgpgfcglefgpgdbglefgpgdcglefgpgecglefgpgddglefgpgdbglefgplffpbfgffgefgpcbgefgefgp
Essayez-le en ligne!
Comment ça fonctionne
Très peu d'instructions utiles dans> <> sont des lettres. Cependant, nous avons toujours le l, poussant la longueur de la pile vers la pile. En tant que tel, il est possible de pousser (très verbalement) des valeurs arbitraires vers la pile. Ainsi, les chaînes peuvent être codées de la même manière que brainfuck, en utilisant apour augmenter la longueur de la pile, et / gou ppour la réduire.
Selon les règles de Quine habituelles, gne sert pas à lire le code source lui - même, au lieu de maintenir des registres à des endroits tels que bbet , bcet ainsi de suite.
La chaîne encodée est le préfixe:
"r&:20&3-:&?.p48*-od0l2)?.;lllll"]"
Qui après plus de 7 000 instructions sort la chaîne d'origine en majuscules.
Gol> <> , 77 75 - 75 = 0
urassssissezplzelssmzmzpssazmkqjmkrmbrrrrrtsuotlballsssssassmzpsssssbssmzpu
Essayez-le en ligne!
Basé sur la réponse de Bubbler , cela va encore plus loin en mettant également le "au début du code pour obtenir un score de 0!
Explication
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> <> , score 34 - 33 = 1
"mrllssslssscsmzpdsmzprrrrrrtsuota
Essayez-le en ligne!
Renvoie ce qui suit et quitte par erreur, qui est tous les caractères en majuscules sauf le premier ".
"MRLLSSSLSSSCSMZPDSMZPRRRRRRTSUOTA
Comment ça fonctionne
Les lignes marquées d'un *sont les différences par rapport à la version précédente.
"..." 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> <> , score 34 - 31 = 3
"mrlTSuotaaaaaaaaaaaaaaaaaaaaaaaaa
Essayez-le en ligne!
Sort les éléments suivants et sort par erreur.
"MRLTSUOTAAAAAAAAAAAAAAAAAAAAAAAAA
Toutes les lettres minuscules sont en majuscules, donc les seuls caractères qui ne sont pas modifiés le sont "TS.
Comment ça fonctionne
"..." 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
Je soupçonne que 2 ou moins pourraient être possibles.
V (vim) , score 3
2i2I
Essayez-le en ligne!
4 octets avec 1 inversion de casse. Insère deux fois ( 2i) la chaîne 2I.
80186+ code machine (format MS-DOS .COM), 115-115 = 0
Il était un peu difficile à faire, car je n'eu accès à INC, DEC, PUSH, certaines POPvariations, POPA, IMULet certains sauts conditionnels. Heureusement, IMULpourrait faire le gros du travail pour ce défi!
J'ai encodé le code réel qui effectue l'impression dans une série de valeurs qui se multiplient. Je calcule ces valeurs (qui sont tronquées à des valeurs 16 bits), les stocke sur la pile que j'ai déplacée juste au-dessus du code, puis saute au code généré pour imprimer le code du programme dans le cas contraire.
Langage machine:
hrXhCNhGUhnPhPwhYkhvLhKwaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaPQRjZTUVjfaiQVGARiQSCARiQPQARiQMJARiQJZARiQGuARiQDkARiQAWARpI
Source de l'assembleur:
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
(nouvelle ligne de fin)
Explication
0"D34çýu"D34çýu # full code
0"D34çý "D34çý # standard 05AB1E quine
u u # uppercase string in stack
# implicit print
Ce n'est pas le meilleur golf, mais c'est mon premier golf alors ayez pitié s'il vous plaît.
Essayez-le en ligne!
05AB1E (ancien), 16 - 8 = 8
0"D34çýš"D34çýš
(nouvelle ligne de fin)
Explication
0"D34çýu"D34çýu # full code
0"D34çý "D34çý # standard 05AB1E quine
š š # switch case builtin
# implicit print
Merci à Kevin Cruijssen pour -2 points. Ne fonctionne pas avec le 05AB1E actuel car la fonction de cas de commutation est .šce qui augmente le nombre d'octets
Essayez-le en ligne!
Rubis , score 24 20 16 12
eval S="print'EVAL s=';p S.swapcase"
Essayez-le en ligne!
37 octets avec 25 inversions de cas. La casse de chaque lettre est modifiée dans la sortie.
Perl 5 , 37 octets, 20 cas échangés, score 17
Merci à @Dominic van Essen pour -1!
eval($a=q{print uc"eval(\$a=q{$a})"})
Essayez-le en ligne!
JavaScript (Node.js) , 70 - 38 = 32
f=x=>`f=${f}`.replace(/(.)/g,y=>y<'`'?y.toLowerCase():y.toUpperCase())
Essayez-le en ligne!
BTW: C'est ma première contribution et je suis un peu confus. Je me suis assuré d'échanger tous les personnages possibles. L'exemple uniquement en majuscules. Si vous n'avez pas besoin d'échanger réellement des cas, alors on peut obtenir 11-0 = 11 avec une variante simplifiée d'une réponse donnée ci-dessus:
f=x=>"f="+f
Keg , score 4
`④`④
Essayez-le en ligne!
4 octets avec 0 conversion de cas.
La quine standard sans conversion de cas bat facilement toutes les approches de Keg qui auraient une conversion de cas: au moment où vous avez jeté des techniques de conversion de cas dans le mélange, vous pourriez aussi bien avoir écrit une quine standard sans détails fantaisistes.
Javascript, 27 - 13 = 14
f=x=>`f=${f}`.toUpperCase()
Essayez-le en ligne!
Python 2 , score 52 - 33 = 19
s='S=%r;PRINT S%%S.SWAPCASE()';print s%s.swapcase()
Essayez-le en ligne!
La casse inverse chaque lettre de la quine.
R , score = 78 - 53 = 25
a="a=%s;cat(toupper(sprintf(a,squote(a))))";cat(toupper(sprintf(a,sQuote(a))))
Essayez-le en ligne!