# WordCube

## 9 letter words with several anagrams

While perusing the statistics of wordcube, I was wondering how many 9 letter words have multiple anagrams (using all the letters in a single word) and what was the maximum number of anagrams. So I wrote a quick and dirty python program to find out. I will first show the results as they are interesting followed by my coding and methods to improve the efficiency of it.

Results
Here are all the nine letter words with more than 2 anagrams:

• 1. auctioned cautioned education
• 2. beastlier bleariest liberates
• 3. cattiness scantiest tacitness
• 4. countries cretinous neurotics
• 5. cratering retracing terracing
• 6. dissenter residents tiredness
• 7. earthling haltering lathering
• 8. emigrants mastering streaming
• 9. estranges greatness sergeants
• 10. gnarliest integrals triangles
• 11. mutilates stimulate ultimates
• 12. reprising respiring springier

I only found 12 sets of 3, there may be more with a larger dictionary. I was also disappointed that there were no words with 4 anagrams yet not entirely unsurprising. My personal favourite is number 10

[poll id=”11″]

Python

I recycled an anagram checking function that I have used before:

```# -*- coding: utf-8 -*-

# Anagram checking function
def anagramchk(word,chkword):
for letter in word:
if letter in chkword:
chkword=chkword.replace(letter, '', 1)
else:
return 0
return 1

```

First program

Firstly I created a dirty program that created a loop to cycle through the 9 letter word dictionary and another loop nested inside to check against every word in the dictionary again. This is a terrible and inefficient method and will create duplicates, I will follow with a more efficient method.

```g=open('eng-9-letter', 'r')
for l in g:

wordin=l.strip()

f=open('eng-9-letter', 'r')
count=0
w=""
for line in f:
line=line.strip()
if anagramchk(line,wordin):
count+=1
w+=" "+line
f.close()
if count>2:
print wordin, count, "(",w,")"

g.close()
```

This program took 80.42s to find the 12 solutions. On the path to better coding I decided to load the dictionary into memory, this sped the code up about 20s to 63.88s.

```# Load dictionary into memory
dic=[]
f=open('eng-9-letter', 'r')
for line in f:
dic.append(line.strip())
f.close()
```

I then attempted to create a method that loops over and removes words from the dictionary as it loops, however I don’t know the correct way (if there is one?) of modifying the loop variable while inside the loop without causing problems.

```for word in dic:
if ....:
dic.remove(word)
```

If anyone knows a good method of doing this please let me know! I did managed to hack together something using slices so that I could modify the dictionary each time, however I imagine this is still quite inefficient.

```for word in dic[:]:
w=""
count=0
for word2 in dic[:]:
if anagramchk(word,word2):
count+=1
dic.remove(word2)
w+=word2+" "
if count>2:
print w
```

Even so this method now avoids duplication of results and completes in 31.87s (machine running at 3.15Ghz). Please let me know of any improvements you think can be made and I’ll happily benchmark to see how much better it is.

## Wordcube feedback

This page was created for feedback from users of wordcube available via the wordcube website or as an app for android phones (available in market). Filling in these polls and leaving feedback will help improve wordcube for everyone.

[poll id=”4″]

[poll id=”5″]

[poll id=”6″]

[poll id=”7″]

[poll id=”8″]

Thanks for your feedback. Please post any bugs, suggestions, complaints or ideas below.

## Android: WordCube – Daily puzzle game

Due to the success (and small amount of addiction) of my browser-based wordcube game (see here), I decided to make a WordCube application for android.

Features

• Anagram / Wordsearch based puzzle
• Small file size (~100kb) and footprint
• Updated daily
• Share score with twitter integration (compete with friends)
• Saves your last attempts so you can continue at later time
• This also means you can continue your last game offline
• Several achievements can be unlocked (more to come, also looking for suggestions for achievements)

screenshot of wordcube

Gameplay
Find as many words as possible using letters from the grid. The words must be 4 letters or more, contain the central letter and each letter may not be used more than once. There is at least one word that uses all of the letters in the cube.

The main interface is by tapping the letters in order to construct a word, but keyboards (and on screen keyboards) are also supported.

Another wordcube screenshot

Once you have attained all the words that you can, you can post your score to twitter and then compare with your friends to see how they did in comparison. In order to use this feature you need to have a twitter client installed, I would recommend twidroid.

Android: WordCube Free
Android: WordCube Pro (only Â£1)
Web: WordCube Free

The pro version is available for Â£1, with the money going to support the developer and the development and maintenance of this application. The pro version features all of the latest features and in the near future will support personal statistics to keep track of performance.

If you enjoyed this please leave feedback for me either here or on the market. Comments, suggestions and constructive criticism is also welcome.

## Android: Blurring and dimming background windows from dialogs

The android SDK has lots of nice goodies built in to make your applications look sexier. One such feature is the blurring of windows. This effect looks particularly nice if a background window is blurred while a dialog box is shown above which can really make it stand out. Below shows the application such an example; on the left is the default about box (for WordCube Pro) and on the right is with added blur and no dimming.

android bluring and dimming effect before and after

I am using the AlterDialog.Builder to create my dialog, however this method will work with all kinds of dialog providing you can access it via getWindow.

```   dialog = new AlertDialog.Builder(WordCube.this)
.setTitle(WordCube.this.getResources().getString(R.string.app_name))
.setMessage(s)
.setIcon(R.drawable.logo)
.setPositiveButton(R.string.btn_close, null)
.show();
```

Below shows the code needed to add blur and remove dimming of the background (as I think the blur looks nicer when the background is well lit).

```WindowManager.LayoutParams lp = dialog.getWindow().getAttributes();
lp.dimAmount=0.0f;
dialog.getWindow().setAttributes(lp);
```

The blur is simply created using the last line (line 4) which sets a flag for the dialog telling android that we want windows below this one to be blurred. To achieve the dimming, we need to retrieve the layout parameters for the dialog window, set the dim amount to zero, update these parameters with setAttributes (lines 1-3).

## Python: Wordwheel / WordCube solver

Often in newspapers there is a wordwheel or some variant, whereby you have to find as many words greater than 3 letters long, containing the centre word and using the letters no more than once. I have created a webpage that generates a “WordCube” daily for people to peruse at their leisure (www.stealthcopter.com/wordcube). This post contains the code and explanation of the solutions to wordcube’s (and all other word<insert shape here>).

Example WordCube image for the 12th December 2009 from www.stealthcopter.com/wordcube/2009/12/12

Below is a function I wrote to check if an input was a valid anagram (or partial anagram, as it isn’t essential to use every letter). The function works by cycling over each letter of word we are testing (word), and checks if the letter is valid (checked against chkword). If the letter is valid then it removes the letter from the original word and moves to the next letter until we run out of letters (returns True) or if the letter is invalid (returns False).

```def anagramchk(word,chkword):
for letter in word:
if letter in chkword:
chkword=chkword.replace(letter, '', 1)
else:
return False
return True

f=open('english', 'r')
word=raw_input('Input letters (starting with mandatory letter) :')
minlen=4
count=0
for l in f:
l=l.strip()
if len(l)<=len(word) and len(l)>=minlen and word[0] in l and anagramchk(l,word):
if len(l)==len(word):
print l,'  <-- Long word'
else:
print l
count+=1
f.close()
print count
```

This will output a list of the possible words, along with a total. The results can be seen for the WordCube in the example above here (To prevent spoiling it if you’d like to have a go at it yourself).

As always I’d be interested to see if anyone knows any faster methods or any other general improvements or comments.

The dictionary file can be found here (not perfect):
here