Words from neighbour ones: Difference between revisions

{{trans|Python}}

V filteredWords = wordList.filter(chosenWord -> chosenWord.len >= 9)

V newWord = (0..8).map(i -> :filteredWords[@position + i][i]).join(‘’)

I newWord C filteredWords

{{out}}

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

end task

{{output}}

===AppleScriptObjC===

Same output as above.

use framework "Foundation"

use scripting additions

end task

=={{header|Arturo}}==

{{trans|Nim}}

wordset: select wordset 'word -> 9 =< size word

lastWord: new newWord

]

{{out}}

=={{header|AutoHotkey}}==

for word in neighbour(wList)

result .= word (Mod(A_Index, 6) ? "`t" : "`n")

}

return oRes

{{out}}

<pre>applicate architect astronomy christine christoph committee

=={{header|AWK}}==

# syntax: GAWK -f WORDS_FROM_NEIGHBOUR_ONES.AWK unixdict.txt

{ if (length($0) < 9) { next }

exit(0)

}

{{out}}

<pre>

</pre>

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

free(words);

return EXIT_SUCCESS;

{{out}}

=={{header|C++}}==

#include <cstdlib>

#include <fstream>

}

return EXIT_SUCCESS;

{{out}}

{{libheader| System.Classes}}

{{Trans|Java}}

program Words_from_neighbour_ones;

Words.Free;

readln;

{{out}}

<pre> 1. applicate

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

{{out}}

<pre>

<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 ;

[ wordset in? ] map-filter ! filter diagonals that are words

members ! remove duplicates

{{out}}

<pre style="height:17em">

=={{header|FreeBASIC}}==

{{trans|Ring}}

Open "unixdict.txt" For Input As #1

Dim As String cStr, wordList()

Print !"\nterminado..."

Sleep

{{out}}

<pre>

=={{header|Go}}==

import (

}

}

{{out}}

=={{header|J}}==

applicate

architect

transcend

transport

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.*;

}

}

{{out}}

=={{header|JavaScript}}==

document.write(`

<p>Choose dictionary: <input id="dict" type="file"></p>

fr.readAsText(f);

}

{{out}}

<pre>

=={{header|jq}}==

# input: the dictionary

# $n: starting point (starting at 0)

| . as $dict

| (reduce.[] as $x ({}; .[$x]=true)) as $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"]

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

($dict | form_word($i)) as $w

| if .hash[$w] then .hash[$w] = null | .words += [$w] else . end)

=={{header|Julia}}==

println("Word source: $wordfile\n")

words = filter(w -> length(w) >= len, split(read(wordfile, String), r"\s+"))

wordsfromneighbourones("unixdict.txt")

<pre>

Word source: unixdict.txt

=={{header|Ksh}}==

#!/bin/ksh

fi

fi

{{out}}<pre>

1 applicate

=={{header|Lua}}==

for word in io.open("unixdict.txt", "r"):lines() do

if #word >= 9 then

print(word)

end

{{out}}

<pre>applicate

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

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

inc count

echo ($count).align(2), ' ', newWord

{{out}}

=={{header|Perl}}==

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

my $new = join '', @{^CAPTURE}, "\n";

$dict{$new} and !$seen{$new}++ and print $new;

{{out}}

applicate

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

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

=={{header|Processing}}==

for (String str : loadStrings("unixdict.txt")) {

if (str.length() >= 9) {

for (String word : found) {

println(word);

{{out}}

<pre style="height: 18em;">applicate

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

#Aamrun, 5th November 2021

if newWord in filteredWords:

print(newWord)

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

=={{header|Raku}}==

my %words_eq_9 = @words_ge_9 .grep( *.chars == 9 ).Set;

}

{{out}}

<pre>

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.*/

end /*j*/

/*stick a fork in it, we're all done. */

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

<pre>

=={{header|Ring}}==

cStr = read("unixdict.txt")

wordList = str2list(cStr)

see "done..." + nl

Output:

<pre>

=={{header|VBScript}}==

Run it in CScript.

with createobject("ADODB.Stream")

.charset ="UTF-8"

next

{{out}}

<pre>

=={{header|Vlang}}==

{{trans|AutoHotkey}}

fn main() {

}

return res_arr

{{out}}

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

import "/sort" for Find

import "/fmt" for Fmt

alreadyFound.add(word)

}

{{out}}

=={{header|XPL0}}==

int Dict(26000); \pointers to words (enough for unixdict.txt)

int DictSize; \actual number of pointers in Dict

until DI >= DictSize-9;

CrLf(0);

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

open "unixdict.txt" for reading as #1

p = 0

next n

end

{{out}}

<pre>