Alternade words: Difference between revisions

{{trans|Nim}}

 

V r = [‘’, ‘’]

L(c) word

L(line) result

V i = L.index

 

{{out}}

 

=={{header|Ada}}==

with Ada.Containers.Indefinite_Ordered_Maps;

 

end;

end loop;

{{out}}

<pre style="height: 45ex">accost acs cot

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

# use the associative array in the Associate array/iteration task #

PR read "aArray.a68" PR

OD

FI

{{out}}

Note - the alternade words as output by this program are not sorted, the output shown here has been sorted for ease of comparison with the output of the other samples.

{{works with|Dyalog APL}}

 

⍺←6

parts←{(⊂k/⍵),⊂(~k←2|⍳≢⍵)/⍵}

long←(⍺≤≢¨words)/words

↑(⊂,parts)¨(∧/∘check∘parts¨long)/long

 

{{out}}

=={{header|AppleScript}}==

 

Now takes the number of subwords per alternade as a parameter.

Extracted texts are validated against the words in the input list.

set wordList to words of (read wordFile as «class utf8»)

-- Return two-word alternades of 6 or more characters. Result in text form.

 

{{output}}

Another example call:

 

 

{{output}}

 

=={{header|Arturo}}==

 

loop words 'word [

if and? [contains? words alt1][contains? words alt2] ->

print [word "=>" alt1 alt2]

 

{{out}}

 

=={{header|AutoHotkey}}==

words := [], sixWords := []

 

result .= w "`t-> " w1 " " w2 "`n"

}

{{out}}

<pre style="height: 45ex">accost -> acs cot

 

=={{header|AWK}}==

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

#

exit(0)

}

{{out}}

<pre>

=={{header|C}}==

 

#include <string.h>

#include <stdlib.h>

scan_trie(root, check_alternade);

return 0;

 

{{out}}

 

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

#include <fstream>

#include <iomanip>

}

return EXIT_SUCCESS;

 

{{out}}

 

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

// Alternade words: Nigel Galloway. June 10th., 2021

let dict=seq{use n=System.IO.File.OpenText("unixdict.txt") in while not n.EndOfStream do yield n.ReadLine()}|>Seq.filter(fun n->n.Length>2)|>List.ofSeq

let fG(n,g)=let fN g=(Array.ofList>>System.String) g in let n,g=fN n,fN g in if List.contains n dict && List.contains g dict then Some(n,g) else None

dict|>Seq.filter(fun n->n.Length>5)|>Seq.iter(fun n->match (fN>>fG) n with Some(g,l)->printfn "%s -> %s * %s" n g l |_->())

{{out}}

<pre>

</pre>

=={{header|Factor}}==

math sequences sequences.extras sets strings ;

 

[ alternade? ] filter

[ length 5 > ] filter

{{out}}

<pre style="height: 45ex">

 

=={{header|FreeBASIC}}==

 

function is_in(word() as string, s as string) as boolean

next j

if is_in(word(), alt(0)) and is_in(word(), alt(1)) then print word(i), alt(1), alt(0)

{{out}}<pre>

accost acs cot

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

 

=={{header|Haskell}}==

import qualified Data.Text as T

import qualified Data.Text.IO as TIO

in T.unlines $ map alterShow $ alternades dict $ filter longEnough words'

where longEnough = (>= 6) . T.length

{{out}}

<pre>

=={{header|J}}==

 

alts=: <@deb"1@|:@(_2]\])@> ref=: (#~ 5<#@>) words

;:inv (ref,.alts) #~ alts */@e."1 words

troupe top rue

truant tun rat

 

=={{header|Java}}==

import java.util.*;

 

}

}

 

{{out}}

 

Note: For gojq, change `keys_unsorted` to `keys`. The results are unaffected.

# if the input is an alternade word relative to the keys of $dict,

# then emit [$even, $odd], else false.

| (select(.) // empty)

| "\($w) → \(.[0]) \(.[1])"

Invocation: jq -n -rR -f alternade-words.jq unixdict.txt

{{out}}

 

=={{header|Julia}}==

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

words = split(read(wordfile, String), r"\s+")

foreachword("unixdict.txt", isalternade, minlen = 6, numcols=1)

 

<pre>

Word source: unixdict.txt

 

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

dic = StringSplit[dic, "\n"];

largerthansix = Select[dic, StringLength /* GreaterEqualThan[6]];

]

all = DeleteCases[Table[AlternadeQ[w, smallerthansix], {w, largerthansix}], {}];

{{out}}

<pre>accost->{acs,cot}

 

=={{header|Nim}}==

 

proc alternatingWords(word: string): array[2, string] =

result.add word.align(8) & " → $1 $2" % altWords

result.sort()

 

{{out}}

 

=={{header|Perl}}==

 

use strict;

my $odd = s/.(.?)/$1/gr;

$words{$even} && $words{$odd} and print "$_ => [ $even $odd ]\n";

 

=={{header|Phix}}==

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

<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"alternade words found"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),{</span><span style="color: #004600;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>

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

{{out}}

<pre>

=={{header|Picat}}==

{{works with|Picat}}

split_word(Word) = Words =>

N = len(Word),

end,

close(Reader).

{{out}}

<pre style="height: 45ex">

=={{header|Prolog}}==

{{works with|SWI Prolog}}

 

main:-

odd_even_chars([Ch], [Ch], []):-!.

odd_even_chars([Ch1, Ch2|Chars], [Ch1|Chars1], [Ch2|Chars2]):-

 

{{out}}

=={{header|Python}}==

 

MINLEN = 6

 

odd = word[1::2]

if even in words and odd in words:

 

{{out}}

=={{header|Quackery}}==

 

protect sift.test

 

else [ drop 2drop ] ]

 

{{out}}

A more straightforward approach:

 

 

[ $ "rosetta/unixdict.txt" sharefile

echo$ cr ]

else drop ]

 

{{out}}

=={{header|Raku}}==

 

 

my %words = $file.IO.slurp.words.map: * => 1;

.say for @alternades > 10

?? (flat @alternades.head(5), '...', @alternades.tail(5))

{{out}}

<pre>58 alternades longer than 5 characters found in unixdict.txt:

 

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= 6 /*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>

 

Independently developed at the same time as version 1 :-)

fid='d:\unix.txt'

cnt.=0 /* cnt.n -> words of length n */

s.v=s.v||vv

End

Output:

<pre>D:\>rexx alternade

 

=={{header|Ring}}==

load "stdlib.ring"

 

next

see "done..." + nl

Output:

<pre>

 

=={{header|Ruby}}==

 

res = words.filter_map do |word|

 

puts res

{{out}}

<pre style="height: 30ex">accost: acs, cot

 

=={{header|Rust}}==

use std::fs::File;

use std::io::{self, BufRead};

Err(error) => eprintln!("{}", error),

}

 

{{out}}

 

=={{header|Swift}}==

 

func loadDictionary(_ path: String) throws -> Set<String> {

} catch {

print(error.localizedDescription)

 

{{out}}

 

=={{header|Tcl}}==

foreach word [read [open unixdict.txt]] {

dict set unixdict $word {}

puts "$word $oddeven"

}

{{out}}

<pre>$ tclsh alternate_words.tcl | column -t

=={{header|Vlang}}==

{{trans|go}}

 

fn main() {

}

}

{{out}}

<pre>Same as Go entry</pre>

{{libheader|Wren-set}}

{{libheader|Wren-fmt}}

import "/set" for Set

import "/fmt" for Fmt

}

}

 

{{out}}

 

=={{header|XPL0}}==

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

int DictSize; \actual number of pointers in Dict

DI:= DI+1;

until DI >= DictSize;

 

{{out}}