Wyjmij klawiaturę qwerty

37

Biorąc pod uwagę znak, wypisz (na ekran) cały układ klawiatury qwerty (ze spacjami i znakami nowej linii), który następuje po znaku. Przykłady wyjaśniają.

Wejście 1

f

Wyjście 1

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

Wejście 2

q

Wyjście 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

Wejście 3

m

Wyjście 3

(Program kończy się bez wyjścia)

Wejście 4

l

Wyjście 4

z x c v b n m

Najkrótszy kod wygrywa. (w bajtach)

PS

Akceptowane są dodatkowe znaki nowej linii lub dodatkowe spacje na końcu linii.

ghosts_in_the_code
źródło
Czy funkcja jest wystarczająca, czy potrzebujesz pełnego programu, który odczytuje / zapisuje na stdin / stdout?
agtoever
1
@agtoever Zgodnie z meta.codegolf.stackexchange.com/questions/7562/ ... jest to dozwolone. Jednak funkcja musi nadal być wyświetlana na ekranie.
ghosts_in_the_code
@agtoever Zamiast tego spróbuj tego linku. meta.codegolf.stackexchange.com/questions/2419/…
ghosts_in_the_code
1
czy odstępy przed linią są dozwolone?
Sahil Arora
1
@SahilArora Nope.
ghosts_in_the_code

Odpowiedzi:

19

CJam, 42 40 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

"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.
Martin Ender
źródło
Co to jest e#? Czy jest to składnia CJam dla komentarza? Z góry dziękuję.
AL,
@AL tak to jest.
Martin Ender
11

Pyth, 33 bajty

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

Pamiętaj, że niektórych znaków nie można wydrukować. Wypróbuj online w kompilatorze Pyth .

Jak to działa

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.
Dennis
źródło
O rany, właśnie stworzyłem swój pierwszy program w Pythonie (tylko 38 bajtów!), Potem przyszedłeś ... +1 BTW, myślę, że \ jest równoważny d.
ETHprodukcje
Ups, myślę, że to nie to samo ... co się różni?
ETHprodukcje
1
@ETHproductions @Dennis Ten sam powód, dla którego md5nie produkuje 5 spacji. djest domyślną zmienną, która iteruje poprzez iterowalny argument operatora mapy. I jL\ <list>jest po prostu skrótem dla operatora mapy mj\ d<list>.
Jakube
1
@Jakube Oh, to ma sens. Dzięki!
Dennis
10

Perl, 56 bajtów

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

Licząc shebang jako 3, dane wejściowe są pobierane ze standardowego wejścia. Jeśli wiodącym nowej linii nie jest problemem dla wejść pi l, po czym /$_\n?/można zastąpić gołe $_zapisać 4.


Przykładowe użycie

$ 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
źródło
2
Dziękuję za nauczenie mnie o\K !
Dom Hastings
@DomHastings w tym przypadku nie było tak naprawdę konieczne do liczenia bajtów, s/.\B/$& /gdziałałoby równie dobrze. Lepszym przykładem .
primo,
6

GS2 , 38 37 bajtów

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

Kod źródłowy używa kodowania CP437 . Wypróbuj online!

Testowe uruchomienie

$ 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

Jak to działa

♦                                      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.
Dennis
źródło
6

C #, 112 bajtów 105 110

Liczba wzrosła o 5 bajtów, ale bardziej poprawnie! Dzięki @ MartinBüttner !!

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

Nie grał w golfa

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());
}
Johan
źródło
5

JavaScript (ES6), 60 bajtów

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

Używa tej samej techniki, co większość innych odpowiedzi. Sugestie mile widziane!

ETHprodukcje
źródło
Czy możesz wyjaśnić, dlaczego używasz „...”. Próbuję bez JSFiddle i nadal działa?
Awashi,
@Awashi To operator rozprzestrzeniania . Dzieli ciąg na tablicę znaków. Bez .join` `tego nic by nie zrobiło i nie byłoby w tym spacji.
user81655,
@ user81655 Tank you
Awashi
4

Rubin, 63 57 bajtów

Pobiera znak jako argument wiersza poleceń: ruby keyboard.rb e

"qwertyuiop
asdfghjkl
zxcvbnm".scan$*[0]
puts$'.chars*' '
daniero
źródło
4

TeaScript , 50 45 44 bajtów

TeaScript to JavaScript do gry w golfa.

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

Bez golfa i wyjaśnienia

`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
ETHprodukcje
źródło
3

JavaScript ES6, 73

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

Jeśli wiodący nowy wiersz nie jest dozwolony, gdy parametr ma wartość plub l, to 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
źródło
3

Python, 83 bajty

lambda c,s="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":s[s.index(c)+2:]

Wypróbuj online

Mego
źródło
3

Sed, 59 znaków

(Kod 58 znaków + opcja wiersza poleceń 1 znak.)

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

Przykładowy przebieg:

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 
człowiek w pracy
źródło
3

Ruby, 86 87 83 71 66

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

Dodatkowa spacja po mto zapobiega awariom programu, jeśli dane wejściowe to „m”.

Dzięki @manatwork za ~ 16 bajtów wskazówek

SnoringFrog
źródło
Niech zgadnę… Za dużo kodowania w Pythonie w ostatnim czasie?
manatwork
1
Niewielkie zmiany składniowe: ARGV$*; each_charchars; do.. end{.. }; printf$><<+ %doprowadziłoby do tego: "qwertyuiop↵asdfghjkl↵zxcvbnm".split($*[0])[1].chars{|i|$><<"%s "%i}. Więcej w Wskazówki dotyczące gry w golfa w Ruby .
manatwork
@manatwork Po raz pierwszy próbujesz grać w golfa w Ruby, dzięki za wskazówki / link!
SnoringFrog
1
Widzę, że nie dostałeś podpowiedzi w moim pierwszym komentarzu. W Ruby nie ma potrzeby potrójnych cytatów wokół ciągów wieloliniowych. (Właściwie do tej pory nie miałem pojęcia, że ​​to zaakceptował Ruby.)
manatwork
1
Wiodące spacje na wyjściu są dość brzydkie. Jak .w wyrażeniu regularnym nie pasuje \ndomyślnie lepsze wykorzystanie że odstępy: puts"qwertyuiop↵asdfghjkl↵zxcvbnm ".split($*[0])[1].gsub(/./,'\& '). Chociaż długość kodu pozostanie taka sama.
manatwork
2

PHP, 88 bajtów

<?=$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)];

Wymaga -Fopcji wiersza poleceń, liczonej jako 3. Domyślne ustawienia .ini są przyjmowane (możesz wyłączyć lokalne .ini za pomocą -n).


Przykładowe użycie

$ 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
źródło
2

Prolog (SWI), 153 133 bajty

Edycja: Wytnij 20 bajtów za pomocą wskazówek z @Fatalize

Kod

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),!.

Wyjaśnienie

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

Przykłady

>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
źródło
Za pomocą SWI-Prolog można skrócić atom_codesczęść, używając cudzysłowów, które ograniczają kody ciągów (dzięki czemu można zastąpić bezpośrednio L w wywołaniu bciągiem).
Fatalize
@Fatalize cool! Ponieważ i tak używam SWI-Prolog do testowania, to brzmi jak świetny pomysł.
Emigna
Ponadto użycie b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).zamiast 2 różnych reguł bjest o 7 bajtów krótsze. Zwykle zawsze jest krótsze, aby scalić wszystkie reguły w jedną z OR, ;zamiast pisać wiele reguł, ponieważ unikasz powtarzania nazwy i parametrów orzeczenia, a także
unikniesz podawania
Minęło tyle czasu, odkąd nauczyłem się Prologu, że zupełnie zapomniałem, że możesz LUB to lubić. Świetna wskazówka! Dzięki :)
Emigna
2

Befunge, 122 bajty

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

Został przetestowany tutaj: Befunge-93 Interpreter .

Jak to działa

  • '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' jest wypychany na stos.
  • Liczba wartości, które należy odrzucić (na stałe @ZVD0FHJ:LNP^\<>,2B48X.T6R) N jest wypychana.
  • Pierwsze N ​​wartości jest odrzucane, a pozostałe wartości są drukowane.

Uwaga

Wybrałem kodowanie, więc ciąg zaczyna się od @, aby pokrył się z programem. Ten ciąg jest generowany przy użyciu następującego kodu python:

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))
Vincent
źródło
1
Dobra pierwsza odpowiedź! Witamy w Code Golf SE. (Jestem również nowy.)
ghosts_in_the_code
1

Świnka - 102 bajtów

Gra w golfa:

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

Nie golfił i skomentował:

 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.

Reguła zezwalająca na dodatkowe znaki nowej linii pozwoliła mi zaoszczędzić prawie 10 bajtów ...

zmerch
źródło
1

Java - 107 bajtów

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

Niegolfowany z odczytem klasy opakowania z 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 "));
    }
}

Gdyby spacje na początku linii były akceptowalne, moglibyśmy zmniejszyć do 99 bajtów:

void q(char c){System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replace(""," "));}
janschweizer
źródło
1

Python 2, 58 67 63 bajtów ##

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

Pobiera dane wejściowe jako ciąg znaków lub znak. Dzieli ciąg na wejściu i drukuje wszystko po podziale.

(Gra w golfa po raz pierwszy, proszę delikatnie: P)

EDYCJA: Nie widziałem dodatkowych spacji wymaganych między postaciami, dodanych teraz

EDYCJA 2: Zmodyfikowana, aby była anonimową funkcją lambda i usuwa dodatkowy podzielony argument, oszczędzając 4 bajty

Jon Alsop
źródło
Witamy w PPCG! Nie sądzę, żebyś potrzebował spacji później print, ale wygląda na to, że nie drukuje to spacji między każdą parą liter.
Martin Ender
Nie można teraz podać odwołania, ale gdy interpreter wymaga dodatkowego formatowania danych wejściowych, jest to również uwzględniane w liczeniu. (Popraw mnie, jeśli się mylę, ale myślę, że to działa tylko wtedy, gdy dane wejściowe są przekazywane razem z otaczającymi cudzysłowami, jak "f".)
Manatwork
Miły pierwszy golf. Funkcje są domyślnie dozwolone, nawet anonimowe, więc krócej jest to zrobić jako lambda s:.... Myślę, że podział nie potrzebuje argumentu 1, ponieważ postać pojawia się tylko raz. To wyświetla spacje na początku kolejnych linii, nie jestem pewien, czy jest to dozwolone.
xnor
1

Rubin, 59 57 67 bajtów

Dodano spacje między literami

puts"qwertyuiop\nasdfghjkl\nzxcvbnm".split(gets.chop)[-1].chars*' '
hbejgel
źródło
Nie udaje się to na wejściu „m”. Można to łatwo naprawić, zmieniając indeks tablicy z -1 na 1, ale wtedy na wejściu pojawi się „m” nil. To nie jest sam problem, ale spowoduje problemy podczas kończenia kodu w celu dodania spacji między literami.
manatwork,
1

JavaScript, 88 bajtów

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

(nie ma potrzeby wprowadzania spacji po pierwszym znaku, ponieważ nigdy nie trafia on do wyjścia)

Ostrzega klawiaturę podczas połączenia s("some letter"). Można go również wykonać za pomocą document.write()lub console.log(), ale hej, jest dłuższy: P

Próbny:

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

Nicość
źródło
1
Prawdopodobnie możesz zaoszczędzić kilka bajtów, po prostu używając \nzamiast ;w ciągu i pozbywając się zamiany.
ETHprodukcje
@Eth Pewnie, dzięki! Użyłem zamiany, ponieważ na początku, nie licząc podziałów linii, zamieniłbym się. Potem zauważyłem, że powinny tam być podziały linii, więc ponownie użyłem metody replace. Nawet nie sądziłem, że może wydłużyć kod: D
nicel
1

SQL (MS T-SQL), 172 bajty

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

Nie golfowany:

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

Jestem tu nowy, dopiero co odkryłem tę stronę. Nie mam pojęcia, czy opublikowałem poprawnie, czy T-SQL jest dozwolony, ale wiem, że powyższa procedura działa.

Steve Matthews
źródło
1

O 2.2, 48 46 znaków

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

Przykładowy przebieg:

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

O, 61 znaków

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

Przykładowy przebieg:

bash-4.3$ java xyz.jadonfowler.o.O keyboard.o <<< 'f'
g h j k l 
z x c v b n m 
człowiek w pracy
źródło
Z jakiegoś powodu to nie działa na IDE, patrząc na to teraz ...
faza
"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;s{n.'\n=ST?}ddziała tylko na nowym tłumaczu, ale ma 51 bajtów.
faza
Permalinki są ... pracą w toku: P
faza
Tak, w katalogu libregexp
faza
git klonuje repozytorium, a git submodule update --initnastępniemake
faza
1

Japt , 49 42 41 40 38 bajtów

Japt to skrócona wersja Ja vaScri pt . Interpretator

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

?Powinna być niecenzuralny char Unicode U + 0086.

Jak to działa

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

Teraz bije CJam! :) Sugestie mile widziane!

Wersja niekonkurencyjna, 12 bajtów

;Dv qU g1 ¬¸

Od 11 stycznia dodałem nową fajną funkcję do Japt: jeśli program zawiera przecinek wiodący, zmienne ABCDEFGHIJLsą przedefiniowywane do różnych wartości. Djest ustawiony na "QWERTYUIOP\nASDFGHJKL\nZXCVBNM", więc ;Dvwystarczy zastąpić ciąg tutaj.

ETHprodukcje
źródło
0

Gema, 56 znaków

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

Przykładowy przebieg:

bash-4.3$ echo -n 'f' | gema '?=@subst{\\A\*?=\;\?=\? ;qwertyuiop\nasdfghjkl\nzxcvbnm}'
g h j k l 
z x c v b n m 
człowiek w pracy
źródło
0

Kod maszynowy 8086 + DOS, 61 bajtów

Hexdump (z widokiem ASCII po prawej):

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.

Kod źródłowy asemblera (może być skompletowany z 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

Dwie zabawne rzeczy tutaj:

  1. Przesunięcie qwertyłańcucha wynosi 0x011e. Górny bajt to 1, który jest numerem funkcji DOS do wprowadzania znaków. To oszczędza 1 bajt w kodzie.
  2. Wszystkie małe litery mają ustawiony bit 5. Kiedy robisz ANDz 0x20, wszystkie są zamieniane w przestrzeń, która jest następnie drukowana. Jeśli poprzedni znak był bajtem końca linii, zostaje zamieniony na 0 i nie jest wyprowadzane spacja. Służy to do uniknięcia nonsensownej sekwencji 0d 20 0a 20na końcu linii.

Jedna prawie zabawna rzecz:

Próbowałem wyszukać znak wejściowy zaczynając od adresu 0 (co zmniejszyło rozmiar programu o 2 bajty), zamiast zwykłego miejsca (początek łańcucha). To prawie działało; jednak nie udało się wprowadzić danych t, ponieważ sam kod zawiera bajt t(jako część kodowania skoku warunkowego). Tak więc t, wyświetliłby kilka śmieciowych bajtów:

wydajność

anatolig
źródło
0

𝔼𝕊𝕄𝕚𝕟, 32 znaki / 79 bajtów

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

Try it here (Firefox only).

Przynajmniej wygrywam w liczbie znaków ... (Liczba bajtów to inna historia.)

O tak, właśnie zdałem sobie sprawę, że zaimplementowałem skróty indeksu ( ⎖1zamiast [1]) jakiś czas temu. Głupi ja!

Mama Fun Roll
źródło
Jaki to język? czy dosłownie to: i.imgur.com/WC7XvYs.png (i czy jest tam dokumentacja) to dziwne, aha!
2015
To jest ESMin. Litery są podwójnie uderzone, więc możesz mieć problemy z ich zobaczeniem. Zobacz github.com/molarmanful/ESMin (dokumenty są jednak nieaktualne).
Mama Fun Roll
0

C ++, 129, 112 97 bajtów

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

Nie golfowany:

#include<string>
#include<cstdio>
void o(char c)
{
    puts(strstr("qwertyuiopasdfghjklzxcvbnm",&c));
}
Tas
źródło
Możesz ogolić 17 bajtów, używając putszamiaststd::cout<<
DJMcMayhem
@DJMcMayhem Dzięki! Doskonały punkt dla jakiegoś powodu ja myślałem nadal będzie potrzebować #includedo puts, ale oczywiście, że nie!
Tas
Także, to jest kolejny 12 krótszy.
DJMcMayhem
Dzięki! Nawet nie wiedziałem, że strstrto coś.
Tas
Myślę, że to trochę przesadzone. Trzeba <stdio.h>za strstr.
DJMcMayhem
0

Partia, 206 + 2 = 208 bajtów

Ponieważ wykorzystuje to opóźnione rozszerzenie, należy je wywołać CMD /V /C keyboard.cmd <letter>, dodając 1 2 dla /Vprzełącznika.

@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 =!
Neil
źródło
Obawiam się, że opcja wiersza poleceń będzie liczyć 1, jeśli cmdzaakceptuje ją tak /VC, jak robią to narzędzia POSIX. Ale jak wiem /Vwymaga własnego /, który również się liczy.
manatwork
0

Python, 109 bajtów

Wiem, że jest trochę duży, ale to wszystko, co wiem, jak teraz zrobić!

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])
Ashwin Gupta
źródło
Nie sądzę, żebyś potrzebował telefonu kb()na końcu; wystarczy zdefiniowanie funkcji. Wystarczy 1 przestrzeń wcięcia. Po dokonaniu tych zmian otrzymuję 108 bajtów, korzystając z tej strony .
ETHprodukcje
@ETHproductions wow, nie wiedziałem, że kiedyś coś kosmicznego. (Nowy w Pythonie). Jeszcze raz dziękuję za pomoc!
Ashwin Gupta
0

Bash, 80 bajtów

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

Wypróbuj sam, albo zamień 1 $ na żądany znak, albo stwórz skrypt #! / Bin / bash.

Oto kilka próbek z cygwina:

$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

Nie jest najkrótszy, ale wciąż jestem z tego dumny!

Cajova_Houba
źródło