Rosetta Code

Words from neighbour ones: Difference between revisions

Page Discussion

Words from neighbour ones (view source)

Revision as of 18:49, 18 February 2024

19,669 bytes added ,  2 months ago
Added Algol 68
(Added Algol 68)
 
(24 intermediate revisions by 15 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===
<langsyntaxhighlight 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.
Line 68 ⟶ 241:
end task
 
task()</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight 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"}</langsyntaxhighlight>
 
===AppleScriptObjC===
Same output as above.
<langsyntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
use scripting additions
Line 111 ⟶ 284:
end task
 
task()</langsyntaxhighlight>
 
=={{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">
<lang AWK>
# syntax: GAWK -f WORDS_FROM_NEIGHBOUR_ONES.AWK unixdict.txt
{ if (length($0) < 9) { next }
Line 134 ⟶ 385:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 163 ⟶ 414:
</pre>
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Line 232 ⟶ 483:
free(words);
return EXIT_SUCCESS;
}</langsyntaxhighlight>
 
{{out}}
Line 263 ⟶ 514:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <algorithm>
#include <cstdlib>
#include <fstream>
Line 301 ⟶ 552:
}
return EXIT_SUCCESS;
}</langsyntaxhighlight>
 
{{out}}
Line 334 ⟶ 585:
{{libheader| System.Classes}}
{{Trans|Java}}
<syntaxhighlight lang="delphi">
<lang Delphi>
program Words_from_neighbour_ones;
 
Line 386 ⟶ 637:
Words.Free;
readln;
end.</langsyntaxhighlight>
{{out}}
<pre> 1. applicate
Line 414 ⟶ 665:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// 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>
</lang>
{{out}}
<pre>
Line 452 ⟶ 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}}
<langsyntaxhighlight lang="factor">USING: formatting grouping hash-sets io.encodings.ascii io.files
kernel literals math math.matrices sequences sequences.extras
sets strings ;
Line 466 ⟶ 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</langsyntaxhighlight>
{{out}}
<pre style="height:17em">
Line 498 ⟶ 749:
=={{header|FreeBASIC}}==
{{trans|Ring}}
<langsyntaxhighlight lang="freebasic">
Open "unixdict.txt" For Input As #1
Dim As String cStr, wordList()
Line 548 ⟶ 799:
Print !"\nterminado..."
Sleep
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 586 ⟶ 837:
</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
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|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 634 ⟶ 953:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 663 ⟶ 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}}==
<langsyntaxhighlight lang="java">import java.io.*;
import java.util.*;
 
Line 698 ⟶ 1,046:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 729 ⟶ 1,077:
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">
document.write(`
<p>Choose dictionary: <input id="dict" type="file"></p>
Line 758 ⟶ 1,106:
fr.readAsText(f);
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 766 ⟶ 1,114:
=={{header|jq}}==
 
For speed, this solution constructs a JSON object as a dictionary ($hash):<langsyntaxhighlight lang="jq">
# input: the dictionary
# $n: starting point (starting at 0)
Line 776 ⟶ 1,124:
| . as $dict
| (reduce.[] as $x ({}; .[$x]=true)) as $hash
| range(0; length-9) as $i | form_word($i) | select($hash[.])</langsyntaxhighlight>
{{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"]
Line 783 ⟶ 1,131:
====Removing duplicates efficiently====
Using `def form_word`, we have only to modify the last line above:
<langsyntaxhighlight lang="jq">[inputs | select(length >= 9)]
| . as $dict
| (reduce.[] as $x ({}; .[$x]=true)) as $hash
Line 789 ⟶ 1,137:
($dict | form_word($i)) as $w
| if .hash[$w] then .hash[$w] = null | .words += [$w] else . end)
| .words</langsyntaxhighlight>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">function wordsfromneighbourones(wordfile::String, len = 9, colwidth = 11, numcols = 8)
println("Word source: $wordfile\n")
words = filter(w -> length(w) >= len, split(read(wordfile, String), r"\s+"))
Line 806 ⟶ 1,154:
 
wordsfromneighbourones("unixdict.txt")
</langsyntaxhighlight>{{out}}
<pre>
Word source: unixdict.txt
Line 814 ⟶ 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}}==
<langsyntaxhighlight lang="lua">wordlist, wordhash = {}, {}
for word in io.open("unixdict.txt", "r"):lines() do
if #word >= 9 then
Line 834 ⟶ 1,266:
print(word)
end
end</langsyntaxhighlight>
{{out}}
<pre>applicate
Line 869 ⟶ 1,301:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="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]</langsyntaxhighlight>
{{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}}==
<langsyntaxhighlight Nimlang="nim">import sets, strutils, sugar
 
# Build list and set of words with length >= 9.
Line 896 ⟶ 1,328:
inc count
echo ($count).align(2), ' ', newWord
lastWord = newWord</langsyntaxhighlight>
 
{{out}}
Line 925 ⟶ 1,357:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Words_from_neighbour_ones
Line 939 ⟶ 1,371:
my $new = join '', @{^CAPTURE}, "\n";
$dict{$new} and !$seen{$new}++ and print $new;
}</langsyntaxhighlight>
{{out}}
applicate
Line 967 ⟶ 1,399:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="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>
Line 974 ⟶ 1,406:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 981 ⟶ 1,413:
 
=={{header|Processing}}==
<langsyntaxhighlight Processinglang="processing">StringList words = new StringList(), found = new StringList();
for (String str : loadStrings("unixdict.txt")) {
if (str.length() >= 9) {
Line 998 ⟶ 1,430:
for (String word : found) {
println(word);
}</langsyntaxhighlight>
{{out}}
<pre style="height: 18em;">applicate
Line 1,024 ⟶ 1,456:
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" perl6line>my @words_ge_9 = 'unixdict.txt'.IO.lines.grep( *.chars >= 9 );
my %words_eq_9 = @words_ge_9 .grep( *.chars == 9 ).Set;
 
Line 1,035 ⟶ 1,580:
}
 
.say for unique @new_words;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,063 ⟶ 1,608:
transpose
</pre>
 
 
=={{header|REXX}}==
Line 1,070 ⟶ 1,614:
 
It also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.
<langsyntaxhighlight lang="rexx">/*REXX pgm finds words that're composed from neighbor words (within an identified dict).*/
parse arg minL iFID . /*obtain optional arguments from the CL*/
if minL=='' | minL=="," then minL= 9 /*Not specified? Then use the default.*/
Line 1,097 ⟶ 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</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,131 ⟶ 1,675:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
cStr = read("unixdict.txt")
wordList = str2list(cStr)
Line 1,175 ⟶ 1,719:
 
see "done..." + nl
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,205 ⟶ 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 1,210 ⟶ 1,895:
{{libheader|Wren-sort}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "io" for File
import "./sort" for Find
import "./fmt" for Fmt
 
var wordList = "unixdict.txt" // local copy
Line 1,226 ⟶ 1,911:
alreadyFound.add(word)
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,254 ⟶ 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}}
<langsyntaxhighlight lang="yabasic">
open "unixdict.txt" for reading as #1
p = 0
Line 1,307 ⟶ 2,066:
next n
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Tigerofdarkness
3,021

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/307569...354537"