Correggi le mie dita grasse

21

Code Golf Challenge

Ho un Isdue, i miei Fingrrs sono grassi e fregato volentieri un Isdue di Ty [ing con un tasto premuto a destra sul mio Kryboard.

Temo che il mondo peggiori e peggiori col passare del tempo.

Sopn ogni sequenza di tasti che faccio wil; sii shiftrd pne a destra!

Prima di allora vorrei un programma (o functipn) per spostare automaticamente ogni tasto sulla sinistra.

Mi assicurerò di prendere il mio tomo tra il resto del tjis chal; enge in modo da non causare confusione!

Obbiettivo:

Scrivi un programma o una funzione che accetta l'input di uno dei seguenti tasti verdi su una tastiera QWERTY standard e restituisce il carattere del tasto a sinistra.inserisci qui la descrizione dell'immagine

condizioni:

• Si può presumere che la persona che esegue questo programma stia utilizzando una tastiera QWERTY come quella nella foto sopra.

• Input e Output non fanno distinzione tra maiuscole e minuscole, è possibile utilizzare qualsiasi caso (o una combinazione di combinazioni di casi) per questa sfida e si può anche supporre che tutti gli input saranno in un caso se lo si desidera.

• Se la tua lingua non ha modo di consentire a un utente di inserire la chiave di ritorno per qualche motivo, puoi ignorare la pressione di un tasto per questo

• Questa sfida riguarda solo i valori predefiniti dei tasti, ad esempio se 4si preme il tasto si può presumere che lo sarà sempre 4e mai$

• Si può presumere che saranno mai premuti solo i tasti verdi.

Esempio Input-> Output:

S-> a
4-> 3
=-> -
[->p

Si tratta di code-golf , quindi vince il programma con il byte più breve!

code-golf  keyboard  hardware 
— Albert Renshaw
fonte
Potresti fornire testcase?
— Kritixi Lithos,
1
@KritixiLithos Certaimly! Ora modificherò tjat @
— Albert Renshaw il
Intendevi ]-> [?
— shooqie,
3
— Rod
3
Potrebbe non interessarti, ma ecco una curiosità interessante: questo è un layout di tastiera ANSI. Notare la barra rovesciata sopra il tasto Invio; a differenza di una tastiera ISO, in cui il pulsante barra rovesciata si trova a sinistra di Z. (È anche americano, ma è più facile da identificare!)
— Doddy,

Risposte:

7

Rubino, 76 71 69 byte

->a{"`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./"[/.#{a}/][0]}
— GB
fonte
5

Perl 6 , 87 83 69 byte

{[Q"`1234567890-=qwertyuiop[]\asdfghjkl;'
zxcvbnm,./".comb].&{%(.[1..*]Z=>$_)}{$_}}

{~Q"`1234567890-=qwertyuiop[]\asdfghjkl;'
zxcvbnm,./".match(/.)>$_/)}

Provalo online!

Mi chiedo se c'è un modo per codificare quella stringa codificata in qualcosa di più corto ...

(Ha rubato l'idea regex di GB per -14 byte.)

— LMS
fonte
1
Forse se avessimo $"i range potremmo risparmiare qualche carattere
— Ven
5

Gelatina , 34 33 byte

ØD”`1¦ṭØqż“[]\“;'¶“,./“0-=”Fṡ2UZy

Provalo online!

Come funziona

ØD”`1¦ṭØqż“[]\“;'¶“,./“0-=”Fṡ2UZy  Main link. Argument: s (string)

ØD                                 Digits; yield "0123456789".
  ”`1|                             Replace '0' with a backtick.
       Øq                          Qwerty; yield
                                   ["qwertyuiop", "asdfghjkl", "zxcvbnm"].
      ṭ                            Tack; add "`123456789" as the last element of
                                   the qwerty array.
          “[]\“;'¶“,./“0-=”        Yield ["[]\\", ";'\n", "0-="].
         ż                         Zip; combine the strings of the array to the
                                   left with the corresponding strings of the array
                                   to the right, yielding an array of string pairs.
                           F       Flatten, yielding a string.
                            ṡ2     Obtain all overlapping pairs of characters.
                              U    Upend; reverse each pair.
                               Z   Zip, yielding a pair of strings.
                                y  Translate the input s according to the generated
                                   replacement table.
— Dennis
fonte
3
Non conosco Jelly, puoi aggiungere una spiegazione del tuo codice? Sono curioso di sapere come sei scappato senza digitare una stringa letterale dell'intera tastiera
— Albert Renshaw,
1
Non ho ancora avuto il tempo, ma aggiungerò una spiegazione al più presto.
— Dennis,
1
Fatto. Ho anche giocato a golf un po '.
— Dennis,
1
Øqnifty! Mi piace, grazie!
— Albert Renshaw,
4

Python 3, 85 78 byte:

lambda x,k="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm<>?":k[k.‌​find(x)-1]
— L3viathan
fonte
1
È possibile passare la stringa come parametro facoltativo, utilizzando 1 lambda: lambda x,k="1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm<>?":k[k.find(x)-1]per ridurre alcuni byte
— Rod
Buon punto, lo aggiungerò.
— L3viathan,
Penso che hai bisogno di un backtick per essere alla sinistra di 1.
— xnor
@xnor Right, riparato quello.
— L3viathan,
4

Python , 76 byte

s="1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm<>?"
dict(zip(s,'`'+s)).get

Provalo online!

Crea un dizionario che porta ciascuna chiave a quella alla sua sinistra comprimendo la stringa di caratteri con la sua versione spostata. La linea di fondo è la funzione, quella in alto è una definizione.

L'uso translateper creare una mappatura ha dato una soluzione più lunga. Provalo online! 

lambda s:s.translate("';"*22+"_0__9`12345678_LM-<>_\\VXSWDFGUHJKNBIO=EARYCQZT\nP][___"*4)
— XNOR
fonte
4

Retina , 53 51 byte

T`1-90\-=QW\ERTYUI\OP[]\\ASDF-HJ-L;'¶ZXCVBNM,./`\`o

Provalo online!

Una semplice traslitterazione che sposta ogni posizione di 1 carattere all'indietro. Tutto da 1a /è il set di caratteri originale, mentre la parte seguente è il nuovo set, usando oper indicare l'altro set.

He Lsono classi di caratteri speciali per la traslitterazione in retina (rispettivamente mappatura su cifre esadecimali e lettere maiuscole), ma fortunatamente si verificano sulla tastiera all'interno di sequenze ordinate alfabeticamente ( FGHe JKL), quindi possiamo evitare di sfuggirle mettendole in intervalli e guadagnando così 2 byte

— Leo
fonte
3

C ++, 109 byte

void f(char i){std::string k="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./";std::cout<<k[k.find(i)-1];}

Provalo online!

— Divcy
fonte
3

TI-Basic, 70 byte

Dubito che potrebbe essere più breve di questo ...

Input Str1
"`1234567890-=QWERTYUIOP[]\ASDFGHJKL;'ZXCVBNM,./
sub(Ans,inString(Ans,Str1)-1,1

PS I token a due byte sono Str1, `, \, sub(, e inString(.

— Timtech
fonte
3

V , 57 54 51 byte

3 byte salvati grazie a @ nmjcman101 per l'utilizzo al hxVpposto di quello che avevo per la tastiera multilinea

i`¬190-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./<esc>/<C-r>a
hxVp

Provalo online!

<esc>è 0x1bed <c-r>è0x12

Nota: questo non supporta il tasto Invio

Contiene non stampabili, quindi ecco il hexdump

00000000: 6960 ac31 3930 2d3d 7177 6572 7479 7569  i`.190-=qwertyui
00000010: 6f70 5b5d 5c61 7364 6667 686a 6b6c 3b27  op[]\asdfghjkl;'
00000020: 7a78 6376 626e 6d2c 2e2f 1b2f 1261 0a68  zxcvbnm,././.a.h
00000030: 7856 70                                  xVp

Spiegazione

La maggior parte del programma genera la tastiera. ientra in modalità inserimento e ogni carattere successivo viene stampato nel buffer. Ma c'è una piccola stranezza qui, ¬19inserisce i caratteri tra 1 e 9.

Il programma esce dalla modalità di inserimento in <esc>. E quindi qui /<c-r>acerca l'argomento nel buffer. Questo porta il cursore sopra il carattere trovato.

h                  " move the cursor to the left
 x                 " delete this character
  Vp               " select this line and replace it with the deleted character
— Kritixi Lithos
fonte
Non sono al 100%, ma penso invece che hylHVGptu possa fare quello che ha fatto @DJMcMayhem nella domanda sulla moto hxVp. Non sono sicuro del motivo per cui ci hai messo Gdentro, non è tutta una riga? Funzionerebbe anche dhVp.
— nmjcman101,
@ nmjcman101 Ah sì, devo averlo mantenuto Gda quando la tastiera era multilinea. Grazie!
— Kritixi Lithos,
2

PowerShell, 82 byte

$k="1234567890-=qwertyuiop[]\asdfghjkl;'
zxcvbnm,./";$k[$k.IndexOf((read-host))-1]

Il tasto Invio è supportato, ma non può essere testato Read-Hostperché l'atto di premere invio senza valore non restituisce nulla in PowerShell.

— Tor
fonte
2

Japt , 56 42 byte

;D=Dv ·q i"[]\\",A i";'",22 +",./")Dg1nDbU

Spiegazione

;D=Dv ·q i"[]\\",A i";'",22 +",./")Dg1nDbU

;D=D                                        // Shortcut for QWERTY (with newlines and spaces), assigning to variable D
    v                                       // Setting D to lowercase
      ·q                                    // Joining D into an array with no spaces or newlines
        i"[]\\",A                          // Inserting "[]\" into index 10 (A)
                   i";'",22                 // Inserting ";'" into index 22
                           +",./"           // Appending ",./"
                                  Dg        // Returns the character at index:
                                    1n      //    -1+
                                       DbU  //     Index of U (the input)

Provalo online!

— Oliver
fonte
Questo è bello, puoi aggiungere una spiegazione?
— Albert Renshaw,
1
@AlbertRenshaw Aggiunta una spiegazione.
— Oliver,
2

Java 8, 99 byte

c->{String r="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./";return r.charAt(r.indexOf(c)-1);}

Spiegazione:

Provalo qui.

c->{                // Method with character as both parameter and return-type
  String r="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./";
                    //  Literal String of the qwerty keyboard layout of the challenge
  return r.charAt(  //  Return the character at the following index:
    r.indexOf(c)    //   The index of the input character
    -1);            //   -1 to shift it to the left
}                   // End of method
— Kevin Cruijssen
fonte
1
Mi arrendo. Stavo cercando di farlo con regex, ma ho miseramente fallire con alcuni caratteri speciali ... c->"`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./".replaceAll("(?s).*(.)"+c+".*","$1").
— Olivier Grégoire,
2

JavaScript (ES6), 74 byte

c=>(s=".,mnbvcxz\n';lkjhgfdsa\\][poiuytrewq=-0987654321`")[s.indexOf(c)+1]

Dato che /non è nella mia stringa, indexOfrestituisce -1, che quando incrementato provoca .l'output. 93 byte per elaborare una stringa:

s=>s.replace(/./g,c=>s[s.indexOf(c)+1],s="><mnbvcxz\n';lkjhgfdsa\\][poiuytrewq=-0987654321`")
— Neil
fonte
@KevinCruijssen Grazie per aver individuato che ho spostato accidentalmente quei tre tasti. Li ho spostati ora.
— Neil,
1

GNU sed , 72 + 1 (flag r) = 73 byte

s:$:`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./:
s:(.).*(.)\1.*:\2:

La chiave di ritorno non può essere testata, perché sed by design divide l'input usando \ncome delimitatore e quindi esegue lo script tutte le volte che ci sono linee.

Esecuzione test: coppia input-output continua (al termine, premere Ctrl + D o Ctrl + C)

me@LCARS:/PPCG$ sed -rf shift_key.sed
s
a
4
3
=
-
a
\
1
`
\
]
— seshoumara
fonte
1

05AB1E , 50 byte

'`žhÀ"-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./"JDÀ‡

Provalo online!

Spiegazione:

'`                                                  # 1 char string: `
  žh                                                # Push numbers 0123456789
    À                                               # Rotated 1 left (123456890)
     "-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./"      # Push string literal
                                              J     # Join all elements pushed to the stack to one string
                                               D    # Duplicate
                                                À   # Rotate 1 left
                                                 ‡  # Transliterate: a.get(b.indexOf(input))
— Okx
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.