A keyboard so real you can almost TASTE it

127

23

... Not that you would, would you? The task is simple, output the following text:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ 
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ 
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

This is the keyboard of the future because in the future spaces are irrelevant, so are spacebars.

To make things a little bit easier on you:

  1. 0123456789ABC...XYZ-=[]\;',./ - These chars are on keys of length 6 (including padding).
  2. TAB / BS / ENTER - These keys are of length 10 (including padding).
  3. CAPS - This key is of length 11 (including padding).
  4. SHIFT - This key is of length 13 (including padding, on both sides).

Each individual key looks more or less like this:

 ____ 
||* ||
||__||
|/__\|

However, you should make note that two consecutive keys are not:

 ____  ____ 
||* ||||* ||
||__||||__||
|/__\||/__\|

But they are "conjoined":

 ____ ____ 
||* |||* ||
||__|||__||
|/__\|/__\|

This challenge shouldn't be too bad, best of luck to you; don't miss out on abusing the repetition! But don't underestimate the "special" keys either ;).

Winning?

Shortest code wins because it's you know.

Magic Octopus Urn

Posted 2016-12-12T22:59:13.740

Reputation: 19 422

50Gotta admit I'm surprised not many people are concerned about futuristic keyboards not containing spaces... – Magic Octopus Urn – 2016-12-13T00:05:57.600

It occurs to me, this might technically be a duplicate of this

– ATaco – 2016-12-13T01:21:49.717

5@ATaco I disagree. That one is just plain English, this one is ASCII-art. I'm sure the approaches will be very different too. – James – 2016-12-13T01:23:27.387

1@DjMcMayhem Although I do quite enjoy this challenge, and agree it shouldn't be considered a duplicate, the community does tend to agree that challenges that simply require a constant text to be outputted are a duplicate of that. – ATaco – 2016-12-13T01:33:05.447

100I guess spaces weren't the final frontier after all. – Greg Martin – 2016-12-13T04:59:17.567

50"TASTE" is the german word for "key" :) – QBrute – 2016-12-13T08:59:18.930

33"TASTE" is the Norwegian word for "typing" :) – Stewie Griffin – 2016-12-13T14:13:24.017

34

But it's the English word for "flavour". Here.

– Mr Lister – 2016-12-13T14:15:54.827

8"TASTE" is the Czech (conditional) "draw" like in "[please] draw your sword"... DRAW YOUR KEYBOARD OUT AND DO NOT LICK IT :) – RudolfJelin – 2016-12-13T17:48:16.673

@StewieGriffin but also for "enter", "input", "key" and "keypad" according to Uncle Google's translator. – RudolfJelin – 2016-12-13T17:51:07.927

4@KevinCruijssen We can finally drop this complicated whitespace-delineated mixed-width language and switch to a fixed-width language like 中文（あるいは日本語）;) – bright-star – 2016-12-14T17:24:24.007

4that moment when, on your new spacebar-less keyboard, you realise you actually need spaces, to make the ascii representation line up correctly! – RozzA – 2016-12-14T21:25:18.713

3Now every time I look at a keyboard, I will only think of a giant chocolate bar. Thanks for that. Taste – Mahathi Vempati – 2016-12-16T16:01:02.170

4This is the keyboard of the future – I hope not, it’s still QWERTY. – Wrzlprmft – 2016-12-17T12:36:56.897

5@Wrzlprmft Still better than AZERTY. >_> – TuxCrafting – 2016-12-17T19:25:29.923

6In Italian keyboard is TASTIERA, key is TASTO and keys are TASTI. – sergiol – 2016-12-18T23:42:24.983

@carusocomputing I just want to say, this is hands down the most fun I've ever had on a challenge. Even 6 months later, it's fun to try and golf down. :D – James – 2017-06-16T19:10:00.773

@DJMcMayhem "edited 7 mins ago" xD! each time I get an upvote on here I swear your answer has lost a byte or two. – Magic Octopus Urn – 2017-06-16T19:13:24.610

Answers

119

V, 189, 179, 175, 164, 161, 157, 155, 149, 145, 141, 135 bytes

¬19É`A0-=BS´ 
TAB³ qwertyuiop[]\
CAPS³ asdfghjkl;'ENTER 
SHIFT´ ÄJizxcvbnm,./̈́A-Z ]/Õ& 
ÍÓ«ü$/|||&
òÙӄ|]/_
ÙÓ׫/Ü|¯
kkPÓ/_ _
kòÎx$x

Try it online!

This answer is now tweetable!

Watch it run! This is a slightly modified version that updates as it runs so you can sorta see how it works. This is an outdated version since I haven't gotten around to re-recording it yet, but the general approach is identical.

This is probably the longest V answer ever written. It certainly didn't help that V's interpreter is extremely slow. It took me around an hour to write the first revision, but I've been repeatedly coming back to it to shave a couple bytes off each time. Since the full keyboard is 1215 bytes, currently this answer is 91% shorter than the output, so I'm pretty happy with the results.

Since this contains some unprintable characters, and a lot of gross non-ASCII, here's a hexdump:

00000000: ac31 39c9 6041 302d 3d42 53b4 200a 5441  .19.`A0-=BS. .TA
00000010: 42b3 2071 7765 7274 7975 696f 705b 5d5c  B. qwertyuiop[]\
00000020: 0a43 4150 53b3 2061 7364 6667 686a 6b6c  .CAPS. asdfghjkl
00000030: 3b27 454e 5445 5220 0a53 4849 4654 b420  ;'ENTER .SHIFT. 
00000040: 1bc4 4a69 7a78 6376 626e 6d2c 2e2f 1bcd  ..Jizxcvbnm,./..
00000050: 8441 2d5a 205d 2fd5 2620 0acd d3ab fc24  .A-Z ]/.& .....$
00000060: 2f7c 7c7c 260a f2d9 d384 7c5d 2f5f 0ad9  /|||&.....|]/_..
00000070: d3d7 ab2f dc7c af0a 6b6b 50d3 2f5f 205f  .../.|..kkP./_ _
00000080: 0a6b f2ce 7824 78                        .k..x$x

How the heck does it work?

Alright, this explanation is gonna be a doozy. You ready? First off, we need enter the letters so we can build up the keys around them. This is

¬19É`A0-=BS´ 
TAB³ qwertyuiop[]\
CAPS³ asdfghjkl;'ENTER 
SHIFT´ <esc>ÄJizxcvbnm,./<esc>

Which inserts:

`1234567890-=BS    
TAB   qwertyuiop[]\
CAPS   asdfghjkl;'ENTER 
SHIFT    zxcvbnm,./SHIFT

It enters it pretty straightforward, but there are a few tricks that we use to save characters. For example, ¬19 enters "123456789", ³ enters three spaces, and we duplicate the shift so that we don't need to enter it multiple times.

Note how the letters are lowercase here. This is so that we can easily distinguish between the uppercase keys like "ENTER" and the single letters. Writing them this way makes it easier to tell which characters to put a bar before, and only adds one byte to convert them to lowercase later. So we do a substitute command to convert these to uppercase, and add one space after each of them:

Í               " Globally replace
 [^A-Z ]        " Anything but a uppercase alphabet character or a space
        /       " with
         Õ&     " The matched pattern made uppercase, followed by a space

Now, we take each key sequence (any run of non-whitespace), and put three bars before and after them:

Í           " Globally replace
 Ó«         "   Any number of non-space characters
   ü        "   or
    $       "   an end of line
     /      " with
      |||   "    Three bars 
         &  "    And the matched pattern

At this point, the buffer looks like this:

|||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    |||
|||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ |||
|||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER |||
|||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||

Having three bars on the first and last columns is actually very convenient and ends up saving many bytes in the long run.

And here is where we run one giant loop. This will convert something like this:

|||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||

into something like this:

 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ 
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Everything between two instances of ò will run until an error happens, which will happen when we try to go up into a line that does exist yet. Since we just ran a globally substitute command, our cursor is on the last line, and we'll transform these working our way up.

ò         " Recursively:
 Ù        "   Duplicate this line
  Ó       "   Substitute all on this line:
   [^|]   "     Anything but a bar
       /  "   With:
        _ "     An underscore

This is the

|||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________|||

line.

Ù         "   Duplicate this line
 Ó        "   Subsitute all on this line:
  ׫      "     A run of *non-word characters* (that is, [^0-9A-Za-z_])
    /     "   With:
     Ü|¯  "     '\|/'

This is the

\|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|/

Line.

kk        "   Move up two lines (to the original text with "SHIFT")
  P       "   Paste the last line we duplicated (the one with all the underscores)
   Ó      "   Substitute:
          "     Since we don't give any regex here, it re-uses the last one 
          "     (a run of *non-word* characters)
    /     "   With:
     _ _  "     '_ _'

This is the:

_ ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ _

Line.

k         "   Move up a line (this will throw an error, breaking the loop when we're done)
 ò        " Endwhile

Now we have the full keyboard, but each line contains either an extra bar, an extra slash (forward or backward), or an extra underscore. Super easy fix

Î             " On every line:
 x            "   Delete a character
  $           "   Move to the end of the line
   x          "   and delete another character

After all that madness, the buffer is implicitly printed.

James

Posted 2016-12-12T22:59:13.740

Reputation: 54 537

1There appear to be 4 extra underscores in the blank space off the right side of the output? – ErikE – 2016-12-14T18:53:27.427

@ErikE On the online interpreter or in the gif? The gif does produce slightly wrong output, but I'm not sure why. It is a modified version though, so I'm not worried about the output being wrong since the original one is right. – James – 2016-12-14T18:55:31.553

Yes, the gif. Ok, no problem, just wanted you to know! – ErikE – 2016-12-14T18:56:42.683

7You underestimate how golfy this answer actually is lol. – Magic Octopus Urn – 2016-12-16T17:56:36.880

1@carusocomputing Haha, I guess you're right. I'm very proud of this answer and my language to be the only answer beating bubblegum. :) – James – 2016-12-16T17:59:06.767

2@DJMcMayhem Marking you as the winner if nobody beats you by 1/3/2017 ;). – Magic Octopus Urn – 2016-12-22T20:06:01.277

Still working out some more bytes I see :P? – Magic Octopus Urn – 2017-02-02T18:51:01.787

@carusocomputing Haha, yep. This challenge is really fun, I'm sure there's a few more bytes in there somewhere. :P – James – 2017-02-02T18:52:37.660

7This is still by far my favorite answer on the site, by the way. I can't count how many times I've watched the GIF. – Magic Octopus Urn – 2017-04-21T18:55:41.057

41

Lua 5.3, 416 394 Bytes.

k="` 1 2 3 4 5 6 7 8 9 0 - = BS|TAB Q W E R T Y U I O P [ ] \\|CAPS A S D F G H J K L ; ' ENTER|SHIFT Z X C V B N M , . / SHIFT"S={TAB=6,BS=6,ENTER=6,CAPS=7,SHIFT=9}for v in k:gmatch"[^|]+"do for i=1,4 do for s in v:gmatch"%S+"do l=S[s]or 2j=("_"):rep(l)io.write(i==1 and" _"..j.."_"or i==2 and"||"..s..(" "):rep(l-#s).."|"or i==3 and"||"..j.."|"or"|/"..j.."\\")end print(i>1 and"|"or"")end end

Ungolfed and with comments.

keys="` 1 2 3 4 5 6 7 8 9 0 - = BS|TAB Q W E R T Y U I O P [ ] \\|CAPS A S D F G H J K L ; ' ENTER|SHIFT Z X C V B N M , . / SHIFT" -- Define a keyboard. Separated with |'s, there's probably a nicer way to do this, but I'm not sure about how to yet.
special_keys={TAB=6,BS=6,ENTER=6,CAPS=7,SHIFT=9} -- Special keys get special definitions
for v in keys:gmatch"[^|]+" do -- For each row on the keyboard...
    for i=1, 4 do -- Each of the 4 rows per key...
        for s in v:gmatch"%S+" do -- Match each individual key.
            l=special_keys[s]or 2 j=("_"):rep(l) -- l is the length of the key, j is "_" repeated length times, which is used a bit.
            io.write(i==1 and -- Lua needs Switch Statements!
                     " _"..j.."_" -- The top of the key is a Space, then j with two _'s around it.
                     or
                     i==2 and
                     "||"..s..(" "):rep(l - #s).."|" -- Second row is || then the key, then the remaining whitespace, and then one more |, which chains together.
                     or
                     i==3 and
                     "||"..j.."|" -- Third row is like the second, but without the key. Instead of whitespace, uses j, which is the underlines.
                     or
                     "|/"..j.."\\") -- Last row is like the third row, but with "|/" and "\" instead of "||" and "|"
        end
        print(i>1 and"|"or"") -- First line is the only line that doresn't need a "|", everything else gets a "|" before the newline.

    end
end

Output

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

I'm going to get destroyed by other langauges, but I thought I'd give this a shot. Nice amount of complexity, and atleast it's shorter than the keyboard!

ATaco

Posted 2016-12-12T22:59:13.740

Reputation: 7 898

15Screw other languages, you were the first in a rare language! Impressive, though I'm sure you definitely don't need to put pipes as delimiters on every letter. Notice how the "special" keys are only at the front and end of lines. I'm sure that hint could save you precious bytes somehow. – Magic Octopus Urn – 2016-12-13T00:03:32.573

Which version of Lua are you using? On Lua 5.1 it gives me a syntax error: stdin:1: malformed number near '2j' – brianush1 – 2016-12-13T23:30:27.473

5@Brianush1 Lua 5.3, It allows number constants to sit next to any letter that isn't a hexadecimal digit or 'x' in the case of 0. – ATaco – 2016-12-14T00:06:07.667

29

Bubblegum, 191 bytes

0000000: ad d2 35 7a c6 30 10 06 e1 5e a7 50 15 66 fe 99  ..5z.0...^.P.f..
0000010: c1 8c 61 50 0e b2 87 8f 27 24 f7 eb af 78 2b e3  ..aP....'$...x+.
0000020: 3c b2 ae 99 1a 66 8d c8 a7 15 91 73 b8 80 4b b8  <....f.....s..K.
0000030: 82 6b b8 81 5b b8 83 1e 9c c1 31 8c 60 5e d9 66  .k..[.....1.`^.f
0000040: 22 46 c4 39 d1 c2 78 d6 a9 73 6f 5a d8 9b 18 ff  "F.9..x..soZ....
0000050: bb 5a e8 55 cf e6 fc ae 48 01 8f b0 82 12 6a 78  .Z.U....H.....jx
0000060: 86 7b 08 20 83 1c 5e e1 1d de e8 e5 7f 57 b4 d0  .{. ..^......W..
0000070: 8b a9 9b f9 5e 5d 9d af c5 2c af 7e 82 cd a0 82  ....^]...,.~....
0000080: 25 ac 61 03 5b 08 21 82 18 06 b0 0b ab b4 5e 95  %.a.[.!.......^.
0000090: ad 5e 5d 9d 2f d6 e9 f9 d2 c4 f2 bd aa 6d b0 ae  .^]./........m..
00000a0: ed 4f b1 17 78 82 05 3c c0 1c 52 48 e0 08 4e e0  .O..x..<..RH..N.
00000b0: 14 5a 77 fb 5e aa 58 be 97 aa 98 bf db 7c 01     .Zw.^.X......|.

Try it online!

Dennis

Posted 2016-12-12T22:59:13.740

Reputation: 196 637

1Bubblegum isn't fair. – Joshua – 2016-12-15T04:09:47.217

7@Joshua it's good to set a baseline for solutions. and if nothing can beat bubblegum, that's problem's problem. – Display Name – 2016-12-15T13:32:35.220

19

Haskell, 263 chars (353 bytes UTF-8)

import Data.List
main=mapM_ putStrLn$transpose.foldr k[g]=<<
 [s"`1234567890-="%"   ←"
 ,"↹   ":s"[]\\"
 ,"⇩    ":s";'"%"     ↵"
 ,"⇧       ":s",./"%"       ⇧"]
r%e=r++[e]
g=" |||"
k s r=g:"_||/":['_':c:"__"|c<-s]%"_||\\"++r
s=map(:" ")

screenshot of that keyboard

As there has been a lot of discussion about the score in light of these unicode characters... here's the same program, reduced to all-ASCII:

Haskell, 263 chars (263 bytes UTF-8)

import Data.List
main=mapM_ putStrLn$transpose.foldr k[g]=<<
 [s"`1234567890-="%"BS  "
 ,"TAB ":s"QWERTYUIOP[]\\"
 ,"CAPS ":s"ASDFGHJKL;'"%"ENTER "
 ,"SHIFT   ":s"ZXCVBNM,./"%"SHIFT   "]
r%e=r++[e]
g=" |||"
k s r=g:"_||/":['_':c:"__"|c<-s]%"_||\\"++r
s=map(:" ")

ceased to turn counterclockwis

Posted 2016-12-12T22:59:13.740

Reputation: 5 200

3Unicode keyboard? Interesting choice (nice looking math letters there), but I think it violates the competition rules. – Mario Carneiro – 2016-12-14T07:58:07.463

@MarioCarneiro To be fair, it doesn't affect the length of the program at all. – pydsigner – 2016-12-14T23:12:41.117

1@pydsigner It does, since words like ENTER are longer than characters like ↩︎. – timothymh – 2016-12-15T09:48:52.680

5But you're comparing ENTER and ↩︎ , The whitespace padding makes it the same length. – CodeMonkey – 2016-12-15T14:52:59.647

2Actually, I expect the unicode to make the program longer by byte count, since high unicode is more bytes in UTF8 than ASCII. – Mario Carneiro – 2016-12-16T01:53:24.630

231 bytes – Max Yekhlakov – 2018-10-04T14:03:32.013

18

PHP, 303 bytes

Lazy but effective. :)

<?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbEAvA88wBuzPsg8vPyLZo3tOMUXmt1k/iy+ycfXYj88kacvIg1oQgva0IEu9KAPA6hDBUYQJn4+IvldxogWhrtqxmRamEw8t66afMc0CO26soczTOAAKVzhCAvYwg7u8IDs06tYVx3Oc+uqw7lef3lfUbBLimABJDCGKcxgDktYwRqGULJ143Ry+O71r/elDvb7vnSx3r2S+WKaFn+U3OACEZzs7wYxbKAMVajZvO6066WK9dNLFcuefgE'));

Alex Howansky

Posted 2016-12-12T22:59:13.740

Reputation: 1 183

1Nice. Annoyingly, I cannot get the same level of compression with compress/gzip/bzip2/7z, otherwise the Bash version would be trivially shorter. As it stands, it’s at 318 characters instead. – Konrad Rudolph – 2016-12-13T11:55:33.523

14I'm pretty sure using an external compression algorithm not in your program is banned or at least frowned upon. It defeats the purpose of the question. – Nobody – 2016-12-13T15:12:18.103

1@KonradRudolph As I understand it, gzdeflate() uses the same compression as gzip command line but skips the file header and checksum so it will always be just a bit shorter. – Alex Howansky – 2016-12-13T15:21:42.363

300 bytes: <?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbHA+0QEvDHrg8zDy79EMbTDFF+3m8yfXdek42phHJG3KyItaEMHutCDPgxgCCNoQg0mMI3cdETSu4wRLQx3NYxJtDCJOL9t1cnSFWNvareVE1xhASHEcIczbOAIATzhBck3V7atupuTb6vulucq43XNvCDKenkQwRyWsII1bGEHexhDxcb140X4n6us16XuVXxdulZZrmi9WcbZd5IH3GAGF/vXwIcDVKEODVs3P53nUrUq5FK1sqc/'));. Compressor: http://sandbox.onlinephpfunctions.com/code/646e96c9ff46de26e17f8604370e55be99c52199 Decompressor: http://sandbox.onlinephpfunctions.com/code/4093a61e6cb082ae188cc7a477a01fad0eef67a2

– Ismael Miguel – 2016-12-14T10:21:09.093

4@Nobody There's nothing external, gz is part of PHP's default compile and is therefore implicitly allowed. – Alex Howansky – 2016-12-14T19:14:38.467

@Nobody http://meta.codegolf.stackexchange.com/a/9814/4163

– Bob – 2016-12-15T05:57:01.060

If you'd compressed the generating program, that'd be one thing. Simply embeddeing then compressing the desired output is just lazy! – Lightness Races with Monica – 2016-12-16T16:09:43.863

Absolutely no need to do base64_decode, just paste the original binary there, escaping \", \\, \n, \x00, \xAF and \x96. See for example http://codegolf.stackexchange.com/questions/18923/create-a-chain-of-spam-generators-in-as-many-languages-as-possible/18979#18979

– SztupY – 2016-12-16T16:56:34.567

@LightnessRacesinOrbit lay, of course, yes. Banned, no. – edc65 – 2016-12-18T13:11:12.520

@LightnessRacesinOrbit Heh yes, please note how I freely admitted as much in my original post... – Alex Howansky – 2016-12-18T16:09:22.543

@SztupY Huh, interesting about the 0xAF and 0x96 -- perhaps that's what screwed me up when I tried doing that on another challenge. I'll keep this in mind for next time, thanks. – Alex Howansky – 2016-12-18T16:11:12.090

18

Python 3.5+, 239 bytes

s="SHIFT   "
for k in[(*"`1234567890-=","BS   "),("TAB  ",*"QWERTYUIOP[]\\"),("CAPS  ",*"ASDFGHJKL;'","ENTER"),(s,*"ZXCVBNM,./",s)]:
 for f in"{1}__ ,|{} ||,|{1}||,/{1}\|".split(","):print(f[-1]+"".join(f.format(c,"_"*-~len(c))for c in k))

orlp

Posted 2016-12-12T22:59:13.740

Reputation: 37 067

Is Python 3.5+ needed for the splat inside the tuples, or something else? – mbomb007 – 2016-12-13T15:07:03.033

1You can save one byte if you invert the construction of each key and use "".join(...) + f[0] in the inner loop. Swapping the format argument order and the respective placeholders in the string also saves two more bytes. – dfernan – 2016-12-13T22:17:39.363

['{1}__ ','|{} ||','|{1}||','/{1}\\|'] is shorter than the use of split. – Alex Hall – 2016-12-17T23:31:17.823

16

Batch, 465 452 bytes

@echo off
call:c _ ` 1 2 3 4 5 6 7 8 9 0 - "=" "BS   " _____
call:c _____ "TAB  " Q W E R T Y U I O P [ ] \ _
call:c ______ "CAPS  " A S D F G H J K L ";" ' ENTER _____
call:c ________ "SHIFT   " Z X C V B N M "," . / "SHIFT   " ________
exit/b
:c
set t=%1_
set s=!!%~2 !!!%3 !!
:l
set t=%t%#__
set s=%s%!%~4 !!
shift
if not "%~5"=="" goto l
set t=%t%#%4_
for %%l in (" _%t:#=_ _%_" "%s:!=|%" "||%t:#=|||%||" "|/%t:#=\|/%\|")do echo %%~l

The :c subroutine handles a line of keys. Keys containing extra spaces need to be quoted, as do the =, ;, , keys, possibly due to a bug in the shift command. The first and last parameters are strings of _s of the same length as the first and last key to aid concatenation. t then ends up as the _s common to the first, third and fourth rows, with #s marking the join, which are replaced appropriately before the leading and trailing characters are added, while s is the second row, but with |s changed to !s as they reduce the number of "s that I need. Edit: Saved 1 byte by printing all four lines in a single statement, and 12 bytes by optimising the way I assigned the s variable.

Neil

Posted 2016-12-12T22:59:13.740

Reputation: 95 035

14

Ruby, 226 bytes

16.times{|i|puts (([[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+%w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars+[['BS   ',?\\,'ENTER',s][j]]).map{|e|e.tr('^|'[-i%4/3,2],?_)}*3*"__ _ |||_|||_\\|/"[i%4*4,4])[72,75]}

Improvements as follows:

1.No empty string elements at the beginning and end of the array. Instead the array is triplicated making 3 side-by side keyboards. After conversion to string we have 3 keyboards with outer edges missing. This is truncated to only display the middle one, complete with edges.

2.Changed version of Ruby. Used Ideone instead of 1.9.3 installed on my machine. This means .chars.to_a can be shortened to just .chars.

Ruby, 239 bytes

There's a few more bytes to be golfed out of this. Will look tomorrow.

16.times{|i|puts ((['']+[[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+%w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars.to_a+[['BS   ',?\\,'ENTER',s][j]]+['']).map{|e|e.tr('^|'[-i%4/3,2],?_)}*"__ _ |||_|||_\\|/"[i%4*4,4])[2..-2]}

ungolfed

16.times{|i|                                                            #iterate throug 16 lines of output
  puts ((['']+[[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+              #build row from blank element plus left special key
    %w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars.to_a+ #plus regular keys
   [['BS   ',?\\,'ENTER',s][j]]+['']).map{|e|                           #plus right special key and another blank element
                                      e.tr('^|'[-i%4/3,2],?_)}*         #if i%4 != 1, replace the keytop legend with _ characters 
   "__ _ |||_|||_\\|/"[i%4*4,4])[2..-2]                                 #join the middle parts of the keys with ends. truncate spurious outer ends before printing.
}

Level River St

Posted 2016-12-12T22:59:13.740

Reputation: 22 049

13

C#, 357 bytes (when in one line, and incorporating most suggestions)

var s="";
foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for(int i=0;i<4;s+=i>0?"|\n":"\n",i++)
foreach(var k in r.Split('|'))
{
var u=new string('_',k.Length+1);
s+=i<1?" "+u+"__"
:i<2
?"||"+k+" |"
:i<3
?"||"+u+"|"
:"|/"+u+@"\";
}
Console.Write(s);

Or, 353 with string interpolation and all other suggestions

var s="";foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))for(int i=0;i<4;s+=i>0?"|\n":"\n",i++)foreach(var k in r.Split('|')){var u=new string('_',k.Length+1);s+=i<1?$" {u}__":i<2?$"||{k} |":i<3?$"||{u}|":$@"|/{u}\";}Console.Write(s);

Ungolfed (without string interpolation):

var solution = "";
foreach (var row in @"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for (int i = 0; i < 4; solution += i > 0 ? "|\n" : "\n", i++)
foreach (var key in row.Split('|'))
{
   var underscores = new string('_', key.Length + 1);
   solution += i < 1 ? " " + underscores + "__"
                     : i < 2
                     ? "||" + key + " |"
                     : i < 3
                     ? "||" + underscores + "|"
                     : "|/" + underscores + @"\";
}
Console.Write(solution);

Klinger

Posted 2016-12-12T22:59:13.740

Reputation: 231

5You can save lots of bytes formatting the golfed code as one line: foreach(var r in q){for(int i=0;i<4;i++){foreach... – Mario – 2016-12-13T08:19:16.207

1@Mario I just byte checked it, the given value is actually the count without newlines, so it technically has already been done – Alfie Goodacre – 2016-12-13T13:21:54.340

1Slight golf down to 397 bytes using interpolation and replacing == with < s+=i<1?$" {u}__":i<2?$"||{k.PadRight(l)}|":i<3?$"||{u}|":$"|/{u}\\"; – Alfie Goodacre – 2016-12-13T13:38:40.057

Thanks @Alfie Goodacre. I replaced '==' with '<' as per your suggestion. I left interpolation out so to make it less version specific. – Klinger – 2016-12-13T15:18:27.067

@Klinger I agree, the interpolation doesn't work on any online compilers either so that is a good choice! – Alfie Goodacre – 2016-12-13T15:19:36.237

You don't need to put q in a separate variable, just inline the new[] in the foreach loop. Also new string('_',l) instead of "_________".Substring(0,l). – milk – 2016-12-13T19:11:50.573

10

PowerShell v2+, 465 bytes

($b=($a=' ____')*10)+$a*3+" "+($d='_'*8)
"||``@$(1..9-join'@')@0@-@=@BS    ||
||$(($f=,'__'*10-join'#'))#__#__#__#$(($g='_'*6))||
$(($c=($e='|/__\')*10))$e$e$e|/$g\|
 $d$b$a$a$a
||TAB  @Q@W@E@R@T@Y@U@I@O@P@[@]@\ ||
||$g#$f#__#__#__||
|/$g\$c$e$e$e|
 _$d$b$a $d
||CAPS  @A@S@D@F@G@H@J@K@L@;@'@ENTER ||
||_$g#$f#__#$g||
|/_$g\$c$e|/$g\|
 ___$d$b ___$d
||SHIFT   @Z@X@C@V@B@N@M@,@.@/@SHIFT    ||
||___$g#$f#___$g||
|/___$g\$c|/___$g\|"-replace'@',' #'-replace'#','|||'

I'm halfway embarrassed to be posting this answer, given how short the PHP and Python answers are, nevermind the C# answer, but I'm unable to get this method shorter. Other approaches may yield better results.

It's basically just a giant multi-line string, with variables ($a and the like) substituting for various substrings, and a couple -replaces at the end to finish it out. Script blocks $(...) are inserted where necessary to introduce new variables.

Try it online!

AdmBorkBork

Posted 2016-12-12T22:59:13.740

Reputation: 41 581

7

Python, 493 458 Bytes.

k=[['|']*75 for i in [0]*16]
v=' '
w='_'
y=0
def a(s,x,o):k[y+o][x:x+len(s)]=list(s)
def p(s,i,x):a(s+v*(i-len(s)),x+2,1);a(v+w*(i+2)+v,x,0);a(w*i,x+2,2);a(w*i,x+2,3);a('/',x+1,3);a('\\',x+i+2,3);return x+i+3
def q(s,x):return reduce(lambda a,b:p(b,2,a),list(s),x)
p('BS',6,q('`1234567890-=',0))
y=4
q('QWERTYUIOP[]\\',p('TAB',6,0))
y=8
p('ENTER',6,q('ASDFGHJKL;\'',p('CAPS',7,0)))
y=12
p('SHIFT',9,q('ZXCVBNM,./',p('SHIFT',9,0)))
for l in k:print''.join(l)

Functionally equivalent but somewhat more readable:

k=[['|']*75 for i in range(16)]
def a(s,x,y):k[y][x:x+len(s)]=list(s)
def p(s,i,x,y):
    a(s+' '*(i-len(s)),x+2,y+1)
    a(' '+'_'*(i+2)+' ',x,y)
    a('_'*i,x+2,y+2)
    a('_'*i,x+2,y+3)
    k[y+3][x+1]='/'
    k[y+3][x+i+2]='\\'
    return x+i+3
def q(s,x,y):return reduce(lambda a,b:p(b,2,a,y),list(s),x)
p('BS',6,q('`1234567890-=',0,0),0)
q('QWERTYUIOP[]\\',p('TAB',6,0,4),4)
p('ENTER',6,q('ASDFGHJKL;\'',p('CAPS',7,0,8),8),8)
p('SHIFT',9,q('ZXCVBNM,./',p('SHIFT',9,0,12),12),12)
for l in k:print ''.join(l)

Unfortunately it's already longer than the answer provided in Lua.

Cobi

Posted 2016-12-12T22:59:13.740

Reputation: 111

You can put the lines in the p function on one line separated by semicolons. Also, I thought that you can't make the first line k=[['|']*75]*16, do you know why? – nedla2004 – 2016-12-13T01:30:23.143

You can also define '_' and ' ' to a variable to save some bytes. – nedla2004 – 2016-12-13T01:34:18.347

Thanks for the tips! I think k=[['|']75]16 creates sixteen references to the same array so a change in one line affects the others as well. – Cobi – 2016-12-13T01:35:19.233

Okay, then you can at least change range(16) to [0]*16. – nedla2004 – 2016-12-13T01:49:44.103

A small issue is that your code does not technically produce the right output, but you can fix that by changing for l in k:print ' '.join(l) to for l in k:print''.join(l). – nedla2004 – 2016-12-13T01:51:26.223

Make the indentations only one space, save tons of bytes. – OldBunny2800 – 2016-12-13T02:00:50.863

On last line, you can eliminate the space between print and ' '. – OldBunny2800 – 2016-12-13T02:01:20.447

@OldBunny2800 To be honest, i coded in vim with tabs for indentations and this is how the bytes are counted. – Cobi – 2016-12-13T02:06:04.360

Useless whitespace at *75 for. – Yytsi – 2016-12-13T05:03:52.863

7

PHP, 316 312 bytes

foreach([($s=str_split)("`1234567890-=")+[13=>"BS   "],["TAB  "]+$s("_QWERTYUIOP[]\\"),["CAPS  "]+$s("_ASDFGHJKL;'")+[12=>ENTER],[$h="SHIFT   "]+$s("_ZXCVBNM,./")+[11=>$h]]as$r)for($y=-1;$y++<3;)foreach($r as$i=>$k)echo["\n".$a="| "[!$y]][$i],"_||/"[$y],str_pad($y-1?_:$k,strlen($k)+1,$y-1?_:" "),"_||\\"[$y],$a;

I´m pretty sure that this approach cannot be golfed any further. But if anyone finds 10 more bytes ... :D
Run with -r.

breakdown

foreach([                       // loop through rows
    ($s=str_split)("`1234567890-=")+[13=>"BS   "],
    ["TAB  "]+$s("_QWERTYUIOP[]\\"),
    ["CAPS  "]+$s("_ASDFGHJKL;'")+[12=>ENTER],
    [$h="SHIFT   "]+$s("_ZXCVBNM,./")+[11=>$h]
]as$r)
    for($y=-1;$y++<3;)          // loop through lines 0..3
        foreach($r as$i=>$k)    // loop through keys
            echo["\n".$a="| "[!$y]][$i],// first key in row: leading NL + space/pipe
                "_||/"[$y],             // key edges
                str_pad(
                    $y-1?_:$k,          // line 1: key label; else underscore
                    strlen($k)+1,       // pad to length+1
                    $y-1?_:" "),        // with spaces for label, underscores else
                "_||\\"[$y],            // more key edges
                $a                      // joining edges
            ;

Titus

Posted 2016-12-12T22:59:13.740

Reputation: 13 814

6

Bash (on OSX), 12 8 + 221 + 1 = 234 230 bytes

Yeah, I know, compression. But it works, no?

gunzip<f

Requires a file called "f" in the current directory with the following contents (put into base64 for PPCG-friendliness - you can decode this into the file "f" first.):

H4sIAHbPT1gAA63TuQ6CQBCA4Z6noLPxvo2xALwPPMAbsz7IPLz8i2aN7TjFFxo2mT+7vsnH12I/PJGnLyINaEIL2tCBLvSgDwOoQwVGECZ+PiL5WcaIFoazasZkWphMPLeumnzHNAjturKHM0zgAClc4QgL2MIO7vCA7NOrWFcdznPrqsO5Xn+5X1GwS4pgASQwhinMYA5LWMEahlCydeN0cvju9a/7pQ72e790sd69kvlimhYvSm5wgQhO9rlBDBsoQxVqNq/72/VSxfrppYpV9HoBoNfjQcAEAAA=

Addison Crump

Posted 2016-12-12T22:59:13.740

Reputation: 10 763

4Can be made trivially shorter by writing gunzip<f. – Konrad Rudolph – 2016-12-13T12:00:02.323

@KonradRudolph Excellent point. Thanks. – Addison Crump – 2016-12-13T15:20:23.047

You can save 2 bytes with zcat f, and 2 bytes by removing the two trailing null bytes (gzip complains but produces the desired output). – Gilles 'SO- stop being evil' – 2016-12-14T11:18:50.513

@Gilles Doesn't really save me bytes - I'd have to rename the file "f.Z" (on OSX at least). Removing the trailing null bytes not only makes gzip complain - it makes it error out and not print anything. – Addison Crump – 2016-12-14T12:15:12.423

@VoteToClose Oh right, zcat<f then. On Linux, zcat without the trailing zeroes makes gzip complain (“gzip: stdin: unexpected end of file”) but only after printing the desired output. – Gilles 'SO- stop being evil' – 2016-12-14T12:57:04.427

Shouldn't the size of the gunzip binary count against your byte count? It's not part of bash. – chepner – 2016-12-17T18:31:52.067

@chepner Nope, since Bash on OSX comes prepackaged with it. It's also a part of the GNU coreutils. – Addison Crump – 2016-12-18T12:17:50.340

bash does not come prepackaged with gunzip; they are two completely separate programs. It's not the same as a standard library that ships with a language. – chepner – 2016-12-18T13:32:41.000

No - but OSX does, which Bash imports. That's why this answer is not "Bash" but "Bash (on OSX)". – Addison Crump – 2016-12-18T13:55:45.867

@chepner I suggest looking at this page about the use of libraries in CG.

– Addison Crump – 2016-12-18T13:57:38.620

That page says nothing about external programs (which are not libraries). You might want to read http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default, which contains several mentions of fetching the output from an external source.

– chepner – 2016-12-18T14:02:54.067

Let us continue this discussion in chat.

– Addison Crump – 2016-12-18T18:03:56.990

6

JavaScript (ES6), 286

An anonymous function with no parameters

_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`

Less golfed

_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"]
  .map(x=>
      (
        w = x < y // special chars are marked '~' that is > '|'
            ? 2 // normal key, width 2
            : ( // else special key, set x and width
                // p should be incremented at next step, but I need to make it numeric as it starts as []
                x = ["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',
                ' 667699'[p], // value for w (note p is off by 1)
              ),
        b = '_'.repeat(w), // bottom border (and top, almost)
        o +=`/${b}\\|`, //  line 4
        n += y+b+y+y,   //  line 3
        m += y+(x+'    ').slice(0,w)+y+y, // line 2
        l += ' __'+b    // top line, the border must be longer
      )[70] && // check if at end of row (check position in l)
         (
            k.push(l, m, n, o), // add lines to list
            l = '', // reset all
            m = n = o = y
         )
    , // initial setup
    // y stays fixed to '|', lines 2,3,4 start as '|'
    m = n = o = y ='|',
    // k is the lines array, l will become as string and starts empty
    // p is the index of current special key and will become numeric
    p = l = k = [] 
  ) 
  && k.join`\n` // return lines as a single string


F=_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`

O.textContent=F()
<pre id=O></pre>

edc65

Posted 2016-12-12T22:59:13.740

Reputation: 31 086

5

Swift, 777 Bytes

func b(_ c:String,_ d:Int,_ e:Int)->[String]{var f=Array(" __ |||||||||/\\|".characters),g=[String]()
for h in 0..<4{var i="";for j in e..<4{i.append(f[j+h*4])
if j==1{var k="_",l=0;if h==1{k=" ";l=c.characters.count;i += c}
for _ in l..<d{i+=k}}};g.append(i)};return g}
func c(_ d:String)->[(String,Int)]{return Array(d.characters).map{("\($0)",2)}}
func d(_ e:String,_ f:Int)->[(String,Int)]{return [(e,f)]}
var e=[c("`1234567890-=")+d("BS",6),d("TAB",6)+c("QWERTYUIOP[]\\")]
e+=[d("CAPS",7)+c("ASDFGHJKL;'")+d("ENTER",6),d("SHIFT",9)+c("ZXCVBNM,./")+d("SHIFT",9)]
var f="";for g in 0..<e.count{let h=e[g]
var i=[[String]]();for j in 0..<h.count{
let k=h[j],l=b(k.0,k.1,(j>0 ? 1:0));i.append(l)}
for k in 0..<4{if g>0||k>0{f+="\n"}
for l in i{f+=l[k]}}};print(f,separator:"")

Swift is generally not a great language of choice for golfing, so being less than double the current smallest answer (that was fast) is a good challenge here!

Ungolfed:

func createKeyboard() {
    func createKey(_ text: String, _ middleWidth: Int, _ startingColumn: Int) -> [String] {
        var keyTempalte = " __ |||||||||/\\|"
        var keyTemplateCharacters = Array(keyTempalte.characters)

        var output = [String]()

        for y in 0 ..< 4 {
            var line = ""
            for x in startingColumn ..< 4 {
                line.append(keyTemplateCharacters[x + y*4])

                if x == 1 {
                    var spacingCharacter = "_"
                    var startingOffset = 0
                    if y == 1 {
                        spacingCharacter = " "
                        startingOffset = text.characters.count
                        line += text
                    }

                    for _ in startingOffset ..< middleWidth {
                        line += spacingCharacter
                    }
                }
            }
            output.append(line)
        }

        return output
    }

    func stringToCharacterStrings(_ str: String) -> [(String, Int)] {
        return Array(str.characters).map {("\($0)",2)}
    }

    func specialKey(_ str: String, _ middleWidth: Int) -> [(String, Int)] {
        return [(str, middleWidth)]
    }

    var keys = [stringToCharacterStrings("`1234567890-=") + specialKey("BS", 6),
                specialKey("TAB", 6) + stringToCharacterStrings("QWERTYUIOP[]\\")]
    keys += [specialKey("CAPS", 7) + stringToCharacterStrings("ASDFGHJKL;'") + specialKey("ENTER", 6),
                specialKey("SHIFT", 9) + stringToCharacterStrings("ZXCVBNM,./") + specialKey("SHIFT", 9)]

    var output = ""
    for r in 0 ..< keys.count {
        let row = keys[r]
        var rowKeys = [[String]]()
        for i in 0 ..< row.count {
            let elem = row[i]
            let key = createKey(elem.0, elem.1, (i>0 ? 1 : 0))
            rowKeys.append(key)
        }

        for y in 0 ..< 4 {
            if r > 0 || y > 0 {
                output += "\n"
            }

            for key in rowKeys {
                output += key[y]
            }
        }
    }

    print(output)
}

createKeyboard()

username tbd

Posted 2016-12-12T22:59:13.740

Reputation: 161

2at least it's not applescript – Addison Crump – 2016-12-13T10:30:54.733

1Now I've got to do Java don't I – CAD97 – 2016-12-13T15:07:03.033

4

Python 2, 394 388 380 bytes

k=[4]*13+[8],[8]+[4]*13,[9]+[4]*11+[8],[11]+[4]*10+[11];m='`1234567890-=*','*QWERTYUIOP[]*',"*ASDFGHJKL;'*",'*ZXCVBNM,./*';c,d,e,n,u=0,'','|','\n','_'
for a in 0,1,2,3:
 f=s=t=o='';x=0
 for y in k[a]:g=y-2;f+=' '+u*y;s+=e*2+m[a][x].replace('*','%s')+' |';t+=e*2+u*g+e;o+='|/'+u*g+'\\';x+=1
 d+=f+n+s+e+n+t+e+n+o+e+n
l='SHIFT   ';print d%('BS   ','TAB  ','\\','CAPS  ','ENTER',l,l)

Just builds a big string representing the whole keyboard, replaces * with %s for the special keys then uses string formatting to update the specials.

Edit

Now has a trailing newline at the end of the output but I don't see anywhere that's not allowed.

Try it online!

ElPedro

Posted 2016-12-12T22:59:13.740

Reputation: 5 301

I think you should remove the output , as it does not add anything relevant. – sergiol – 2017-06-21T15:13:33.727

1@sergiol - good point. Wasn't aware to TIO at the time of posting. Now updated. – ElPedro – 2017-06-21T15:20:03.823

4

SOGL V0.12, 131 128 127 bytes (competing?)

⅟]y‘9Δø∑"`ŗ0-=”čΚ"TAB  ”QWERTYUIOP[]\”č+"oF«▒Β²‘⁷Ο‘ASDFGHJKL;'”čΚ+"_№K³‘ZXCVBNM,./”č⁴++¹{"^쳑č;{U;"_||/”┼;{"_ŗ__”┼}"Ο  ψ¦℮³‘┼}O

SOGL does have the 2*2/ and 2/2* quirks, but those feel too much like a built-in for this challenge.
Try it Here!

...‘               push "BS   "                                            ["BS   "]
    9Δ             push an array of numbers up to 9                        ["BS   ", [1,2,3,4,5,6,7,8,9]]
      ø∑           join into a single string (without ø it results to 45)  ["BS   ", "123456789"]
        "`ŗ0-=”    push "`ŗ0-=" with ŗ replaced with the digits            ["BS   ", "`1234567890-="]
               č   chop that into an array of characters                   ["BS   ", ["`","1","2","3","4","5","6","7","8","9","0","-","="]]
                Κ  add the first "BS   " to the end of the array           [["BS   ","`","1","2","3","4","5","6","7","8","9","0","-","="]]

"TAB  ”            push "TAB  "                  [[..], "TAB  "]
       Q..P[]\”    push "QWERTYUIOP[]\"          [[..], "TAB  ", "QWERTYUIOP[]\"]
               č   chop that                     [[..], "TAB  ", ["Q","W","E","R","T","Y","U","I","O","P","[","]","\"]]
                +  prepend to the array "TAB  "  [[..], ["TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\"]]

"...‘             push "caps  "                       [.. , "caps  "]
     ⁷Ο‘          push "enter"                        [.. , "caps  ", "enter"]
        AL;'”     push "ASDFGHJKL;'"                  [.. , "caps  ", "enter", "ASDFGHJKL;'"]
             č    chop that                           [.. , "caps  ", "enter", ["A","S","D","F","G","H","J","K","L",";","'"]]
              Κ   append "enter" to the end of array  [.. , "caps  ", ["A","S","D","F","G","H","J","K","L",";","'","enter"]]
               +  prepend "caps  " to the array       [.. , ["caps  ","A","S","D","F","G","H","J","K","L",";","'","enter"]]

"..‘             push "shift   "                [..., "shift   "]
    ZM,./”       push "ZXCVBNM,./"              [..., "shift   ", "ZXCVBNM,./"]
          č      chop it                        [..., "shift   ", ["Z","X","C","V","B","N","M",",",".","/"]]
           ⁴     duplicate the shift            [..., "shift   ", ["Z","X","C","V","B","N","M",",",".","/"], "shift   "]
            ++   append and prepend the shifts  [..., ["shift   ","Z","X","C","V","B","N","M",",",".","/","shift   "]]
              ¹  get all the arrays into one big array
result: [[["BS   ","`","1","2","3","4","5","6","7","8","9","0","-","="], ["TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\"], ["caps  ","A","S","D","F","G","H","J","K","L",";","'","enter"], ["shift   ","Z","X","C","V","B","N","M",",",".","/","shift   "]]]
 - a 2D array of the keyboard characters

{                                    for each array in the array do
 "...‘                                 push " |||"
      č                                chop to chars
       ;                               get the main array ontop
        {                        }     for each string in the array
         U                               uppercase it (before lowercase was used for better compression)
          ;                              get the chopped array ontop
           "_||/”                        push "_||/"
                 ┼                       append vertically
                  ;                      get the string ontop
                   {       }             for each char in the string do
                    "_ŗ__”                 push "_ŗ__"
                          ┼                append vertically
                            "..‘         push "    _||\ |||"
                                ┼        append vertically-then horizontally
                                  O    output that in a newline

dzaima

Posted 2016-12-12T22:59:13.740

Reputation: 19 048

Wow, this is super impressive! No one's managed to beat me on this one yet, so good job! I might try to get mine just a little shorter, but no promises. ;) – James – 2017-06-19T17:07:25.363

@dzamia even though it's competing now, I accepted the answer back when this wasn't. Should I switch answers? – Magic Octopus Urn – 2018-03-28T16:32:27.960

@MagicOctopusUrn IMO it's up to you. There's a reason it's suggested to not accept answers :p – dzaima – 2018-03-28T18:19:20.960

It's suggested to not accept answers? Oh... fair enough. Then I guess I'll stop accepting answers in the future and leave stuff as-is. – Magic Octopus Urn – 2018-03-28T19:17:08.227

@MagicOctopusUrn okay, maybe not accepting answers is a bit controversial, but still, a major positive

– dzaima – 2018-03-28T19:22:38.800

3

C#, 376 bytes (when in one line)

var s="";foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))for(int i=0,l;i<4;i++){foreach(var k in r.Split('|')){l=k.Length+1;var u=new string('_',l);s+=i<1?" "+u+"__":i<2?"||"+k.PadRight(l)+"|":i<3?"||"+u+"|":"|/"+u+@"\";}s+=i>0?"|\n":"\n";}Console.Write(s);

This is based entirely on Klinger's C# answer. I don't have enough rep to comment on his answer, otherwise I would.

I was able to slim down Klinger's code by 5 bytes, by modifying the initial foreach loop, and removing extraneous brackets.

var s="";
foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for(int i=0,l;i<4;i++)
{
foreach(var k in r.Split('|'))
{
l=k.Length+1;
var u=new string('_',l);
s+=i<1?" "+u+"__"
:i<2
?"||"+k.PadRight(l)+"|"
:i<3
?"||"+u+"|"
:"|/"+u+@"\";
}
s+=i>0?"|\n":"\n";
}
Console.Write(s);

Bence Joful

Posted 2016-12-12T22:59:13.740

Reputation: 101

Good one @Bence Joful. With your suggestion I would be able to get it to 367. I have not incorporated to the current answer. – Klinger – 2016-12-14T02:43:37.383

Could not resist. Your suggestion + some additional minor changes brings it to 361 (or 358 with string interpolation). – Klinger – 2016-12-14T03:49:09.673

@Klinger - please do use my tweaks! I was inspired to play around with it based on your work. I learned something about initialization in the process. – Bence Joful – 2016-12-14T07:08:52.343

Could you include the one line program? You won't exactly lose much readability over the current one – Cyoce – 2016-12-14T23:50:24.337

@Cyoce, you got it, thanks for the suggestion. Though at this point, Klinger has already posted a new, smaller version incorporating these changes. – Bence Joful – 2016-12-15T01:33:38.470

3

m4, 456

changequote({,})define(d,{define($@)})d(p,{patsubst($@)})d(a,{{_}p({$1},.,_)_ })d(b,{|$1||})d(c,{|p({$1},.,_)||})d(e,{/p({$1},.,_)\|})d(f,{ifelse(len({$2}),0,,{indir({$1},{$2})f({$1},shift(shift($@)))})})d(g,{ f({a},$@)
|f({b},$@)
|f({c},$@)
|f({e},$@)
})g(` ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,0 ,- ,= ,BS    )g(TAB   ,Q ,W ,E ,R ,T ,Y ,U ,I ,O ,P ,[ ,] ,\ )g(CAPS   ,A ,S ,D ,F ,G ,H ,J ,K ,L ,; ,' ,ENTER )g(SHIFT    ,Z ,X ,C ,V ,B ,N ,M ,{,} ,. ,/ ,SHIFT    )

Ungolfed:

changequote({,})dnl
define(key1, {{_}patsubst({$1}, ., _)_ })dnl _______ 
define(key2, {|$1||})dnl                     |TAB  ||
define(key3, {|patsubst({$1}, ., _)||})dnl   |_____||
define(key4, {/patsubst({$1}, ., _)\|})dnl   /_____\|
define(rkey, {dnl
ifelse(dnl
len({$2}), 0, ,dnl terminate on empty argument
{dnl
indir({$1}, {$2})dnl
rkey({$1}, shift(shift($@)))dnl
}dnl
)dnl
})dnl
define(row, {dnl
 rkey({key1}, $@)
|rkey({key2}, $@)
|rkey({key3}, $@)
|rkey({key4}, $@)dnl
})dnl
row(` ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,0 ,- ,= ,BS    )
row(TAB   ,Q ,W ,E ,R ,T ,Y ,U ,I ,O ,P ,[ ,] ,\ )
row(CAPS   ,A ,S ,D ,F ,G ,H ,J ,K ,L ,; ,' ,ENTER )
row(SHIFT    ,Z ,X ,C ,V ,B ,N ,M ,{,} ,. ,/ ,SHIFT    )

(This is actually the first time I'm both code-golfing and giving m4 a try.)

Thriller

Posted 2016-12-12T22:59:13.740

Reputation: 91

Not bad for a first answer. Welcome to the site! :) – James – 2016-12-18T18:18:36.240

3

stacked, 228 bytes

Try it here!

[,{a:a size@n(' __' '_'n 1+:@k*LF'||'a' ' '|'LF'||' '_'k*:@o'|'LF'|/'o'\')sum}"!$hcat#/!' |||'hcat out]@:p$chars@:c'`1234567890-='c'BS   'p'TAB  ' 'QWERTYUIOP[]\'c p'CAPS  ' 'ASDFGHJKL;'''c,'ENTER'p'SHIFT   ':@q'ZXCVBNM,./'c,q p

Or, slightly more readable:

{a:a size@n(' __' '_'n 1+:@k*LF'||'a' ' '|'LF'||' '_'k*'|'LF'|/' '_'k*'\')sum}"@:m
[,m$hcat#/!' |||'hcat out]@:p
'`1234567890-='chars'BS   'p
'TAB  ' 'QWERTYUIOP[]\'chars p
'CAPS  ' 'ASDFGHJKL;'''chars,'ENTER'p
'SHIFT   ':@q'ZXCVBNM,./'chars,q p

This works by defining a function p that makes a key, then hcating multiple keys.

Conor O'Brien

Posted 2016-12-12T22:59:13.740

Reputation: 36 228

2

Haskell, 255

import Data.List;a#b=a++[b];e=" |||";s=map(:" ");k x=[e,"_||/"]++['_':c:"__"|c<-x]#"_||\\";t="SHIFT    ";main=mapM_ putStrLn$transpose.(#e).(k=<<)=<<[s"`1234567890-="#"BS    ","TAB   ":s"QWERTYUIOP[]\\","CAPS   ":s"ASDFGHJKL;'"#"ENTER ",t:s"ZXCVBNM,./"#t]

In retrospect, similar in concept to this Haskell answer, but producing the ASCII keyboard, and with slightly different golfing.

Formatted and renamed:

import Data.List

main :: IO ()
main = mapM_ putStrLn
  $ concatMap (transpose . (`append` end) . concatMap key)
  [ split "`1234567890-=" `append` "BS    "
  , "TAB   " : split "QWERTYUIOP[]\\"
  , "CAPS   " : split "ASDFGHJKL;'" `append` "ENTER "
  , shift : split "ZXCVBNM,./" `append` shift
  ]

key :: String -> [String]
key x
  = [end, "_||/"]
  ++ ['_' : c : "__" | c <- x]
  `append` "_||\\"

append :: [a] -> a -> [a]
append a b = a ++ [b]

split :: [Char] -> [String]
split = map (: " ")

end :: String
end = " |||"

shift :: String
shift = "SHIFT    "

Jon Purdy

Posted 2016-12-12T22:59:13.740

Reputation: 471

2

tcl, 368

As counted by http://textmechanic.com/text-tools/basic-text-tools/count-characters-words-lines/ with the "Count line breaks as spaces." set to on, it occupies 505 496 452 451 439 403 401 396 391 388 385 384 382 379 378 377 369 368 

proc N x {split $x @}
proc M a\ b {string map $a $b}
regsub -all \[^@|] [set b [M [N {||||@|||@$@BS   @%@TAB  @&@CAPS @? @ENTER  @*@SHIFT   }] [regsub -all {[^@]} "`1234567890-=$@%QWERTYUIOP\[\]\\@&ASDFGHJKL;'?@*ZXCVBNM,./*" {||& ||}]]] _ f
lmap x [N [M {\\ _ / _ | \ } [set g [M {||_ |/_ _|| _\\|} [M {||| \\|/} $f]]]]] y [N $b] z [N $f] w [N $g] {puts "$x
$y
$z
$w"}

Demo: http://rextester.com/live/NTVAV88033

The ungolf:

Live cooperation on http://rextester.com/live/UDO43692

regsub -all {(\S)} "`1234567890-=←\n%QWERTYUIOP\[\]\\\n⇩ASDFGHJKL;'↵\n⇧ZXCVBNM,./⇧" {||\1 ||} b
set b [string map {|||| |||  ← "BS   " % "TAB  " ⇩ "CAPS  " ↵ "ENTER" ⇧ "SHIFT   "} $b]

regsub -all {[^\n|]} $b _ f

set g [string map {||| \\|/} $f]
set g [string map {||_ |/_  _|| _\\|} $g]
set h [string map {\\ _ / _ | " "} $g]

set H [split $h \n]
set B [split $b \n]
set F [split $f \n]
set G [split $g \n]

lmap x $H y $B z $F w $G {
puts $x
puts $y
puts $z
puts $w
}

Anyone is free and welcome to improve my version on live cooperation sites, but please: do not edit my original answer here; just say you've edited in the comments and people will visit the links.

UPDATE 1: Replaced for by foreach, because latter produces shorter code

UPDATE 2: Replaced foreach by lmap, because latter produces shorter code

UPDATE 3: Shaved one char because I Replaced " " by \

UPDATE 4: In respect to first comment, I changed all the 1st line 2 byte Unicode place holder characters to 1 byte ASCII ones

UPDATE 5: multiple puts line made into only one

UPDATE 6: use directly split commands return values on the lmap call instead of using intermediate list variables

UPDATE 7: Quotes around ENTER were not needed

UPDATE 8: string map is long enough and repeated a number of times that it is worth to encapsulate it in a proc

UPDATE 9: split $x \n is long enough and repeated a number of times that it is worth to encapsulate it in a proc

UPDATE 10: On "replacement" string can use & instead of \1, because in this case both coincide; another consequence of this is it allows to get rid of ()on the "matching" string.

UPDATE 11: Use @ instead of \nas line separator for further use on split instructions. Although the "match" string lengthens from \S to [^@] it pays off , due to number of repetitions

UPDATE 12: Replaced the first regsub "match" string {[^@|]} by\[^@|] to shave one character off. Unfortunately, could not do the same to the second regsub, because the instruction is inside a pair of [] :(

UPDATE 13: Shaved two Enter characters by concentrating the lmap body with its own heading.

UPDATE 14: Used a call to the split based procedure N instead of a direct call to the string map based procedure N which allows to shorten by 3 characters

UPDATE 15: There was an unneeded space character. Removed it to shave one char off.

UPDATE 16: set h can be embedded to get rid of $h, to shave one character off.

UPDATE 17: set h statement can really be shaved off.

UPDATE 18: puts argument changed from the ...\n...\n...\n... format to the 

"...
...
...
..."

format.

Thanks to people that helped me to shorten it, especially evilotto and aspect of the tcl IRC channel!

sergiol

Posted 2016-12-12T22:59:13.740

Reputation: 3 055

Nice answer, and Welcome to the site! I made a minor edit to your post so that the byte count would appear in the header, I hope you don't mind. Just so you know, I think this is actually 469 bytes since some of those characters are multiple bytes in UTF-8. I don't know very much about tcl, does it use a custom encoding where those are one byte?

– James – 2016-12-18T18:17:53.190

@DJMcMayhem I didn't know it was based byte count instead of character count but it is a non-problem because everything that is a one byte symbol still not used can be a placeholder and I still have many available. – sergiol – 2016-12-18T21:56:02.290

@DJMcMayhem after my edit, the non-problem you reported has gone! – sergiol – 2016-12-18T22:12:34.557

@DJMcMayhem Why the 401 on top had a yellow background for some time? – sergiol – 2016-12-20T14:57:20.930

2

tcl, 369

Initially based in tcl's sergiol version.
(Note that many left spaces are part of tcl's "nature")

lmap z {S R M} w {set "regsub -all" "string map"} {interp alias {} $z {} {*}$w};lmap x {"`1234567890-=¿BS   ¿" "¿TAB  ¿QWERTYUIOP\[\]\\" "¿CAPS  ¿ASDFGHJKL;'¿ENTER¿" "¿SHIFT   ¿ZXCVBNM,./¿SHIFT   ¿"} {S h [M {\\ _ / _ | \ } [S g [M {||_ |/_  _|| _\\|} [M {||| \\|/} [S f [R {[^\n|]} [S b [M {|||| |||} [R {¿(\S+\s*)¿|(.)} $x {||\1\2 ||}]]] _ ]]]]]];puts $h\n$b\n$f\n$g}

Alejandro Muzzachiodi

Posted 2016-12-12T22:59:13.740

Reputation: 31

@muddyfish Edited and fixed. Thanks! – Alejandro Muzzachiodi – 2016-12-24T15:48:41.840

You can shorten more if you directly replace all foreach occurrences by lmap! – sergiol – 2016-12-26T21:53:53.900

Tried to use your interp alias approach to shorten my version, but the shortest I could get when doing it was 398 :( http://rextester.com/live/NTVAV88033

– sergiol – 2016-12-26T22:26:53.353

My last try I got 395: lmap z {S R M N} w {set "regsub -all" "string map" split} {interp alias {} $z {} {*}$w};lmap y [N [S b [M [N {||||@|||@$@BS @%@TAB @&@CAPS @? @ENTER @*@SHIFT } @] [R {[^@]} "\1234567890-=$@%QWERTYUIOP[]\@&ASDFGHJKL;'?@ZXCVBNM,./" {||& ||}]]] @] z [N [S f [R {[^@|]} $b ]] @] w [N [S g [M {|| |/_ _|| _\|} [M {||| \|/} $f]]] @] x [N [M {\ _ / _ | \ } $g] @] {puts $x\n$y\n$z\n$w}` – sergiol – 2016-12-26T23:46:56.283

You can save one char if you removed an unneeded space like in my last update! – sergiol – 2016-12-27T14:50:39.823

aspect has created a new paste at http://paste.tclers.tk/4068 "golf in 358"

– sergiol – 2016-12-27T20:44:07.317

BTW, relatively to my last comment, if I test it on www.rextester.com I can remove the package require zlib line and things still run well! – sergiol – 2016-12-27T21:04:14.513

And shorter using puts [zlib gu [binary d base64.That's 328 !. – Alejandro Muzzachiodi – 2016-12-27T21:36:07.947

— Em português e en castellano: EMPATE! – sergiol – 2017-06-22T23:10:45.393

I've got you beaten by me! – sergiol – 2017-09-23T11:05:03.110

1 byte less: https://tio.run/##TZBtT8IwFIW/71ecNEtEFCb4HuMHQBBUENf5us45DAySSQgbgdD2ty3ZH5tdg4lNbtOc89zTm5t8R3ke/QQLbMEpbPQl1uDxOAFZjsN4NUIliCICEifL2TyEQokEn82T8XKBIJoFMbiEuS1uXpbmWho6bwNOvmr145PTs/OLy6PKdZY2KYAsVWFZ6jSaxfvptW0778@9xyFzmceY9lqNIS3MBr3p3Hbv7h@u9rK0PXDa9q6ZdnsdR2d9vLVemoP@YdX6rxYTUkzh9sEZgw9LlQCDhEsRal0IJVk@4AsBnzEhd7LimLA0OYFrg7ufbC48LYz@GAFVUttZWmL0gMXl/SwVpeq@WsamYFiN1RUlPc9Tv3v6GItVEoOYU8McGebEMEMi8/wX

– sergiol – 2018-12-29T23:33:22.273

2

C (gcc), 378 342 330 327 bytes

-10 -3 bytes thanks to ceilingcat.

A first stab at it. The repeated g()'s suggests room for improvement.

Edit: There we go.

char*k[]={"eZXCVBNM,./e","cASDFGHJKL;'d","bQWERTYUIOP[]\\","`1234567890-=a","BS","TAB","CAPS","ENTER","SHIFT"},*s;f(w,i,j){for(i=16;i--;puts(""))for(s=k[i/4],j=i%4;*s;printf("%s%s%-*.*s%.2s",L" |"+(s++-k[i/4]?2:j<3),L"/||"+j,w,i&2?j^3?w>2?w:1:w+2:w,j^2?"___________":w>2?k[*s-93]:s,"\\||||| "+j*2))w=*s>96?"FFGFI"[*s-97]-64:2;}

Try it online!

gastropner

Posted 2016-12-12T22:59:13.740

Reputation: 3 264

1

Python 2, 672 bytes

Using a compressed zlib string:

print 'x\x9c\xad\xd3\xb9\x0e\x82@\x10\x80\xe1\x9e\xa7\xa0\xb3\xf1\xbe\x8d\xb1\x00\xbc\x0f<\xc0\x1b\xb3>\xc8<\xbc\xfc\x8bf\x8d\xed8\xc5\x17\x9a\xddd\xfe,\xbe\xc9\xc7\xd7b?<\x91\xa7/"\rhB\x0b\xda\xd0\x81.\xf4\xa0\x0f\x03\xa8C\x05F\x10&~>"\xf9]\xc6\x88\x16\x86\xbbj\xc6dZ\x98L<\xb7\xae\x9a|\xc74\x08\xed\xba\xb2\x873L\xe0\x00)\\\xe1\x08\x0b\xd8\xc2\x0e\xee\xf0\x80\xec\xd3\xabXW\x1d\xces\xeb\xaa\xc3\xb9^\x7fy_Q\xb0K\x8a`\x01$0\x86)\xcc`\x0eKX\xc1\x1a\x86P\xb2u\xe3tr\xf8\xee\xf5\xaf\xf7\xa5\x0e\xf6\xfb\xbet\xb1\xde\xbd\x92\xf9b\x9a\x16\x7f\x94\xdc\xe0\x02\x11\x9c\xec\xef\x061l\xa0\x0cU\xa8\xd9\xbc\xee\xb4\xeb\xa5\x8a\xf5\xd3K\x15\xcb\x9e~\x01r\xfc\xb9\xee'.decode('zlib')

Whatever

Posted 2016-12-12T22:59:13.740

Reputation: 19

2That's 672 bytes, not 232 bytes. – nneonneo – 2016-12-18T16:07:08.250

Explain further, I did not understand you. @nneonneo – Whatever – 2016-12-21T16:52:34.157

1If you paste your code into a file, that file will be 672 bytes long. You appear to have counted your code with len("print 'x\x9c...'") which will unescape the \xs, resulting in an incorrect byte count. You could obtain a correct count by counting with len(r"print 'x\x9c...'") but the easiest solution, as always, is to see what your text editor or filesystem says. – nneonneo – 2016-12-21T17:05:08.860

1

Powershell, 249 242 bytes

"``1234567890-=Bs   
Tab  QWERTYUIOP[]\
Caps  ASDFGHJKL;'Enter
Shift   ZXCVBNM,./Shift   "-split'
'|%{($u=($r=,''+($_-csplit'(.[a-z ]*)'-ne''|% t*per)+'')-replace'.','_')-join'__ _'
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'}|%{-join$_[2..76]}

Ungolfed & Explained

The middot · uses instead spaces to to clarify the source string.

"``1234567890-=Bs···
Tab··QWERTYUIOP[]\
Caps··ASDFGHJKL;'Enter
Shift···ZXCVBNM,./Shift···"-split"`n"|%{        # split the string with rows by new line
$r=,''+($_-csplit'(.[a-z ]*)'-ne''|% t*per)+''  # split each row by key labels (any char plus small letters or spaces), 't*per' is shortcut for toUpper method
$u=$r-replace'.','_'                            # replace any char to _ to take an upper 
$u-join'__ _'                                   # join labels and push 4 strings to pipe
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'
}|%{
    -join$_[2..76]                              # return substring for each string
}

# $r =
# ["","`","1","2","3","4","5","6","7","8","9","0","-","=","BS   ",""]
# ["","TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\",""]
# ["","CAPS  ","A","S","D","F","G","H","J","K","L",";","'","ENTER",""]
# ["","SHIFT   ","Z","X","C","V","B","N","M",",",".","/","SHIFT   ",""]
# $u =
# ["","_","_","_","_","_","_","_","_","_","_","_","_","_","_____",""]
# ["","_____","_","_","_","_","_","_","_","_","_","_","_","_","_",""]
# ["","______","_","_","_","_","_","_","_","_","_","_","_","_____",""]
# ["","________","_","_","_","_","_","_","_","_","_","_","________",""]
# before substring:
# __ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ _
#  |||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    |||
# _|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______|||
# _\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|/
# __ ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ _
#  |||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ |||
# _|||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||
# _\|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/
# __ _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ _
#  |||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER |||
# _|||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______|||
# _\|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|/
# __ ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ _
#  |||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||
# _|||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________|||
# _\|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|/
# final output:
#  ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
# ||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
# ||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
# |/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
#  ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
# ||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
# ||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
# |/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
#  _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
# ||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
# ||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
# |/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
#  ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
# ||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
# ||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
# |/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Extra: keyboard with a space bar & right aligned labels, 278 bytes

I've added a couple of bytes to the regular expression to handle the space bar (old regexp (.[a-z ]*), new one ~|(.[a-z ]*)). That's one small step for the regexp, one giant leap for the solution: you can now display space bar and key labels aligned to the right (see SHIFT, CTRL and BS on the right side of the keyboard).

"``1234567890-=~   bs
Tab  QWERTYUIOP[]\
Caps  ASDFGHJKL;'Enter
Shift   ZXCVBNM,./~   shift
Ctrl  Alt ~$(' '*34)Alt ~  ctrl"-split'
'|%{($u=($r=,''+($_-csplit'~|(.[a-z ]*)'-ne''|% t*per)+'')-replace'.','_')-join'__ _'
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'}|%{-join$_[2..76]}

Output:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||   BS ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||   SHIFT ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
 _________ _______ _____________________________________ _______ _________
||CTRL   |||ALT  |||                                   |||ALT  |||  CTRL ||
||_______|||_____|||___________________________________|||_____|||_______||
|/_______\|/_____\|/___________________________________\|/_____\|/_______\|

mazzy

Posted 2016-12-12T22:59:13.740

Reputation: 4 832

0

///, 360 bytes

/f/!!//e/SHIFT   //d/\/\///c/ "db/ 
\|\|da/\\\|d@/#####d?/__d>/?\\\\a
c"d</aa
ad:/fffff!d&/ccccd%/ aaad#/?aaa?aaad"/??d!/?\\\\a\\\d&&&cc"b`%1%2%3%4%5%6%7%8%9%0%-%=%BS    <|@#?|||"?<\/:f">&&&cbTAB  %Q%W%E%R%T%Y%U%I%O%P%[%]%\\ <|"@#?|||?<\/":f>_&&&"bCAPS  %A%S%D%F%G%H%J%K%L%;%'%ENTER <|"_@#"?<\/"_:!">?_&&ccc"?_be%Z%X%C%V%B%N%M%,%.%\/%e <|""_|||@""_<\/"?_:""_\a

Try it online!

Conor O'Brien

Posted 2016-12-12T22:59:13.740

Reputation: 36 228

0

Mathematica 323 bytes

Uncompress@"1:eJyt00luwjAUgGE2vUdYsWGeEeoiUGYIEKcTTWXEBXqBd3jy26CUYWe/xads8iT/sounv1gFL4VCoLNxxnyk9UZT5BiISAOa0II2dKALPejDAOpQgVcYqSAbEbtOa3GFuayraZ2mPmWyL5bnIZyxR0/CkQkhe/iECcSQwDe8wwK2sIMf+IV/IW0H56LXkJej+016E9LXlRyHO2VLhqDgDaYwgzksYQVrGELJZI+SSXxX0uOV9Jry2Y10q5iHVPPFNLGvUw7wBWP4ME8XIthAGapQM93zv29COlV8DOkrol10BmvF28U="

Boring and uncreative. The string is just the output of the built-in Compress command applied to the desired output.

Ian Miller

Posted 2016-12-12T22:59:13.740

Reputation: 727

@Downvoted please indicate what is wrong with my program. – Ian Miller – 2017-06-18T10:14:27.980

0

Wolfram Language (Mathematica), 293 bytes

c=##&@@(#|2&/@Characters@#)&
r=StringRiffle
p=StringPadRight
Print/@{j=p["",#2,"_"]&@@@#;(" __"<>#&/@j)<>" ",r[p@@@#,i={l="||","|||",l}],j~r~i,j~r~{"|/","\|/","\|"}}&/@{{c@"`1234567890-=","BS"|6},{"TAB"|6,c@"QWERTYUIOP[]\\"},{"CAPS"|7,c@"ASDFGHJKL;'","ENTER"|6},{h="SHIFT"|9,c@"ZXCVBNM,./",h}}

Try it online!

Relatively straightforward: encodes rows of keys as lists of (key name)|(key width)

c=##&@@(#|2&/@Characters@#)&    (*converts a string into (key)|2 s*)
r=StringRiffle
p=StringPadRight
 Print/@
  {j=p["",#2,"_"]&@@@#;
   (" __"<>#&/@j)<>" ",         (*top of the keys*)
   r[p@@@#,i={l="||","|||",l}], (*key names*)
   j~r~i,                       (*space under key names*)
   j~r~{"|/","\|/","\|"}            (*bottom of the keys*)
  }
 &/@
{
 {c@"`1234567890-=","BS"|6},
 {"TAB"|6,c@"QWERTYUIOP[]\\"},
 {"CAPS"|7,c@"ASDFGHJKL;'","ENTER"|6},
 {h="SHIFT"|9,c@"ZXCVBNM,./",h}
}

attinat

Posted 2016-12-12T22:59:13.740

Reputation: 3 495

0

Perl 5 -MList::Util=pairmap, 313 bytes

pairmap{$_=$b;s/\|{3}/|-|/g;y/-/_/c;y/-/ /;s/./ /;chop;say;$_=$b;for$r($a=~/./g){s/\| /|$r/}say;y/|/_/c;say;s,\|_,/_,g;s/_\|/_\\/g;say}"`1234567890-=",($;="||  |")x13 ."||BS    ||","QWERTYUIOP[]\\",'||TAB   |'.$;x13 .'|',"ASDFGHJKL;'","||CAPS   |".$;x11 ."||ENTER ||","ZXCVBNM,./",($s='||SHIFT    |').$;x10 ."$s|"

Try it online!

Xcali

Posted 2016-12-12T22:59:13.740

Reputation: 7 671

Asked: 2016-12-12T22:59:13.740

Viewed: 17 956 times

Active: 2019-10-25T15:16:54.670