Word wheel: Difference between revisions

{{trans|Python}}

 

‘N D E

O K G

V chars = GRID.lowercase().split_py().join(‘’)

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

 

{{out}}

(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}}

=={{header|APL}}==

{{works with|Dyalog APL}}

words←((~∊)∘⎕TC⊆⊢) 80 ¯1⎕MAP ⍵

match←{

words←(⍺∘match¨words)/words

(⍺⍺≤≢¨words)/words

{{out}}

<pre> 'ndeokgelw' (3 wordwheel) 'unixdict.txt'

eke elk keel keen keg ken keno knee kneel knew know knowledge kong leek week wok woke </pre>

=={{header|AppleScript}}==

use framework "Foundation"

use scripting additions

return lst

end tell

{{Out}}

<pre>17 matches:

 

=={{header|AutoHotkey}}==

 

FileRead, wList, % A_Desktop "\unixdict.txt"

}

return oRes

{{out}}

<pre>eke

 

=={{header|AWK}}==

# syntax: GAWK -f WORD_WHEEL.AWK letters unixdict.txt

# the required letter must be first

exit(0)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

20 DATA "ndeokgelw","unixdict.txt"

30 READ WH$, F$

140 C=0: FOR I=1 TO LEN(C$): C=C-(MID$(C$,I,1)="@"): NEXT

150 IF C>=3 THEN PRINT W$,

{{out}}

<pre>eke elk keel keen keg

 

=={{header|BCPL}}==

 

// Read word from selected input

writef("%S*N", word)

endread()

{{out}}

<pre>eke

 

=={{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}}

{{libheader| System.Classes}}

{{Trans|Wren}}

program Word_wheel;

 

end.

 

 

=={{header|F_Sharp|F#}}==

// Word Wheel: Nigel Galloway. May 25th., 2021

let fG k n g=g|>Seq.exists(fun(n,_)->n=k) && g|>Seq.forall(fun(k,g)->Map.containsKey k n && g<=n.[k])

let wW n g=let fG=fG(Seq.item 4 g)(g|>Seq.countBy id|>Map.ofSeq) in seq{use n=System.IO.File.OpenText(n) in while not n.EndOfStream do yield n.ReadLine()}|>Seq.filter(fun n->2<(Seq.length n)&&(Seq.countBy id>>fG)n)

wW "unixdict.txt" "ndeokgelw"|>Seq.iter(printfn "%s")

{{out}}

<pre>

=={{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">

 

=={{header|FreeBASIC}}==

#include "file.bi"

 

print matches;" matches"

Sleep

{{out}}

<pre>

=={{header|Go}}==

{{trans|Wren}}

 

import (

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

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (sort)

import System.IO (readFile)

. gridWords ["NDE", "OKG", "ELW"]

. lines

{{Out}}

<pre>eke

 

=={{header|J}}==

wwhe=: {{

ref=. /:~each words=. cutLF tolower fread 'unixdict.txt'

;:inv r=. r,words #~ ref e. target

end.

 

 

=={{header|JavaScript}}==

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

{{Works with|JXA}}

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>eke

 

=={{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>

=={{header|Lua}}==

new = function(self, word)

local t = { word=word, letters={} }

print(word)

end

{{out}}

<pre>eke

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

possible[letters_List][word_String] := Module[{c1, c2, m},

c1 = Counts[Characters@word];

words //= Select[StringMatchQ[Repeated[Alternatives @@ chars]]];

words //= Select[possible[chars]];

{{out}}

<pre>{eke,elk,keel,keen,keg,ken,keno,knee,kneel,knew,know,knowledge,kong,leek,week,wok,woke}</pre>

 

=={{header|Nim}}==

 

const Grid = """N D E

if count > gridCount[ch]:

break checkWord

 

{{out}}

=={{header|Pascal}}==

{{works with|Free Pascal}}

program WordWheel;

 

search('NDE' + 'OKG' + 'ELW');

end.

{{out}}

<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}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.1"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (fixed another glitch in unique())</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

{{out}}

<small>(Only the first three lines are shown under pwa/p2js)</small>

 

=={{header|Picat}}==

MinLen = 3,

MaxLen = 9,

foreach(E in L)

D.put(E,D.get(E,0)+1)

 

{{out}}

 

'''Optimal word(s)''':

WordList = "unixdict.txt",

MinLen = 3,

end,

println(maxLResen=MaxResLen),

 

{{out}}

 

=={{header|PureBasic}}==

Shared letters$

If Len(word$)<3 Or FindString(word$,"k")<1

Input()

EndIf

{{out}}

<pre>eke

 

=={{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

 

=={{header|q}}==

lc:ce group@ / letter count

dict:"\n"vs .Q.hg "http://wiki.puzzlers.org/pub/wordlists/unixdict.txt"

solve:{[grid;dict]

i:where(grid 4)in'dict;

A naive solution to the second question is simple

grids:distinct raze(til 9)rotate\:/:dict where(ce dict)=9;

wc:(count solve@)each grids;

but inefficient. Better:

dlc:lc each dict; / letter counts of dictionary words

ig:where(ce dict)=9; / find grids (9-letter words)

ml:4 rotate'dict ig; / mid letters for each grid

wc:ce raze igw inter/:'iaz ml; / word counts for grids

"ntclaremo"

"tspearmin"

 

q)ce solve each w

Full discussion at [https://code.kx.com/q/learn/pb/word-wheel/ code.kx.com]

 

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>

 

=={{header|Ruby}}==

middle, wheel_size = wheel[4], wheel.size

 

 

puts res

{{out}}

<pre>eke

 

=={{header|Transd}}==

 

MainModule: {

(lout "New max. number: " maxRes ", word: " w ", central letter: " centl)

) ) ) )

{{out}}

<pre>

{{libheader|Wren-sort}}

{{libheader|Wren-seq}}

import "/sort" for Sort, Find

import "/seq" for Lst

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

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

 

{{out}}

 

=={{header|XPL0}}==

int I, Set, HasK, HasOther, HasDup, ECnt, Ch;

char Word(25);

];

until Ch = EOF;

 

{{out}}