Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
Write a quine which attempts to invert the case of as many ascii characters in the source code as possible. For example in javascript:
(x=function(y){return ('(x='+y+')(x)').toUpperCase();})(x)
Standard quine rules apply.
The score is given by number of bytes in the source code - number of case inversions. For example, the quine above has a score of 29.
The program with the lowest score wins. If two programs have the same score then the shorter one wins.
lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllbfppllfepeeppppgglcepppbeppppppppppplfdppedpddpgglcdppbdpfcpecpggldcppllccpbcpplfbpebppldbppcbpggcbglefgpgbeglefgpgcbglefgpgggggedglefgpgccglefgpgfdglefgpgebglefgpgecglefgpggdcglefgpgceglefgpgeeglefgpgbcglefgpgfbglefgpgcdgfefgpbdgeefgpfegdefgpccgcefgpfdgbefgpdbgaefgpppddglefgpgbcglefgpgfcglefgpgdbglefgpgdcglefgpgecglefgpgddglefgpgdbglefgplffpbfgffgefgpcbgefgefgp
Very few useful instructions in ><> are letters.
However, we still have the l, pushing the length of the stack to the stack. As such, it's possible to (very verbosely) push arbitrary values to the stack. Thus, strings can be encoded in a similar fashion to brainfuck, using a to increase the length of the stack, and g or p to reduce it.
As per usual quine rules, g is not used to read the source code itself, instead maintaining registers at locations such asbb and bc and so on.
The string encoded is the prefix:
"r&:20&3-:&?.p48*-od0l2)?.;lllll"]"
Which after over 7,000 instructions outputs the original string in upper case.
urassssissezplzelssmzmzpssazmkqjmkrmbrrrrrtsuotlballsssssassmzpsssssbssmzpu
Based on Bubbler's answer, this goes even further by also putting the " at the start of the code to get a score of 0!
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
"mrllssslssscsmzpdsmzprrrrrrtsuota
Outputs the following and exits by error, which is every char uppercased except the leading ".
"MRLLSSSLSSSCSMZPDSMZPRRRRRRTSUOTA
The lines marked with * are the differences from the previous version.
"..." 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
"mrlTSuotaaaaaaaaaaaaaaaaaaaaaaaaa
Outputs the following and exits by error.
"MRLTSUOTAAAAAAAAAAAAAAAAAAAAAAAAA
Every lowercase letters are uppercased, so the only chars that are not modified are "TS.
"..." 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
I suspect 2 or lower might be possible.
2I. <esc> completes the i insert so the initial 2 can be used to double the insertion to 2I2I.
\$\endgroup\$
– Noodle9
Aug 19 '20 at 9:40
ñéÑ"qpxVUllvulllllvlu would have a score of 1 Try it online!
\$\endgroup\$
– James
Aug 19 '20 at 20:45
It was a bit tricky to do this, as I only had access to INC, DEC, PUSH, certain POP variations, POPA, IMUL, and certain conditional jumps. Fortunately, IMUL could do the heavy lifting for this challenge!
I encoded the actual code that does the printing in a series of values that get multiplied together. I compute those values (which get truncated to 16-bit values), store them on the stack which I moved to be just above the code, and then jump to the generated code to print the program's code in the opposite case.
Machine code:
hrXhCNhGUhnPhPwhYkhvLhKwaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaPQRjZTUVjfaiQVGARiQSCARiQPQARiQMJARiQJZARiQGuARiQDkARiQAWARpI
Assembler source:
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
0"D34çýu"D34çýu
(trailing newline)
0"D34çýu"D34çýu # full code
0"D34çý "D34çý # standard 05AB1E quine
u u # uppercase string in stack
# implicit print
Not the best golf, but it is my first golf so have mercy please.
0"D34çýš"D34çýš
(trailing newline)
0"D34çýu"D34çýu # full code
0"D34çý "D34çý # standard 05AB1E quine
š š # switch case builtin
# implicit print
Thanks to Kevin Cruijssen for -2 score.
Doesnt work with current 05AB1E becuase the switch case function is .š which makes the byte count larger
.š (switch case builtin) only works on ASCII letters a-zA-Z in the new version of 05AB1E. You can however improve your score by switching to the older legacy version of 05AB1E, and use š instead of u: 0"D34çýš"D34çýš, which also switches the unicode letters çýš. Btw, I think your current score is actually 16-2=14, since only the two u are U in your output, and everything else is the same. The new score would become 16-8=8. Nice first answer regardless, and welcome to CGCC! :)
\$\endgroup\$
– Kevin Cruijssen
Aug 20 '20 at 15:06
u only worked with ASCII letters, but apparently I was mistaken. You can still lower your score by 2 by changing the language to 05AB1E (legacy) and changing both u to š, which is the switch-case builtin. :) In the new 05AB1E version this would be .š instead, which make the byte-count larger.
\$\endgroup\$
– Kevin Cruijssen
Aug 20 '20 at 16:39
eval S="print'EVAL s=';p S.swapcase"
37 bytes with 25 case inversions. The case of every letter is changed in the output.
Thanks to @Dominic van Essen for -1!
eval($a=q{print uc"eval(\$a=q{$a})"})
printf+qw()x2 approach, but %S doesn't work... Also looked as using letters as delimeters (q z...z) but the nesting is problematic, didn't think to rearrange though... :)
\$\endgroup\$
– Dom Hastings
Aug 19 '20 at 12:00
\$ doesn't count :P
\$\endgroup\$
– Dom Hastings
Aug 19 '20 at 14:07
f=x=>`f=${f}`.replace(/(.)/g,y=>y<'`'?y.toLowerCase():y.toUpperCase())
BTW: This is my first contribution and I'm a bit confused. I made sure to swap every possible character. The example only uppercases. If you don't need to actually swap cases, then one can get 11-0=11 with a simplified variant of an answer given above:
f=x=>"f="+f
`④`④
4 bytes with 0 case conversions.
The standard quine without case conversion easily beats any Keg approaches that would have case conversion: by the time you've thrown case conversion techniques into the mix, you might as well have just written a standard quine with no fancy details.
s='S=%r;PRINT S%%S.SWAPCASE()';print s%s.swapcase()
Case inverts every letter in the quine.
a="a=%s;cat(toupper(sprintf(a,squote(a))))";cat(toupper(sprintf(a,sQuote(a))))
invert the case of as many ascii charactersDoes that mean that if a unicode character has its case inverted complement, we aren't expected to count that unicode character if we invert it in our output? \$\endgroup\$ – user96495 Aug 19 '20 at 9:40Gol><>wins over><>). OP didn't have access to the sandbox when they wrote the challenge (see OP's first comment). \$\endgroup\$ – Bubbler Aug 20 '20 at 2:24