Words from neighbour ones: Difference between revisions
Added Algol 68
(C - revert to previous version) |
(Added Algol 68) |
||
| (45 intermediate revisions by 27 users not shown) | |||
Line 25:
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V wordList = File(‘unixdict.txt’).read().split("\n")
V filteredWords = wordList.filter(chosenWord -> chosenWord.len >= 9)
L(word) filteredWords[0 .< (len)-9]
V position = filteredWords.index(word)
V newWord = (0..8).map(i -> :filteredWords[@position + i][i]).join(‘’)
I newWord C filteredWords
print(newWord)</syntaxhighlight>
{{out}}
<pre>
applicate
architect
astronomy
christine
christoph
committee
committee
committee
committee
committee
composite
constrict
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
interrupt
philosoph
prescript
receptive
telephone
transcend
transcend
transport
transpose
</pre>
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">
# find words where concatenating the nth character from this and the next 8 #
# words results in another word - only words of 9 or more characters are to #
# be considered #
IF FILE input file;
STRING file name = "unixdict.txt";
open( input file, file name, stand in channel ) /= 0
THEN
# failed to open the file #
print( ( "Unable to open """ + file name + """", newline ) )
ELSE
# file opened OK #
BOOL at eof := FALSE;
# set the EOF handler for the file - notes eof has been reached and #
# returns TRUE so processing can continue #
on logical file end( input file, ( REF FILE f )BOOL: at eof := TRUE );
# table of possible words - there are around 8 000 9+ character words #
[ 1 : 10 000 ]STRING words; # in unixdict.txt #
# in-place quick sort an array of strings #
PROC s quicksort = ( REF[]STRING a, INT lb, ub )VOID:
IF ub > lb
THEN
# more than one element, so must sort #
INT left := lb;
INT right := ub;
# choosing the middle element of the array as the pivot #
STRING pivot := a[ left + ( ( right + 1 ) - left ) OVER 2 ];
WHILE
WHILE IF left <= ub THEN a[ left ] < pivot ELSE FALSE FI
DO
left +:= 1
OD;
WHILE IF right >= lb THEN a[ right ] > pivot ELSE FALSE FI
DO
right -:= 1
OD;
left <= right
DO
STRING t := a[ left ];
a[ left ] := a[ right ];
a[ right ] := t;
left +:= 1;
right -:= 1
OD;
s quicksort( a, lb, right );
s quicksort( a, left, ub )
FI # s quicksort # ;
# returns the length of s #
OP LENGTH = ( STRING s )INT: 1 + ( UPB s - LWB s );
# returns TRUE if words[ low : high ] comntains s, FALSE otherwise #
PROC is word = ( STRING s, INT low, high )BOOL:
IF high < low THEN FALSE
ELSE INT mid = ( low + high ) OVER 2;
IF words[ mid ] > s THEN is word( s, low, mid - 1 )
ELIF words[ mid ] = s THEN TRUE
ELSE is word( s, mid + 1, high )
FI
FI # is word # ;
INT min length = 9; # minimum length of word to consider #
INT w count := 0; # store the 9 character words #
WHILE
STRING word;
get( input file, ( word, newline ) );
NOT at eof
DO
IF LENGTH word >= min length THEN
words[ w count +:= 1 ] := word
FI
OD;
close( input file );
s quicksort( words, 1, w count ); # sort the words #
FOR i TO ( w count + 1 ) - min length DO # find the required words #
STRING c word := words[ i ][ LWB words[ i ] ];
INT w pos := i;
FOR c pos TO 8 DO
STRING w = words[ w pos +:= 1 ];
c word +:= w[ c pos + LWB words[ i ] ]
OD;
IF is word( c word, 1, w count ) THEN
print( ( c word, newline ) )
FI
OD
FI
</syntaxhighlight>
{{out}}
<pre>
applicate
architect
astronomy
christine
christoph
committee
committee
committee
committee
committee
composite
constrict
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
interrupt
philosoph
prescript
receptive
telephone
transcend
transcend
transport
transpose
</pre>
=={{header|AppleScript}}==
===Core language===
<syntaxhighlight lang="applescript">on task()
-- Since the task specifically involves unixdict.txt, this code's written in
-- the knowlege that the words are on individual lines and in dictionary order.
set dictPath to (path to desktop as text) & "unixdict.txt"
script o
property wordList : paragraphs of (read file dictPath as «class utf8»)
property matches : {}
end script
-- Zap words with fewer than 9 characters and work with what's left.
repeat with i from 1 to (count o's wordList)
if ((count item i of o's wordList) < 9) then set item i of o's wordList to missing value
end repeat
set o's wordList to o's wordList's every text
set wordListCount to (count o's wordList)
set previousNewWord to missing value
repeat with i from 1 to (wordListCount - 8)
set newWord to character 1 of item i of o's wordList
set j to (i - 1)
repeat with k from 2 to 9
set newWord to newWord & character k of item (j + k) of o's wordList
end repeat
-- Since wordList's known to be in dictionary order, a lot of time can be saved
-- by only checking the necessary few words ahead for a match instead of
-- using AppleScript's 'is in' or 'contains' commands, which check the entire list.
if (newWord is not previousNewWord) then
repeat with j from i to wordListCount
set thisWord to item j of o's wordList
if (newWord comes after thisWord) then
else
if (newWord is thisWord) then set end of o's matches to newWord
exit repeat
end if
end repeat
set previousNewWord to newWord
end if
end repeat
return o's matches
end task
task()</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">{"applicate", "architect", "astronomy", "christine", "christoph", "committee", "composite", "constrict", "construct", "different", "extensive", "greenwood", "implement", "improvise", "intercept", "interpret", "interrupt", "philosoph", "prescript", "receptive", "telephone", "transcend", "transport", "transpose"}</syntaxhighlight>
===AppleScriptObjC===
Same output as above.
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
use scripting additions
on task()
set |⌘| to current application
set dictPath to (POSIX path of (path to desktop)) & "unixdict.txt"
set dictText to |⌘|'s class "NSString"'s stringWithContentsOfFile:(dictPath) ¬
usedEncoding:(missing value) |error|:(missing value)
set newlineSet to |⌘|'s class "NSCharacterSet"'s newlineCharacterSet()
set wordArray to dictText's componentsSeparatedByCharactersInSet:(newlineSet)
-- Lose words with fewer than 9 characters.
set filter to |⌘|'s class "NSPredicate"'s predicateWithFormat:("self MATCHES '.{9,}+'")
set relevantWords to wordArray's filteredArrayUsingPredicate:(filter)
-- Creating the new words is most easily and efficiently done with core AppleScript.
script o
property wordList : relevantWords as list
property newWords : {}
end script
repeat with i from 1 to ((count o's wordList) - 8)
set newWord to character 1 of item i of o's wordList
set j to (i - 1)
repeat with k from 2 to 9
set newWord to newWord & character k of item (j + k) of o's wordList
end repeat
set end of o's newWords to newWord
end repeat
-- But Foundation sets are good for filtering the results.
set matches to |⌘|'s class "NSMutableOrderedSet"'s orderedSetWithArray:(o's newWords)
tell matches to intersectSet:(|⌘|'s class "NSSet"'s setWithArray:(relevantWords))
return (matches's array()) as list
end task
task()</syntaxhighlight>
=={{header|Arturo}}==
{{trans|Nim}}
<syntaxhighlight lang="rebol">wordset: map read.lines relative "unixdict.txt" => strip
wordset: select wordset 'word -> 9 =< size word
lastWord: ""
newWord: " "
count: 0
loop 0..(size wordset)-9 'i [
loop 0..8 'j -> newWord\[j]: wordset\[i+j]\[j]
if and? [in? newWord wordset][lastWord <> newWord][
count: count + 1
print [(pad to :string count 3)++":" newWord]
lastWord: new newWord
]
]</syntaxhighlight>
{{out}}
<pre> 1: applicate
2: architect
3: astronomy
4: christine
5: christoph
6: committee
7: composite
8: constrict
9: construct
10: different
11: extensive
12: greenwood
13: implement
14: improvise
15: intercept
16: interpret
17: interrupt
18: philosoph
19: prescript
20: receptive
21: telephone
22: transcend
23: transport
24: transpose</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">FileRead, wList, % A_Desktop "\unixdict.txt"
for word in neighbour(wList)
result .= word (Mod(A_Index, 6) ? "`t" : "`n")
MsgBox, 262144, , % result
return
neighbour(wList){
words := [], wordExist := [], oRes := []
for i, w in StrSplit(wList, "`n", "`r")
{
if (StrLen(w) < 9)
continue
words.Push(w)
wordExist[w] := true
}
loop % words.Count()-9
{
n := A_Index
newword := ""
loop 9
newword .= SubStr(words[n+A_Index-1], A_Index, 1)
if wordExist[newword]
oRes[newword] := true
}
return oRes
}</syntaxhighlight>
{{out}}
<pre>applicate architect astronomy christine christoph committee
composite constrict construct different extensive greenwood
implement improvise intercept interpret interrupt philosoph
prescript receptive telephone transcend transport transpose</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f WORDS_FROM_NEIGHBOUR_ONES.AWK unixdict.txt
{ if (length($0) < 9) { next }
Line 47 ⟶ 385:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 76 ⟶ 414:
</pre>
=={{header|C}}==
<
#include <stdlib.h>
#include <string.h>
Line 145 ⟶ 483:
free(words);
return EXIT_SUCCESS;
}</
{{out}}
Line 176 ⟶ 514:
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <algorithm>
#include <cstdlib>
#include <fstream>
Line 184 ⟶ 521:
#include <string>
#include <vector>
int main(int argc, char** argv) {
const int min_length = 9;
Line 196 ⟶ 531:
}
std::string line;
while (getline(in, line)) {
if (line.size() >= min_length)
words.push_back(line);
}
std::sort(words.begin(), words.end());
std::string previous_word;
int count = 0;
for (size_t i = 0, n = words.size(); i + min_length <= n; ++i) {
std::string word;
word.reserve(min_length);
for (size_t
word += words[i + j][
if (previous_word == word)
continue;
auto
if (
std::cout << std::setw(2) << ++count << ". " << word << '\n';
previous_word = word;
}
return EXIT_SUCCESS;
}</
{{out}}
Line 246 ⟶ 581:
24. transpose
</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Classes}}
{{Trans|Java}}
<syntaxhighlight lang="delphi">
program Words_from_neighbour_ones;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
System.Classes;
function GetWords(minLength: Integer = 1): TStringList;
var
i: Integer;
begin
Result := TStringList.create;
Result.LoadFromFile('Unixdict.txt');
with Result do
for i := Count - 1 downto 0 do
if Strings[i].Length < minLength then
Delete(i);
Result.Sort;
end;
var
Words: TStringList;
const
minLength = 9;
begin
Words := GetWords(minLength);
var previousWord := '';
var count := 0;
var n := Words.Count;
for var i := 0 to n - minLength do
begin
var W := '';
for var j := 0 to minLength - 1 do
W := W + Words[i + j][j + 1];
if W.Equals(previousWord) then
Continue;
if Words.IndexOf(W) >= 0 then
begin
inc(count);
writeln(count: 2, '. ', W);
end;
previousWord := W;
end;
Words.Free;
readln;
end.</syntaxhighlight>
{{out}}
<pre> 1. applicate
2. architect
3. astronomy
4. christine
5. christoph
6. committee
7. composite
8. constrict
9. construct
10. different
11. extensive
12. greenwood
13. implement
14. improvise
15. intercept
16. interpret
17. interrupt
18. philosoph
19. prescript
20. receptive
21. telephone
22. transcend
23. transport
24. transpose</pre>
=={{header|F_Sharp|F#}}==
<
// Words from neighbour ones. Nigel Galloway: February 11th., 2021.
let g=[|use n=System.IO.File.OpenText("unixdict.txt") in while not n.EndOfStream do yield n.ReadLine()|]|>Array.filter(fun n->n.Length>8)
g|>Array.windowed 9|>Array.map(fun n->n|>Array.mapi(fun n g->g.[n])|>System.String)|>Array.filter(fun n-> Array.contains n g)|>Array.distinct|>Array.iter(printfn "%s")
</syntaxhighlight>
{{out}}
<pre>
Line 286 ⟶ 703:
<code><clumps></code> is the same idea except it doesn't actually store all that redundant information in memory; it's a generator that generates clumps on demand. Notice that clumps are matrices, so we can take their diagonal with <code>main-diagonal</code>.
{{works with|Factor|0.99 2020-08-14}}
<
kernel literals math math.matrices sequences sequences.extras
sets strings ;
Line 300 ⟶ 717:
[ wordset in? ] map-filter ! filter diagonals that are words
members ! remove duplicates
[ 1 + swap "%2d. %s\n" printf ] each-index ! print words formatted nicely</
{{out}}
<pre style="height:17em">
1. applicate
2. architect
3. astronomy
4. christine
5. christoph
6. committee
7. composite
8. constrict
9. construct
10. different
11. extensive
12. greenwood
13. implement
14. improvise
15. intercept
16. interpret
17. interrupt
18. philosoph
19. prescript
20. receptive
21. telephone
22. transcend
23. transport
24. transpose
</pre>
=={{header|FreeBASIC}}==
{{trans|Ring}}
<syntaxhighlight lang="freebasic">
Open "unixdict.txt" For Input As #1
Dim As String cStr, wordList()
Dim As Integer n, p = 0, posic = 0
Do While Not Eof(1)
Line Input #1, cStr
p += 1
If Len(cStr) > 8 Then
posic += 1
Redim Preserve wordList(posic)
wordList(posic) = cStr
End If
Loop
Close #1
Print p; " palabras en el archivo de diccionario: unixdict.txt"
Print Ubound(wordList); " palabras utilizables en el archivo del diccionario."
Dim As String char(1 To 9), palabra
Dim As String nextwords(Ubound(wordList))
Print !"\ntrabajando...\n"
Print !"Las nuevas palabras son:\n"
posic = 0
For n = 1 To Ubound(wordList)-8
palabra = ""
For p = 1 To 9
char(p) = Mid(wordList(n+p-1),p,1)
palabra += char(p)
Next p
For p = 1 To Ubound(wordList)
If wordList(p) = palabra Then
posic += 1
nextwords(posic) = palabra
End If
Next p
Next n
posic = 0
For n = 2 To Ubound(nextwords)
If nextwords(n) <> nextwords(n-1) Then
posic += 1
Print ""; posic; ". "; nextwords(n-1)
End If
Next n
Print !"\nterminado..."
Sleep
</syntaxhighlight>
{{out}}
<pre>
25104 palabras en el archivo de diccionario: unixdict.txt
7250 palabras utilizables en el archivo del diccionario.
trabajando...
Las nuevas palabras son:
1. applicate
2. architect
3. astronomy
4. christine
5. christoph
6. committee
7. composite
8. constrict
9. construct
10. different
11. extensive
12. greenwood
13. implement
14. improvise
15. intercept
16. interpret
17. interrupt
18. philosoph
19. prescript
20. receptive
21. telephone
22. transcend
23. transport
24. transpose
terminado...
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
#plist NSAppTransportSecurity @{NSAllowsArbitraryLoads:YES}
local fn WordList as CFArrayRef
CFURLRef url = fn URLWithString( @"http://wiki.puzzlers.org/pub/wordlists/unixdict.txt" )
CFStringRef string = lcase(fn StringWithContentsOfURL( url, NSUTF8StringEncoding, NULL )), testStr
CFArrayRef wordArr = fn StringComponentsSeparatedByString( string, @"\n" )
CFMutableArrayRef wordsToKeep = fn MutableArrayNew
for testStr in wordArr
if len(testStr) > 8 then MutableArrayAddObject( wordsToKeep, testStr )
next
end fn = fn ArrayWithArray( wordsToKeep )
local fn TestWords
CFArrayRef wordArr = fn WordList
NSInteger i = 0, j = 0, count = len( wordArr )
CFMutableStringRef mutStr = fn MutableStringNew
CFMutableArrayRef mutArr = fn MutableArrayNew
for i = 0 to count - 9
CFMutableStringRef tempMutStr = fn MutableStringNew
for j = 0 to 8
MutableStringAppendString( tempMutStr, mid( wordArr[i + j], j, 1 ) )
next
if fn ArrayContainsObject( wordArr, tempMutStr ) then MutableArrayAddObject( mutArr, fn StringWithFormat( @"%@", tempMutStr ) )
next
CFArrayRef noDuplicates = fn OrderedSetArray( fn OrderedSetWithArray( mutArr ) )
MutableStringSetString( mutStr, @"" )
for i = 0 to len(noDuplicates) - 1
MutableStringAppendString( mutStr, fn StringWithFormat( @"%2ld. %@\n", i+1, noDuplicates[i] ) )
next
printf @"%@", mutStr
end fn
fn TestWords
HandleEvents
</syntaxhighlight>
{{output}}
<pre style="height:20ex;">
1. applicate
2. architect
Line 330 ⟶ 907:
=={{header|Go}}==
<
import (
Line 376 ⟶ 953:
}
}
}</
{{out}}
Line 405 ⟶ 982:
24: transpose
</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> >(([-.-.)9 <@((=i.9)#&,])\ 9{.&>(#~ 8<#@>)) cutLF fread 'unixdict.txt'
applicate
architect
astronomy
christine
christoph
committee
composite
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
philosoph
prescript
receptive
telephone
transcend
transport
transpose</syntaxhighlight>
In other words: find the set intersection (<code>([-.-.)</code>) between words and the sequences of 9 ascending position characters (<code>9 <@((=i.9)#&,])\</code> ...) from extracting the first 9 characters (<code>9{.&></code> ...) of words with more than 8 characters (<code>(#~ 8<#@>)</code>) for words from unixdict.txt (( ... )<code>cutLF fread 'unixdict.txt'</code>)
=={{header|Java}}==
<syntaxhighlight lang="java">import java.io.*;
import java.util.*;
public class NeighbourWords {
public static void main(String[] args) {
try {
int minLength = 9;
List<String> words = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(new FileReader("unixdict.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
if (line.length() >= minLength)
words.add(line);
}
}
Collections.sort(words);
String previousWord = null;
int count = 0;
for (int i = 0, n = words.size(); i + minLength <= n; ++i) {
StringBuilder sb = new StringBuilder(minLength);
for (int j = 0; j < minLength; ++j)
sb.append(words.get(i + j).charAt(j));
String word = sb.toString();
if (word.equals(previousWord))
continue;
if (Collections.binarySearch(words, word) >= 0)
System.out.printf("%2d. %s\n", ++count, word);
previousWord = word;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}</syntaxhighlight>
{{out}}
<pre>
1. applicate
2. architect
3. astronomy
4. christine
5. christoph
6. committee
7. composite
8. constrict
9. construct
10. different
11. extensive
12. greenwood
13. implement
14. improvise
15. intercept
16. interpret
17. interrupt
18. philosoph
19. prescript
20. receptive
21. telephone
22. transcend
23. transport
24. transpose
</pre>
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">
document.write(`
<p>Choose dictionary: <input id="dict" type="file"></p>
<p>Word length: <input id="wlen" type="number" value="9"</p>
<div id="out"></div>
`);
function go(dict) {
let wordLen = parseInt(document.getElementById('wlen').value),
result = [];
dict = dict.replace(/\n|\r/g, '_');
dict = dict.replace(/__/g, ' ').split(' ');
dict = dict.filter(e => e.length >= wordLen);
for (let i = 0; i < dict.length - wordLen; i++) {
let word = dict[i][0];
for (let j = 1; j < wordLen; j++) {
word += dict[i+j][j];
}
if (dict.includes(word) && !result.includes(word)) result.push(word);
}
document.getElementById('out').innerText = result.join(', ');
}
document.getElementById('dict').onchange = function() {
let f = document.getElementById('dict').files[0],
fr = new FileReader();
fr.onload = function() { go(fr.result) }
fr.readAsText(f);
}
</syntaxhighlight>
{{out}}
<pre>
applicate, architect, astronomy, christine, christoph, committee, composite, constrict, construct, different, extensive, greenwood, implement, improvise, intercept, interpret, interrupt, philosoph, prescript, receptive, telephone, transcend, transport, transpose
</pre>
=={{header|jq}}==
For speed, this solution constructs a JSON object as a dictionary ($hash):<syntaxhighlight lang="jq">
# input: the dictionary
# $n: starting point (starting at 0)
def form_word($n):
. as $dict
| reduce range(0;9) as $i (""; . + $dict[$n+$i][$i: $i+1] );
[inputs | select(length >= 9)]
| . as $dict
| (reduce.[] as $x ({}; .[$x]=true)) as $hash
| range(0; length-9) as $i | form_word($i) | select($hash[.])</syntaxhighlight>
{{out}}
<pre>["applicate","architect","astronomy","christine","christoph","committee","committee","committee","committee","committee","composite","constrict","constrict","construct","different","extensive","greenwood","implement","improvise","intercept","interpret","interrupt","interrupt","philosoph","prescript","receptive","telephone","transcend","transcend","transport","transpose"]
</pre>
====Removing duplicates efficiently====
Using `def form_word`, we have only to modify the last line above:
<syntaxhighlight lang="jq">[inputs | select(length >= 9)]
| . as $dict
| (reduce.[] as $x ({}; .[$x]=true)) as $hash
| reduce range(0; length-9) as $i ({$hash};
($dict | form_word($i)) as $w
| if .hash[$w] then .hash[$w] = null | .words += [$w] else . end)
| .words</syntaxhighlight>
=={{header|Julia}}==
<
println("Word source: $wordfile\n")
words = filter(w -> length(w) >= len, split(read(wordfile, String), r"\s+"))
Line 421 ⟶ 1,154:
wordsfromneighbourones("unixdict.txt")
</
<pre>
Word source: unixdict.txt
Line 429 ⟶ 1,162:
interrupt philosoph prescript receptive telephone transcend transport transpose
</pre>
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
# Words from neighbour ones
# # Variables:
#
dict='/home/ostrande/prj/roscode/unixdict.txt'
integer MIN_WORD_LEN=9 TRUE=1 FALSE=0
typeset -a word newword
integer i j=0
# # Functions:
#
# # Function _buildword(arr) - build MIN_WORD_LEN word from arr eles
#
function _buildword {
typeset _arr ; nameref _arr="$1"
typeset _indx ; integer _indx=$2
typeset _i _str ; integer _i
for ((_i=0; _i<MIN_WORD_LEN; _i++)); do
_str+=${_arr[$((_indx+_i))]:${_i}:1}
done
echo "${_str}"
}
# # Function _isword(word, wordlist) - return 1 if word in wordlist
#
function _isword {
typeset _word ; _word="$1"
typeset _wordlist ; nameref _wordlist="$2"
[[ ${_word} == @(${_wordlist}) ]] && return $TRUE
return $FALSE
}
######
# main #
######
while read; do
(( ${#REPLY} >= MIN_WORD_LEN )) && word+=( $REPLY )
done < ${dict}
oldIFS="$IFS" ; IFS='|' ; words=${word[*]} ; IFS="${oldIFS}"
for ((i=0; i<${#word[*]}; i++)); do
candidate=$(_buildword word ${i})
_isword "${candidate}" words
if (( $? )); then
if [[ ${candidate} != @(${uniq%\|*}) ]]; then
print $((++j)) ${candidate}
uniq+="${candidate}|"
fi
fi
done</syntaxhighlight>
{{out}}<pre>
1 applicate
2 architect
3 astronomy
4 christine
5 christoph
6 committee
7 composite
8 constrict
9 construct
10 different
11 extensive
12 greenwood
13 implement
14 improvise
15 intercept
16 interpret
17 interrupt
18 philosoph
19 prescript
20 receptive
21 telephone
22 transcend
23 transport
24 transpose</pre>
=={{header|Lua}}==
<syntaxhighlight lang="lua">wordlist, wordhash = {}, {}
for word in io.open("unixdict.txt", "r"):lines() do
if #word >= 9 then
wordlist[#wordlist+1] = word
wordhash[word] = #wordlist
end
end
for n = 1, #wordlist-8 do
local word = ""
for i = 0, 8 do
word = word .. wordlist[n+i]:sub(i+1,i+1)
end
if wordhash[word] then
-- task appears to say "for every n, do all of the following"
-- but doesn't appear to say "..unless a duplicate"
-- so, intentionally verbose/redundant:
print(word)
end
end</syntaxhighlight>
{{out}}
<pre>applicate
architect
astronomy
christine
christoph
committee
committee
committee
committee
committee
composite
constrict
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
interrupt
philosoph
prescript
receptive
telephone
transcend
transcend
transport
transpose</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">dict = Once[Import["https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt"]];
dict //= StringSplit[#,"\n"]&;
dict //= Select[StringLength/*GreaterEqualThan[9]];
firsts9 = Characters[dict][[All,;;9]];
words = StringJoin[Diagonal[firsts9,-#]]&/@Range[0,Length[firsts9]-9];
Intersection[words,dict]</syntaxhighlight>
{{out}}
<pre>{"applicate", "architect", "astronomy", "christine", "christoph", "committee", "composite", "constrict", "construct", "different", "extensive", "greenwood", "implement", "improvise", "intercept", "interpret", "interrupt", "philosoph", "prescript", "receptive", "telephone", "transcend", "transport", "transpose"}</pre>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import sets, strutils, sugar
# Build list and set of words with length >= 9.
let words = collect(newSeq):
for word in "unixdict.txt".lines:
if word.len >= 9: word
let wordSet = words.toHashSet
var lastWord = ""
var newWord = newString(9)
var count = 0
for i in 0..words.high-9:
for j in 0..8: newWord[j] = words[i+j][j]
if newWord in wordSet:
if newWord != lastWord:
inc count
echo ($count).align(2), ' ', newWord
lastWord = newWord</syntaxhighlight>
{{out}}
<pre> 1 applicate
2 architect
3 astronomy
4 christine
5 christoph
6 committee
7 composite
8 constrict
9 construct
10 different
11 extensive
12 greenwood
13 implement
14 improvise
15 intercept
16 interpret
17 interrupt
18 philosoph
19 prescript
20 receptive
21 telephone
22 transcend
23 transport
24 transpose</pre>
=={{header|Perl}}==
<syntaxhighlight lang="perl">#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Words_from_neighbour_ones
use warnings;
@ARGV = 'unixdict.txt';
my $skew = join '', map { s/^.{9}\K.+//r } my @words = grep length() > 9, <>;
my %dict = map { $_ => 1 } grep length == 10, @words;
my %seen;
my $nextch = '.{10}(\\w)' x 8;
while( $skew =~ /^(\w)(?=$nextch)/gms )
{
my $new = join '', @{^CAPTURE}, "\n";
$dict{$new} and !$seen{$new}++ and print $new;
}</syntaxhighlight>
{{out}}
applicate
architect
astronomy
christine
christoph
committee
composite
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
philosoph
prescript
receptive
telephone
transcend
transport
transpose
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">over9</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">word</span><span style="color: #0000FF;">)>=</span><span style="color: #000000;">9</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">over9</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">slicen</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">vslice</span><span style="color: #0000FF;">(</span><span style="color: #000000;">words</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">+</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">neighwords</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">9</span><span style="color: #0000FF;">),</span><span style="color: #000000;">slicen</span><span style="color: #0000FF;">)),</span><span style="color: #008000;">"in"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">words</span><span style="color: #0000FF;">))</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d words: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">neighwords</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">neighwords</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">))})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
24 words: applicate architect astronomy ... transcend transport transpose
</pre>
=={{header|Processing}}==
<syntaxhighlight lang="processing">StringList words = new StringList(), found = new StringList();
for (String str : loadStrings("unixdict.txt")) {
if (str.length() >= 9) {
words.append(str);
}
}
for (int i = 0; i < words.size() - 9; i++) {
String temp = "";
for (int j = 0; j < 9; j++) {
temp += words.get(i + j).charAt(j);
}
if (words.hasValue(temp) && !found.hasValue(temp)) {
found.append(temp);
}
}
for (String word : found) {
println(word);
}</syntaxhighlight>
{{out}}
<pre style="height: 18em;">applicate
architect
astronomy
christine
christoph
committee
composite
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
philosoph
prescript
receptive
telephone
transcend
transport
transpose</pre>
=={{header|Python}}==
Tested on Python 3+, the file download will work only if the link is still active. It is possible that you may be able to fetch the file in your browser but download via code may still fail. Check whether you are connected to a VPN, it works on open networks.
<syntaxhighlight lang="python">
#Aamrun, 5th November 2021
import urllib.request
from collections import Counter
urllib.request.urlretrieve("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt", "unixdict.txt")
dictionary = open("unixdict.txt","r")
wordList = dictionary.read().split('\n')
dictionary.close()
filteredWords = [chosenWord for chosenWord in wordList if len(chosenWord)>=9]
for word in filteredWords[:-9]:
position = filteredWords.index(word)
newWord = "".join([filteredWords[position+i][i] for i in range(0,9)])
if newWord in filteredWords:
print(newWord)
</syntaxhighlight>
{{Output}}
Yes, there are duplicates, the task doesn't say that only unique elements should be present, hence the complete raw list will appear as below :
<pre>
applicate
architect
astronomy
christine
christoph
committee
committee
committee
committee
committee
composite
constrict
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
interrupt
philosoph
prescript
receptive
telephone
transcend
transcend
transport
transpose
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery"> [ [] swap
behead nested swap
witheach
[ over 0 peek
over = iff
drop done
nested
dip join ]
join ] is unique ( [ --> [ )
[ over find swap found ] is has ( [ x --> b )
[ [] swap 9 split drop
witheach
[ i^ peek join ] ] is diagonal ( [ --> [ )
$ "rosetta/unixdict.txt" sharefile
drop nest$
[] [] rot witheach
[ dup size 9 < iff
drop
else
[ nested join ] ]
dup temp put
dup size 8 - times
[ dup diagonal
temp share
over has iff
[ nested
swap dip join ]
else drop
behead drop ]
temp release
drop
unique
witheach
[ echo$
i^ 4 mod 3 = iff
cr else sp ]</syntaxhighlight>
{{out}}
<pre>applicate architect astronomy christine
christoph committee composite constrict
construct different extensive greenwood
implement improvise intercept interpret
interrupt philosoph prescript receptive
telephone transcend transport transpose</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
my %words_eq_9 = @words_ge_9 .grep( *.chars == 9 ).Set;
Line 452 ⟶ 1,580:
}
.say for unique @new_words;</
{{out}}
<pre>
Line 480 ⟶ 1,608:
transpose
</pre>
=={{header|REXX}}==
Line 487 ⟶ 1,614:
It also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.
<
parse arg minL iFID . /*obtain optional arguments from the CL*/
if minL=='' | minL=="," then minL= 9 /*Not specified? Then use the default.*/
Line 514 ⟶ 1,641:
end /*j*/
/*stick a fork in it, we're all done. */
say copies('─', 30) finds ' neighbor words found with a minimum length of ' minL</
{{out|output|text= when using the default inputs:}}
<pre>
Line 548 ⟶ 1,675:
=={{header|Ring}}==
<
cStr = read("unixdict.txt")
wordList = str2list(cStr)
Line 592 ⟶ 1,719:
see "done..." + nl
</syntaxhighlight>
Output:
<pre>
Line 622 ⟶ 1,749:
24. transpose
done...
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">new_word_size = 9
well_sized = File.readlines("unixdict.txt", chomp: true).reject{|word| word.size < new_word_size}
list = well_sized.each_cons(new_word_size).filter_map do |slice|
candidate = (0...new_word_size).inject(""){|res, idx| res << slice[idx][idx] }
candidate if well_sized.include?(candidate)
end
puts list.uniq
</syntaxhighlight>
{{out}}
<pre>applicate
architect
astronomy
christine
christoph
committee
composite
constrict
construct
different
extensive
greenwood
implement
improvise
intercept
interpret
interrupt
philosoph
prescript
receptive
telephone
transcend
transport
transpose
</pre>
=={{header|VBScript}}==
Run it in CScript.
<syntaxhighlight lang="vb">
with createobject("ADODB.Stream")
.charset ="UTF-8"
.open
.loadfromfile("unixdict.txt")
s=.readtext
end with
a=split (s,vblf)
set d=createobject("scripting.dictionary")
redim b(ubound(a))
i=0
for each x in a
s=trim(x)
if len(s)>=9 then
if len(s)= 9 then d.add s,""
b(i)=s
i=i+1
end if
next
redim preserve b(i-1)
wscript.echo i
j=1
for i=0 to ubound(b)-9
s9=mid(b(i+0),1,1)& mid(b(i+1),2,1)& mid(b(i+2),3,1)& mid(b(i+3),4,1)& mid(b(i+4),5,1)&_
mid(b(i+5),6,1)& mid(b(i+6),7,1)& mid(b(i+7),8,1)& mid(b(i+8),9,1)
'wscript.echo b(i), s9
if d.exists(s9) then
wscript.echo j,s9
d.remove(s9)
j=j+1
end if
next
</syntaxhighlight>
{{out}}
<pre>
1 applicate
2 architect
3 astronomy
4 christine
5 christoph
6 committee
7 composite
8 constrict
9 construct
10 different
11 extensive
12 greenwood
13 implement
14 improvise
15 intercept
16 interpret
17 interrupt
18 philosoph
19 prescript
20 receptive
21 telephone
22 transcend
23 transport
24 transpose
</pre>
=={{header|V (Vlang)}}==
{{trans|AutoHotkey}}
<syntaxhighlight lang="v (vlang)">import os
fn main() {
mut result :=''
unixdict := os.read_file('./unixdict.txt') or {panic('file not found')}
for idx, word in neighbour(unixdict) {
if ((idx + 1) % 6 == 0) == true {result += '$word \n'} else {result += '$word '}
}
println(result)
}
fn neighbour(list string) []string {
mut word_arr, mut res_arr := []string{}, []string{}
mut word_exist := map[string]bool
mut new_word :=''
for word in list.split_into_lines() {
if word.len >= 9 {
word_arr << word
word_exist[word] = true
}
}
for out_idx in 0..word_arr.len - 9 {
new_word =''
for in_idx in 0..9 {
new_word += word_arr[out_idx + in_idx].substr(in_idx, in_idx + 1)
if word_exist[new_word] == true && res_arr.any(it == new_word) == false {res_arr << new_word}
}
}
return res_arr
}</syntaxhighlight>
{{out}}
<pre>
applicate architect astronomy christine christoph committee
composite constrict construct different extensive greenwood
implement improvise intercept interpret interrupt philosoph
prescript receptive telephone transcend transport transpose
</pre>
Line 627 ⟶ 1,895:
{{libheader|Wren-sort}}
{{libheader|Wren-fmt}}
<
import "./sort" for Find
import "./fmt" for Fmt
var wordList = "unixdict.txt" // local copy
Line 643 ⟶ 1,911:
alreadyFound.add(word)
}
}</
{{out}}
Line 671 ⟶ 1,939:
23: transport
24: transpose
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">string 0; \use zero-terminated strings
int Dict(26000); \pointers to words (enough for unixdict.txt)
int DictSize; \actual number of pointers in Dict
func StrCmp(A, B); \Compare string A to B
char A, B; \Returns: >0 if A>B, =0 if A=B, and <0 if A<B
int I;
[for I:= 0 to -1>>1 do
[if A(I) # B(I) then return A(I) - B(I);
if A(I) = 0 then return 0;
];
]; \StrCmp
func LookUp(Word); \Return 'true' if Word is in Dict
char Word;
int Lo, Hi, I, Cmp;
[Lo:= 0; Hi:= DictSize-1;
loop [I:= (Lo+Hi) / 2; \binary search
Cmp:= StrCmp(Word, Dict(I));
if Cmp < 0 then Hi:= I-1 else Lo:= I+1;
if Cmp = 0 then return true;
if Lo > Hi then return false;
];
]; \LookUp
int DI, I, Ch, Count;
char Word, Neigh(10), Last(10);
def LF=$0A, CR=$0D, EOF=$1A;
[FSet(FOpen("unixdict.txt", 0), ^I); \load dictionary
OpenI(3); \assume alphabetical order and all lowercase
DI:= 0;
repeat Dict(DI):= Reserve(0); \get pointer to memory used to store Word
Word:= Dict(DI);
I:= 0;
loop [repeat Ch:= ChIn(3) until Ch # CR; \remove possible CR
if Ch=LF or Ch=EOF then quit;
Word(I):= Ch;
I:= I+1;
];
if I >= 9 then \ignore words less than 9 characters
[Word(I):= 0; \terminate Word string
I:= Reserve(I+1); \reserve memory used for Word
DI:= DI+1; \next dictionary entry
];
until Ch = EOF;
DictSize:= DI;
DI:= 0; Count:= 0; Last(0):= 0;
repeat for I:= 0 to 9-1 do \build Neigh word using letters from
[Word:= Dict(DI+I); \ following words
Neigh(I):= Word(I);
];
Neigh(9):= 0; \terminate string
if LookUp(Neigh) then \if it's a word and not already listed
if StrCmp(Neigh, Last) # 0 then
[CopyMem(Last, Neigh, 10);
Count:= Count+1;
Text(0, Neigh);
if rem(Count/8) = 0 then CrLf(0) else ChOut(0, ^ );
];
DI:= DI+1; \next word in dictionary
until DI >= DictSize-9;
CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
applicate architect astronomy christine christoph committee composite constrict
construct different extensive greenwood implement improvise intercept interpret
interrupt philosoph prescript receptive telephone transcend transport transpose
</pre>
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">
open "unixdict.txt" for reading as #1
p = 0
posic = 0
while not eof(1)
line input #1 cStr$
p = p + 1
if len(cStr$) > 8 then
posic = posic + 1
redim wordList$(posic)
wordList$(posic) = cStr$
end if
wend
close #1
print p, " palabras en el archivo de diccionario: unixdict.txt"
print arraysize(wordList$(), 1), " palabras utilizables en el archivo del diccionario."
dim char$(9)
dim nextwords$(arraysize(wordList$(), 1))
print chr$(10), "trabajando...", chr$(10)
print "Las nuevas palabras son:", chr$(10)
posic = 0
for n = 1 to arraysize(wordList$(), 1) - 8
palabra$ = ""
for p = 1 to 9
char$(p) = mid$(wordList$(n + p - 1), p, 1)
palabra$ = palabra$ + char$(p)
next p
for p = 1 to arraysize(wordList$(), 1)
if wordList$(p) = palabra$ then
posic = posic + 1
nextwords$(posic) = palabra$
end if
next p
next n
posic = 0
for n = 2 to arraysize(nextwords$(), 1)
if nextwords$(n) <> nextwords$(n - 1) then
posic = posic + 1
print "", posic, ". ", nextwords$(n - 1)
end if
next n
end
</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
| |||