'exagerado' es un ejemplo de una palabra que se puede escribir en la mano izquierda, en un mapa de teclado qwerty normal. 'monopolio' es un ejemplo para la mano derecha.

Buscando en el wordsarchivo unix palabras que puedan escribirse con una mano. La salida debe ser dos líneas: lista separada por espacios de tales palabras para la mano izquierda, seguida de la lista para la mano derecha. p.ej

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

Las letras de la izquierda son:

qwertasdfgzxcvb

Las letras de la derecha son:

yuiophjklnm'

Las letras mayúsculas cuentan como una mano; Las letras con signos diacríticos cuentan como a dos manos y, por lo tanto, las palabras que las contienen pueden ignorarse.

sed, 78 bytes

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

requiere GNU sed, ejecuta con sed -n -f words.sed < /usr/share/dict/words

Bash ( 100 89 caracteres)

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

Tenga en cuenta que 21 caracteres van a la ruta completa al archivo de palabras: si se nos permite suponer que pwd es / usr / share / dict, se pueden guardar 16 de ellos.

Crédito a cron para las expresiones regulares más cortas.

Bash, 86

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

Taylors for, mi egrep, agrupación crónica de caracteres.

Por definición, si escribe con las dos manos ciegas, si desea producir una letra mayúscula, siempre usa la mano izquierda para producir un carácter en mayúscula de la mano derecha y viceversa.

Por supuesto, puede producir mayúsculas Wsolo con la mano izquierda, pero también puede producir junkcon la mano izquierda, si lo desea.

Bourne shell, 55 caracteres

^{(O cualquier shell similar a Bourne pero bash, zsho yash)}

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

Llamado como sh -f words.sh /usr/share/dict/words. (por supuesto, en sistemas donde shen realidad es bashigual que en algunas distribuciones de Linux, utilice otro Bourne-como la cáscara como ash, ksh, mksh, pdksh, posh...)

Javascript (nodo), 201 bytes

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)

Esto probablemente se puede volver a escribir en una versión mucho más corta en otro idioma, pero solo quería probar el nodo.

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

Q ( 121 140 bytes)

La salida no es exactamente la misma (backticks en lugar de espacios), pero esto es sintomático de cómo Q muestra los tipos de cadena.

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

EDITAR: tuvo que manejar mayúsculas y minúsculas, +20 caracteres

Ruby, 112 92 caracteres

EDITAR: Esto es más corto, aunque no tan divertido:

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

Original:

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

Solución bastante simple basada en expresiones regulares. Al igual que con los demás, puede guardar algunos caracteres si puede pasar el nombre de archivo en ARGV o si se supone que está en su directorio actual.

Python, 130 bytes

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

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

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 bytes

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

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

Python - 152137 caracteres (sin probar)

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)

editar: manejar mayúsculas y apóstrofo.

Python, 243 caracteres

editar: aquí hay un programa más compatible de acuerdo con la pregunta:

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)

invocar: python onehanded.py > /usr/share/dict/wordso cualquier otro archivo de palabras con palabras separadas por nueva línea

antiguo: 141 caracteres, solo una función de una sola palabra

regresa righto leftsi wes de una mano, y bothsi se usan ambas manos.

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 ruta dict codificada)

{`$'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`..

14 caracteres más si lo codifica

`$'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$_

Estoy seguro de que esto se puede hacer mejor, no sé cómo manipular cadenas :-(

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)

Lanzado con:

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

La idea es principalmente la misma que la de Dillon Cower, pero uso set(w)<=Spara indicar un subconjunto mientras que set(w)^S>=Spara un conjunto disjunto.