## DISARM THE B.O.M.B.!

218

45

You have been hired for your tech knowledge as a Secret Agent's sidekick to ensure that the good guy can get his job done and the world can be saved.

SPECS

1. Write a program that outputs in any way you want the string PASSWORD_01 (uppercase).
2. Since your keyboard has been hit by a bullet, you can only use these keys:

1 2 3 4 5

Q W E R T

A S D F G

< > Z X C

Ctrl Shift Tab Space

Using the Shift key, your keyboard allows you to use these characters:

! " · $% 3. You don't have any other hardware than the keyboard and the screen (a mouse for example), nor a file with the password written in your computer. 4. You don't have an Internet connection. 5. You can assume you have the interpreter shell / source editor opened before the bullets came in. Sadly you have not written anything in it before the keyboard was hit. 6. You don't have a virtual keyboard. In fact the BOMB has a TOO_FUNNY detector that will make it explode if you try to use the Standard loopholes. 7. Since your buddy is waiting for you to finish soon to escape off the Secret Base, you will have to write the smallest code possible (so it's and !). Good luck because the count down has begun! HELP MODE: Also a KEY (only one Key you want from the keyboard, but not the Shift + Key or any other combination) has miraculously survived too. E.g.: You can use =, or 0 or /… This extra key cannot be any of the letters in PASSWORD_01 (so you cannot add P or O). Name that key in your answer. You have a penalization of 10 characters for use of this key regardless of how many times you use the key. 3What happens is you do Shift-<>? – CalculatorFeline – 2016-03-04T15:20:53.817 -1: doesn't include the ; line ending that is required for many languages, not to mention , these challenges are typically not well received in the first place... – None – 2016-09-28T20:01:05.013 1@tuskiomi You having a bad day? You realize this challenge is amazingly received and 2 years old? Look at the successful answers. Go learn some more languages besides Java. I literally just solved the challenge, so it's do-able. – mbomb007 – 2016-09-28T21:46:51.320 @mbomb007 not having a bad day. I'm strongly against challenges that promote golf / esoteric languages. – None – 2016-09-28T21:58:43.053 2@tuskiomi I see a Ruby answer, a Perl answer, and multiple Python answers... – Steven H. – 2016-09-28T22:06:06.700 @StevenH. that's good. – None – 2016-09-28T22:15:23.970 @german_guy You don't have the Enter or Return keys, so there is no WS support here. – Erik the Outgolfer – 2016-09-29T14:40:09.267 Can I swap those unusable characters with their ascii codes, represented with 1 to 5? – Matthew Roh – 2017-02-16T06:32:02.840 @MatthewRoh By the spec, yes. – wizzwizz4 – 2017-02-22T19:58:03.790 Uh trying to do this in JavaScript is hard, I can't seem to get to a point of getting any useful characters... – Naruyoko – 2019-10-01T00:36:48.017 The thing is English generally use keys on the right side of the keyboard to form a word... – Naruyoko – 2019-10-01T00:55:16.210 Any chance you could include the characters : = or I cant even attempt this challenge since I need to assign values :P Also, are the arrow keys still working? – Teun Pronk – 2014-06-11T10:43:51.767 @TeunPronk added Help Mode ;) – Averroes – 2014-06-11T10:51:04.200 69Can I change the layout of the keyboard to DVORAK? – n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ – 2014-06-11T10:54:05.007 3@n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ No, sorry. I'm afraid that the Agency only provide you a Qwerty Keyboard :S – Averroes – 2014-06-11T10:59:14.357 Can I assume I'm running in a Python or JS console? Because I can't think of a language where I can actually print anything at all without the right side of the keyboard :s – Tal – 2014-06-11T11:02:09.537 @Tal You can assume it while you play in the spirit of the challenge. – Averroes – 2014-06-11T11:04:49.227 What's the third Shift character? (It doesn't look like a period or a hyphen, so...) – Volatility – 2014-06-11T11:06:49.113 1@Volatility · A middle dot (In my keyboard... I say in the Agency Keyboard is Shift + 3) – Averroes – 2014-06-11T11:12:31.213 9What bastardised version of the Spanish keyboard layout are you using which puts & on shift-5 rather than %? – Peter Taylor – 2014-06-11T11:15:22.300 Deleted my answer, will look for a better solution. So to make sure, besides the keys you named nothing else works? not even the keys that don't generate input? – Teun Pronk – 2014-06-11T11:16:58.353 2@PeterTaylor my bad! It's a %. Fixed. Hope not to cause any disrupt to other answers. – Averroes – 2014-06-11T11:20:25.270 5no parenthesis, no square brackets, no chain brackets... well that must eliminate 99% of languages. – Eoin Campbell – 2014-06-11T11:21:22.237 1It's much more troublesome without &. – gxtaillon – 2014-06-11T11:50:53.533 42Do we get the enter key at least? – Οurous – 2014-06-11T11:51:52.060 4Is "·" === "." ? This will brainfuck brainfuck.... – Tejas Kale – 2014-06-11T12:08:27.793 @TejasKale I hope it is, because otherwise I actually can't think of how to do this at all. – Οurous – 2014-06-11T12:10:16.493 Thinking about it again, "·" is coming from Shift + 3and is not equal to "." – Tejas Kale – 2014-06-11T12:16:33.393 1. is not equal to · Also, maybe we could allow multiple uses of help mode adding 10 to the code count for each new key saved. – Averroes – 2014-06-11T12:30:34.710 12Where's my CAPS LOCK? Must have been multiple bullets... – Timtech – 2014-06-11T12:36:24.863 @Averroes yes do that :D are we gonna do that? :P – Teun Pronk – 2014-06-11T12:46:40.220 @Averroes Also, can you pick any key you want for the help mode? – Teun Pronk – 2014-06-11T12:49:27.410 @TeunPronk I would like to prevent someone just picking all the letters from PASSWORD_01. – Averroes – 2014-06-11T12:52:36.343 73Whitespace, here is your big chance! – german_guy – 2014-06-11T13:08:10.393 1"You have a penalization of 10 characters for use this key." Is that 10 for each press of the key, or for each distinct character used? You might want to make that clear, since current answers are scoring it the latter way. – Geobits – 2014-06-11T13:15:40.217 What about boilerplate code created by your IDE, which included disallowed characters. Can they still be there, I don't want to copy/paste from it or anything like that, if not then this excludes languages like C# and Java doesn't it? – JMK – 2014-06-11T13:30:59.563 Wouldn't you only be able to use the keys on the broken keyboard to write the program too? – Elias – 2014-06-11T13:34:52.763 @Geobits +10 for use the Help mode. Then you can use that key as many times as you want (edited, thanks). – Averroes – 2014-06-11T13:39:59.203 1@BumblebeeMan I'm afraid that it will open the door to more changes and ambiguities in the specs. – Averroes – 2014-06-11T14:32:34.517 1@Averroes No worries, at least now I can claim that I totally could have completed the challenge otherwise...honest – JMK – 2014-06-11T14:46:30.827 1If only I had some parenthesis :( – nderscore – 2014-06-11T14:47:20.857 1hopefully, before the mission i configured my PHP installation with asp_tags, so i can start with <%. * hands on *..... can't use functions nor arrays.... * run run run * – Einacio – 2014-06-11T15:14:56.603 Can the Help Mode key be one from the number pad section of the keyboard? – Bradley Uffner – 2014-06-11T16:43:11.377 44Why couldn't the password have been stewardesses? – codebreaker – 2014-06-11T18:07:13.183 4 Is the character map a virtual keyboard? http://i.imgur.com/Bk9PHv9.png – Shane – 2014-06-11T19:10:30.993 4Is this one of these weird keyboards that doesn't have an Alt key?How did my control key survive, and my spacebar, but not my alt? – Nzall – 2014-06-11T20:40:59.927 @Shane nice try but how did you get there? :P – Averroes – 2014-06-11T20:41:36.517 4@NateKerkhofs It was a JFK bullet. It hit the keyboard multiple times. – Averroes – 2014-06-11T20:42:43.933 @BradleyUffner Nope. You can get a character but not a function or something like that. You could have the number nonetheless. – Averroes – 2014-06-11T20:44:21.413 24Joke answer: I'm a spy, I switch to the backup keyboard hidden in my watch. – Nzall – 2014-06-11T20:50:33.403 @NateKerkhofs or the one in your shoe! – Averroes – 2014-06-11T20:51:58.337 11I also hope whoever needs to enter this code can touch type really well, because there's no backspace to correct mistakes. – Nzall – 2014-06-11T20:56:58.333 8Every code-golf users should look at this question for how to create an interesting background story. – justhalf – 2014-06-12T03:26:12.193 Can I use the Tab key for auto-completion in bash? – user80551 – 2014-06-12T08:07:47.223 @user80551 I would say autocompletion will go against the spririt of the game if it make your work very easy. – Averroes – 2014-06-12T08:10:24.227 Can I use vi or emacs? or would it be a loophole? :grin: – Luka Ramishvili – 2014-06-12T08:56:31.123 "This is your last mission before retiring" - well, there's no way I'm surviving the day, then. I suppose copy-pasting characters from places like other documents or desktop icon names is out of the question; is it? – user2357112 supports Monica – 2014-06-12T09:46:34.150 < and > aren't on the left part of a keyboard – kinokijuf – 2014-06-12T10:44:08.467 @kinokijuf mine yes – Averroes – 2014-06-12T10:47:28.320 @user2357112 I would say it is – Averroes – 2014-06-12T10:48:04.097 This is a bitch in PHP :( Can't use any function because of the (), and a lot of functions have an underscore in them. – Martijn – 2014-06-12T11:52:16.187 @Martijn next challenge will be with the other side of the keyboard :P – Averroes – 2014-06-12T12:09:17.480 2“Big Overly Massive BOMB” is not a recursive acronym because the B is fixed. – kinokijuf – 2014-06-12T12:56:51.070 19@kinokijuf: It is. It's a tail recursive acronym. – justhalf – 2014-06-13T02:08:50.127 does the mouse work? – Stack Tracer – 2014-06-14T15:37:55.990 @StackTracer Nope, you haven't a mouse. – Averroes – 2014-06-15T12:21:06.320 Although the TOO_FUNNY detector catches the standard loopholes (which is a neat idea to get around those), I’d be somewhat intrigued to see which of the standard loopholes can still work here. – alexwlchan – 2014-06-17T14:03:21.787 ## Answers 43 # CJam - 24 + 10 (() = 34 "Q"c("ASSW"1$("aRD"(((T1


## No additional key - 39

211 131%c"ASSW"211 132%c"RD"321 113%cT1


Try it at http://cjam.aditsu.net/

14

– aditsu quit because SE is EVIL – 2014-06-11T13:52:43.443

136

I'm sitting at a bash prompt which has been configured by the Evil Genius, and of course he has VISUAL=vim in the default environment. Using the default bash binding for edit-and-execute-command (C-x C-e) bash invokes $VISUAL and will execute its buffer contents on exit (ZZ). I type in the following sequence (Note: kbd-mode are commands issued in normal mode and control sequences): 1. C-xC-e 2. acat<<<45C-c4C-aaa Now the vim buffer contains cat<<<49a. Continuing ... 3. 45C-c3C-aaa 4. 54C-c41C-aaa 5. 55C-c13C-aaa Now the vim buffer contains cat<<<49a48a95a68a. Continuing ... 6. 51C-c31C-aaa 7. 55C-c24C-aaa 8. 44C-c43C-aaa 9. 42C-c41C-aaa 10. 42C-c41C-aaa 11. 54C-c11C-aaa 12. 55C-c25C-aaa>s Now the vim buffer contains cat<<<49a48a95a68a82a79a87a83a83a65a80a>s Get out of insert mode, save and exit 13. C-cZZ The s file now contains a dc script that generates the desired string on the stack, now we need to add print commands. 14. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ Repeat the above command 9 times. 15. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 16. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 17. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 18. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 19. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 20. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 21. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 22. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 23. C-xC-eadc<<<55C-c25C-aaa>>sC-cZZ 24. C-xC-eacat<<< f >>s Execute the dc script: 25. C-xC-eadc sC-cZZ Output: PASSWORD_01  Contents of the s file: 49a48a95a68a82a79a87a83a83a65a80a P P P P P P P P P P f  4I was thinking to do a vim script because of the Ctrl character; good thinking to pair it with dc! Also, excellent solution :) – nneonneo – 2014-06-12T00:28:58.130 2How long did it take you to write all those <kbd></kbd> tags? – justhalf – 2014-06-13T17:13:03.810 15@justhalf: I wrote it in vim with <Leader>k bound like this map <Leader>k i<kbd></kbd>^[F>a, so it wasn't as bad as it looks :-). – Thor – 2014-06-13T23:25:59.360 19Now it's apparent that Agent Thor knows his tool thoroughly. You deserve the retirement, sir! – justhalf – 2014-06-14T01:46:06.850 67 ## Ruby, 57 + 10 (*) = 67 $*<<4*4*5<<214%135<<44%25*5<<1%1
$><<"%cASSW%cRD%c%d1"%$*


This answer uses * and % to build the ASCII values of the missing characters (and 0 as Fixnum) and pushes them into $* (ARGV). This array is then used in combination with a format string to generate the correct password, which is printed with $><< ($> is stdout). ## Ruby, 62 + 10 (.) = 72, no linebreak $>.<< "%cASSW%cRD%c%d1".% %w%%<<311%231<<214%135<<321%113<<1%1


Roughly the same principle as the above version, except that here the array is built from an empty array literal (%w%%). Some fiddling with . is needed to get the desired operator precedence.

13"This is your last mission before retiring with a high paycheck and the gratitude of the whole world." Congratulations, we all thank you :) – Timtech – 2014-06-11T14:01:51.357

4The ultimate proof that Perl is one of the biggest inspiration of Ruby. – Pierre Arlaud – 2014-06-11T14:11:11.073

11How did you do the linebreak? – Cephalopod – 2014-06-11T16:21:48.437

4@Arian The same way nneonneo runs his Python code after typing it into the REPL ... I'll add a version without linebreak. – Ventero – 2014-06-11T21:26:10.907

Does the evil genius have ruby installed? – Mohammad – 2014-06-13T10:24:28.373

36

# Whitespace (148 + 10 = 158)

Enter key needs to be used here.

SS+1010000L // Push code of P
TLSS        // Output character
SS+1000001L // Push code of A
TLSS        // Output character
SS+1010011L // Push code of S
SLS         // Duplicate top stack
TLSS
TLSS
SS+1010111L // Push code of W
TLSS
SS+1001111L // Push code of O
TLSS
SS+1010010L // Push code of R
TLSS
SS+1000100L // Push code of D
TLSS
SS+1011111L // Push code of _
TLSS
SS+0L       // Push 0
TLST        // Output number
SS+1L       // Push 1
TLST        // Output number
LLL         // End program


My notation's explanation:

• S, +, 0 are spaces.
• T, 1 are tabs.
• L is new line.
• // starts comment.

Each line is a command in whitespace language.

Demo

I know it's been almost 4 years, but you can golf the three trailing new-lines. Try it online.

– Kevin Cruijssen – 2018-02-26T12:20:12.240

@KevinCruijssen Is it part of the specs, or implementation-dependent? – n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ – 2018-03-01T21:13:00.123

Implementation-dependent I guess. The specs say a program should end with three LF, but many interpreters will run without. Got it from the Whitespace tip thread.

– Kevin Cruijssen – 2018-03-01T22:09:32.663

101 bytes. Here a highlighted/commented version: Try it online. It basically utilizes this Whitespace tip of mine, and the best constant 80 is generated with a Java program. – Kevin Cruijssen – 2019-08-08T09:01:31.497

@KevinCruijssen: Please go ahead and post your solution as an answer :) – n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ – 2019-08-08T10:12:57.320

@n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Done. :) – Kevin Cruijssen – 2019-08-08T10:34:48.127

1Ah man... I was just working on that :( – Teun Pronk – 2014-06-11T13:09:27.167

1Me too, but I gave up on this knowing someone would be faster – german_guy – 2014-06-11T13:11:25.350

I thought 'L' wasn't available? – 500 - Internal Server Error – 2014-06-12T14:18:03.980

@500-InternalServerError: Actually L stands for new line character. Check the Demo for the real code. What I posted is a readable version. – n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ – 2014-06-12T15:07:44.440

Ah, I get it now. – 500 - Internal Server Error – 2014-06-12T15:17:07.927

25

# Python (2200 395 + 10)

exec"""exec"exec"+"%ca"%34+"%c52+53"""+"%c55+55"%44+"%c34"%44+"%c45+35"%44+"%c"%44+"""34%%cexec"%"""+"%c"%54+"""1+"%c"%34+"%%5%c+"%5"""+"%c"%55+"""+"%c"%34+"%c"""+"%c"%112+"""r%%c%%ct%%c%%cASSW"+"%c%%34+"%34+"%c%%cRD"%34+"%c%%"""+"%c"%55+""""%34+"%c+"%5"""+"%c"%55+"""+"%c%%c"%34+"%c%%"%34+"%c5+"%5"""+"%c"%55+"""+"%c"%34+"%c1%%c"+"%c%%4"%34+"%c+"%5"""+"%c"%54+"""+"%c"%34+"%c%%a"+"%c%%34"%34"""


I needed the + character (costing +10), which can be obtained from the numpad (or on certain key layouts).

Yeah, the BOMB probably went off while I was typing that.

The basic approach is to construct ever larger character sets by using exec and "%c"%(number). There are four execs nested inside each other. Gradually, my digit set progresses up from

1. 12345
2. 1234567 (6 = ASCII 54, 7 = ASCII 55)
3. 123456789 (8 = ASCII 56, 9 = ASCII 57)
4. 0x0123456789abcdef

so that in the final iteration it is possible to express any character (so that the innermost version can actually run any program at all).

Around 50% of the program is just quote characters ("%c"%34 is a double quote), because the nested nature of the exec statements demands "escaping" quote characters aggressively.

If you use the "+" from the numeric keypad, you are independent from the keyboard language. – celtschk – 2014-06-12T20:31:14.710

@celtschk: Good point! I will edit that in. – nneonneo – 2014-06-12T20:32:28.243

1Rather than constructing digit sets with nested execs, couldn't you get numbers using arithmetic? Ex. exec '%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c'%(112,114,51+54,55+55,1+115,32,4+35,25+55,11+54,31+52,31+52,32+55,24+55,31+51,13+55,41+54,3+45,4+45,4+35) – Kevin – 2014-06-17T12:09:08.813

2Because you can't get both parens. (I did consider this!) – nneonneo – 2014-06-17T13:37:44.077

Additionally, Python doesn't have a lot of operators that bind more strongly than %. ** is one, but it tends to be fairly useless for constructing most terms. – nneonneo – 2014-06-17T13:39:43.840

25

# Insomnia393531 29

This language comes up when I was looking around for a language that encodes its instructions with single ASCII character. The language actually operates on the decimal ASCII code of the character, so it is still quite flexible with half of the keyboard destroyed.

Drop it down further to 29 characters, which is possible after reducing memory usage and increases the search space:

FdFzt%dF<rGdt>tt Gtreeet t%4s


I decided to run my tweaked up program on the full set of allowed characters, and cut the solution down to 31 characters:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s


I used a program to search for this solution. It is one among many solutions returned by my program, all with the same size.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s


Old version constructed by hand. I remember staying up till morning to do this.

Fddx>"eCeezdC>Cef>dx"dCezeeedeCrqeeC%4s


Here is the Insomnia interpreter for testing.

4+1 for the "staying up till morning" match with your programming language choice. – justhalf – 2014-12-04T02:36:59.990

20

## Vim + PHP on Some Window Managers

65 keys in 44 strokes, with a 10-point penalty for using =.

aEACE<Alt+Tab>z=5<Alt+Tab>$xxxxaASSWRD<Alt+Tab>z=1<Alt+Tab>$a$aA<Alt+Tab>==wxx$r1<^X>a1


A breakdown:

• Alt+Tab appears to work like Esc with Vim, or perhaps with this terminal emulator. Thanks for teaching me something new!
• aEACE<Alt+Tab>: Enter append mode and insert “EACE”. Exit.
• z=5<Alt+Tab>: Perform spelling correction. Select 5, “PEACE”. Exit. (Esc seems to work as Enter here!)
• $xxxxaASSWRD<Alt+Tab>: Go to the end of the line. Delete 4 characters and add ASSWRD, resulting in PASSWRD. Back to normal mode. (No, 4x won’t work.) • z=1<Alt+Tab>: PASSWORD is probably going to be the first correction for this. Select it. • $a$aA<Alt+Tab>: Go to the end of the line, and add a $aA. Back to normal mode.
• ==: Format this line of PHP nicely, changing the camelCase $aA to $a_a. This also moves the cursor back to the start of the line.
• wxx: Go forward a word; the cursor is now before $. Delete two characters – the $ and the a – to make PASSWORD_a.
• $r1: Go to the end of the line and replace the current character (i.e. a) with 1, resulting in PASSWORD_1. • ^X: Decrement the integer under the cursor, resulting in PASSWORD_0. • a1: Finally, append 1, for PASSWORD_01! I can't replicate == command, it just toggles large indentation mode in my vi setup (debian 7, v7.3.547) – Cengiz Can – 2014-06-19T14:34:34.393 12 # Python 2, 75889 bytes No extra character! Unfortunately, the code is super long. So instead, here's the code to generate the program: x=[2**n for n in xrange(16)] y=-5 print('exec"""exec'+x[7]*'%'+'c""'+x[6]*'%'+'cr'+x[-2]*'%'+'c'+x[-1]*'%'+'ct'+x[8]*'%'+'c'+x[-4]*'%'+'cASSW'+x[-5]*'%'+'cRD'+x[-3]*'%'+'c'+x[0]*'%'+'s1'+x[10]*'%'+'c '+x[9]*'%'+'c""'+x[y]*'%'+x[1]*'%'+'s'+x[y]*'%'+x[2]*'%'+'s'+x[y]*'%'+x[3]*'%'+'s'+x[y]*'%'+x[4]*'%'+'s'+x[y]*'%'+x[5]*'%'+'s"""'+'%1>>1%2531>>5%321>>2%1521>>4%211>>1%221>>1%112%34%34%34%34')  Try it online (to run the code, change the outer print into an exec. Or, generate the program, then paste and run. Or copy from the hastebin linked below.) ### Explanation: The goal is to execute: print"PASSWORD_01"  To avoid using ()+ chars, we have to use multiple string format operations chained together. This means that each step added effectively doubles the number of % characters needed for each previous step: print"%cASSW%%cRD%%%%c%%%%%%%%c1"%80%79%95%48  This is not enough though, because some of the numbers required cannot be created, and neither can we create print. So we add a level of abstraction with exec for printing, and a level for the ASCII code points we cannot create to format with. The following is essentially my answer, but with each string of % reduced to a single one (note that the %s%s%s%s%s is not an accurate representation, failing to account for the literal %'s required before each): exec"""exec%c""%cr%c%ct%c%cASSW%cRD%c%s1%c %c""%s%s%s%s%s""" % 1>>1%2531>>5%321>>2%1521>>4%211>>1%221>>1%112%34%34%34%34  The First Step: Outermost exec: exec""" ... ASSW%cRD ... %s%s%s%s%s""" % 1>>1 % 2531>>5 % 321>>2 % 1521>>4 % 211>>1 % 221>>1  1. 1>>1: 0, used for the 0 in PASSWORD_01 2. 2531>>5: 79, used for inner exec to create O 3. 321>>2: 80, used for inner exec to create P 4. 1521>>4: 95, used for inner exec to create _ 5. 211>>1: 105, used for inner exec to create i 6. 221>>1: 110, used for inner exec to create n Second Step: Prepare Inner exec After the above, the inner exec is something like this: exec%c""%cr%c%ct%c%cASSWORD%c01%c %c""%79%80%95%105%110  Except that you wouldn't quite get that. Still wtih the simplifications, you'd get this: exec%c""%cr%c%ct%c%cASSWORD%c01%c %c""798095105110  The literal %'s need to be included. So basically I had to add a bunch of them before each %s to end up with literal %'s left after all the formatting. 2**11 of them. Times five. The rest of the outer exec string format operations are %112%34%34%34%34. The 112 is for p, and the others are quotation marks. After applying those, the result is something like this: exec"""pr%c%ct"%cASSW%cRD%c01" """%79%80%95%105%110  But in reality it has a bunch more %. It's this: exec"""pr%%%%%%%%c%%%%%%%%%%%%%%%%ct"%%cASSW%cRD%%%%c01" """%79%80%95%105%110  The final step is to simply run that, after which you get the necessary output. Full code here: https://hastebin.com/ehemizivum.apache 7Impressive! You typed all that by hand before the BOMB exploded? Without making any mistakes (no backspace key)? You, sir or madam, deserve your pension. ;D – DLosc – 2017-02-16T02:17:53.833 10 # Perl, (31+10 / 41+10 / 64+10) (^ key used, 3 ways) exec"easswsrdcqw"^"5 < <AF" # exec "PASSWORD_01"  • Valid if running as a system command qualifies as "output." exec"QQZSqeasswsrdcqw"^"422<Q5 < <AF" # exec "echo PASSWORD_01"  • Valid if I'm allowed to use external/OS commands. (Run here) exec"EQAXqwQqQZQxqeasswsrdcqwxqq"^q!5434QZ4S534$S5    <  <AF$SS! # exec "perl -e\"die\\\"PASSWORD_01\\\"\""  • Valid if I can execute Perl via the system. (Run here) <-- this one uses print instead of die The scripts use Perl's bitwise string XOR operator ^, which does an XOR on the character bits of the two strings. This lets me recreate the missing characters for PASSWORD_01, and create the characters for the system command. I made the three variants depending on how lenient the rules are. I assume that since variants 2 and 3 actually output the words on Ideone, the solutions are valid. I removed the little story I had here since I figured no one would read it, but you can read it in the edits if you're curious! 10 # bash + vim (56) Borrowing the Ctrl-XCtrl-E bash trick from Thor's solution, here is how I would do it in bash+vim: C-XC-E starts default editor (usually vim) a starts insert mode .space ASSW C-Vx4f inserts O RD C-Vx5f inserts _ 1 C-3 is equivalent to escape (not just in vim, but anywhere in a terminal) C-X subtracts 1 from the 1 i just typed a insert mode again 1 C-3 buffer content is now . ASSWORD_01 << unindent line (a no-op, since line is not indented) and move cursor to 1st column a C-X start word completion C-V complete with ex command C-V 9 more times selects the entry Print C-3 back to normal mode XXXxx deletes rint  < < back to column 1 s delete ., start insert mode e c C-X C-V ex command completion once again, entry echo already selected because of the ec i just typed space C-3 buffer content now echo PASSWORD_01 Z Z save buffer, close vim, bash executes file content, i.e. echo PASSWORD_01 By the way: C-3 has many useful brethren: C-J is Enter, C-I is Tab, C-H is Backspace, C-2 is C-@ (i.e. a null-byte). And for emacs users it is nice to know that Escape followed by another key is equivalent to Alt + that key. So, even without Escape and Alt you can still type Meta-x like this: C-3x 4 # oOo code (300) QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc QwertaSdFgzXcQWertASdFgZXCq  Easy. (Linefeeds are optional, and just here to make the code "more readable") Code generator used: o=lambda b,c:"".join(i.upper()if j else i for i,j in zip(__import__('itertools').cycle(c),map(int,"".join((3-len(i))*'0'+i for i in(bin('><[]-+.,'.index(i))[2:]for i in b)))))  The same code in a less silly encoding: EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee EeeeeeEeEeeEeEEeeeEEeEeEEEe  But silly encoding is so much more fun – Dorian – 2019-10-01T12:05:57.980 3 # Decimal, 190 180 + 10 = 190 bytes 12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301  Try it online! Decimal is an esoteric language that uses nothing but decimals and the letter D. However, I needed the +10 penalty because almost every command uses 0. Luckily, all of the commands needed to print PASSWORD_01 don't require any numbers over 6: • 12...D - push a character • 2 - pop a value • 41D - pop top two stack values, multiply and push result • 301 - print DSI (default stack index) By repeatedly pushing character values that only use the digits 1 through 5, then adding them, I can make the character values for each letter in PASSWORD_01. Ungolfed and commented: 12055D ; push char 55 to stack 12025D ; push char 25 to stack 41D ; pop [DSI] and [DSI-1], add and push result 3012 ; print from stack to output, pop 12055D ; push char 55 to stack 12010D ; push char 10 to stack 41D ; pop top two stack values, add and push result 3012 ; print from stack to output, pop 12055D ; push char 55 to stack 12025D ; push char 25 to stack 41D ; pop x2, add, push 12003D ; push char 3 to stack 41D ; pop x2, add, push 301301 ; print, print 12004D ; push char 4 to stack 41D ; pop x2, add, push 3012 ; print, pop 12055D ; push char 55 to stack 12024D ; push char 24 to stack 41D ; pop x2, add, push 301 ; print 12003D ; push char 4 to stack 41D ; pop x2, add, push 3012 ; print, pop 12055D ; push char 55 to stack 12013D ; push char 13 to stack 41D ; pop x2, add, push 3012 ; print, pop 12055D ; push char 55 to stack 12040D ; push char 40 to stack 41D ; pop x2, add, push 3012 ; print, pop 12045D ; push char 45 to stack 12003D ; push char 3 to stack 41D ; pop x2, add, push 301 ; print 12001D ; push char 1 to stack 41D ; pop x2, add, push 301 ; print  3 # Stax, 91+10 bytes "W"EEEd$"$"1 !$Re]"$""ASSW"R"$""a"EEE$"$"a$Re]R"$""RD"R"$""a"EEEd$"$""5"Re]R"$"1 !$R"$""1"R


Try it online!

Uses ] to make singletons.

## Explanation

Let's see how "P" is generated and how the "ASSW" is appended without using the usual +.

"W"                             Push "W", or [87]
E                            Convert to a scalar, 87
E                           Convert to an array of digits, [8,7]
E                          Push 8 on the stack, then push 7.
d                         Pop the 7 and discard it.

Start making components of regex substitution
$Pop 8, push "8" "$"                     Push "$" 1 ! Push 0. The space is necessary because normally one doesn't do 1! to obtain 0$                 Pop 0, push "0"
R                Do regex substitution 's/$/0/g' on the string "8" Basically doing "8"+"0" without using + e Pop "80", push 80 ] Singleton. Pop 80, push [80], or "P" "$""ASSW"R    Use the same trick again to append "ASSW" to "P"


The rest are just repeating the same trick.

"a"EEE$"$"a$Re]R swaps the digits of "a" or [97] to make [79] or "O" and appends it to the string. "$""RD"R appends "RD".

"$""a"EEEd$"$""5"Re]R uses "a" again to obtain "9" and discards the "7", then combines the "9" with a literal "5" to form [95] or "_", and appends it to the string. "$"1 !$R obtains a zero by logical not of 1 and appends it to the string. "$""1"R appends the final "1" and we are done.

Implicit output.

1O_O ... this is clever. – recursive – 2018-02-25T07:20:03.417

Thank you for your appreciation. I believe it can be made shorter (perhaps by choosing a different key?) though. – Weijun Zhou – 2018-02-25T07:37:44.390

3

# Whitespace, score: 111 (101 bytes + 10 for Enter)

[S S T  T   T   T   T   T   N
_Push_-31_1][S S T  T   S S S S S N
_Push_-32_0][S S S T    T   T   T   N
_Push_15__][S S T   T   T   S S N
_Push_-12_D][S S S T    S N
_Push_2_R][S S T    T   N
_Push_-1_O][S S S T T   T   N
_Push_7_W][S S S T  T   N
_Push_3_S][S N
S _Duplicate_3_S][S S T T   T   T   T   N
_Push_-15_A][S S S N
_Push_0_P][N
S S N
_Create_Label_LOOP][S S S T S T S S S S N
_Push_80][T S S S _Add][T   N
S S _Output_as_character][N
S N
N
_Jump_to_Label_LOOP]


Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

This solution is shorter than the existing Whitespace answer (@n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ asked me to post it as a separated answer when I suggested it as golf) by utilizing this Whitespace tip of mine.

Push the code-points for the characters of "10_DROWSSAP" minus constant 80 to the stack
Start LOOP:
Add 80 to the current code-point
Pop and output it as character
Go to the next iteration of LOOP


The constant 80 has been generated with this Java program, which I've created and used for some previous Whitespace answers of mine.

3

# JS-Forth, 103 bytes

The string will be returned on the stack as an array of characters.

12544 1 3 << >> 24 1 << 1521 4 >> 34 1 << 41 1 << 2531 5 >> 351 2 >> 332 2 >> 32 2 >> 131 1 >> 321 2 >>


Try it online - Commented version

### Explanation:

I first found the list of allowed words. Essentially, the only things I could use that would be useful are:

• 12345 Numeric constants
• << Shift left
• >> Shift right
• s>f Push single to float stack
• f>d Pop double from float stack
• fsqrt Square root on float stack

So I could use numeric constants, bit-shift, and compute a square root using the following (>> replaces drop, shifting by 0 to remove the 0):

s>f fsqrt f>d >>


Fortunately, I found possible bit-shifts for every constant I needed to create that were shorter than using square roots. For the most part, I searched by simply printing each number squared, or a larger power of two if any of them contained a digit 6-0. Then, I realized I could use loss of precision from f>d to find more possibilities. (I could add to the number, but still get the same integer square root.) A bit later, I started using bit-shifting to find some, and then all, of the constants. The greater the >> bit-shift, the more I could add to the "magic number" and still get the same result. So I found the smallest bit-shifts I could use to get the necessary results. Even numbers could sometimes use <<, odds had to use >>.

### Commented code (\ starts a comment):

\ 49
12544 1 3 << >>

\ 48
24 1 <<

\ 95
1521 4 >>

\ 68
34 1 <<

\ 82
41 1 <<

\ 79
2531 5 >>

\ 87
351 2 >>

\ 83 (x2)
332 2 >> 332 2 >>

\ 65
131 1 >>

\ 80
321 2 >>


gForth does not have the words << or >>. Instead it has lshift and rshift, which I could not use.

3

# ferNANDo, 179 + 10 = 189 bytes

2 1
1 2 1 2 1 1 1 1
1 2 1 1 1 1 1 2
1 2 1 2 1 1 2 2
1 2 1 2 1 1 2 2
1 2 1 2 1 2 2 2
1 2 1 1 2 2 2 2
1 2 1 2 1 1 2 1
1 2 1 1 1 2 1 1
1 2 1 2 2 2 2 2
1 1 2 2 1 1 1 1
1 1 2 2 1 1 1 2


Try it online!

Enter used. I'd use 0 and 1 to make the code more readable but I can't use 0.

I think enter is allowed. – Conor O'Brien – 2016-09-28T22:19:49.313

3OP didn't say Enter was allowed. – acrolith – 2016-09-28T23:35:13.060

2

# brainfuck, 400 + 10 (+) = 410 bytes

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.<.>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..++++.<<++++++++++++++.+++.>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.<++++++++.>>>>++++++++++++++++++++++++++++++++++++++++++++++++.+.<


Try it online!

1You can remove the < at the end. – pppery – 2020-06-18T18:35:18.393

2

# MS-DOS .COM 8086 machine code (72 bytes)

Time is precious, so no time to dilly-dally with compilers or interpreters! Simply open your text editor of choice and type in the following (replace \t with TAB):

451D<1DAQX1D11D3AQX4c1DDQX4<SZ!Gq\tGq3WqEEEEESX5\t\t2!<<<<<<<<<eASSWzRD<11$ As a hexdump: 00000000 : 34 35 31 44 3C 31 44 41 51 58 31 44 31 31 44 33 : 451D<1DAQX1D11D3 00000010 : 41 51 58 34 63 31 44 44 51 58 34 3C 53 5A 21 47 : AQX4c1DDQX4<SZ!G 00000020 : 71 09 47 71 33 57 71 45 45 45 45 45 53 58 35 09 : q.Gq3WqEEEEESX5. 00000030 : 09 32 21 3C 3C 3C 3C 3C 3C 3C 3C 3C 65 41 53 53 : .2!<<<<<<<<<eASS 00000040 : 57 7A 52 44 3C 31 31 24 : WzRD<11$


Save as a .COM file and run it to save the day.

The code assumes certain start values for registers, so might not work for all DOS flavours. Just hope that someone risked being fired by not buying IBM.

Slightly more understandable representation:

org 0x100
bits 16
cpu 8086

; Assumes the following start values for registers (as per http://www.fysnet.net/yourhelp.htm):
;
;   AX = 0
;   BX = 0
;   CX = 0x00ff
;   SI = 0x100

; Change e => P and z => O
xor al, 0x35
xor [si+0x3c], ax
xor [si+0x41], ax

; Fix int 0x21 and ret
push cx
pop ax              ; AX = 0xFF
xor [si+0x31], ax
xor [si+0x33], ax

; Change <1 => _0
inc cx              ; CX = 0x100
push cx
pop ax              ; AX = 0x100
xor al, 0x63        ; AX = 0x163
xor [si+0x44], ax

; We're using DOS interrupt 0x21, function 0x09 to output the final string.

; AH must equal 0x09 to select the function.
; DS:DX must point to the $-terminated string we want to output. ; Get DX to the correct value (0x13c) push cx pop ax ; AX = 0x100 xor al, 0x3c ; AX = 0x13c push bx pop dx ; DX = 0 ; We use part of the Program Segment Prefix to temporarily store the value, ; since MOVing or PUSHing AX is impossible. ; The part in question is the second File Control Block, which we will not use anyway. and [bx+0x71], ax or [bx+0x71], ax xor dx, [bx+0x71] ; DX = 0x13c ; NOPs to get int 0x21 and ret on high enough addresses inc bp inc bp inc bp inc bp inc bp ; Set AH to the correct value. AL is set too, but is ignored by the DOS interrupt. push bx pop ax ; AX = 0 xor ax, 0x0909 ; AX = 0x0909 ; What will become instructions int 0x21 and ret db 0x32, 0x21 db 0x3c ; Padding to have the password at an address we can refer to. times 60-($-) db '<'

pw  db  "eASSWzRD<11$"  2 # Poetic, 319 bytes war restarts.a test.a craze.a few desecrated areas.a few deceased staff.a sad defeat.waters red.we start a retreat after a war.a carcass wasted.a war act started warfare.war gets screwed.crew defeated.targets set.war affects qatar.a red war creates regret.a war deterred far extra starred staff.we scatter.gee!a regress  Try it online! Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols. It was an interesting challenge to write a piece of text with certain word lengths without the right side of the keyboard (or many spaces or punctuation marks). I can only hope that it was worth it. 1 # Befunge-98, 43 +10 = 53 bytes "1qA·DR·WSSA·g"%,$,,,,$"s"%,,,$"c"%,%,,q


Try it online!

The 10 byte penalty is for the use of the , key (not sure why this couldn't be accomplished with Shift+<, but that seems to be the rule). And although the source is technically 40 characters, the three · characters contribute an additional three bytes because of their UTF-8 encoding.

1

# 05AB1E, 87 86 bytes

"."A1.$R24.$AT<.$R15>.$A21<.$R5.$.V.VD21s.V.V15>X.V"ASSW"15X.V"RD"122D<s2X.V.VTRTX.V.V


Try it online!

Maybe the longest 05AB1E code ever?

Unfortunately the language doesn't support things like "Q"< for "decrement Q to get P"

My extra key is the V.

Thanks to @Kevin Cruijssen for -1 byte.

Code:

Build the string ".b". This is the code to turn integers to upper case letters:
"."             push "."
A               push the lower case alphabet
1.$drop the first letter of that R reverse the remaining string 24.$            drop the first 24 letters of that, so only "b" remains
AT<.$R15>.$     do the same trick for "j"
A21<.$R5.$      and for "u"
.V              run "u" as code to turn "j" to "J"
.V              run "J" as code, to join ".", "b" to ".b"

Save that string for later use:
D               duplicate
21              push 21
s               switch the top two elements [".b", 21, ".b"]
.V              run ".b" as code, to get "U"
.V              run "U" as code, to save ".b" in X

15>X.V          push the 16th letter of the alphabet ("P")
"ASSW"          push "ASSW"
15X.V           push "O"
"RD"            push "RD"
122D<s2X.V      push 121, 122, "B"
.V              run that as code to push "_"
TR              push 01
TX.V            push "J"
.V              run that as code, to join everything to the desired string


For comparison: The shortest way to print "PASSWORD_01" is 6 bytes long

Try it online!

"Maybe the longest 05AB1E code ever?" Nah, this one of mine is almost 6 times as large. ;p Nice answer regardless. It's hard to only use a certain amount of allowed ASCII character. So many convenient builtins aren't allowed for this challenge. :(

– Kevin Cruijssen – 2019-09-30T12:57:30.937

1-1 byte by using TR instead of 1<1 for the 01 part of the output. – Kevin Cruijssen – 2019-09-30T13:03:09.173

1

## Emacs, 26 bytes (possibly + 10 = 36, or − 2 = 24)

The extra key that's needed in this answer is Esc. This is on the half of the keyboard that's still intact, but isn't mentioned in the question for some reason, so might or might not give a penalty to the score. (Esc and Alt are equivalent in Emacs; Alt is also on the intact half of the keyboard but isn't mentioned in the question, but has to be held rather than tapped so I can't use it as my extra key. It would save two bytes, though, because it has a shorter encoding than Esc does.)

The program itself (the commas delimit the boundaries between bytes in the on-the-wire format that Emacs uses to accept its input):

W, S, Esc, $, D, A, Ctrl-T, S, R, W, D, Esc,$, 5, Ctrl-Q, 5, f, Ctrl-X, r, Ctrl-Space, 1, Ctrl-X, r, g, 1, Ctrl-T

Encoding of this as raw bytes, to prove byte count:

00000000: 5753 1b24 4441 1453 5257 441b 2435 1135  WS.$DA.SRWD.$5.5
00000010: 6618 7200 3118 7267 3114                 f.r.1.rg1.


(Note: some of the details may vary based on how Emacs is configured; this answer requires quoted-char-radix to be set to 16, and for Emacs to use the spellcheck dictionary that's default on my British English system. Both of these seem like reasonable configuration settings, but it's possible that your copy of Emacs may be configured differently. A different dictionary would likely still give a 26-byte program, but slightly different misspellings might need to be used so that the corrections we wanted can be accepted by non-bullet-ridden keys.)

## Explanation

I'm not sure whether it should have any influence on the editor wars, but Emacs seems to beat vim at least in the case of this question. Emacs is pretty suited to editor golf measured in bytes, because it relies heavily on chords which take up multiple keypresses but only a single byte (thus an Emacs program is often slower to type than the equivalent Vim program, but shorter on disk). Additionally, most of the most important Emacs commands are in the bottom-left corner of the keyboard, to be close to Ctrl, very helpful with a question like this one.

"You can assume you have the interpreter shell / source editor opened before the bullets came in. Sadly you have not written anything in it before the keyboard was hit.", so I'm assuming that we have an empty file open in Emacs and need to type the password into it. (We'd need to save the file afterwards, and probably exit Emacs, but the bytes for that aren't being counted in other people's answers so I'm not counting them here either. It's totally doable using the left hand side of the keyboard, though, Ctrl-X, Ctrl-S, Ctrl-X, Ctrl-C.)

Taking it a command (or block of similar commands) at a time:

• W, S: Enter WS into the document.
• Esc, $: Invoke the spellchecker. WS isn't a real word, but it finds lots of similar two-letter words. • D: Using the spellchecker, correct WS to PS. (When the spellchecker is invoked using Alt-$, as happened here (Esc and Alt are equivalent to Emacs), it only checks one word, so it deactivates after doing this.)
• A: insert A, giving PSA.
• Ctrl-T: Swap the previous two characters, giving PAS.
• S, R, W, D: Type SRWD, giving PASSRWD.
• Esc, $, 5: We invoke the spellchecker again, because we want to correct our misspelled PASSRWD into PASSWORD. Note that we can't have it guess the word we want on our first try, like it would with PASSWRD, because the key to accept the closest real word is 0 which we can't press. As a result, the slightly more extreme misspelling PASSRWD is used to push the word we want into position 5, where we can accept it. • Ctrl-Q, 5, f: Insert the character with character code U+5f, i.e. _. The document now reads PASSWORD_ (or will when we start typing the next command; before then, the underscore doesn't appear in case we type another hex digit). • Ctrl-X, r, Ctrl-Space, 1: Store the current cursor position (relative to the start of the file) in register 1. For some bizarre reason, this is 1-indexed, so (having written 9 characters so far) the cursor is at position 10. • Ctrl-X, r, g, 1: Copy the content of register 1 into the document. It now reads PASSWORD_10. • Ctrl-T: Swap the two characters before the cursor. We now have PASSWORD_01, like the question asks for. If we're allowed to use Alt, we can probably encode the "invoke spellchecker" command as the single byte a4 rather than spelling it out as 1b 24; it appears twice, so that leads to two bytes of savings. (Most modern terminals use 1b 24 as the encoding for Alt-$ to avoid clashes with UTF-8, but the a4 encoding is also encountered from time to time, sometimes available as a configuration option.)

Possible byte savings probably involve golfier misspellings to correct. PSASWRD would be a byte shorter to type, but unfortunately, the spellchecker doesn't seem capable of gleaning PASSWORD out of that, so PASSRWD is the best approach I've found so far. The register-based approach to gaining 10 is also ridiculously unwieldy, but there aren't many ways of creating numbers from nowhere in Emacs, and 0 is a painful character to get hold of otherwise. (At least there were a couple of amazingly useful coincidences: the cursor just happening to end up in position 10, which contains a 0, right when needed; and the fact that Emacs accepts the redundant g register operation to insert the contents of a register into the document, in addition to the more intuitive i.)

1

## Lenguage, 814814390776628060509605577373181765864505940171473720140916436885644483746988990322785194756 bytes

Converted from this program:

++++++++++[>++++++++>+++++++>+++++++++>++++++++++>+++++<<<<<-]>.>-----.<+++..>>---.<<----.+++.>+++.>>-----.>--.+.


Try BF code online!

1

# Width, 23 + 10 (m) = 33 bytes

GFmaaAfAfAAFGAiawwafwfG


Try it online!

This language reminds me of the CUNEIFORM NUMERIC SIGN NINE SHAR2: , an awesome character that is awesome because it's a single character – the default. – 2020-04-06T14:52:50.517