"esagerato" è un esempio di una parola che può essere digitata sulla mano sinistra, su una normale mappa della tastiera qwerty. "monopolio" è un esempio per la mano destra.

Ricerca nel wordsfile unix di parole che possono essere digitate da un lato. L'output dovrebbe essere di due righe: elenco separato da spazi di tali parole per la mano sinistra, seguito dall'elenco per la mano destra. per esempio

a abaft abase abased abases abate abated abates abbess abbesses ...
h hi hill hilly him hip hippo hippy ho hokum ...

Le lettere a sinistra sono:

qwertasdfgzxcvb

Le lettere a destra sono:

yuiophjklnm'

Le lettere maiuscole contano come una mano; le lettere con segni diacritici contano come due mani e quindi le parole che le contengono possono essere ignorate.

sed, 78 byte

1{x;s/^/! /;x};/^['h-puy]*$/IH;/^[a-gq-tv-xz]*$/I{G;x};${x;y/\n/ /;s/! */\n/p}

richiede GNU sed, funziona con sed -n -f words.sed < /usr/share/dict/words

Bash ( 100 89 caratteri)

for x in a-gq-tvwxz h-puy\'
do grep -iE ^[$x]*$ /usr/share/dict/words|tr '
' \ 
echo
done

Nota che 21 caratteri passano al percorso completo del file di parole: se ci è permesso supporre che pwd sia / usr / share / dict, 16 di questi possono essere salvati.

Ringraziamo chron per le regex più brevi.

Bash, 86

for x in a-gq-tvwxz h-pyu\'
do egrep ^[$x]*$ /usr/share/dict/words|tr '
' \ 
echo
done

Taylors for, il mio egrep, raggruppamento di caratteri di Chrons.

Per definizione, se digiti con due mani cieche, se ti piace produrre una lettera maiuscola, usi sempre la mano sinistra per produrre un carattere maiuscolo della mano destra e viceversa.

Ovviamente puoi produrre un maiuscolo Wsolo con la mano sinistra, ma puoi anche produrre junkcon la mano sinistra, se lo desideri.

Bourne shell, 55 caratteri

^{(O qualsiasi shell tipo Bourne ma bash, zsho yash)}

w=$1;f()echo `grep -ixe[$1]*<$w`;f a-gq-tvwxz;f h-puy\'

Chiamato come sh -f words.sh /usr/share/dict/words. (ovviamente, nei sistemi in cui shè in realtà bashcome su alcune distribuzioni Linux, usare un altro Bourne-come le coperture, come ash, ksh, mksh, pdksh, posh...)

Javascript (nodo), 201 byte

f=require('fs');c=d='';r=(a=f.readFileSync('/dev/stdin')+c).split('\n');a.
replace(/[aqzxswcdevfrbgt]/ig,'').split('\n').map(function(k,i){k==r[i]&&(
d+=k+' ');!k.length&&(c+=r[i]+' ')});console.log(c,d)

Probabilmente questo può essere riscritto in una versione molto più corta in un'altra lingua, ma volevo solo provare nodo.

Corri con node words.js < /usr/share/dict/words

Q ( 121 140 byte)

L'output non è esattamente lo stesso (backtick anziché spazi) ma questo è sintomatico di come Q mostra i tipi di stringa.

i:read0`:/usr/share/dict/words;
0N!/:i:`$/:i where each (min each) each flip i in/:\:(x,upper x:"qwertasdfgzxcvb";y,upper y:"yuiophjklnm");

EDIT: ha dovuto gestire caso misto, +20 caratteri

Ruby, 112 92 caratteri

EDIT: questo è più breve, anche se non altrettanto divertente:

puts %w(a-gq-tv-xz 'h-puy).map{|r|File.read('/usr/share/dict/words').scan(/^[#{r}]+$/i)*' '}

Originale:

puts File.read('/usr/share/dict/words').scan(/(^[a-gq-tv-xz]+$)|(^['h-puy]+$)/i).transpose.map{|w|w.compact*' '}

Soluzione basata su regex piuttosto semplice. Come con gli altri, potresti salvare alcuni caratteri se ti è permesso passare il nome file in ARGV o se si presume che si trovi nella tua directory corrente.

Python, 130 byte

a="\n"
b=""
try:
 while 1:v=raw_input();m=[x.lower()in"yuiophjklnm'"for x in v];v+=" ";a+=v*all(m);b+=0**any(m)*v
except:print b+a

Corri con python one_handed_words.py < /usr/share/dict/words

Haskell (191)

import Char
g x=all(`elem`x)
f m[]=m
f[x,y](w:ws)|g"quertasdfgzxcvb"w=f[w:x,y]ws|g"yuiophjklnm'"w=f[x,w:y]ws|1<2=f[x,y]ws
main=getContents>>=mapM(putStrLn.unwords).f[[],[]].lines.map toLower

Python 2.7 (139 caratteri)

import os
a=set("yuiophjklnm'")
c=os.read(0,9**9).lower().split()
print'\n'.join([' '.join(filter(x,c))for x in a.isdisjoint,a.issuperset])

Perl, 72 byte

$a{/^['h-puy]+$/i-/^[a-gq-tv-xz]+$/i}.=y/\n/ /rfor<>;print@a{1,-1,$,=$/}

Corri con perl words.pl /usr/share/dict/words

Python - 152 137 caratteri (non testato)

r,a,b=set("YUIOPHJKLNM'"),[],[]
try:
 while 1:
  w=raw_input()
  s=set(w.upper())
  if r|s==r:a+=w
  if s-r==s:b+=w
except:for x in a,b:print' '.join(x)

modifica: gestire maiuscolo e apostrofo.

Python, 243 caratteri

modifica: ecco un programma più conforme secondo la domanda:

import sys
def o(w):
 r="yuiophjklnm'";f=2;w=w.lower()
 for l in w:
  if(f==1)&(l in r)|(f==0)&(l not in r):return 2
  f=l not in r
 return f
y=[[],[],[]]
for w in sys.stdin.read().split('\n'):y[o(w)].append(w)
for i in y[0:2]:print' '.join(i)

invocare: python onehanded.py > /usr/share/dict/words o qualsiasi altro file di parole con parole separate da nuova riga

vecchio: 141 caratteri, solo una funzione di una sola parola

ritorna righto leftse wè a una bothmano e se si usano entrambe le mani.

def o(w):
 r="yuiophjklnm'";f=2
 for l in w:
  if(f==1)&(l in r)|(f==0)&(l not in r):f=2;break
  f=[1,0][l in r]
 return'rlbieogfththt'[f::3]

Q, 95 (111 con dict path codificato)

{`$'e[(w(&)l(w)in .Q.a except a)],(e:enlist)w(&)(l:all')(w:(_)read0 -1!`$x)in a:"yuiophjklnm'"}

uso

q){`$'e[(w(&)l(w)in .Q.a except a)],(e:enlist)w(&)(l:all')(w:(_)read0 -1!`$x)in a:"yuiophjklnm'"} "/usr/share/dict/words"
`a`a`aa`aa`aaa`aaa`aaaa`aaaaaa`aaas`aaberg`aae`aaee`aaf`aag`aar`aara`aarc`aas..
`h`h`hh`hi`hi`hi`hih`hiko`hikuli`hili`hill`hill`hillo`hilly`hilly`hilo`hilum`..

Altri 14 caratteri se lo codifichi

`$'e[(w(&)l(w)in .Q.a except a)],(e:enlist)w(&)(l:all')(w:(_)read0`:/usr/share/dict/words)in a:"yuiophjklnm'"

J, 109

1!:2&2;:^:_1('qwertasdfgzxcvb';'yuiophjkl''nm')((#@[>[:>./i.)&>/#]);:1!:1<'/usr/share/dict/words'[9!:37]0,3$_

Sono sicuro che questo può essere fatto meglio, non so come manipolare le stringhe :-(

Python: 122

import os
S=set("yuiophjklnm'")
c=os.read(0,9**9).lower().split()
print"\n".join(w for w in c if set(w)<=S or set(w)^S>=S)

Lanciato con:

python name_of_program.py < /usr/share/dict/words

L'idea è principalmente la stessa di Dillon Cower, ma io uso set(w)<=Sper indicare un sottoinsieme mentre set(w)^S>=Sper un insieme disgiunto.