क्वर्टी कीबोर्ड का आउटपुट

37

एक चरित्र को देखते हुए, आउटपुट (स्क्रीन के लिए) पूरे क्वर्टी कीबोर्ड लेआउट (रिक्त स्थान और नई लाइनों के साथ) जो चरित्र का अनुसरण करता है। उदाहरण इसे स्पष्ट करते हैं।

इनपुट 1

f

आउटपुट 1

g h j k l
z x c v b n m

इनपुट 2

q

आउटपुट 2

w e r t y u i o p
a s d f g h j k l
z x c v b n m

इनपुट 3

m

आउटपुट 3

(कार्यक्रम आउटपुट के बिना समाप्त होता है)

इनपुट 4

l

आउटपुट 4

z x c v b n m

सबसे छोटा कोड जीतता है। (बाइट्स में)

पुनश्च

अतिरिक्त न्यूलाइन्स, या एक पंक्ति के अंत में अतिरिक्त स्थान स्वीकार किए जाते हैं।

code-golf  keyboard 
— ghosts_in_the_code
स्रोत
क्या एक फ़ंक्शन पर्याप्त है या क्या आपको एक पूर्ण कार्यक्रम की आवश्यकता है जो स्टड / स्टडआउट को पढ़ता / लिखता है?
— 14
1
के अनुसार @agtoever meta.codegolf.stackexchange.com/questions/7562/... , यह अनुमति दी है। हालाँकि, फ़ंक्शन को अभी भी स्क्रीन पर आउटपुट करना होगा।
— भूत_न_थे_कोड १४
@agtoever इसके बजाय इस लिंक को आज़माएं। meta.codegolf.stackexchange.com/questions/2419/…
— ghosts_in_the_code 15
1
एक पंक्ति से पहले अग्रणी स्थान की अनुमति है?
— साहिल अरोड़ा
1
@ साहिल अरोरा नोप।
— भूत_न_थे_कोड ३

जवाबों:

19

CJam, 42 40 बाइट्स

"wertyuiop asdfghjkl zxcvbnm"q/W=S%Sf*N*

इसका परीक्षण यहां करें।

व्याख्या

"we...nm"
     e# Push the letters in order, without q. We don't need q, because it will never
     e# be part of the output.
q/   e# Split the string around the input. If the input is "q", the entire string
     e# will go into a single chunk.
W=   e# Select the last chunk.
S%   e# Split the string around spaces, discarding empty segments (only relevant for the 
     e# first segment if the input is "p" or "l").
Sf*  e# Join each line by spaces.
N*   e# Join the lines by linefeeds.
— मार्टिन एंडर
स्रोत
क्या है e#? क्या यह एक टिप्पणी के लिए CJam वाक्यविन्यास है? अग्रिम में धन्यवाद।
— AL
@ हाँ यह है
— मार्टिन एंडर
11

पायथ, 33 बाइट्स

jjL\ cec."`zÈ´ýß44,ûtKÕÀ@"z\`

ध्यान दें कि कुछ अक्षर अप्राप्य हैं। इसे Pyth Compiler में ऑनलाइन आज़माएँ ।

यह काम किस प्रकार करता है

jjL\ cec."`z…"z\`

        ."`z…"     Unpack …, with lowest character '`' and highest character `z`.
       c      z    Split at occurrences of the input (z).
      e            Retrieve the last resulting chunk.
     c         \`  Split into rows, at backticks.
 jL\               Separate the characters of each row by spaces.
j                  Separate the rows by linefeeds.
— डेनिस
स्रोत
अरे यार, मैंने अभी तक अपना पहला पायथ प्रोग्राम बनाया था (केवल 38 बाइट्स!), फिर तुम साथ आए ... +1 बीटीडब्ल्यू, मुझे लगता \ है कि इसके बराबर है d।
— ETHproductions
ओह, मुझे लगता है कि यह समान नहीं है ... क्या अलग है?
— 18
1
@ETHproductions @ डेनिस md55 स्थानों का उत्पादन नहीं करने का एक ही कारण है । dडिफ़ॉल्ट चर है जो मानचित्र ऑपरेटर के चलने योग्य तर्क के माध्यम से पुनरावृत्त करता है। और jL\ <list>बस मानचित्र ऑपरेटर के लिए एक शॉर्टकट है mj\ d<list>।
— 18
1
@ जकुब ओह, यह समझ में आता है। धन्यवाद!
— डेनिस
10

पर्ल, 56 बाइट्स

#!perl -p
'qwertyuiop
asdfghjkl
zxcvbnm'=~/$_
?/;$_=$';s/\B/ /g

शेबंग को 3 के रूप में गिना जाता है, इनपुट स्टड से लिया जाता है। यदि एक प्रमुख न्यूलाइन इनपुट्स के लिए चिंता का विषय नहीं है pऔर l, तो 4 को बचाने के लिए /$_\n?/नंगे के साथ प्रतिस्थापित किया जा सकता है $_।

नमूना उपयोग

$ echo g|perl qwerty.pl
h j k l
z x c v b n m

$ echo v|perl qwerty.pl
b n m
— Primo
स्रोत
2
मुझे\K सिखाने के लिए धन्यवाद !
— डोम हेस्टिंग्स
इस मामले में @DomHastings, यह बाइट गिनती के लिए वास्तव में आवश्यक नहीं था, s/.\B/$& /gसमान रूप से अच्छी तरह से काम करेगा। एक बेहतर उदाहरण ।
— प्रिमो
6

जीएस 2 , 38 37 बाइट्स

♦wertyuiop asdfghjkl zxcvbnm♣B3$,■♪2◙

स्रोत कोड CP437 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

परीक्षण चालन

$ base64 -d > qwerty.gs2 <<< BHdlcnR5dWlvcCBhc2RmZ2hqa2wgenhjdmJubQVCMyQs/g0yCg==
$ wc -c qwerty.gs2
37 qwerty.gs2
$ echo -n f | gs2 qwerty.gs2
g h j k l
z x c v b n m

यह काम किस प्रकार करता है

♦                                      Begin string literal.
 wertyuiop asdfghjkl zxcvbnm
                            ♣          End string literal.
                             B         Swap the string with the input.
                              3        Split the string at the input character.
                               $       Select the last chunk.
                                ,      Split the selected chunk at spaces.
                                 ■     Map over the resulting array:
                                  ♪      Push ' '.
                                   2     Join the characters, separating by ' '.
                                    ◙    Push a linefeed.
— डेनिस
स्रोत
6

सी #, 112 बाइट्स 105 110

गिनती 5 बाइट्स से ऊपर चली गई, लेकिन अधिक सही! धन्यवाद @ मार्टिनबटनर !!

void c(char i){System.Console.Write(@"q w e r t y u i o p
a s d f g h j k l
z x c v b n m".Split(i)[1].Trim());}

संयुक्त राष्ट्र के golfed

void c(char i)
{
    System.Console.Write(@"q w e r t y u i o p
    a s d f g h j k l
    z x c v b n m".Split(i)[1].Trim());
}
— जोहान
स्रोत
5

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

x=>[...`qwertyuiop
asdfghjkl
zxcvbnm`].join` `.split(x)[1]

अधिकांश अन्य उत्तरों के समान तकनीक का उपयोग करता है। सुझावों का स्वागत है!

— ETHproductions
स्रोत
क्या आप समझा सकते हैं कि आप "..." का उपयोग क्यों करते हैं। मैं JSFiddle और अभी भी काम पर बिना कोशिश?
— अवाशी
@ अवाशी यह एक फैला हुआ ऑपरेटर है । यह स्ट्रिंग को वर्णों की एक सरणी में अलग करता है। इसके बिना- .join` `कुछ नहीं करेगा और परिणाम में कोई स्थान नहीं होगा।
— user81655
@ user81655 आप को टेंक
— अवशी
4

रूबी, 63 57 बाइट्स

कमांड लाइन तर्क के रूप में चरित्र लेता है: ruby keyboard.rb e

"qwertyuiop
asdfghjkl
zxcvbnm".scan$*[0]
puts$'.chars*' '
— daniero
स्रोत
4

टीस्क्रिप्ट , 50 45 44 बाइट्स

TeaScript गोल्फिंग के लिए जावास्क्रिप्ट है।

`qwertyuiop
asdfghjkl
zxcvbnm`.s×[1]s(b)j(p)

अपुष्ट और व्याख्या

`qwertyuiop
asdfghjkl
zxcvbnm`.s(x)[1]s(b)j(p)

      // Implicit: x = input string
`...` // Take the qwerty string,
.s(x) // and split it at the input.
[1]   // Take the second item from this,
s(b)  // split it into chars,
j(p)  // and join the result with spaces.
      // Implicit: output final expression
— ETHproductions
स्रोत
3

जावास्क्रिप्ट ईएस 6, 73

f=x=>[...(k=`qwertyuiop
asdfghjkl
zxcvbnm`).slice(k.search(x)+1)].join` `

यदि पैरामीटर है pया l, तो 83 पर एक अग्रणी न्यूलाइन की अनुमति नहीं है

f=x=>(k=`q w e r t y u i o p
a s d f g h j k l
z x c v b n m`).slice(k.search(x)+2)
— edc65
स्रोत
3

सेड, 59 वर्ण

(58 अक्षर कोड + 1 वर्ण कमांड लाइन विकल्प।)

s/./&qwertyuiop\nasdfghjkl\nzxcvbnm/
s/(.).*\1//
s/\w/& /g

नमूना रन:

bash-4.3$ echo -n 'f' | sed -r 's/./&qwertyuiop\nasdfghjkl\nzxcvbnm/;s/(.).*\1//;s/\w/& /g'
g h j k l 
z x c v b n m
— आदमी काम पर है
स्रोत
3

रूबी, 86 87 83 71 66

puts"qwertyuiop
asdfghjkl
zxcvbnm ".split($*[0])[1].gsub /./,'\& '

mयदि इनपुट 'm' है तो प्रोग्राम को क्रैश होने से रोकने के लिए अतिरिक्त स्थान है।

सुझावों के लिए ~ 16 बाइट्स के लिए @manatwork धन्यवाद

— SnoringFrog
स्रोत
मुझे लगता है कि ... अंतिम समय में बहुत सारे पायथन कोडिंग?
— मैनटवर्क
1
कुछ मामूली वाक्यविन्यास में परिवर्तन: ARGV→ $*; each_char→ chars; do.. end→ {.. }; printf→ $><<+ %इस के लिए नेतृत्व करेंगे "qwertyuiop↵asdfghjkl↵zxcvbnm".split($*[0])[1].chars{|i|$><<"%s "%i}:। में अधिक सुझाव रूबी में गोल्फ के लिए ।
— 16
@manatwork पहली बार रूबी में गोल्फ की कोशिश कर रहा है, सुझावों / लिंक के लिए धन्यवाद!
— SnoringFrog
1
मुझे लगता है कि आपको मेरी पहली टिप्पणी में संकेत नहीं मिला है। रूबी में मल्टीलाइन स्ट्रिंग्स के आसपास ट्रिपल कोट्स की आवश्यकता नहीं है। (वास्तव में मुझे अब तक कोई अंदाजा नहीं था कि इसे रूबी ने स्वीकार किया है।)
— मैनटवर्क
1
आउटपुट में प्रमुख स्थान काफी बदसूरत हैं। जैसा कि .नियमित अभिव्यक्ति \nडिफ़ॉल्ट रूप से मेल नहीं खाती , बेहतर है कि रिक्ति के लिए उपयोग करें puts"qwertyuiop↵asdfghjkl↵zxcvbnm ".split($*[0])[1].gsub(/./,'\& '):। हालांकि कोड की लंबाई समान रहेगी।
— मैनटवर्क
2

PHP, 88 बाइट्स

<?=$m[1&ereg("$argn.(.*)",'q w e r t y u i o p
a s d f g h j k l
z x c v b n m',$m)];

आवश्यक -Fआदेश पंक्ति विकल्प, के रूप में 3. डिफ़ॉल्ट .ini सेटिंग ग्रहण कर रहे हैं (आप के साथ अपने स्थानीय .ini निष्क्रिय कर सकता गिना -n)।

नमूना उपयोग

$ echo g|php -F qwerty.php
h j k l
z x c v b n m

$ echo v|php -F qwerty.php
b n m
— Primo
स्रोत
2

प्रोलोग (एसडब्ल्यूआई), 153 133 बाइट्स

संपादित करें: @Fatalize से युक्तियों के साथ 20 बाइट्स काटें

कोड

b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).
p(X):-name(X,C),b(`q w e r t y u i o p \r\na s d f g h j k l \r\nz x c v b n m`,C),!.

व्याख्या

p(X):-name(X,C),                                                               % Get charcode of input
      b(`q w e r t y u i o p \r\na s d f g h j k l \r\nz x c v b n m`,C),!.    % Get keyboard chars as charcodes and call b
b([A,_|T],[H]):-A=H,                                                           % If list head is input element
                writef('%s',[T]);                                              % Interpret list as charcodes and print as string
                b(T,[H]).                                                      % Else remove first element of list and try again

उदाहरण

>p(f).
g h j k l 
z x c v b n m

>p(q).
w e r t y u i o p 
a s d f g h j k l 
z x c v b n m
— Emigna
स्रोत
SWI-Prolog का उपयोग करते हुए, आप atom_codesबैककॉट्स का उपयोग करके भाग को छोटा कर सकते हैं जो स्ट्रिंग कोडों को परिसीमित करता है (इसलिए आप bस्ट्रिंग के साथ कॉल में सीधे एल को बदल सकते हैं )।
— घातक
@ शांत शांत! जैसा कि मैं वैसे भी परीक्षण के लिए SWI- प्रोलॉग का उपयोग कर रहा हूं, यह एक महान विचार की तरह लगता है।
— एमिगा
इसके अलावा, b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).2 अलग-अलग नियमों के बजाय b7 बाइट्स का उपयोग करना कम है। आमतौर पर, ;कई नियमों को लिखने के बजाय ओआरएस के साथ सभी नियमों को एक एकल में विलय करने के लिए हमेशा कम होता है, क्योंकि आप विधेय के नाम और मापदंडों को दोहराने से बचते हैं और आप एक
— लाइनफीड से
जब से मैंने प्रोलॉग सीखा है तब से यह बहुत लंबा हो चुका है कि मैं पूरी तरह से भूल गया था कि आप ऐसा कर सकते हैं। महान टिप! धन्यवाद :)
— एमिगा
2

Befunge, 122 बाइट्स

"m n b v c x z"25*"l k j h g f d s a"v
v1-")"g2-"U"~"q w e r t y u i o p"*25<
>-:#v_$>:#,_@ZVD0FHJ:LNP^\<>,2B48X.T6R
^1$\<

इसका परीक्षण यहां किया गया है: बेफुंज -93 इंटरप्रेटर ।

यह काम किस प्रकार करता है

  • 'q w e r t y u i o p\na s d f g h j k l\nz x c v b n m' स्टैक पर धकेल दिया जाता है।
  • मानों को छोड़ने के लिए (हार्डकोड इन @ZVD0FHJ:LNP^\<>,2B48X.T6R) एन को धकेल दिया जाता है।
  • पहले N मानों को छोड़ दिया जाता है और शेष मान मुद्रित किए जाते हैं।

ध्यान दें

मैंने एन्कोडिंग को उठाया, ताकि @प्रोग्राम के साथ ओवरलैप करने के लिए स्ट्रिंग शुरू हो । यह स्ट्रिंग निम्नलिखित अजगर कोड के साथ उत्पन्न होती है:

import string
letters = string.ascii_lowercase
base = 'q w e r t y u i o p a s d f g h j k l z x c v b n m'
print(''.join(chr(base.index(x) + 32 + 9 + 3) for x in letters))
— विंसेंट
स्रोत
1
अच्छा पहला जवाब! कोड गोल्फ एसई में आपका स्वागत है। (मैं भी नया हूं।)
— भूत_____कोड
1

कण्ठमाला - 102 बाइट्स

गोल्फ स्क्रिप्ट:

S A="qwertyuiopasdfghjklzxcvbnm",B=0 R P F I=1:1:$L(A) S Q=$E(A,I) W:B Q," " X:"qpl"[Q "W !" S:Q=P B=1

असंबद्ध और टिप्पणी:

 S A="qwertyuiopasdfghjklzxcvbnm" ; Need the qwerty order
 S B=0 ; boolean flag for printing, default to false.
 R P   ; read from stdin into P
 F I=1:1:$L(A) D   ; Count I from 1 to length of qwerty variable; do all of the following:
 . S Q=$E(A,I)     ; Extract 1 letter (at position I) from A and save in Q.
 . W:B Q," "       ; If our print flag (B) is true, print the letter in Q & a space.
 . X:"qpl"[Q "W !" ; If Q is q, p or l, write a cr/lf
 . S:Q=P B=1       ; If Q == P (stdin) change our print flag from false to true.

अतिरिक्त newlines की अनुमति देने वाले नियम ने मुझे लगभग 10 बाइट बचाए ...

— zmerch
स्रोत
1

जावा - 107 बाइट्स

void q(char c){System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replaceAll("\\w","$0 "));}

System.in से रैपर-क्लास रीडिंग के साथ अनगुल्ड

public class Qwerty {

    public static void main(String[] args) {
        new Qwerty().q(new java.util.Scanner(System.in).next().charAt(0));
    }
    void q(char c) {
        System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replaceAll("\\w","$0 "));
    }
}

यदि स्टार्ट-ऑफ़-लाइन पर स्थान स्वीकार्य थे, तो हम 99 बाइट्स तक नीचे जा सकते हैं:

void q(char c){System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replace(""," "));}
— janschweizer
स्रोत
1

पायथन 2, 58 67 63 बाइट्स ##

lambda x:" ".join("qwertyuiop\nasdfghjkl\nzxcvbnm".split(x)[1])

एक स्ट्रिंग या चार के रूप में इनपुट लेता है। विभाजन पर स्ट्रिंग को विभाजित करता है और विभाजन के बाद सब कुछ बंद कर देता है।

(पहली बार कोड-गोल्फिंग, कृपया सौम्य रहें: पी)

संपादित करें: वर्णों के बीच आवश्यक अतिरिक्त स्थान नहीं देखा, अब जोड़ा

EDIT 2: एक अनाम लंबो फ़ंक्शन होने के लिए संशोधित किया गया और अतिरिक्त बंटवारे को हटा दिया गया, जिससे 4 बाइट्स बच गए

— जॉन अलसॉप
स्रोत
PPCG में आपका स्वागत है! मुझे नहीं लगता कि आपको बाद में स्थान की आवश्यकता है print, लेकिन ऐसा लगता है कि यह प्रत्येक जोड़ी पत्रों के बीच रिक्त स्थान को प्रिंट नहीं करता है।
— मार्टिन एंडर
अभी एक संदर्भ प्रदान नहीं किया जा सकता है, लेकिन जब दुभाषिया को इनपुट के अतिरिक्त स्वरूपण की आवश्यकता होती है, तो वह भी गिनती में शामिल होता है। (यदि मैं गलत हूं तो मुझे सुधारें, लेकिन मुझे लगता है कि यह केवल तभी काम करता है जब इनपुट चारों ओर से घेरे हुए उद्धरणों के साथ पारित हो जाए, जैसे "f"।)
— मैनटवर्क
अच्छा पहला गोल्फ। कार्यों को डिफ़ॉल्ट रूप से, यहां तक ​​कि अनाम लोगों द्वारा भी अनुमति दी जाती है, इसलिए यह ऐसा करने के लिए कम है lambda s:...। मुझे लगता है कि विभाजन के लिए एक arg की जरूरत नहीं है 1, क्योंकि चरित्र केवल एक बार दिखाई देता है। यह सफल होने वाली लाइनों की शुरुआत में स्पेस उत्पन्न करता है, निश्चित नहीं कि अगर इसकी अनुमति है।
— xnor
1

माणिक, ५ ९ ५ 67 बाइट्स

अक्षरों के बीच जोड़ा रिक्त स्थान

puts"qwertyuiop\nasdfghjkl\nzxcvbnm".split(gets.chop)[-1].chars*' '
— hbejgel
स्रोत
यह इनपुट "एम" पर विफल रहता है। यह आसानी से सरणी सूचकांक को 1 से 1 में बदलकर तय किया जा सकता है, लेकिन फिर इनपुट "एम" पर परिणाम होगा nil। जो अपने आप में कोई समस्या नहीं है, लेकिन अक्षरों के बीच रिक्त स्थान जोड़ने के लिए अपना कोड पूरा करते समय आपको समस्याएँ आएंगी।
— मैनटवर्क
1

जावास्क्रिप्ट, 88 बाइट्स

function s(d){alert("qw e r t y u i o p\na s d f g h j k l\nz x c v b n m".split(d)[1])}

(पहले चार के बाद अंतरिक्ष में कोई ज़रूरत नहीं है, क्योंकि यह आउटपुट के लिए कभी नहीं मिलता है)

जब आप कॉल करते हैं तो कीबोर्ड को अलर्ट करता है s("some letter")। के साथ document.write()या भी बनाया जा सकता है console.log(), लेकिन हे, यह लंबा है: पी

डेमो:

function s(d){alert("qw e r t y u i o p\na s d f g h j k l\nz x c v b n m".split(d)[1])}

s(prompt("Enter the key"));
स्निपेट का विस्तार करें

— nicael
स्रोत
1
तुम शायद स्ट्रिंग के \nबजाय का उपयोग करके ;और प्रतिस्थापन से छुटकारा पाकर कुछ बाइट्स बचा सकते हैं ।
— ETHproductions
@ यकीन है, धन्यवाद! मैंने रिप्लेस का उपयोग किया, क्योंकि पहली बार में, लाइन को तोड़ने के बिना, रिप्ले को छोटा कर दिया जाता था। तब मैंने देखा है कि लाइन ब्रेक होना चाहिए, इसलिए मैंने फिर से उपयोग किया है। यह भी नहीं सोचा था कि यह कोड को लंबा कर सकता है: D
— nicael
1

SQL (MS T-SQL), 172 बाइट्स

CREATE PROC c @I CHAR(1) AS DECLARE @S CHAR(49) SET @S = 'w e r t y u i o p' + CHAR(13) + 'a s d f g h j k l' + CHAR(13) + 'z x c v b n m' PRINT RIGHT(@S,LEN(@S)-CHARINDEX(@I,@S))

Ungolfed:

CREATE PROC c                           -- Create a procedure named "c"
    @I CHAR(1)                          -- Which is invoked with a single character input (@I)
AS

DECLARE @S CHAR(49) = 'w e r t y u i o p' + CHAR(13) + 'a s d f g h j k l' + CHAR(13) + 'z x c v b n m' -- Initialise the entire output omitting "q " as @S
PRINT RIGHT(@S,LEN(@S)-CHARINDEX(@I,@S))    -- Use the charindex funtion to effectively substring @S

मैं यहाँ नया हूँ, केवल इस साइट की खोज की है। कोई विचार नहीं अगर मैंने सही तरीके से पोस्ट किया है या यदि टी-एसक्यूएल की अनुमति है, लेकिन मुझे काम करने के ऊपर की प्रक्रिया पता है।

— स्टीव मैथ्यूज
स्रोत
1

O 2.2, 48 46 वर्ण

"qwertyuiop
asdfghjkl
zxcvbnm
"i/r;s{n.U=ST?}d

नमूना रन:

bash-4.3$ ./o keyboard.o <<< 'f'
g h j k l 
z x c v b n m

ओ, ६१ अक्षर

"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;""/rl{.o"\n"={}{' o}?}d

नमूना रन:

bash-4.3$ java xyz.jadonfowler.o.O keyboard.o <<< 'f'
g h j k l 
z x c v b n m
— आदमी काम पर है
स्रोत
यह किसी कारण से IDE पर काम नहीं करता है, अब इसे देख रहा है ...
— चरण
"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;s{n.'\n=ST?}dकेवल नए दुभाषिया पर काम करता है लेकिन 51 बाइट्स है।
— चरण
पर्मलिंक्स हैं ... एक कार्य प्रगति पर: पी
— चरण
यूप, लिबरेजएक्सपैप डायरेक्टरी में
— चरण
git ने रेपो क्लोन किया, फिर git submodule update --init,make
— चरण
1

जाप , 49 42 41 40 38 बाइट्स

Japt , Ja vaScri pt का छोटा संस्करण है । दुभाषिया

`qØÆyuiop\n?dfghjkl\nzxcvbnm`qU g1 ¬qS

?गंदा यूनिकोड वर्ण U + 0086 होना चाहिए।

यह काम किस प्रकार करता है

          // Implicit: U = input char
`...`     // Take the compressed string and decompress it.
qU g1     // Split the string at the input and take the second item.
¬qS       // Split into chars, then join with spaces.
          // Implicit: output final expression

अब सीजम की पिटाई! :) सुझावों का स्वागत है!

गैर-प्रतिस्पर्धात्मक संस्करण, 12 बाइट्स

;Dv qU g1 ¬¸

11 जनवरी तक, मैंने जाप में एक नया फीचर जोड़ा है: यदि प्रोग्राम में एक प्रमुख अल्पविराम है, तो चर ABCDEFGHIJLविभिन्न मूल्यों पर नए सिरे से परिभाषित किए जाते हैं। Dके लिए सेट है "QWERTYUIOP\nASDFGHJKL\nZXCVBNM", इसलिए ;Dvयहां स्ट्रिंग को बदलने के लिए पर्याप्त है।

— ETHproductions
स्रोत
0

गामा, 56 वर्ण

?=@subst{\\A\*?=\;\?=\? ;qwertyuiop\nasdfghjkl\nzxcvbnm}

नमूना रन:

bash-4.3$ echo -n 'f' | gema '?=@subst{\\A\*?=\;\?=\? ;qwertyuiop\nasdfghjkl\nzxcvbnm}'
g h j k l 
z x c v b n m
— आदमी काम पर है
स्रोत
0

8086 मशीन कोड + डॉस, 61 बाइट्स

Hexdump (दाईं ओर ASCII दृश्य के साथ):

B8 1E 01 8B F8 CD 21 B1 1F F2 AE 8B F7 AC 8A D0 ......!.........
B4 02 CD 21 80 E2 20 74 02 CD 21 E2 F0 C3 71 77 ...!.. t..!...qw
65 72 74 79 75 69 6F 70 0D 0A 61 73 64 66 67 68 ertyuiop..asdfgh
6A 6B 6C 0D 0A 7A 78 63 76 62 6E 6D 0D          jkl..zxcvbnm.

विधानसभा स्रोत कोड (tasm के साथ इकट्ठा किया जा सकता है):

    .MODEL TINY

    .CODE
    org 100h

    MAIN PROC

    mov ax, offset qwerty ; sets ah=1 (coincidence)
    mov di, ax      ; di points to the string
    int 21h         ; reads a char from keyboard into al

    mov cl, 31      ; cx is the length of the string
    repne scasb     ; look for the char
    mov si, di      ; si now points beyond the found char

myloop:
    lodsb           ; load a char
    mov dl, al
    mov ah, 2
    int 21h         ; output the char

    and dl, 20h     ; if it's a letter, set it to a space
    jz print_done   ; if it's not a letter, don't print a space
    int 21h         ; if it's a letter, print a space
print_done:
    loop myloop     ; repeat until end of string

    ret

qwerty db 'qwertyuiop',13,10,'asdfghjkl',13,10,'zxcvbnm',13

    MAIN ENDP
    END MAIN

यहां दो मजेदार बातें:

  1. qwertyस्ट्रिंग ऑफ़सेट है 0x011e। इसका ऊपरी बाइट 1 है, जो चरित्र इनपुट के लिए डॉस फ़ंक्शन नंबर है। यह कोड में 1 बाइट बचाता है।
  2. सभी लोअर-केस अक्षरों में बिट 5 सेट है। एक ANDसाथ करते समय 0x20, वे सभी एक स्थान में बदल जाते हैं, जो तब मुद्रित होता है। यदि पिछला चार-छोर बाइट था, तो यह 0 में बदल जाता है, और कोई स्थान आउटपुट नहीं है। इसका उपयोग 0d 20 0a 20पंक्ति के अंत में निरर्थक अनुक्रम से बचने के लिए किया जाता है ।

एक लगभग मजेदार बात:

मैंने सामान्य स्थान (स्ट्रिंग की शुरुआत) के बजाय पता 0 (जो कि 2 बाइट्स द्वारा प्रोग्राम आकार में कमी आई) पर शुरू होने वाले इनपुट चार के लिए खोज करने की कोशिश की। यह लगभग काम किया; हालाँकि, यह इनपुट के लिए विफल रहा t, क्योंकि कोड में ही बाइट t(सशर्त कूद के एन्कोडिंग के भाग के रूप में) शामिल है। तो इसके लिए t, यह कुछ जंक बाइट्स का उत्पादन करेगा:

उत्पादन

— anatolyg
स्रोत
0

S, 32 चार्ट / 79 बाइट्स

⟦ɘƄ瀛ذ鸊ް΀ꀆဓƘ᳀ᘁ堍怍訁码聮Ęݠⶰ䀀#]ø⬭Čï⎖1

Try it here (Firefox only).

कम से कम मैं चार गिनती में जीत रहा हूं ... (बाइट गिनती एक अलग कहानी है।)

अरे हाँ, बस एहसास हुआ कि मैंने इंडेक्स शॉर्टकट ( ⎖1बदले में [1]) थोड़ी देर बाद लागू किया। मुझे मूर्ख!

— मामा फन रोल
स्रोत
यह कौनसी भाषा है? या यह सचमुच यह है: i.imgur.com/WC7XvYs.png (और वहाँ प्रलेखन है) यह अजीब है, अहा!
— 11
यह ESMin है। पत्र दोहरीपत्रिका में हैं, इसलिए आपको उन्हें देखने में परेशानी हो सकती है। देखें github.com/molarmanful/ESMin (डॉक्स पुराने हैं, हालांकि)।
— मामा फन रोल
0

सी ++, 129, 112 97 बाइट्स

#include<string>
#include<cstdio>
void o(char c){puts(strstr("qwertyuiopasdfghjklzxcvbnm",&c));}

Ungolfed:

#include<string>
#include<cstdio>
void o(char c)
{
    puts(strstr("qwertyuiopasdfghjklzxcvbnm",&c));
}
— TAS
स्रोत
आप का उपयोग करके 17 बाइट्स बंद दाढ़ी सकता है putsबजायstd::cout<<
— DJMcMayhem
@DJMcMayhem धन्यवाद! एक उत्कृष्ट बिंदु: किसी कारण मैंने सोचा कि मैं अभी भी एक की आवश्यकता होगी के लिए #includeके लिए putsहै, लेकिन जाहिर है मैं नहीं!
— तस्स
इसके अलावा, यह एक और 12 छोटा है।
— DJMcMayhem
धन्यवाद! मुझे पता भी नहीं strstrथा कि यह एक चीज़ है।
— तस्स
मुझे लगता है कि यह थोड़ा-बहुत अतिरंजित है। आप के लिए की जरूरत <stdio.h>है strstr।
— DJMcMayhem
0

बैच, 206 + 2 = 208 बाइट्स

क्योंकि यह विलंबित विस्तार का उपयोग करता है CMD /V /C keyboard.cmd <letter>, इसलिए आपको इसे लागू करने की आवश्यकता है , इसलिए स्विच के लिए 1 2 जोड़ें /V।

@echo off
set a=q w e r t y u i o p
set b=a s d f g h j k l
set c=z x c v b n m
if not "!a:*%1 =!"=="!a!" echo !a:*%1 =!
if not "!a:*%1=!!b:*%1 =!"=="!a!!b!" echo !b:*%1 =!
if not %1==m echo !c:*%1 =!
— नील
स्रोत
मुझे डर है कि कमांड लाइन विकल्प 1 की गिनती cmdकरेगा अगर वह इसे स्वीकार करेगा /VC, जैसे कि POSIX टूल करता है। लेकिन जैसा कि मुझे पता है कि /Vइसकी स्वयं की आवश्यकता है /, जो भी गिना जाता है।
— मैनावर्क
0

अजगर, 109 बाइट्स

मैं इसका एक बड़ा हिस्सा जानता हूं, लेकिन मुझे पता है कि अभी कैसे करना है! 

def kb(c): 
 s = "q w e r t y u i o p \n a s d f g h j k l \n z x c v b n m"
 a = s.split(c)
 print(a[1])
— अश्विन गुप्ता
स्रोत
मुझे नहीं लगता कि आपको kb()अंत में कॉल की आवश्यकता है ; फ़ंक्शन को परिभाषित करना पर्याप्त है। इसके अलावा, इंडेंटेशन का 1 स्थान पर्याप्त है। इन परिवर्तनों को करने के बाद, मुझे इस साइट का उपयोग करते हुए, 108 बाइट्स मिलते हैं ।
— 20
@ETHproductions वाह मुझे नहीं पता था कि एक बार अंतरिक्ष बात। (अजगर के लिए नया)। आपकी सहायता के लिए एक बार फिर से धन्यवाद!
— अश्विन गुप्ता
0

बैश, 80 बाइट्स

x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*$1}|sed 's/./& /g'

इसे स्वयं आज़माएँ, या तो $ 1 को वांछित चरित्र के साथ बदलें या एक #! / बिन / बैश स्क्रिप्ट बनाएं।

साइबरगन के कुछ नमूने इस प्रकार हैं:

$x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*q}|sed 's/./& /g'
w e r t z u i o p
a s d f g h j k l
y x c v b n m

$x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*m}|sed 's/./& /g'

$x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*h}|sed 's/./& /g'
j k l
y x c v b n m

यह सबसे छोटा नहीं है, लेकिन मुझे अभी भी इस पर गर्व है!

— Cajova_Houba
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.