Word wheel: Difference between revisions

 

 

| N

| D

| L

| W

 

;Task:

Specifically:

:* Find all words of 3 or more letters using only the letters in the string   '''ndeokgelw'''.

:* Each letter may be used only as many times as it appears in the string.

:* For this task we'll use lowercase English letters exclusively.

{{Template:Strings}}

<br><br>

 

=={{header|8080 Assembly}}==

(the given ~206kb <code>unixdict.txt</code> works fine).

 

fopen: equ 15 ; CP/M syscall to open a file

fread: equ 20 ; CP/M syscall to read from file

wheel: ds 9 ; Room for wheel

wcpy: ds 9 ; Copy of wheel (to mark characters used)

 

{{out}}

</pre>

 

=={{header|AppleScript}}==

use framework "Foundation"

use scripting additions

 

 

 

on |λ|(w)

end |λ|

end script

 

 

 

 

 

-- all :: (a -> Bool) -> [a] -> Bool

acc

end concat

 

 

if |λ|(v, i, xs) then set end of lst to v

end repeat

end tell

end filter

 

 

-- mReturn :: First-class m => (a -> b) -> m (a -> b)

on mReturn(f)

if script is class of f then

f

 

 

 

 

 

 

 

 

set my text item delimiters to dlm

s

{{Out}}

<pre>eke

elk

 

=={{header|C}}==

#include <stdio.h>

 

fclose(in);

return 0;

 

{{out}}

{{libheader|Boost}}

The puzzle parameters can be set with command line options. The default values are as per the task description.

#include <iostream>

#include <fstream>

}

return EXIT_SUCCESS;

 

{{out}}

claremont with central letter a

spearmint with central letter a

</pre>

 

{{libheader| System.Classes}}

{{Trans|Wren}}

program Word_wheel;

 

end.

 

 

=={{header|Factor}}==

{{works with|Factor|0.99 2020-07-03}}

math.statistics prettyprint sequences sorting ;

 

[ words ] keepd [ can-make? ] curry filter ;

 

{{out}}

<pre style="height:20ex">

"knowledge"

}

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Println(mostWords9[i], "with central letter", string(mostLetters[i]))

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (sort)

 

gridWords :: [String] -> [String] -> [String]

gridWords grid =

where

cs = toLower <$> concat grid

 

wheelFit :: String -> String -> Bool

where

go _ [] = True

go [] _ = False

| w == c = go ws cs

| otherwise = go ws ccs

 

main :: IO ()

{{Out}}

<pre>eke

wok

woke</pre>

 

=={{header|JavaScript}}==

A version using local access to the dictionary, through the macOS JavaScript for Automation API.

{{Works with|JXA}}

 

 

// gridWords :: [String] -> [String] -> [String]

lexemes => {

const

wSet = new Set(wheel),

mid = wheel[4];

return lexemes.filter(w => {

return 2 < cs.length && cs.every(

c => wSet.has(c)

wheelFit(wheel, cs)

);

});

};

 

// wheelFit :: [Char] -> [Char] -> Bool

go(ws.slice(1), cs.slice(1))

) : go(ws.slice(1), cs);

return go(wheel, sort(word));

};

 

 

 

 

 

// lines :: String -> [String]

const lines = s =>

) : [];

 

 

// readFile :: FilePath -> IO String

const readFile = fp => {

// The contents of a text file at the

const

e = $(),

e

);

return ObjC.unwrap(

ns.isNil() ? (

);

};

 

// sort :: Ord a => [a] -> [a]

 

// toLower :: String -> String

s.toLocaleLowerCase();

 

 

// MAIN ---

return main();

{{Out}}

<pre>eke

wok

woke</pre>

 

=={{header|Julia}}==

 

const tfile = download("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")

 

println(wordwheel("ndeokgelw", "k"))

<pre>

["ken", "keg", "eke", "elk", "wok", "keno", "knee", "keen", "knew", "kong", "know", "woke", "keel", "leek", "week", "kneel", "knowledge"]

</pre>

===Faster but less general version===

const wordarraylist = [[string(c) for c in w] for w in split(read(tfile, String), r"\s+")]

 

 

println(wordwheel2("ndeokgelw", "k"))

<pre>

["eke", "elk", "keel", "keen", "keg", "ken", "keno", "knee", "kneel", "knew", "know", "knowledge", "kong", "leek", "week", "wok", "woke"]

</pre>

 

UPDATED: this version builds a single regex that will select all valid words

straight from the file string.

 

use strict; # https://rosettacode.org/wiki/Word_wheel

my @words = $file =~ /$valid/g;

 

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

The following 17 words were found:

claremont with central letter 'a'

spearmint with central letter 'a'

</pre>

 

=={{header|Python}}==

from collections import Counter

 

chars = ''.join(GRID.strip().lower().split())

found = solve(chars, dictionary=getwords())

 

{{out}}

 

Or, using a local copy of the dictionary, and a recursive test of wheel fit:

 

from os.path import expanduser

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>eke

wok

woke</pre>

 

=={{header|Raku}}==

Using [https://modules.raku.org/search/?q=Terminal%3A%3ABoxer Terminal::Boxer] from the Raku ecosystem.

 

 

my %*SUB-MAIN-OPTS = :named-anywhere;

say "{sum %words.values».elems} words found";

 

 

{{out}}

;Using defaults

 

<pre>Using ./unixdict.txt, minimum 3 letters.

╭───┬───┬───╮

Using the much larger dictionary '''words.txt''' file from '''https://github.com/dwyl/english-words'''

 

 

<pre>Using ./words.txt, minimum 3 letters.

Additional information is also provided concerning how many words have been skipped due to

the various filters.

parse arg grid minL iFID . /*obtain optional arguments from the CL*/

if grid==''|grid=="," then grid= 'ndeokgelw' /*Not specified? Then use the default.*/

do n=1 for length(aa); p= pos( substr(aa,n,1), gg); if p==0 then return 1

gg= overlay(., gg, p) /*"rub out" the found character in grid*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

number of nine-letter wheel words found: 0

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

{{libheader|Wren-seq}}

 

var letters = ["d", "e", "e", "g", "k", "l", "n", "o","w"]

for (i in 0...mostWords9.count) {

System.print("%(mostWords9[i]) with central letter '%(mostLetters[i])'")

 

{{out}}

claremont with central letter 'a'

spearmint with central letter 'a'

</pre>