Words from neighbour ones: Difference between revisions
Added Algol 68
Drkameleon (talk | contribs) (Added Arturo implementation) |
(Added Algol 68) |
||
(16 intermediate revisions by 9 users not shown) | |||
Line 29:
{{trans|Python}}
<
V filteredWords = wordList.filter(chosenWord -> chosenWord.len >= 9)
Line 37:
V newWord = (0..8).map(i -> :filteredWords[@position + i][i]).join(‘’)
I newWord C filteredWords
print(newWord)</
{{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>
Line 76 ⟶ 201:
=={{header|AppleScript}}==
===Core language===
<
-- 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 116 ⟶ 241:
end task
task()</
{{output}}
<
===AppleScriptObjC===
Same output as above.
<
use framework "Foundation"
use scripting additions
Line 159 ⟶ 284:
end task
task()</
=={{header|Arturo}}==
{{trans|Nim}}
<
wordset: select wordset 'word -> 9 =< size word
Line 177 ⟶ 302:
lastWord: new newWord
]
]</
{{out}}
Line 207 ⟶ 332:
=={{header|AutoHotkey}}==
<
for word in neighbour(wList)
result .= word (Mod(A_Index, 6) ? "`t" : "`n")
Line 232 ⟶ 357:
}
return oRes
}</
{{out}}
<pre>applicate architect astronomy christine christoph committee
Line 240 ⟶ 365:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f WORDS_FROM_NEIGHBOUR_ONES.AWK unixdict.txt
{ if (length($0) < 9) { next }
Line 260 ⟶ 385:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 289 ⟶ 414:
</pre>
=={{header|C}}==
<
#include <stdlib.h>
#include <string.h>
Line 358 ⟶ 483:
free(words);
return EXIT_SUCCESS;
}</
{{out}}
Line 389 ⟶ 514:
=={{header|C++}}==
<
#include <cstdlib>
#include <fstream>
Line 427 ⟶ 552:
}
return EXIT_SUCCESS;
}</
{{out}}
Line 460 ⟶ 585:
{{libheader| System.Classes}}
{{Trans|Java}}
<syntaxhighlight lang="delphi">
program Words_from_neighbour_ones;
Line 512 ⟶ 637:
Words.Free;
readln;
end.</
{{out}}
<pre> 1. applicate
Line 540 ⟶ 665:
=={{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 578 ⟶ 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 592 ⟶ 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">
Line 624 ⟶ 749:
=={{header|FreeBASIC}}==
{{trans|Ring}}
<
Open "unixdict.txt" For Input As #1
Dim As String cStr, wordList()
Line 674 ⟶ 799:
Print !"\nterminado..."
Sleep
</syntaxhighlight>
{{out}}
<pre>
Line 712 ⟶ 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}}==
<
import (
Line 760 ⟶ 953:
}
}
}</
{{out}}
Line 789 ⟶ 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}}==
<
import java.util.*;
Line 824 ⟶ 1,046:
}
}
}</
{{out}}
Line 855 ⟶ 1,077:
=={{header|JavaScript}}==
<
document.write(`
<p>Choose dictionary: <input id="dict" type="file"></p>
Line 884 ⟶ 1,106:
fr.readAsText(f);
}
</syntaxhighlight>
{{out}}
<pre>
Line 892 ⟶ 1,114:
=={{header|jq}}==
For speed, this solution constructs a JSON object as a dictionary ($hash):<
# input: the dictionary
# $n: starting point (starting at 0)
Line 902 ⟶ 1,124:
| . as $dict
| (reduce.[] as $x ({}; .[$x]=true)) as $hash
| range(0; length-9) as $i | form_word($i) | select($hash[.])</
{{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 909 ⟶ 1,131:
====Removing duplicates efficiently====
Using `def form_word`, we have only to modify the last line above:
<
| . as $dict
| (reduce.[] as $x ({}; .[$x]=true)) as $hash
Line 915 ⟶ 1,137:
($dict | form_word($i)) as $w
| if .hash[$w] then .hash[$w] = null | .words += [$w] else . end)
| .words</
=={{header|Julia}}==
<
println("Word source: $wordfile\n")
words = filter(w -> length(w) >= len, split(read(wordfile, String), r"\s+"))
Line 932 ⟶ 1,154:
wordsfromneighbourones("unixdict.txt")
</
<pre>
Word source: unixdict.txt
Line 942 ⟶ 1,164:
=={{header|Ksh}}==
<
#!/bin/ksh
Line 998 ⟶ 1,220:
fi
fi
done</
{{out}}<pre>
1 applicate
Line 1,026 ⟶ 1,248:
=={{header|Lua}}==
<
for word in io.open("unixdict.txt", "r"):lines() do
if #word >= 9 then
Line 1,044 ⟶ 1,266:
print(word)
end
end</
{{out}}
<pre>applicate
Line 1,079 ⟶ 1,301:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
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]</
{{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}}==
<
# Build list and set of words with length >= 9.
Line 1,106 ⟶ 1,328:
inc count
echo ($count).align(2), ' ', newWord
lastWord = newWord</
{{out}}
Line 1,135 ⟶ 1,357:
=={{header|Perl}}==
<
use strict; # https://rosettacode.org/wiki/Words_from_neighbour_ones
Line 1,149 ⟶ 1,371:
my $new = join '', @{^CAPTURE}, "\n";
$dict{$new} and !$seen{$new}++ and print $new;
}</
{{out}}
applicate
Line 1,177 ⟶ 1,399:
=={{header|Phix}}==
<!--<
<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 1,184 ⟶ 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>
<!--</
{{out}}
<pre>
Line 1,191 ⟶ 1,413:
=={{header|Processing}}==
<
for (String str : loadStrings("unixdict.txt")) {
if (str.length() >= 9) {
Line 1,208 ⟶ 1,430:
for (String word : found) {
println(word);
}</
{{out}}
<pre style="height: 18em;">applicate
Line 1,238 ⟶ 1,460:
=={{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
Line 1,259 ⟶ 1,481:
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 :
Line 1,295 ⟶ 1,517:
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 1,306 ⟶ 1,580:
}
.say for unique @new_words;</
{{out}}
<pre>
Line 1,340 ⟶ 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 1,367 ⟶ 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 1,401 ⟶ 1,675:
=={{header|Ring}}==
<
cStr = read("unixdict.txt")
wordList = str2list(cStr)
Line 1,445 ⟶ 1,719:
see "done..." + nl
</syntaxhighlight>
Output:
<pre>
Line 1,475 ⟶ 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,480 ⟶ 1,895:
{{libheader|Wren-sort}}
{{libheader|Wren-fmt}}
<
import "./sort" for Find
import "./fmt" for Fmt
var wordList = "unixdict.txt" // local copy
Line 1,496 ⟶ 1,911:
alreadyFound.add(word)
}
}</
{{out}}
Line 1,527 ⟶ 1,942:
=={{header|XPL0}}==
<
int Dict(26000); \pointers to words (enough for unixdict.txt)
int DictSize; \actual number of pointers in Dict
Line 1,591 ⟶ 2,006:
until DI >= DictSize-9;
CrLf(0);
]</
{{out}}
Line 1,602 ⟶ 2,017:
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<
open "unixdict.txt" for reading as #1
p = 0
Line 1,651 ⟶ 2,066:
next n
end
</syntaxhighlight>
{{out}}
<pre>
|