"übertrieben" ist ein Beispiel für ein Wort, das auf einer normalen QWERTY-Tastaturkarte mit der linken Hand eingegeben werden kann. "Monopol" ist ein Beispiel für die rechte Hand.

Durchsuchen der Unix- wordsDatei nach Wörtern, die einerseits eingegeben werden können. Die Ausgabe sollte aus zwei Zeilen bestehen: eine durch Leerzeichen getrennte Liste solcher Wörter für die linke Hand, gefolgt von der Liste für die rechte Hand. z.B

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

Die linken Buchstaben sind:

qwertasdfgzxcvb

Die rechten Buchstaben sind:

yuiophjklnm'

Großbuchstaben gelten als einhändig; Buchstaben mit diakritischen Zeichen gelten als Zweihandbuchstaben, daher können Wörter, die sie enthalten, ignoriert werden.

sed, 78 bytes

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

benötigt GNU sed, lauf mit sed -n -f words.sed < /usr/share/dict/words

Bash ( 100 89 Zeichen)

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

Beachten Sie, dass 21 Zeichen den vollständigen Pfad zur Wortdatei enthalten: Wenn wir annehmen dürfen, dass pwd / usr / share / dict ist, können 16 davon gespeichert werden.

Dank an chron für die kürzeren regulären Ausdrücke.

Bash, 86

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

Taylors for, mein Egrep, gruppiert Zeichen.

Wenn Sie per Definition mit zwei blinden Händen tippen und einen Großbuchstaben erzeugen möchten, verwenden Sie immer die linke Hand, um einen Großbuchstaben der rechten Hand zu erzeugen und umgekehrt.

Natürlich können Sie Wnur mit der linken Hand einen Großbuchstaben erzeugen , aber Sie können auch junkmit der linken Hand produzieren, wenn Sie möchten.

Borowski-Schale, 55 Zeichen

^{(Oder irgendeine Bourne-ähnliche Muschel, aber bash, zshoder yash)}

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

Genannt als sh -f words.sh /usr/share/dict/words. (natürlich auf Systeme , bei denen shtatsächlich sind bashwie bei einigen Linux - Distributionen verwenden andere Bourne-Shell wie wie ash, ksh, mksh, pdksh, posh...)

Javascript (Knoten), 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)

Dies kann wahrscheinlich in einer viel kürzeren Version in einer anderen Sprache umgeschrieben werden, aber ich wollte Node nur ausprobieren.

Laufen Sie mit node words.js < /usr/share/dict/words

Q ( 121 - 140 Byte)

Die Ausgabe ist nicht exakt gleich (Backticks statt Leerzeichen), dies ist jedoch symptomatisch für die Anzeige von Zeichenfolgentypen durch Q.

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: Hatte gemischte Groß- und Kleinschreibung, +20 Zeichen zu behandeln

Ruby, 112 92 Zeichen

EDIT: Das ist kürzer, aber bei weitem nicht so lustig:

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*' '}

Ziemlich einfache, auf Regex basierende Lösung. Wie bei den anderen können Sie einige Zeichen speichern, wenn Sie den Dateinamen in ARGV übergeben dürfen oder wenn davon ausgegangen wird, dass er sich in Ihrem aktuellen Verzeichnis befindet.

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

Laufen Sie mit python one_handed_words.py < /usr/share/dict/words

Haskell

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

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,$,=$/}

renn mit perl words.pl /usr/share/dict/words

Python - 152 137 Zeichen (ungetestet)

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)

Bearbeiten: Großbuchstaben und Apostroph behandeln.

Python, 243 Zeichen

edit: hier ist ein kompatibleres programm entsprechend der frage:

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/wordsoder eine beliebige andere Wortdatei mit durch Zeilenumbrüche getrennten Wörtern

alt: 141 Zeichen, nur eine Einzelwortfunktion

kehrt zurück rightoder leftwenn wzur Hand ist und bothbeide Hände verwendet werden.

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 mit fest codiertem Diktatpfad)

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

Verwendung

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 weitere Zeichen, wenn Sie es fest codieren

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

Ich bin mir sicher, dass das besser geht, ich weiß nicht, wie man Strings manipuliert :-(

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)

Gestartet mit:

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

Die Idee ist größtenteils die gleiche wie bei Dillon Cower, aber ich benutze sie set(w)<=S, um eine Teilmenge anzugeben, während set(w)^S>=Sfür eine disjunkte Menge.