Find one-handed words

Question

'exaggerated' is an example of a word which can be typed on the left hand, on a normal qwerty keyboard map. 'monopoly' is an example for the right hand.

Searching the unix words file for words that can be typed on one hand. Output should be two lines: space separated list of such words for the left hand, followed by the list for the right hand. e.g.

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

The left-hand letters are:

qwertasdfgzxcvb

The right-hand letters are:

yuiophjklnm'

Uppercase letters count as one-handed; letters with diacritics count as two-handed and hence words containing them can be ignored.

Answer 1

sed, 78 bytes

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

requires GNU sed, run with sed -n -f words.sed < /usr/share/dict/words

Answer 2

Bash (100 89 chars)

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

Note that 21 chars go to the full path to the words file: if we're allowed to assume that pwd is /usr/share/dict then 16 of those can be saved.

Credit to chron for the shorter regexes.

Answer 3

Bash, 86

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

Taylors for, my egrep, chrons grouping of chars.

By definition, if you type by two hands blind, if you like to produce an uppercase letter, you always use the left hand to produce an uppercase character of the right hand and vice versa.

Of course you may produce an uppercase W with only the left hand, but you can produce junk with the left hand, too, if you like.

Answer 4

Python 2.7 (139 characters)

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

Answer 5

Bourne shell, 55 chars

^{(Or any Bourne-like shell but bash, zsh or yash)}

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

Called as sh -f words.sh /usr/share/dict/words. (of course, on systems where sh is actually bash like on some Linux distributions, use another Bourne-like shell like ash, ksh, mksh, pdksh, posh...)

Answer 6

Python 3.8 - 126 135 139 144 152 137 chars

r,a={*"YUIOPHJKLNM'"},'\n'
try:
 while w:=input():
  s={*w.upper()}
  if r|s==r:a=w+' '+a
  if s-r==s:a+=w+' '
except:print(a)

edit: handle upper case and apostrophe.

edit 2: move to python 3. get rid of ' '.join(). use walrus operator. change +=w to +=[w] to fix bug.

edit 3: change printing to save 5 characters.

edit 4: change set creation from set(iterable) to {*iterable} to save 2 characters twice.

edit 5: change two lists to one string to hold result allowing one less assignment on the first line and one less print statement on the last line to save 9 characters.

Answer 7

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

This can probably be rewritten to a much shorter version in another language, but I just wanted to give node a try.

Run with node words.js < /usr/share/dict/words

Answer 8

Q (121 140 Bytes)

Output isn't the exact same (backticks instead of spaces) but this is symptomatic of how Q displays string types.

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: Had to handle mixed case, +20 chars

Answer 9

Ruby, 112 92 characters

EDIT: This is shorter, though not nearly as fun:

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

Pretty simple regex-based solution. As with the others, you could save some characters if you're allowed to pass the filename in ARGV or if it's assumed to be in your current directory.

Answer 10

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

Run with python one_handed_words.py < /usr/share/dict/words

Answer 11

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

Answer 12

Perl, 72 bytes

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

run with perl words.pl /usr/share/dict/words

Answer 13

Jelly, 26 24 25 bytes

Øqs€5⁾q'ṭZF€
ỴŒlfƑ¥ƇⱮ¢K€Y

Try it online!

Explanation (older version)

Øqs€5⁾q'ṭZF€   Auxiliary niladic link
Øq             Lowercase QWERTY keyboard
  s€5          Split each row into chunks of at most 5 letters
     ⁾q'ṭ      Append the string "q'"
         Z     Zip (transpose)
          F€   Flatten each => ["qwertasdfgzxcvbq", "yuiophjklnm'"]

ỴŒlfƑƇⱮ¢K€Y   Main monadic link
Ỵ             Split on newlines
 Œl           Lowercase
      Ɱ¢      Map over the result of the auxiliary link:
     Ƈ          Filter by
    Ƒ             Invariant under
   f                Filtering by the right argument
        K€    Join each with spaces
          Y   Join with a newline

Answer 14

Python, 243 chars

edit: here's a more compliant program according to the question:

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/words or any other words file with newline-separated words

old: 141 chars, just a single-word function

returns right or left if w is onehanded, and both if both hands are used.

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]

Answer 15

Q, 95 (111 with hardcoded dict path)

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

usage

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 more chars if you hardcode it

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

Answer 16

J, 109

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

I'm sure this can be done better, I don't know how to do string manipulation :-(

Answer 17

Pyth, 44 bytes

Ljdf.A}RbrT0cQdy."az:ïÑý>Íï“"y"yuiophjklnm'

Try it online!

---

Ljdf.A}RbrT0cQdy."az:ïÑý>Íï“"y"yuiophjklnm' | # Python 3 Translation
---------------------------------------------+------------------------------
                                             | from operator import contains
                                             | from itertools import repeat
                                             | Q = eval(input())
L                                            | y = lambda b:
 jd                                          |   " ".join(
   f                                         |     filter(lambda T:
    .A                                       |       all(
      }R                                     |         map(contains,
        b                                    |           repeat(b),
         rT0                                 |           T.lower()
                                             |         )
                                             |       ),
            cQd                              |       Q.split(" ")
                                             |     )
                                             |   )
               y."az:ïÑý>Íï“"               | print(y("qwertasdfgzxcvb"))
                              y"yuiophjklnm' | print(y("yuiophjklnm'"))

Answer 18

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)

Launched with:

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

---

The idea is mostly the same of Dillon Cower's, but I use set(w)<=S to indicate a subset while set(w)^S>=S for a disjoint set.