„przesadzone” to przykład słowa, które można wpisać lewą ręką na normalnej mapie klawiatury qwerty. „monopol” jest przykładem dla prawej ręki.

Przeszukiwanie wordspliku uniksowego pod kątem słów, które można wpisać jedną ręką. Dane wyjściowe powinny składać się z dwóch wierszy: rozdzielonej spacjami listy takich słów dla lewej ręki, a następnie listy dla prawej ręki. na przykład

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

Litery po lewej stronie to:

qwertasdfgzxcvb

Prawe litery to:

yuiophjklnm'

Wielkie litery liczone są jedną ręką; litery z znakami diakrytycznymi liczone są jako dwuręczne, dlatego słowa zawierające je można zignorować.

sed, 78 bajtów

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

wymaga GNU sed, uruchom z sed -n -f words.sed < /usr/share/dict/words

Bash ( 100 89 znaków)

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

Zauważ, że 21 znaków przechodzi do pełnej ścieżki do pliku słów: jeśli wolno nam założyć, że pwd to / usr / share / dict, to 16 z nich można zapisać.

Kredyt dla Kron dla krótszych regexes.

Bash, 86

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

Taylors for, mój egrep, chronią grupowanie znaków.

Z definicji, jeśli piszesz ślepo na dwie ręce, jeśli chcesz utworzyć wielką literę, zawsze używasz lewej ręki, aby uzyskać znak wielkiej litery prawej ręki i odwrotnie.

Oczywiście możesz produkować wielkie litery Wtylko lewą ręką, ale możesz również produkować junklewą ręką, jeśli chcesz.

Łuska Bourne'a, 55 znaków

^{(Lub dowolną powłoką podobną do Bourne'a bash, ale zshlub yash)}

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

Nazywany jako sh -f words.sh /usr/share/dict/words. (oczywiście, w systemach, gdzie shjest rzeczywiście bashjak na niektórych dystrybucjach systemu Linux, należy użyć innego podobnego Bourne shell jak ash, ksh, mksh, pdksh, posh...)

JavaScript (węzeł), 201 bajtów

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)

Prawdopodobnie można to przepisać na znacznie krótszą wersję w innym języku, ale chciałem tylko wypróbować węzeł.

Biegnij z node words.js < /usr/share/dict/words

Q ( 121 140 bajtów)

Dane wyjściowe nie są dokładnie takie same (backsticks zamiast spacji), ale jest to symptomatyczne dla tego, jak Q wyświetla typy łańcuchów.

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

EDYCJA: Musiałem poradzić sobie z mieszaną wielkością liter, +20 znaków

Ruby, 112 92 znaków

EDYCJA: Jest krótsza, choć nie tak zabawna:

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

Oryginał:

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

Całkiem proste rozwiązanie oparte na wyrażeniach regularnych. Podobnie jak w przypadku innych, możesz zapisać niektóre znaki, jeśli możesz przekazać nazwę pliku w ARGV lub jeśli zakłada się, że znajduje się ona w bieżącym katalogu.

Python, 130 bajtów

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

Biegnij z 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 znaków)

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 bajty

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

Biegnij z perl words.pl /usr/share/dict/words

Python - 152 137 znaków (nieprzetestowane)

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)

edycja: obsługa wielkich liter i apostrofów.

Python, 243 znaki

edycja: oto program bardziej zgodny z pytaniem:

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)

invoke: python onehanded.py > /usr/share/dict/wordslub dowolny inny plik ze słowami oddzielonymi znakiem nowej linii

stary: 141 znaków, tylko funkcja jednego słowa

zwraca rightlub leftjeśli wjest obsługiwany jedną ręką i bothjeśli używane są obie ręce.

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 z zakodowaną ścieżką dyktowania)

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

stosowanie

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 dodatkowych znaków, jeśli go kodujesz

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

Jestem pewien, że można to zrobić lepiej, nie wiem jak manipulować łańcuchem :-(

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)

Uruchomiony z:

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

Pomysł jest w większości taki sam jak w przypadku Dillona Cowera, ale używam, set(w)<=Saby wskazać podzbiór set(w)^S>=Sdla zestawu rozłącznego.