Teacup rim text: Difference between revisions

{{draft task|Teacup rim text}}

On a set of coasters we have, there's a picture of a teacup.   On the rim of the teacup the word "  '''TEA"'''   appears a number of times separated by bullet characters. It  occurred to me that if the bullet were removed and the words run together, you could start at any letter and still end up with a meaningful three-letter word(•). So start at the "T" and read "TEA". Start at the "E" and read "EAT", or start at the "A" and read "ATE".

<syntaxhighlight lang ="factor">USING: combinators.short-circuit fry grouping hash-sets http.client kernel math prettyprint

"\n" split [ { [ length 23 < ] [ all-equal? ] } >1|| ] filterreject

'[ [ _ in? ] all? ] filter [ natural-sort ] map members .</langsyntaxhighlight>

<langsyntaxhighlight lang="go">package main

wordsdicts := readWords([]string{"mit_10000.txt"), "unixdict.txt"} // using local copycopies

nfor _, dict := len(words)range dicts {

for _, word n := range len(words {)

runesused := make(map[string]rune(wordbool)

for i_, word := 0; i < len(runes)-1;range i++words {

rotate(runes := []rune(word)

word2variants := []string(runes){word}

iffor used[word2]i := 0; i < len(runes)-1; i++ {

continue outerrotate(runes)

ixfor _, variant := sort.SearchStrings(words,range variants word2){

if ix == n || wordsused[ixvariant] != word2 {true

variants = appendfmt.Println(variants, word2)

fmt.Println(variants)

}</langsyntaxhighlight>

rotations = liftA2 fmap <$> rotated <*> (enumFromTo 0 . pred . length)

<pre>aaaarc -> car -> rca

<langsyntaxhighlight lang="javascript">(() => {

[0, true, rotated(w)]

};

).filter(gp => 1 < gp.length)

})();</langsyntaxhighlight>

<pre>aaaarc -> car -> rca

wordlistdictconst rotations = getwords()s =>

pas: ["spaaim", "ima", "aspmai"]

xxx: ["xxxarc", "car", "xxxrca"]

iii: ["iiiasp", "pas", "iiispa"]

asp: ["pasate", "eat", "spatea"]

tea: ["ateips", "psi", "eatsip"]

<langsyntaxhighlight lang="javascript">

const lines = wc.DownloadString("httpshttp://wwwwiki.mitpuzzlers.eduorg/~ecpricepub/wordlistwordlists/unixdict.10000txt");

aimapt, imapta, maitap

=={{header|PerlMathematica}}/{{header|Wolfram 6Language}}==

next if %$seen{$_};

for ^my $maybei (0 .chars. length $maybe) {

if (any { $maybe ∈eq $_ } @$these) {

push @print.push:, $maybe;

$maybe = substr($maybe,1) .comb.list.rotate.join; substr($maybe,0,1)

@print = (); and next MAYBE

if (@print.elems) {

push @teacups.push:, [@print];

%$seen{$_}++ for @print;

say .join(" ', ")', uniqstr @$_ for sort @teacups;</langsyntaxhighlight>

<pre>AAAARC, AAARCA, AAACAR

ATEIPS, TEAPSI, EATSIP</pre>

Composing generic functions, and takingconsidering only circularanagram words of more than two charactersgroups.

<langsyntaxhighlight lang="python">'''Teacup rim text'''

from itertools import chain, groupby

'''Circular wordsanagram groups, of more than twoone charactersword,

inand acontaining local copywords of alength word> list.2, found in:

print('\n'.join(

showGroupsconcatMap(circularGroup)(

circularWordsanagrams(3)(

# LocalReading copyfrom ofa local copy.

))

# circularWordsanagrams :: Int -> [String] -> [[String]]

def circularWordsanagrams(wsn):

'''The subsetGroups of thoseanagrams, wordsof inminimum thegroup givensize listn,

whichfound arein circularthe given word list.

lexicondef = setgo(ws):

'''True if theall givenof a word's contains more thanrotations

twoare characters,found andin allthe ofgiven its rotationslexicon.

return 1 < iLast and until(

(0, True, rotated(w))

return lambdadef go(xs): [

'''A liststring rotated 1 character to the right.'''

def go(f, x):

v =def g(x):

while not p( v): = x

vwhile =not fp(v):

return v = f(v)

return lambda f: lambda x: go(f, x) return v

main()</langsyntaxhighlight>

<pre>aaaarc -> rca -> car

arcate -> cartea -> rcaeat

asp -> passpa -> spapas

underbars, or embedded blanks) &nbsp; weren't considered as candidates for circular words.

<langsyntaxhighlight lang="rexx">/*REXX pgm finds circular words (length>2), using a dictionary, suppress permutations.*/

do r=0 while lines(iFID) \==0 0 /*read all lines (words) in dictionary.*/

z= space(parse upper value linein(iFID) ) with z . /*obtain get a word from the dictionary. */

if length(z)<L | @.z\=='' then iterate /*length must be L or more, no dups.*/

if \datatype(z, 'MU') then iterate /*Word contains non-letters? Then skip*/

@.z = z /*assign a word from the dictionary. */

#= # + 1; $.#= z /*bump word count; append word to list.*/

end /*r*/ /* [↑] dictionary need not be sorted. */

cw= 0 do j=1 for #; x= $.j; y= x /*obtain the Jth word in /*the number of circularlist. words (so far)*/

do jif x==1'' forthen #;iterate x= $.j; y= x /*obtainif thea null, Jthdon't show wordvariants. in the list. */

if xyy=='' y then iterate /*if a null, don't show variants. /*the start of a list of the variants. */

yy= y do k=1 for length(x)-1 /*"circulate" the start of a listlitters ofin the variantsword. */

do ky=1 substr(y, for2)left(y, length(x1)-1 /*"circulate"add the littersleft inletter to the word.right end.*/

y= substr(y,if 2)left(@.y,=='' 1) then iterate j /*addif thenot lefta letterword, to thethen rightskip endthis word. */

if @.y=yy= yy',' then iteratey j /*if not a word, then skip this word /*append to the list of the variants. */

yy @.y= yy',' y /*append to the list of/*nullify theword variants.to suppress permutations*/

if y\==xend /*k*/ then @.y= /*nullify word to suppress permutations*/

cw= cw + 1 end /*k*/ /*bump [↓]counter ···of exceptcircular forwords monolithic wordsfound.*/

cw= cw + 1 say 'circular word: ' yy /*bumpdisplay counter ofa circular wordsword and foundvariants.*/

say cw ' circular words were found.' /*stick a fork in it, we're all done. */</langsyntaxhighlight>

circular word: aaaAIM, aaaIMA, aaaMAI

circular word: aimARC, imaRCA, maiCAR

circular word: arcASP, rcaSPA, carPAS

circular word: aspATE, spaTEA, pasEAT

circular word: ateIPS, teaPSI, eatSIP

105 circular words were found.

rots,w,szseen := List(), word, word.lenDictionary();

if(sz>2foreach andword notin seen(words.holds(word)keys){

do(rots,w,sz-1 := List(){, word, word.len();

}</langsyntaxhighlight>