एक कीबोर्ड इतना वास्तविक है कि आप इसे लगभग TASTE कर सकते हैं

Question

... ऐसा नहीं है कि तुम करोगे? कार्य सरल है, निम्न पाठ का आउटपुट:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||` |||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    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

यह भविष्य का कीबोर्ड है क्योंकि भविष्य में रिक्त स्थान अप्रासंगिक हैं, इसलिए स्पेसबार हैं।

---

चीजों को थोड़ा आसान बनाने के लिए आप पर:

1. 0123456789ABC...XYZ-=[]\;',./ - ये चार्ट लंबाई 6 की कुंजी पर हैं (पैडिंग सहित)।
2. TAB / BS / ENTER - ये चाबियां लंबाई 10 (गद्दी सहित) की हैं।
3. CAPS - यह कुंजी लंबाई 11 (पैडिंग सहित) है।
4. SHIFT - यह कुंजी लंबाई 13 की है (दोनों तरफ पैडिंग सहित)।

---

प्रत्येक व्यक्तिगत कुंजी इस तरह से कम या ज्यादा दिखती है:

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

हालाँकि, आपको ध्यान देना चाहिए कि दो लगातार कुंजियाँ नहीं हैं:

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

लेकिन वे "संयुक्त" हैं:

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

यह चुनौती बहुत बुरी नहीं होनी चाहिए, आपको शुभकामनाएँ; पुनरावृत्ति का दुरुपयोग करने से न चूकें! लेकिन या तो "विशेष" कुंजी को कम मत समझना;)।

---

जीतना?

सबसे छोटा कोड जीतता है क्योंकि यह कोड-गोल्फ है जिसे आप जानते हैं।

Comments

मैं मानता हूँ कि मैं आश्चर्यचकित नहीं हूं कि बहुत से लोग भविष्य के कीबोर्डों के बारे में चिंतित हैं जिनमें रिक्त स्थान नहीं हैं ...

— मैजिक ऑक्टोपस Urn

मुझे लगता है कि अंतरिक्ष सभी के बाद अंतिम सीमा नहीं थे।

— ग्रेग मार्टिन

"TASTE" "की" के लिए जर्मन शब्द है :)

— QBrute

"TASTE" "टाइपिंग" के लिए नॉर्वेजियन शब्द है :)

— Stewie Griffin

लेकिन यह "स्वाद" के लिए अंग्रेजी शब्द है। यहाँ ।

— मिस्टर लिस्टर

Answer 1

वी , 189, 179, 175, 164, 161, 157, 155, 149, 145, 141 , 135 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह जवाब अब ट्वीट करने योग्य है!

---

इसे देखो! यह थोड़ा संशोधित संस्करण है जो अपडेट होता है क्योंकि यह चलता है ताकि आप यह देख सकें कि यह कैसे काम करता है। यह एक पुराना संस्करण है क्योंकि मैंने इसे अभी तक फिर से रिकॉर्ड करने के लिए तैयार नहीं किया है, लेकिन सामान्य दृष्टिकोण समान है।

यह शायद अब तक का सबसे लंबा V उत्तर है। यह निश्चित रूप से मदद नहीं करता है कि वी का दुभाषिया बेहद धीमा है। पहला संशोधन लिखने में मुझे लगभग एक घंटे का समय लगा, लेकिन मैं बार-बार वापस आ रहा हूं ताकि हर बार एक जोड़े को बाइट दे सकूं। चूंकि पूर्ण कीबोर्ड 1215 बाइट्स है, वर्तमान में यह उत्तर आउटपुट से 91% कम है, इसलिए मैं परिणामों से बहुत खुश हूं।

चूँकि इसमें कुछ अचूक अक्षर हैं, और बहुत सारे गैर-ASCII हैं, यहाँ एक हेक्सडंप है:

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

कैसे बिल्ली यह काम करता है?

ठीक है, यह स्पष्टीकरण एक कामचोर होने वाला है। आप तैयार हैं? सबसे पहले, हमें अक्षरों को दर्ज करने की आवश्यकता है ताकि हम उनके चारों ओर कुंजियों का निर्माण कर सकें। ये है

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

जो सम्मिलित करता है:

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

यह बहुत सरलता से प्रवेश करता है, लेकिन कुछ चालें हैं जिनका उपयोग हम पात्रों को बचाने के लिए करते हैं। उदाहरण के लिए, ¬19"123456789" में ³प्रवेश करता है , तीन स्थानों में प्रवेश करता है, और हम बदलाव की नकल करते हैं ताकि हमें इसे कई बार दर्ज करने की आवश्यकता न हो।

ध्यान दें कि पत्र यहां कैसे कम किए गए हैं। ऐसा इसलिए है ताकि हम "एंटर" और एकल अक्षरों जैसे बड़े अक्षरों के बीच आसानी से अंतर कर सकें। उन्हें इस तरह से लिखने से यह बताना आसान हो जाता है कि कौन से अक्षर पहले एक बार लगाना है, और बाद में उन्हें कम करने के लिए कन्वर्ट करने के लिए केवल एक बाइट जोड़ता है। इसलिए हम इन्हें अपरकेस में बदलने के लिए एक स्थानापन्न कमांड करते हैं, और उनमें से प्रत्येक के बाद एक स्थान जोड़ते हैं:

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

अब, हम प्रत्येक महत्वपूर्ण अनुक्रम (गैर-व्हाट्सएप के किसी भी रन) को लेते हैं, और उनसे पहले और बाद में तीन बार डालते हैं:

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

इस बिंदु पर, बफर इस तरह दिखता है:

|||` |||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    |||

पहले और आखिरी कॉलम पर तीन बार होना वास्तव में बहुत सुविधाजनक है और लंबे समय में कई बाइट्स की बचत करता है।

और यहां वह जगह है जहां हम एक विशाल लूप चलाते हैं। यह कुछ इस तरह परिवर्तित होगा:

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

कुछ इस तरह से:

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

दो उदाहरणों के बीच सब कुछ òतब तक चलेगा जब तक कि कोई त्रुटि नहीं होती है, जो तब होगा जब हम एक पंक्ति में जाने की कोशिश करेंगे जो अभी तक मौजूद है। चूंकि हम सिर्फ एक विश्व स्तर पर स्थानापन्न कमांड चलाते थे , हमारा कर्सर अंतिम पंक्ति में है, और हम इन कामों को अपने तरीके से बदल देंगे।

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

यह है

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

लाइन।

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

यह है

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

लाइन।

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:
     _ _  "     '_ _'

यह है:

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

लाइन।

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

अब हमारे पास पूर्ण कीबोर्ड है, लेकिन प्रत्येक पंक्ति में एक अतिरिक्त पट्टी, एक अतिरिक्त स्लैश (आगे या पीछे), या एक अतिरिक्त अंडरस्कोर है। सुपर आसान तय

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

उस पागलपन के बाद, बफर को स्पष्ट रूप से मुद्रित किया जाता है।

Comments

आउटपुट के दाईं ओर रिक्त स्थान में 4 अतिरिक्त अंडरस्कोर दिखाई देते हैं?

— एरिक

आप इस बात को कम आंकते हैं कि वास्तव में यह जवाब कितना गंभीर है।

— मैजिक ऑक्टोपस Urn

@carusocomputing Haha, मुझे लगता है कि आप सही हैं। मुझे इस उत्तर पर और अपनी भाषा पर बहुत गर्व है कि मैं केवल एक जवाब हूँ। :)

— DJMcMayhem

@DJMcMayhem आपको विजेता के रूप में चिह्नित करता है यदि कोई आपको 1/3/2017;

— मैजिक ऑक्टोपस Urn

यह अभी भी साइट पर मेरा पसंदीदा जवाब है, वैसे। मैं यह नहीं गिन सकता कि मैंने कितनी बार GIF देखी है।

— मैजिक ऑक्टोपस Urn

Answer 2

लुआ 5.3, 416 394 बाइट्स।

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

अपुष्ट और टिप्पणियों के साथ।

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

उत्पादन

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||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    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

मैं अन्य languges द्वारा नष्ट होने जा रहा हूं, लेकिन मुझे लगा कि मैं इसे एक शॉट दूंगा। जटिलता की अच्छी मात्रा, और कम से कम यह कीबोर्ड से कम है!

Comments

अन्य भाषाओं को पेंच करें, आप एक दुर्लभ भाषा में पहले थे! प्रभावशाली, हालांकि मुझे यकीन है कि आपको निश्चित रूप से हर पत्र पर सीमांकक के रूप में पाइप डालने की आवश्यकता नहीं है। ध्यान दें कि "विशेष" कुंजी केवल लाइनों के आगे और छोर पर कैसे हैं। मुझे यकीन है कि संकेत आपको किसी तरह अनमोल बाइट्स बचा सकता है।

— मैजिक ऑक्टोपस Urn

लुआ का कौन सा संस्करण आप उपयोग कर रहे हैं? लुआ 5.1 पर यह मुझे एक सिंटैक्स त्रुटि देता है: स्टडिन: 1: '2 जे' के पास विकृत संख्या

— ब्रायनुष 1

@ ब्रायनश 1 लुआ 5.3, यह नंबर कॉन्स्टेंट को किसी भी अक्षर के आगे बैठने की अनुमति देता है जो कि हेक्साडेसिमल अंक या 'x' 0. के मामले में नहीं है

— ATaco

Answer 3

बबलगम , 191 बाइट्स

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......|.

इसे ऑनलाइन आज़माएं!

Comments

बबलगम उचित नहीं है।

— यहोशू

@ जोशुआ समाधान के लिए आधार रेखा सेट करना अच्छा है। और अगर कुछ भी बबलगम को हरा नहीं सकता है, तो यह समस्या की समस्या है।

— सर्ज बॉर्श

Answer 4

हास्केल, 263 वर्ण _{^{(353 बाइट्स 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(:" ")

जैसा कि इन यूनिकोड पात्रों के प्रकाश में स्कोर के बारे में बहुत चर्चा हुई है ... यहाँ एक ही कार्यक्रम है, जो सभी-एएससीआईआई के लिए कम है:

हास्केल, 263 वर्ण _{^{(263 बाइट्स 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(:" ")

Comments

यूनिकोड कीबोर्ड? दिलचस्प विकल्प (वहां गणित के अच्छे दिखने वाले अक्षर), लेकिन मुझे लगता है कि यह प्रतियोगिता के नियमों का उल्लंघन करता है।

— मारियो कार्नेइरो

@MarioCarneiro निष्पक्ष होने के लिए, यह कार्यक्रम की लंबाई को बिल्कुल भी प्रभावित नहीं करता है।

— १६

@pydsigner ऐसा करता है, जैसे शब्द ENTERवर्णों की तुलना में लंबे होते हैं ↩︎।

— टिमोथीम

लेकिन आप तुलना कर रहे हैं ENTER और ↩︎ , व्हाट्सएप पैडिंग इसे समान लंबाई बनाता है।

— कोडमोंकी

वास्तव में, मुझे उम्मीद है कि यूनिकोड प्रोग्राम को बाइट की गिनती से अधिक लंबा बना देगा, क्योंकि यूसीएफ 8 में एएससीआईआई की तुलना में उच्च यूनिकोड अधिक बाइट्स है।

— मारियो कार्नेरो

Answer 5

PHP, 303 बाइट्स

आलसी लेकिन प्रभावी। :)

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

Comments

अच्छा लगा। आमतौर पर, मैं संपीड़ित / gzip / bzip2 / 7z के साथ संपीड़न के समान स्तर प्राप्त नहीं कर सकता, अन्यथा बैश संस्करण तुच्छ रूप से छोटा होगा। जैसा कि यह खड़ा है, यह इसके बजाय 318 वर्णों पर है।

— कोनराड रुडोल्फ

मुझे पूरा यकीन है कि बाहरी संपीड़न एल्गोरिदम का उपयोग करने से आपके कार्यक्रम पर प्रतिबंध नहीं लगाया जाता है या कम से कम पर फेंक दिया जाता है। यह प्रश्न के उद्देश्य को पराजित करता है।

— कोई भी

@KonradRudolph जैसा कि मैं इसे समझता हूं, gzdeflate () gzip कमांड लाइन के समान संपीड़न का उपयोग करता है लेकिन फ़ाइल हेडर और चेकसम को छोड़ देता है इसलिए यह हमेशा थोड़ा छोटा होगा।

— एलेक्स हॉन्सस्की

300 बाइट्स <?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbHA+0QEvDHrg8zDy79EMbTDFF+3m8yfXdek42phHJG3KyItaEMHutCDPgxgCCNoQg0mMI3cdETSu4wRLQx3NYxJtDCJOL9t1cnSFWNvareVE1xhASHEcIczbOAIATzhBck3V7atupuTb6vulucq43XNvCDKenkQwRyWsII1bGEHexhDxcb140X4n6us16XuVXxdulZZrmi9WcbZd5IH3GAGF/vXwIcDVKEODVs3P53nUrUq5FK1sqc/'));:। कंप्रेसर: sandbox.onlinephpfunctions.com/code/… Decompressor: sandbox.onlinephpfunctions.com/code/…

— इस्माईल मिगुएल

@ कोई नहीं बाहरी कुछ भी नहीं है, gz PHP के डिफ़ॉल्ट संकलन का हिस्सा है और इसलिए इसे आसानी से अनुमति दी जाती है।

— एलेक्स हॉवानस्की

Answer 6

पायथन 3.5+, 239 बाइट्स

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))

Comments

क्या पायथन 3.5+ को ट्यूपल्स के अंदर के स्पैट के लिए आवश्यक है, या कुछ और?

— mbomb007

यदि आप प्रत्येक कुंजी के निर्माण को उल्टा करते हैं और "".join(...) + f[0]आंतरिक लूप में उपयोग करते हैं , तो आप एक बाइट बचा सकते हैं । गमागमन formatतर्क क्रम और स्ट्रिंग में संबंधित प्लेसहोल्डर भी दो और बाइट्स बचाता है।

— डेफरन

['{1}__ ','|{} ||','|{1}||','/{1}\\|']के उपयोग से कम है split।

— एलेक्स हॉल

Answer 7

बैच, 465 452 बाइट्स

@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

:cसबरूटीन कुंजी की एक पंक्ति को संभालती है। अतिरिक्त रिक्त स्थान युक्त कुंजी, उद्धृत किया जाना करने की आवश्यकता है के रूप में =, ;, ,चाबियाँ, संभवतः में बग के कारण shiftआदेश। पहला और आखिरी पैरामीटर समता की _सहायता के लिए पहली और आखिरी कुंजी के समान लंबाई के तार हैं । tइसके बाद _पहली, तीसरी और चौथी पंक्तियों के लिए आम के रूप में समाप्त होता है #, जिसमें शामिल होने को चिह्नित करने के साथ, जो कि प्रमुख और अनुगामी पात्रों को जोड़ने से पहले उचित रूप से प्रतिस्थापित किया जाता है, जबकि sदूसरी पंक्ति है, लेकिन |s को बदलकर !s के रूप में वे कम कर देते हैं एस की संख्या "जो मुझे चाहिए। संपादित करें: एक ही कथन में सभी चार पंक्तियों को मुद्रित करके 1 बाइट सहेजा गया, और 12 बाइट्स जिस तरह से मैंने sचर को सौंपा है, उसे अनुकूलित करके ।

Answer 8

रूबी, 226 बाइट्स

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]}

निम्नानुसार सुधार:

1. सरणी के आरंभ और अंत में खाली स्ट्रिंग तत्व नहीं। इसके बजाय सरणी को 3 साइड-बाय साइड कीबोर्ड बनाया गया है। स्ट्रिंग में रूपांतरण के बाद हमारे पास 3 कीबोर्ड हैं जिनमें बाहरी किनारे गायब हैं। यह केवल किनारों के साथ, मध्य एक को प्रदर्शित करने के लिए छोटा है।

2. रूबी का परिवर्तित संस्करण। मेरी मशीन पर स्थापित 1.9.3 के बजाय Ideone का उपयोग किया। इस साधन .chars.to_aको छोटा किया जा सकता है .chars।

रूबी, 239 बाइट्स

इससे बाहर निकलने के लिए कुछ और बाइट्स हैं। कल देखेंगे।

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.
}

Answer 9

सी #, 357 बाइट्स (जब एक पंक्ति में, और अधिकांश सुझावों को शामिल करना)

---

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);

या, स्ट्रिंग इंटरपोलेशन और अन्य सभी सुझावों के साथ 353

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 (स्ट्रिंग प्रक्षेप के बिना):

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);

Comments

आप गोल्फ लाइन को एक पंक्ति के रूप में स्वरूपित करने वाले बहुत से बाइट्स बचा सकते हैं:foreach(var r in q){for(int i=0;i<4;i++){foreach...

— मारियो

@ मेरियो मैं सिर्फ बाइट की जाँच करता हूं, दिया गया मूल्य वास्तव में नई कहानियों के बिना गिनती है, इसलिए यह तकनीकी रूप से पहले ही हो चुका है

— अल्फी गुडाक्रे

397 बाइट्स के नीचे थोड़ा गोल्फ इंटरपोलेशन का इस्तेमाल करते हुए और उसके ==साथ< s+=i<1?$" {u}__":i<2?$"||{k.PadRight(l)}|":i<3?$"||{u}|":$"|/{u}\\";

— अल्फी गुडाक्रे

धन्यवाद @ एलाफ़ी गुडाकरे मैंने आपके सुझाव के अनुसार '==' को '<' से बदल दिया। मैंने प्रक्षेप को छोड़ दिया ताकि इसे कम संस्करण विशिष्ट बनाया जा सके।

— क्लिंगर

@ क्लिंगर मैं सहमत हूं, प्रक्षेप किसी भी ऑनलाइन संकलक पर काम नहीं करता है, इसलिए यह एक अच्छा विकल्प है!

— अल्फी गुडाक्रे

Answer 10

PowerShell v2 +, 465 बाइट्स

($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'#','|||'

मैं इस उत्तर को पोस्ट करने में शर्मिंदा हूं, यह देखते हुए कि पीएचपी और पायथन के उत्तर कितने कम हैं, सी # उत्तर को कभी नहीं छोड़ें, लेकिन मैं इस विधि को छोटा नहीं कर पा रहा हूं। अन्य तरीकों से बेहतर परिणाम मिल सकते हैं।

यह मूल रूप से केवल एक विशाल मल्टी-लाइन स्ट्रिंग है, जिसमें $aविभिन्न सबस्ट्रिंग के लिए चर ( और इसी तरह) प्रतिस्थापन है, और -replaceइसे समाप्त करने के लिए अंत में एक युगल है। $(...)नए ब्लॉक शुरू करने के लिए जहां आवश्यक हो वहां स्क्रिप्ट ब्लॉक डाले जाते हैं।

इसे ऑनलाइन आज़माएं!

Answer 11

पायथन, 493 458 बाइट्स।

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)

कार्यात्मक रूप से समतुल्य लेकिन कुछ अधिक पठनीय:

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)

दुर्भाग्य से यह पहले से ही लुआ में दिए गए उत्तर से अधिक लंबा है।

Comments

आप pफ़ंक्शन को लाइनों को अर्धविराम द्वारा अलग किए गए एक लाइन पर रख सकते हैं । इसके अलावा, मैंने सोचा था कि आप पहली पंक्ति नहीं बना सकते k=[['|']*75]*16, क्या आप जानते हैं कि क्यों?

— nedla2004

आप कुछ बाइट्स को बचाने के लिए '_'और ' 'एक चर के लिए भी परिभाषित कर सकते हैं ।

— nedla2004

सुझावों के लिए धन्यवाद! मुझे लगता है कि k = [['|'] * 75] * 16 एक ही सरणी के सोलह संदर्भ बनाता है इसलिए एक पंक्ति में बदलाव दूसरों को भी प्रभावित करता है।

— कोबी

ठीक है, तो आप कम से कम कर सकते हैं परिवर्तन range(16)करने के लिए [0]*16।

— nedla2004

एक छोटा सा मुद्दा यह है कि अपने कोड तकनीकी रूप से सही उत्पादन का उत्पादन नहीं करता है, लेकिन आप को बदलने के द्वारा कि ठीक कर सकते हैं है for l in k:print ' '.join(l)करने के लिए for l in k:print''.join(l)।

— nedla2004

Answer 12

PHP, 316 312 बाइट्स

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;

मुझे पूरा यकीन है कि इस दृष्टिकोण को और आगे नहीं बढ़ाया जा सकता है। लेकिन अगर किसी को भी 10 और बाइट्स पाता है ...: डी
के साथ भागो -r।

टूट - फूट

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
            ;

Answer 13

बैश (OSX पर), 12 8 + 221 + 1 = 234 230 बाइट्स

हाँ, मुझे पता है, संपीड़न। लेकिन यह काम करता है, नहीं?

gunzip<f

निम्न सामग्री के साथ वर्तमान निर्देशिका में "एफ" नामक एक फ़ाइल की आवश्यकता होती है (पीपीसीजी-मित्रता के लिए बेस 64 में डाल दिया जाता है - आप इसे पहले "एफ" फ़ाइल में डिकोड कर सकते हैं।):

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

Comments

लेखन से तुच्छ रूप से छोटा किया जा सकता है gunzip<f।

— कोनराड रुडोल्फ

@KonradRudolph उत्कृष्ट बिंदु। धन्यवाद।

— Addison Crump

आप दो बाइट्स को बचा सकते हैं zcat f, और दो बाइट्स को दो अनुगामी नल बाइट्स को हटाकर (गज़िप शिकायत करता है लेकिन वांछित आउटपुट पैदा करता है)।

— गिल्स

@ गिल्स वास्तव में मुझे बाइट्स नहीं बचाते हैं - मुझे फ़ाइल "fZ" (OSX पर कम से कम) का नाम बदलना होगा। अनुगामी नल बाइट्स को हटाने से न केवल गज़िप शिकायत होती है - यह इसे बाहर त्रुटि करता है और कुछ भी प्रिंट नहीं करता है।

— Addison Crump

@VoteToClose ओह ठीक है, zcat<fफिर। लिनक्स पर, अनुगामी शून्य के बिना zcat gzip शिकायत ("gzip: stdin: अप्रत्याशित समाप्ति फ़ाइल") बनाता है, लेकिन केवल वांछित आउटपुट प्रिंट करने के बाद।

— गिल्स

Answer 14

जावास्क्रिप्ट (ईएस 6), 286

एक अनाम फ़ंक्शन जिसमें कोई पैरामीटर नहीं है

_=>[..."`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`
`

कम गोल्फ वाला

_=>[..."`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>

Answer 15

स्विफ्ट, 777 बाइट्स

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:"")

स्विफ्ट आमतौर पर गोल्फ के लिए पसंद की एक महान भाषा नहीं है, इसलिए वर्तमान छोटे से छोटे उत्तर (जो तेज था) की तुलना में दोगुना से कम होना एक अच्छी चुनौती है!

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()

Comments

कम से कम यह अपीलीय नहीं है

— Addison Crump

अब मुझे जावा है I नहीं

— CAD97

Answer 16

SOGL V0.12 , 131 128 127 बाइट्स ( प्रतिस्पर्धा? )

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

एसओजीएल के पास 2*2/और 2/2*quirks हैं, लेकिन वे इस चुनौती के लिए बिल्ट-इन की तरह महसूस करते हैं।
यह कोशिश करो!

...‘               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

Comments

वाह, यह सुपर प्रभावशाली है! कोई भी मुझे इस पर एक हरा करने में कामयाब नहीं है, इसलिए अच्छा काम! मैं बस थोड़ा छोटा होने की कोशिश कर सकता हूं, लेकिन कोई वादा नहीं। ;)

— डीजेमैकेम

@dzamia भले ही अब प्रतिस्पर्धा कर रही हो, लेकिन मैंने जवाब वापस स्वीकार कर लिया जब यह नहीं था। क्या मुझे जवाब बदल देना चाहिए?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn IMO यह आपके ऊपर है। वहाँ एक कारण है कि यह जवाब स्वीकार नहीं करने के लिए सुझाव दिया है: पी

— dzaima

यह उत्तर स्वीकार नहीं करने का सुझाव दिया गया है? ओह ... काफी उचित। फिर मुझे लगता है कि मैं भविष्य में उत्तर स्वीकार करना बंद कर दूंगा और सामान को छोड़ दूंगा।

— मैजिक ऑक्टोपस यूरन

@MagicOctopusUrn ठीक है, हो सकता है कि उत्तर स्वीकार न करना थोड़ा विवादास्पद है, लेकिन फिर भी, एक बड़ा सकारात्मक

— द्विजिमा

Answer 17

पायथन 2, 394 388 380 बाइट्स

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)

बस पूरे कीबोर्ड का प्रतिनिधित्व करने वाला एक बड़ा स्ट्रिंग बनाता है, विशेष कुंजी के लिए% s के साथ * बदलता है फिर विशेष को अपडेट करने के लिए स्ट्रिंग प्रारूपण का उपयोग करता है।

संपादित करें

अब आउटपुट के अंत में एक अनुगामी न्यूलाइन है लेकिन मुझे ऐसा कहीं भी नहीं दिखता है जिसकी अनुमति नहीं है।

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि आपको आउटपुट को हटा देना चाहिए, क्योंकि यह कुछ भी प्रासंगिक नहीं जोड़ता है।

— सेरगिल

@sergiol - अच्छी बात है। पोस्टिंग के समय टीआईओ को जानकारी नहीं थी। अब अद्यतन किया गया।

— ElPedro

Answer 18

C #, 376 बाइट्स (जब एक लाइन में)

---

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);

यह पूरी तरह से क्लिंगर के उत्तर # पर आधारित है। मेरे पास उसके जवाब पर टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है, अन्यथा मैं कर सकता था।

मैं शुरुआती बर्च लूप को संशोधित करके और बाहरी ब्रैकेट्स को हटाकर, 5 बाइट्स द्वारा क्लिंगर के कोड को पतला करने में सक्षम था।

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);

Comments

अच्छा एक @ बंस जोफुल। आपके सुझाव के साथ मैं इसे 367 में ले पाऊंगा। मैंने वर्तमान उत्तर को शामिल नहीं किया है।

— क्लिंगर

विरोध नहीं कर सकता। आपका सुझाव + कुछ अतिरिक्त मामूली बदलाव इसे 361 (या स्ट्रिंग प्रक्षेप के साथ 358) में लाता है।

— क्लिंगर

@ क्लिंगर - कृपया मेरे ट्वीक्स का उपयोग करें! मुझे आपके काम के आधार पर इसके साथ खेलने के लिए प्रेरित किया गया। मैंने प्रक्रिया में आरंभीकरण के बारे में कुछ सीखा।

— बेंस जोफुल

क्या आप एक पंक्ति कार्यक्रम शामिल कर सकते हैं? आप वर्तमान में बहुत अधिक पठनीयता नहीं खोएंगे

— Cyoce

@ सही है, आपको यह मिल गया, सुझाव के लिए धन्यवाद। हालांकि इस बिंदु पर, क्लिंगर ने पहले से ही एक नया, छोटा संस्करण पोस्ट किया है जिसमें इन परिवर्तनों को शामिल किया गया है।

— बेन्स जोफुल

Answer 19

एम 4, 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    )

(यह वास्तव में पहली बार है जब मैं कोड-गोल्फिंग कर रहा हूं और m4 को आज़मा रहा हूं।)

Comments

पहले जवाब के लिए बुरा नहीं है। साइट पर आपका स्वागत है! :)

— DJMcMayhem

Answer 20

खड़ी , 228 बाइट्स

यहाँ कोशिश करो!

[,{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

या, थोड़ा अधिक पठनीय:

{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

यह एक फ़ंक्शन को परिभाषित करके काम करता है pजो एक कुंजी बनाता है, फिर hcatकई कुंजियों को सम्मिलित करता है।

Answer 21

हास्केल, 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]

रेट्रोस्पेक्ट में, इस हास्केल उत्तर की अवधारणा में समान है , लेकिन एएससीआईआई कीबोर्ड का उत्पादन कर रहा है, और थोड़ा अलग गोल्फिंग के साथ।

प्रारूपित और नामांकित:

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    "

Answer 22

tcl, 368

के रूप में http://textmechanic.com/text-tools/basic-text-tools/count-characters-words-lines/ द्वारा गिना जाता है "रिक्त स्थान टूटता है।" सेट पर, यह 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"}

डेमो: http://rextester.com/live/NTVAV88033

द अनगुल्फ:

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
}

कोई भी स्वतंत्र है और लाइव सहयोग साइटों पर मेरे संस्करण को बेहतर बनाने के लिए आपका स्वागत है, लेकिन कृपया: यहां मेरे मूल उत्तर को संपादित न करें; केवल यह कहें कि आपने टिप्पणियों में संपादित किया है और लोग लिंक पर जाएंगे।

अद्यतन 1:for द्वारा प्रतिस्थापित foreach, क्योंकि उत्तरार्द्ध कम कोड का उत्पादन करता है

अद्यतन 2:foreach द्वारा प्रतिस्थापित lmap, क्योंकि उत्तरार्द्ध कम कोड का उत्पादन करता है

अद्यतन 3: एक चार मुंडा क्योंकि मैं " "द्वारा प्रतिस्थापित\

अद्यतन 4: पहली टिप्पणी के संबंध में, मैंने सभी 1 पंक्ति 2 बाइट यूनिकोड स्थान धारक वर्णों को 1 बाइट ASCII वाले में बदल दिया

अद्यतन 5: एकाधिक putsलाइन केवल एक में बनी

अद्यतन 6: इंटरमीडिएट सूची चर का उपयोग करने के बजाय कॉल splitपर सीधे रिटर्न मानों lmapका उपयोग करें

अद्यतन 7: उद्धरण की ENTERआवश्यकता नहीं थी

अद्यतन 8: string map यह काफी लंबा है और कई बार दोहराया गया है कि यह इसे एनकैप्सुलेट करने के लायक हैproc

अद्यतन 9: split $x \n काफी लंबा है और कई बार दोहराया गया है कि यह इसे एनकैप्सुलेट करने के लायक हैproc

अद्यतन 10: "प्रतिस्थापन" स्ट्रिंग के &बजाय का उपयोग कर सकते हैं \1, क्योंकि इस मामले में दोनों मेल खाते हैं; इसका एक और परिणाम यह है कि यह ()"मिलान" स्ट्रिंग पर छुटकारा पाने की अनुमति देता है ।

अद्यतन 11: का प्रयोग करें @बजाय \nपर आगे उपयोग के लिए लाइन विभाजक के रूप में splitदिए गए निर्देशों का। हालांकि "मैच" स्ट्रिंग से लंबा \Sकरने के लिए [^@]इसे बंद कर देता है, repetitions की संख्या के कारण

अद्यतन 12: पहले बदला गया regsub"मैच" स्ट्रिंग {[^@|]}से \[^@|]एक चरित्र बंद दाढ़ी बनाने के लिए। दुर्भाग्य से, दूसरे के लिए ऐसा नहीं कर सका regsub, क्योंकि निर्देश एक जोड़ी के अंदर है []:(

अद्यतन 13: शेव किए गए दो अक्षरों को lmapअपने शीर्षकों के साथ शरीर को एकाग्र करके ।

अद्यतन 14: के लिए एक कॉल प्रयुक्त splitआधारित प्रक्रिया Nके लिए एक सीधा कॉल के बजाय string mapआधारित प्रक्रिया Nहै जो 3 अक्षरों से कम करने के लिए अनुमति देता है

अद्यतन 15: एक अनावश्यक स्थान वर्ण था। इसे हटाने के लिए एक चार दाढ़ी बनानी चाहिए।

अद्यतन 16: एक चरित्र को बंद करने के लिए, set hछुटकारा पाने के लिए एम्बेड किया जा सकता $hहै।

अद्यतन 17: set h कथन को वास्तव में बंद किया जा सकता है।

अद्यतन 18: puts तर्क को ...\n...\n...\n...प्रारूप से बदल दिया गया

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

प्रारूप।

उन लोगों के लिए धन्यवाद जिन्होंने मुझे इसे छोटा करने में मदद की, विशेष रूप से टिल्ट आईआरसी चैनल के बैडोटाइप और पहलू!

Comments

अच्छा जवाब, और साइट पर आपका स्वागत है! मैंने आपकी पोस्ट को एक मामूली संपादित किया है ताकि बाइट गिनती हैडर में दिखाई दे, मुझे आशा है कि आपको कोई आपत्ति नहीं है। जैसा कि आप जानते हैं, मुझे लगता है कि यह वास्तव में 469 बाइट्स हैं, क्योंकि उन पात्रों में से कुछ यूटीएफ -8 में कई बाइट्स हैं। मुझे tcl के बारे में बहुत अधिक जानकारी नहीं है, क्या यह एक कस्टम एन्कोडिंग का उपयोग करता है जहां वे एक बाइट हैं?

— डीजेमेकमैम

@DJMcMayhem मुझे नहीं पता था कि यह कैरेक्टर काउंट के बजाय बाइट काउंट पर आधारित था, लेकिन यह एक गैर-समस्या है क्योंकि सब कुछ जो एक बाइट का प्रतीक है, जिसका उपयोग अभी भी नहीं किया गया है वह एक प्लेसहोल्डर हो सकता है और मेरे पास अभी भी कई उपलब्ध हैं।

— सर्गिओल

@DJMcMayhem मेरे संपादन के बाद, आपके द्वारा रिपोर्ट की गई गैर-समस्या!

— सर्गिओल

@DJMcMayhem क्यों 401 के शीर्ष पर कुछ समय के लिए एक पीले रंग की पृष्ठभूमि थी?

— सर्गियोल डेसी 20'16

Answer 23

tcl, 369

प्रारंभ में tcl के सेरगिओल संस्करण में आधारित है।
(ध्यान दें कि कई बायां स्थान tcl की "प्रकृति" का हिस्सा हैं)

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}

Comments

@muddyfish संपादित और नियत। धन्यवाद!

— एलेजांद्रो मुज़ाचियोदी

आप अधिक छोटा कर सकते हैं यदि आप सीधे सभी foreachघटनाओं को बदल देते हैं lmap!

— सर्गिओल

interp aliasमेरे संस्करण को छोटा करने के लिए आपके दृष्टिकोण का उपयोग करने की कोशिश की , लेकिन सबसे छोटा मैं ऐसा कर सकता था जब यह 398 कर रहा था :( rextester.com/live/NTVAV88033

— sergiol

मेरी आखिरी कोशिश मुझे 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}

— सर्जियोल डे

यदि आपने मेरे पिछले अपडेट की तरह एक अनावश्यक स्थान को हटा दिया तो आप एक चार्ज को बचा सकते हैं!

— सेरगिओल

Answer 24

सी (जीसीसी) , 378 342 330 बाइट्स

-10 बाइट्स सीलिंगकैट के लिए धन्यवाद।

इस पर पहला छुरा। दोहराया जी () के सुधार के लिए जगह का सुझाव देता है।

संपादित करें: हम वहाँ जाते हैं।

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

इसे ऑनलाइन आज़माएं!

Answer 25

पायथन 2, 672 बाइट्स

एक संकुचित zlib स्ट्रिंग का उपयोग करना:

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')

Comments

वह 672 बाइट है, 232 बाइट नहीं।

— nnonneo 16

आगे बताइए, मैं आपको समझ नहीं पाया। @nneonneo

— जो भी हो

यदि आप किसी फ़ाइल में अपना कोड पेस्ट करते हैं, तो वह फ़ाइल 672 बाइट्स लंबी होगी। आपको अपना कोड गिना हुआ प्रतीत होता है , जिसके साथ एस len("print 'x\x9c...'")अनसेस्केप होगा \x, जिसके परिणामस्वरूप गलत बाइट गिनती होगी। आप len(r"print 'x\x9c...'")हमेशा की तरह सबसे आसान समाधान के साथ गिनती करके एक सही गणना प्राप्त कर सकते हैं, यह देखना है कि आपका टेक्स्ट एडिटर या फाइलसिस्टम क्या कहता है।

— nnonneo

Answer 26

पॉवरशेल, 249 242 बाइट्स

"``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]}

अनगढ़ और समझाया हुआ

·स्रोत स्ट्रिंग को स्पष्ट करने के लिए रिक्त स्थान के बजाय middot का उपयोग करता है।

"``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    ||
# ||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
# |/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

---

अतिरिक्त: एक स्पेस बार और दाएं संरेखित लेबल के साथ कीबोर्ड, 278 बाइट्स

मैंने स्पेस बार (पुराने regexp (.[a-z ]*), नया एक ~|(.[a-z ]*)) को संभालने के लिए नियमित अभिव्यक्ति के लिए कुछ बाइट्स जोड़े हैं । यह regexp के लिए एक छोटा कदम है, समाधान के लिए एक विशाल छलांग: आप अब दाईं ओर संरेखित स्पेस बार और कुंजी लेबल प्रदर्शित कर सकते हैं (कीबोर्ड के दाईं ओर SHIFT, CTRL और BS देखें)।

"``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]}

आउटपुट:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||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 ||
||_______|||_____|||___________________________________|||_____|||_______||
|/_______\|/_____\|/___________________________________\|/_____\|/_______\|

Answer 27

/// , 360 बाइट्स

/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

इसे ऑनलाइन आज़माएं!

Answer 28

गणितज्ञ 323 बाइट्स

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

बोरिंग और अनिश्चित। स्ट्रिंग केवल Compressवांछित आउटपुट पर लागू अंतर्निहित कमांड का आउटपुट है।

Comments

@Downvoted कृपया इंगित करें कि मेरे कार्यक्रम में क्या गलत है।

— इयान मिलर

Answer 29

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 293 बाइट्स

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}}

इसे ऑनलाइन आज़माएं!

अपेक्षाकृत सीधा: सूचियों की पंक्तियों को सांकेतिक शब्दों में बदलना (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}
}

Answer 30

पर्ल 5 -MList::Util=pairmap , 313 बाइट्स

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|"

इसे ऑनलाइन आज़माएं!