An alternade is a word whose alternating letters themselves form two words.

Alternade words is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page. [[Category:]]


Example

The word lounge contains the word lug (lounge) and the word one (lounge).

For a word to be an alternade, all its letters must be used.

The two words that form an alternade don't need to be the same length; for example, the word board is an alternade made up of the words bad (board) and or (board).


Task

Print out every alternade in unixdict.txt whose length is 6 or greater, also showing both the words that make up the alternade.


See also


Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences



11l

Translation of: Nim
F alternating_words(word)
   V r = [‘’, ‘’]
   L(c) word
      r[L.index [&] 1] ‘’= c
   R r

V words = Set(File(‘unixdict.txt’).read().split("\n"))

[String] result
L(word) words
   I word.len >= 6
      V alt_words = alternating_words(word)
      I alt_words[0] C words & alt_words[1] C words
         result.append(word.rjust(8)‘ → ’alt_words[0]‘ ’alt_words[1])
result.sort()
L(line) result
   V i = L.index
   print((‘#2:’.format(i + 1))‘ ’line)
Output:
 1:   accost → acs cot
 2:   accuse → acs cue
 3:   afield → ail fed
 4:   agleam → ala gem
 5:   alcott → act lot
 6:   allele → all lee
 7:   allied → ale lid
 8:   alpert → apr let
 9:   apport → apr pot
10:   assist → ass sit
11:   battle → btl ate
12:   blaine → ban lie
13:   brenda → bed rna
14:   choose → cos hoe
15:   choosy → cos hoy
16:   claire → car lie
17:   effete → eft fee
18:   fabric → fbi arc
19:   fealty → fat ely
20:   fluent → fun let
21:   friend → fin red
22:   george → gog ere
23:   inroad → ira nod
24:   israel → ire sal
25:   jaunty → jut any
26:   joanne → jan one
27:   lounge → lug one
28:   oriole → oil roe
29:   oswald → owl sad
30:   parrot → pro art
31:   peoria → poi era
32:   pierre → per ire
33:   poodle → pol ode
34:   pounce → puc one
35:   racial → rca ail
36:   realty → rat ely
37:   sordid → sri odd
38:   sprain → sri pan
39:   strain → sri tan
40:   strait → sri tat
41:   sturdy → sud try
42:   sweaty → set way
43:   tattle → ttl ate
44:   though → tog huh
45:   triode → tid roe
46:   triune → tin rue
47:   troupe → top rue
48:   truant → tun rat
49:   twirly → til wry
50:  ambient → abet min
51:  annette → ante net
52:  ariadne → aide ran
53:  collude → clue old
54:  forwent → fret own
55:  spatial → sail pta
56:  theorem → term hoe
57:  throaty → tray hot
58: calliope → clip aloe

Ada

with Ada.Text_Io;
with Ada.Containers.Indefinite_Ordered_Maps;

procedure Alternade_Words is
   use Ada.Text_Io;

   package String_Maps is
     new Ada.Containers.Indefinite_Ordered_Maps (Key_Type     => String,
                                                 Element_Type => String);

   function Get_Odd (Word : String) return String is
      Odd : String (1 .. (Word'Length + 1) / 2);
   begin
      for Index in Odd'Range loop
         Odd (Index) := Word (1 + 2 * (Index - 1));
      end loop;
      return Odd;
   end Get_Odd;

   function Get_Even (Word : String) return String is
      Even : String (1 .. Word'Length / 2);
   begin
      for Index in Even'Range loop
         Even (Index) := Word (1 + 1 + 2 * (Index - 1));
      end loop;
      return Even;
   end Get_Even;

   Filename : constant String := "unixdict.txt";
   Words    : String_Maps.Map;
   File     : File_Type;
begin
   Open (File, In_File, Filename);
   while not End_Of_File (File) loop
      declare
         Word : constant String := Get_Line (File);
      begin
         Words.Insert (Word, Word);
      end;
   end loop;
   Close (File);

   for Word of Words loop
      declare
         Odd  : constant String := Get_Odd  (Word);
         Even : constant String := Get_Even (Word);
      begin
         if
           Word'Length >= 6       and then
             Words.Contains (Odd) and then
             Words.Contains (Even)
         then
            Put (Word);
            Set_Col (15); Put (Odd);
            Set_Col (25); Put (Even);
            New_Line;
         end if;
      end;
   end loop;
end Alternade_Words;
Output:
accost        acs       cot
accuse        acs       cue
afield        ail       fed
agleam        ala       gem
alcott        act       lot
allele        all       lee
allied        ale       lid
alpert        apr       let
ambient       abet      min
annette       ante      net
apport        apr       pot
ariadne       aide      ran
assist        ass       sit
battle        btl       ate
blaine        ban       lie
brenda        bed       rna
calliope      clip      aloe
choose        cos       hoe
choosy        cos       hoy
claire        car       lie
collude       clue      old
effete        eft       fee
fabric        fbi       arc
fealty        fat       ely
fluent        fun       let
forwent       fret      own
friend        fin       red
george        gog       ere
inroad        ira       nod
israel        ire       sal
jaunty        jut       any
joanne        jan       one
lounge        lug       one
oriole        oil       roe
oswald        owl       sad
parrot        pro       art
peoria        poi       era
pierre        per       ire
poodle        pol       ode
pounce        puc       one
racial        rca       ail
realty        rat       ely
sordid        sri       odd
spatial       sail      pta
sprain        sri       pan
strain        sri       tan
strait        sri       tat
sturdy        sud       try
sweaty        set       way
tattle        ttl       ate
theorem       term      hoe
though        tog       huh
throaty       tray      hot
triode        tid       roe
triune        tin       rue
troupe        top       rue
truant        tun       rat
twirly        til       wry

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32
# find alternade words in a list of words                            #
# use the associative array in the Associate array/iteration task    #
PR read "aArray.a68" PR
# read the list of words and store the words in an associative array #
# check for alternades                                               #
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 #
    on logical file end( input file, ( REF FILE f )BOOL:
                                     BEGIN
                                         # note that we reached EOF on the #
                                         # latest read #
                                         at eof := TRUE;
                                         # return TRUE so processing can continue #
                                         TRUE
                                     END
                       );
    # returns w split into n parts by taking alternate characters    #
    PRIO SPLIT = 1;
    OP   SPLIT = ( STRING w, INT n )[]STRING:
         BEGIN
            [ n ]STRING result;
            FOR r pos FROM LWB result TO UPB result DO result[ r pos ] := "" OD;
            INT r pos := 1;
            FOR w pos FROM LWB w TO UPB w DO
                result[ r pos ] +:= w[ w pos ];
                r pos +:= 1;
                IF r pos > n THEN r pos := 1 FI
            OD;
            result
         END; # SPLIT #
    # build an associative array of the words                        #
    REF AARRAY words := INIT LOC AARRAY;
    WHILE STRING word;
          get( input file, ( word, newline ) );
          NOT at eof
    DO
        words // word := word
    OD;
    close( input file );
    # find the alternades by traversing the array - note this will   #
    # not find the words in sorted order                             #
    REF AAELEMENT e := FIRST words;
    WHILE e ISNT nil element DO
        IF STRING word = key OF e;
           INT w len = ( UPB word + 1 ) - LWB word;
           w len >= 6
        THEN
            # the word is at least 6 characters long                 #
            []STRING sub word = word SPLIT 2;
            IF  ( words CONTAINSKEY sub word[ 1 ] )
            AND ( words CONTAINSKEY sub word[ 2 ] )
            THEN
                # the word is an alternade                           #
                print( ( word, ": " ) );
                FROM w len + 1 TO 18 DO print( ( " " ) ) OD;
                print( ( sub word[ 1 ], ", ", sub word[ 2 ], newline ) )
            FI
        FI;
        e := NEXT words
    OD
FI
Output:

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.

accost:             acs, cot
accuse:             acs, cue
afield:             ail, fed
agleam:             ala, gem
alcott:             act, lot
allele:             all, lee
allied:             ale, lid
alpert:             apr, let
ambient:            abet, min
annette:            ante, net
apport:             apr, pot
ariadne:            aide, ran
assist:             ass, sit
battle:             btl, ate
blaine:             ban, lie
brenda:             bed, rna
calliope:           clip, aloe
choose:             cos, hoe
choosy:             cos, hoy
claire:             car, lie
collude:            clue, old
effete:             eft, fee
fabric:             fbi, arc
fealty:             fat, ely
fluent:             fun, let
forwent:            fret, own
friend:             fin, red
george:             gog, ere
inroad:             ira, nod
israel:             ire, sal
jaunty:             jut, any
joanne:             jan, one
lounge:             lug, one
oriole:             oil, roe
oswald:             owl, sad
parrot:             pro, art
peoria:             poi, era
pierre:             per, ire
poodle:             pol, ode
pounce:             puc, one
racial:             rca, ail
realty:             rat, ely
sordid:             sri, odd
spatial:            sail, pta
sprain:             sri, pan
strain:             sri, tan
strait:             sri, tat
sturdy:             sud, try
sweaty:             set, way
tattle:             ttl, ate
theorem:            term, hoe
though:             tog, huh
throaty:            tray, hot
triode:             tid, roe
triune:             tin, rue
troupe:             top, rue
truant:             tun, rat
twirly:             til, wry

APL

Works with: Dyalog APL
alternade{
    6  
    parts{(k/),⊂(~k2|⍳≢)/}
    check(words(~words⎕TC)words⎕NGET) 
    long(≤≢¨words)/words
    (⊂,parts)¨(/∘checkparts¨long)/long
}
Output:
      alternade'p:\test\unixdict.txt'
 accost    acs   cot  
 accuse    acs   cue  
 afield    ail   fed  
 agleam    ala   gem  
 alcott    act   lot  
 allele    all   lee  
 allied    ale   lid  
 alpert    apr   let  
 ambient   abet  min  
 annette   ante  net  
 apport    apr   pot  
 ariadne   aide  ran  
 assist    ass   sit  
 battle    btl   ate  
 blaine    ban   lie  
 brenda    bed   rna  
 calliope  clip  aloe 
 choose    cos   hoe  
 choosy    cos   hoy  
 claire    car   lie  
 collude   clue  old  
 effete    eft   fee  
 fabric    fbi   arc  
 fealty    fat   ely  
 fluent    fun   let  
 forwent   fret  own  
 friend    fin   red  
 george    gog   ere  
 inroad    ira   nod  
 israel    ire   sal  
 jaunty    jut   any  
 joanne    jan   one  
 lounge    lug   one  
 oriole    oil   roe  
 oswald    owl   sad  
 parrot    pro   art  
 peoria    poi   era  
 pierre    per   ire  
 poodle    pol   ode  
 pounce    puc   one  
 racial    rca   ail  
 realty    rat   ely  
 sordid    sri   odd  
 spatial   sail  pta  
 sprain    sri   pan  
 strain    sri   tan  
 strait    sri   tat  
 sturdy    sud   try  
 sweaty    set   way  
 tattle    ttl   ate  
 theorem   term  hoe  
 though    tog   huh  
 throaty   tray  hot  
 triode    tid   roe  
 triune    tin   rue  
 troupe    top   rue  
 truant    tun   rat  
 twirly    til   wry  

AppleScript

use AppleScript version "2.3.1" -- OS X 10.9 (Mavericks) or later
use sorter : script ¬
    "Custom Iterative Ternary Merge Sort" --<www.macscripter.net/t/timsort-and-nigsort/71383/3>
use scripting additions

on binarySearch(v, theList, l, r)
    script o
        property lst : theList
    end script
    
    repeat until (l = r)
        set m to (l + r) div 2
        if (o's lst's item m < v) then
            set l to m + 1
        else
            set r to m
        end if
    end repeat
    if (o's lst's item l = v) then return l
    return 0
end binarySearch

on join(lst, delim)
    set astid to AppleScript's text item delimiters
    set AppleScript's text item delimiters to delim
    set txt to lst as text
    set AppleScript's text item delimiters to astid
    return txt
end join

on alternades(inputList, subsPerAlternade, minAlternadeLen, outputType)
    script o
        property wordList : inputList's items
        property searchRanges : {}
        property output : {}
        
        -- Custom comparison handler for the sort.
        on isGreater(a, b)
            set lenA to a's length
            set lenB to b's length
            if (lenA = lenB) then return (a > b)
            return (lenA > lenB)
        end isGreater
        
        on finish()
            if (outputType is text) then set output to join(output, linefeed)
            return output
        end finish
    end script
    
    set wordCount to (count o's wordList)
    if (wordCount  subsPerAlternade) then return o's finish()
    -- Sort the word list ascending by length, lexically within lengths.
    tell sorter to sort(o's wordList, 1, wordCount, {comparer:o})
    -- Deduce the maximum possible "subword" length from the length of the longest word.
    set maxWordLen to o's wordList's end's length
    if (maxWordLen < minAlternadeLen) then return o's finish()
    set maxSubLen to (maxWordLen + subsPerAlternade - 1) div subsPerAlternade
    -- Give the searchRanges list that many slots.
    repeat maxSubLen times
        set end of o's searchRanges to missing value
    end repeat
    -- For each word length in wordlist that's suitable for a subword, set the same-numbered slot in
    -- searchRanges to the range indices of the wordList range covering the words of that length.
    -- Also find the index in wordList of the first word whose length ≥ minAlternadeLen.
    set minSubLen to minAlternadeLen div subsPerAlternade
    set minAltLenStart to 1
    set i to 1
    set currentLength to o's wordList's beginning's length
    repeat with j from 2 to wordCount
        set wordLen to o's wordList's item j's length
        if (wordLen > currentLength) then
            if ((currentLength  minSubLen) and (currentLength  maxSubLen)) then
                set o's searchRanges's item currentLength to {i, j - 1}
                if (wordLen  minAlternadeLen) then
                    if (minAltLenStart = 1) then
                        set minAltLenStart to j
                    else if (wordLen > maxSubLen) then
                        exit repeat
                    end if
                end if
            end if
            set i to j
            set currentLength to wordLen
        end if
    end repeat
    
    -- Extract subtexts from words having minAlternadeLen or more characters and see if they match
    -- words from the same-length ranges in wordList. Append any hits to the output.
    if (outputType is text) then set end of o's output to ""
	repeat with w from minAltLenStart to wordCount -- Per long-enough word.
        set thisWord to o's wordList's item w
        set wordLen to thisWord's length
        set foundSubs to {}
        repeat with s from 1 to subsPerAlternade -- Per subword.
            set sub to thisWord's character s
            repeat with c from (s + subsPerAlternade) to wordLen by subsPerAlternade -- Per chr.
                set sub to sub & thisWord's character c
            end repeat
            set range to o's searchRanges's item (sub's length)
            if ((range = missing value) or ¬
                (binarySearch(sub, o's wordList, range's beginning, range's end) = 0)) then ¬
                exit repeat
            set end of foundSubs to sub
        end repeat
        if ((count foundSubs) = subsPerAlternade) then
            if (outputType is text) then
                set beginning of foundSubs to thisWord & ":"
                set end of o's output to join(foundSubs, tab & tab)
            else
                set end of o's output to {alternade:thisWord, subs:foundSubs}
            end if
        end if
    end repeat
    
    return o's finish()
end alternades

-- Task code:
local wordFile, wordList
set wordFile to ((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as «class furl»
set wordList to words of (read wordFile as «class utf8»)
-- Return two-word alternades of 6 or more characters. Result as text (as opposed to list).
return alternades(wordList, 2, 6, text)
Output:
"
accost:        acs        cot
accuse:        acs        cue
afield:        ail        fed
agleam:        ala        gem
alcott:        act        lot
allele:        all        lee
allied:        ale        lid
alpert:        apr        let
apport:        apr        pot
assist:        ass        sit
battle:        btl        ate
blaine:        ban        lie
brenda:        bed        rna
choose:        cos        hoe
choosy:        cos        hoy
claire:        car        lie
effete:        eft        fee
fabric:        fbi        arc
fealty:        fat        ely
fluent:        fun        let
friend:        fin        red
george:        gog        ere
inroad:        ira        nod
israel:        ire        sal
jaunty:        jut        any
joanne:        jan        one
lounge:        lug        one
oriole:        oil        roe
oswald:        owl        sad
parrot:        pro        art
peoria:        poi        era
pierre:        per        ire
poodle:        pol        ode
pounce:        puc        one
racial:        rca        ail
realty:        rat        ely
sordid:        sri        odd
sprain:        sri        pan
strain:        sri        tan
strait:        sri        tat
sturdy:        sud        try
sweaty:        set        way
tattle:        ttl        ate
though:        tog        huh
triode:        tid        roe
triune:        tin        rue
troupe:        top        rue
truant:        tun        rat
twirly:        til        wry
ambient:       abet       min
annette:       ante       net
ariadne:       aide       ran
collude:       clue       old
forwent:       fret       own
spatial:       sail       pta
theorem:       term       hoe
throaty:       tray       hot
calliope:      clip       aloe"

Arturo

words: map read.lines relative "unixdict.txt" => strip

loop words 'word [
    sw: new size word
    if 6 > sw ->
        continue

    dec 'sw

    alt1: join map select 0..sw => odd? 'x -> word\[x]
    alt2: join map select 0..sw => even? 'x -> word\[x]

    if and? [contains? words alt1][contains? words alt2] ->
        print [word "=>" alt1 alt2]
]
Output:
accost => cot acs 
accuse => cue acs 
afield => fed ail 
agleam => gem ala 
alcott => lot act 
allele => lee all 
allied => lid ale 
alpert => let apr 
ambient => min abet 
annette => net ante 
apport => pot apr 
ariadne => ran aide 
assist => sit ass 
battle => ate btl 
blaine => lie ban 
brenda => rna bed 
calliope => aloe clip 
choose => hoe cos 
choosy => hoy cos 
claire => lie car 
collude => old clue 
effete => fee eft 
fabric => arc fbi 
fealty => ely fat 
fluent => let fun 
forwent => own fret 
friend => red fin 
george => ere gog 
inroad => nod ira 
israel => sal ire 
jaunty => any jut 
joanne => one jan 
lounge => one lug 
oriole => roe oil 
oswald => sad owl 
parrot => art pro 
peoria => era poi 
pierre => ire per 
poodle => ode pol 
pounce => one puc 
racial => ail rca 
realty => ely rat 
sordid => odd sri 
spatial => pta sail 
sprain => pan sri 
strain => tan sri 
strait => tat sri 
sturdy => try sud 
sweaty => way set 
tattle => ate ttl 
theorem => hoe term 
though => huh tog 
throaty => hot tray 
triode => roe tid 
triune => rue tin 
troupe => rue top 
truant => rat tun 
twirly => wry til

AutoHotkey

FileRead, db, % A_Desktop "\unixdict.txt"
words := [], sixWords := []

for i, w in StrSplit(db, "`n", "`r")
    if (StrLen(w) >= 6)
        sixWords[w] := true
    else
        Words[w] := true

for w in sixWords
{
    w1 := w2 := ""
    for j, letter in StrSplit(w)
        if Mod(j, 2)
            w1 .= letter
        else
            w2 .= letter

    if words[w1] && words[w2]
        result .= w "`t-> " w1 " " w2 "`n"
}
MsgBox % result
Output:
accost	-> acs cot
accuse	-> acs cue
afield	-> ail fed
agleam	-> ala gem
alcott	-> act lot
allele	-> all lee
allied	-> ale lid
alpert	-> apr let
ambient	-> abet min
annette	-> ante net
apport	-> apr pot
ariadne	-> aide ran
assist	-> ass sit
battle	-> btl ate
blaine	-> ban lie
brenda	-> bed rna
calliope	-> clip aloe
choose	-> cos hoe
choosy	-> cos hoy
claire	-> car lie
collude	-> clue old
effete	-> eft fee
fabric	-> fbi arc
fealty	-> fat ely
fluent	-> fun let
forwent	-> fret own
friend	-> fin red
george	-> gog ere
inroad	-> ira nod
israel	-> ire sal
jaunty	-> jut any
joanne	-> jan one
lounge	-> lug one
oriole	-> oil roe
oswald	-> owl sad
parrot	-> pro art
peoria	-> poi era
pierre	-> per ire
poodle	-> pol ode
pounce	-> puc one
racial	-> rca ail
realty	-> rat ely
sordid	-> sri odd
spatial	-> sail pta
sprain	-> sri pan
strain	-> sri tan
strait	-> sri tat
sturdy	-> sud try
sweaty	-> set way
tattle	-> ttl ate
theorem	-> term hoe
though	-> tog huh
throaty	-> tray hot
triode	-> tid roe
triune	-> tin rue
troupe	-> top rue
truant	-> tun rat
twirly	-> til wry

AWK

# syntax: GAWK -f ALTERNADE_WORDS.AWK unixdict.txt
#
# sorting:
#   PROCINFO["sorted_in"] is used by GAWK
#   SORTTYPE is used by Thompson Automation's TAWK
#
{ arr[$0]++ }
END {
    PROCINFO["sorted_in"] = "@ind_str_asc" ; SORTTYPE = 1
    for (word in arr) {
      leng = length(word)
      if (leng < 6) {
        continue
      }
      odd_word = even_word = ""
      for (i=1; i<=leng; i++) {
        if (i ~ /[13579]$/) {
          odd_word = odd_word substr(word,i,1)
        }
        else {
          even_word = even_word substr(word,i,1)
        }
      }
      if (odd_word in arr && even_word in arr) {
        printf("%-9s %-5s %-5s\n",word,odd_word,even_word)
      }
    }
    exit(0)
}
Output:
accost    acs   cot
accuse    acs   cue
afield    ail   fed
agleam    ala   gem
alcott    act   lot
allele    all   lee
allied    ale   lid
alpert    apr   let
ambient   abet  min
annette   ante  net
apport    apr   pot
ariadne   aide  ran
assist    ass   sit
battle    btl   ate
blaine    ban   lie
brenda    bed   rna
calliope  clip  aloe
choose    cos   hoe
choosy    cos   hoy
claire    car   lie
collude   clue  old
effete    eft   fee
fabric    fbi   arc
fealty    fat   ely
fluent    fun   let
forwent   fret  own
friend    fin   red
george    gog   ere
inroad    ira   nod
israel    ire   sal
jaunty    jut   any
joanne    jan   one
lounge    lug   one
oriole    oil   roe
oswald    owl   sad
parrot    pro   art
peoria    poi   era
pierre    per   ire
poodle    pol   ode
pounce    puc   one
racial    rca   ail
realty    rat   ely
sordid    sri   odd
spatial   sail  pta
sprain    sri   pan
strain    sri   tan
strait    sri   tat
sturdy    sud   try
sweaty    set   way
tattle    ttl   ate
theorem   term  hoe
though    tog   huh
throaty   tray  hot
triode    tid   roe
triune    tin   rue
troupe    top   rue
truant    tun   rat
twirly    til   wry

C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#define WORD_BUF_SIZE 30
#define MIN_WORD_SIZE 6

/* Print last error and exit */
void fail(void) {
    fprintf(stderr, "%s\n", strerror(errno));
    exit(42);
}

/* Define a trie data structure to store the words */
struct trie_node {
    char ch, final;
    struct trie_node *parent, *sibling, *root, *child; 
};

struct trie_node *alloc_node() {
    struct trie_node *t = calloc(1, sizeof(struct trie_node));
    if (t == NULL) fail();
    return t;
}

struct trie_node *make_sibling(struct trie_node *node) {
    struct trie_node *t = alloc_node();
    node->sibling = t;
    t->ch = node->ch;
    t->parent = node->parent;
    t->root = node->root;
    return t;
}

struct trie_node *make_child(struct trie_node *node, char ch) {
    struct trie_node *t = alloc_node();
    t->parent = node;
    t->ch = ch;
    t->root = node->root;
    node->child = t;
    return t;
}

/* Add a word to the trie */
struct trie_node *add_word(struct trie_node *root, const char *word) {
    struct trie_node *cur = root;
    for (; *word; word++) {
        while (cur->child == NULL || cur->child->ch != *word) {
            if (cur->child == NULL) {
                /* Node does not exist yet; insert it */
                make_child(cur, *word);
            } else {
                /* Check next sibling, if it exists */
                if (cur->sibling == NULL) make_sibling(cur);
                cur = cur->sibling;
            }
        }
        
        /* We have either made or found the right node, descend */
        cur = cur->child;
    }
    cur->final = 1; /* This node marks the end of a word */
    return cur;
}

/* Check if a word is in the trie; returns the word or NULL if not there */
struct trie_node *find_word(struct trie_node *root, const char *word) {
    struct trie_node *cur = root;
    for (; *word && cur; word++) {
        while (cur != NULL && cur->child != NULL && cur->child->ch != *word) {
            cur = cur->sibling;
        }
        if (cur == NULL) return NULL; /* node doesn't exist */
        cur = cur->child;
    }
    if (cur && cur->final) return cur;
    else return NULL;
}

/* Call function for every word in the trie */
void scan_trie(struct trie_node *node, void callback(struct trie_node *)) {
    if (node == NULL) return;
    if (node->final) callback(node);
    scan_trie(node->child, callback);
    scan_trie(node->sibling, callback);
}

/* Retrieve word from trie given pointer to end node */
char *get_word(struct trie_node *node, char *buffer) {
    char t, *ch = buffer, *s = buffer;
    for (; node != NULL; node=node->parent) *ch++ = node->ch;
    for (ch-=2; ch >= s; ch--, s++) *ch ^= *s ^= *ch ^= *s;
    return buffer;
}

/* See if a word is an alternade, and print it if it is */
void check_alternade(struct trie_node *node) {
    static char word[WORD_BUF_SIZE], even[WORD_BUF_SIZE], odd[WORD_BUF_SIZE];
    char *p_even = even, *p_odd = odd;
    int i;
    
    /* Ignore words that are shorter than the minimum length */
    if (strlen(get_word(node, word)) < MIN_WORD_SIZE) return;
    
    /* Make even and odd words */
    for (i=0; word[i]; i++) {
        if (i & 1) *p_odd++ = word[i];
        else *p_even++ = word[i];
    }
    *p_odd = *p_even = '\0';
        
    /* If both words exist, this is an alternade */
    if (find_word(node->root, even) && find_word(node->root, odd)) {
        printf("%-20s%-10s%-10s\n", word, even, odd);
    }
}
          
int main(void) {
    struct trie_node *root = alloc_node();
    root->root = root;
    char word[WORD_BUF_SIZE], *nl;
    
    /* Read all words from stdin */
    while (!feof(stdin)) {
        fgets(word, WORD_BUF_SIZE, stdin);
        if (nl = strchr(word, '\n')) *nl = '\0'; /* remove newline */ 
        add_word(root, word);
    }
    
    /* Print all alternades */
    scan_trie(root, check_alternade);
    return 0;
}
Output:
$ ./alternade < unixdict.txt
accost              acs       cot
accuse              acs       cue
afield              ail       fed
agleam              ala       gem
alcott              act       lot
allele              all       lee
allied              ale       lid
alpert              apr       let
ambient             abet      min
annette             ante      net
apport              apr       pot
ariadne             aide      ran
assist              ass       sit
battle              btl       ate
blaine              ban       lie
brenda              bed       rna
calliope            clip      aloe
choose              cos       hoe
choosy              cos       hoy
claire              car       lie
collude             clue      old
effete              eft       fee
fabric              fbi       arc
fealty              fat       ely
fluent              fun       let
forwent             fret      own
friend              fin       red
george              gog       ere
inroad              ira       nod
israel              ire       sal
jaunty              jut       any
joanne              jan       one
lounge              lug       one
oriole              oil       roe
oswald              owl       sad
parrot              pro       art
peoria              poi       era
pierre              per       ire
poodle              pol       ode
pounce              puc       one
racial              rca       ail
realty              rat       ely
sordid              sri       odd
spatial             sail      pta
sprain              sri       pan
strain              sri       tan
strait              sri       tat
sturdy              sud       try
sweaty              set       way
tattle              ttl       ate
theorem             term      hoe
though              tog       huh
throaty             tray      hot
triode              tid       roe
triune              tin       rue
troupe              top       rue
truant              tun       rat
twirly              til       wry

C++

#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>

int main(int argc, char** argv) {
    const char* filename(argc < 2 ? "unixdict.txt" : argv[1]);
    std::ifstream in(filename);
    if (!in) {
        std::cerr << "Cannot open file '" << filename << "'.\n";
        return EXIT_FAILURE;
    }
    std::string line;
    std::set<std::string> dictionary;
    while (getline(in, line))
        dictionary.insert(line);
    std::cout << std::left;
    for (const std::string& word : dictionary) {
        size_t len = word.size();
        if (len < 6)
            continue;
        std::string word1, word2;
        for (size_t i = 0; i < len; i += 2) {
            word1 += word[i];
            if (i + 1 < len)
                word2 += word[i + 1];
        }
        if (dictionary.find(word1) != dictionary.end()
            && dictionary.find(word2) != dictionary.end()) {
            std::cout << std::setw(10) << word
                    << std::setw(6) << word1 << word2 << '\n';
        }
    }
    return EXIT_SUCCESS;
}
Output:
accost    acs   cot
accuse    acs   cue
afield    ail   fed
agleam    ala   gem
alcott    act   lot
allele    all   lee
allied    ale   lid
alpert    apr   let
ambient   abet  min
annette   ante  net
apport    apr   pot
ariadne   aide  ran
assist    ass   sit
battle    btl   ate
blaine    ban   lie
brenda    bed   rna
calliope  clip  aloe
choose    cos   hoe
choosy    cos   hoy
claire    car   lie
collude   clue  old
effete    eft   fee
fabric    fbi   arc
fealty    fat   ely
fluent    fun   let
forwent   fret  own
friend    fin   red
george    gog   ere
inroad    ira   nod
israel    ire   sal
jaunty    jut   any
joanne    jan   one
lounge    lug   one
oriole    oil   roe
oswald    owl   sad
parrot    pro   art
peoria    poi   era
pierre    per   ire
poodle    pol   ode
pounce    puc   one
racial    rca   ail
realty    rat   ely
sordid    sri   odd
spatial   sail  pta
sprain    sri   pan
strain    sri   tan
strait    sri   tat
sturdy    sud   try
sweaty    set   way
tattle    ttl   ate
theorem   term  hoe
though    tog   huh
throaty   tray  hot
triode    tid   roe
triune    tin   rue
troupe    top   rue
truant    tun   rat
twirly    til   wry


Delphi

Works with: Delphi version 6.0

Delphi-style problem solving, using standard Delphi controls like the TStringList, which greatly simplifies the solution.

unit Alternade;

interface

uses Classes,StdCtrls,SysUtils;

procedure FindAlternadeWords(Memo: TMemo);

implementation

var Dict: TStringList;	{List holds dictionary}

function GetAlts(S: string; var Alt1,Alt2: string): boolean;
{Grab Alternades from string and test if they are valid }
var I: integer;
begin
Alt1:='';
Alt2:='';
{Copy every other letter into different string}
for I:=1 to Length(S) do
 if (I mod 2)=0 then Alt2:=Alt2+S[I]
 else Alt1:=Alt1+S[I];
{Check if the two strings are in the dictionary}
Result:=(Dict.IndexOf(Alt1)>=0) and (Dict.IndexOf(Alt2)>=0);
end;

procedure FindAlternadeWords(Memo: TMemo);
{test all words in the dictionary}
{And diplays the Alternade words in the Memo}
var I,Cnt: integer;
var Alt1,Alt2: string;
begin
Cnt:=0;
for I:=0 to Dict.Count-1 do
 if (Length(Dict[I])>=6) and GetAlts(Dict[I], Alt1, Alt2) then
	begin
	Inc(Cnt);
	Memo.Lines.Add(IntToStr(Cnt)+': '+Dict[I]+' '+Alt1+' '+Alt2);
	end
end;


initialization
{Create/load dictionary}
Dict:=TStringList.Create;
Dict.LoadFromFile('unixdict.txt');
Dict.Sorted:=True;
finalization
Dict.Free;
end.
Output:
1: accost acs cot
2: accuse acs cue
3: afield ail fed
4: agleam ala gem
5: alcott act lot
6: allele all lee
7: allied ale lid
8: alpert apr let
9: ambient abet min
10: annette ante net
11: apport apr pot
12: ariadne aide ran
13: assist ass sit
14: battle btl ate
15: blaine ban lie
16: brenda bed rna
17: calliope clip aloe
18: choose cos hoe
19: choosy cos hoy
20: claire car lie
21: collude clue old
22: effete eft fee
23: fabric fbi arc
24: fealty fat ely
25: fluent fun let
26: forwent fret own
27: friend fin red
28: george gog ere
29: inroad ira nod
30: israel ire sal
31: jaunty jut any
32: joanne jan one
33: lounge lug one
34: oriole oil roe
35: oswald owl sad
36: parrot pro art
37: peoria poi era
38: pierre per ire
39: poodle pol ode
40: pounce puc one
41: racial rca ail
42: realty rat ely
43: sordid sri odd
44: spatial sail pta
45: sprain sri pan
46: strain sri tan
47: strait sri tat
48: sturdy sud try
49: sweaty set way
50: tattle ttl ate
51: theorem term hoe
52: though tog huh
53: throaty tray hot
54: triode tid roe
55: triune tin rue
56: troupe top rue
57: truant tun rat
58: twirly til wry

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 fN g=let n=Seq.foldBack2(fun n g (z:char list [])->z.[g]<-n::z.[g]; z) g (let rec fN()=seq{yield![0;1]; yield! fN()} in fN())([|[];[]|]) in (n.[0],n.[1])
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 |_->())
Output:
accost -> acs * cot
accuse -> acs * cue
afield -> ail * fed
agleam -> ala * gem
alcott -> act * lot
allele -> all * lee
allied -> ale * lid
alpert -> apr * let
ambient -> abet * min
annette -> ante * net
apport -> apr * pot
ariadne -> aide * ran
assist -> ass * sit
battle -> btl * ate
blaine -> ban * lie
brenda -> bed * rna
calliope -> clip * aloe
choose -> cos * hoe
choosy -> cos * hoy
claire -> car * lie
collude -> clue * old
effete -> eft * fee
fabric -> fbi * arc
fealty -> fat * ely
fluent -> fun * let
forwent -> fret * own
friend -> fin * red
george -> gog * ere
inroad -> ira * nod
israel -> ire * sal
jaunty -> jut * any
joanne -> jan * one
lounge -> lug * one
oriole -> oil * roe
oswald -> owl * sad
parrot -> pro * art
peoria -> poi * era
pierre -> per * ire
poodle -> pol * ode
pounce -> puc * one
racial -> rca * ail
realty -> rat * ely
sordid -> sri * odd
spatial -> sail * pta
sprain -> sri * pan
strain -> sri * tan
strait -> sri * tat
sturdy -> sud * try
sweaty -> set * way
tattle -> ttl * ate
theorem -> term * hoe
though -> tog * huh
throaty -> tray * hot
triode -> tid * roe
triune -> tin * rue
troupe -> top * rue
truant -> tun * rat
twirly -> til * wry


Factor

USING: formatting io.encodings.ascii io.files kernel literals
math sequences sequences.extras sets strings ;

<< CONSTANT: words $[ "unixdict.txt" ascii file-lines ] >>

CONSTANT: wordset $[ words HS{ } set-like ]

: word? ( str -- ? ) wordset in? ;

: subwords ( str -- str str )
    dup <evens> >string swap <odds> >string ;

: alternade? ( str -- ? ) subwords [ word? ] both? ;

words
[ alternade? ] filter
[ length 5 > ] filter
[ dup subwords "%-8s %-4s %-4s\n" printf ] each
Output:
accost   acs  cot 
accuse   acs  cue 
afield   ail  fed 
agleam   ala  gem 
alcott   act  lot 
allele   all  lee 
allied   ale  lid 
alpert   apr  let 
ambient  abet min 
annette  ante net 
apport   apr  pot 
ariadne  aide ran 
assist   ass  sit 
battle   btl  ate 
blaine   ban  lie 
brenda   bed  rna 
calliope clip aloe
choose   cos  hoe 
choosy   cos  hoy 
claire   car  lie 
collude  clue old 
effete   eft  fee 
fabric   fbi  arc 
fealty   fat  ely 
fluent   fun  let 
forwent  fret own 
friend   fin  red 
george   gog  ere 
inroad   ira  nod 
israel   ire  sal 
jaunty   jut  any 
joanne   jan  one 
lounge   lug  one 
oriole   oil  roe 
oswald   owl  sad 
parrot   pro  art 
peoria   poi  era 
pierre   per  ire 
poodle   pol  ode 
pounce   puc  one 
racial   rca  ail 
realty   rat  ely 
sordid   sri  odd 
spatial  sail pta 
sprain   sri  pan 
strain   sri  tan 
strait   sri  tat 
sturdy   sud  try 
sweaty   set  way 
tattle   ttl  ate 
theorem  term hoe 
though   tog  huh 
throaty  tray hot 
triode   tid  roe 
triune   tin  rue 
troupe   top  rue 
truant   tun  rat 
twirly   til  wry 

FreeBASIC

#define DLEN 25104

function is_in(word() as string, s as string) as boolean
    for i as uinteger = 1 to DLEN
        if word(i)=s then return true
    next i
    return false
end function

dim as string word(1 to DLEN), alt(0 to 1)
dim as integer i, j
open "unixdict.txt" for input as #1
while not eof(1)
    i+=1
    line input #1, word(i)
wend
close #1

for i = 1 to DLEN
    if len(word(i))<6 then continue for
    alt(0) = ""
    alt(1) = ""
    for j = 1 to len(word(i))
        alt(j mod 2) += mid(word(i),j, 1)
    next j
    if is_in(word(), alt(0)) and is_in(word(), alt(1)) then print word(i), alt(1), alt(0)
next i
Output:

accost acs cot accuse acs cue afield ail fed agleam ala gem alcott act lot allele all lee allied ale lid alpert apr let ambient abet min annette ante net apport apr pot ariadne aide ran assist ass sit battle btl ate blaine ban lie brenda bed rna calliope clip aloe choose cos hoe choosy cos hoy claire car lie collude clue old effete eft fee fabric fbi arc fealty fat ely fluent fun let forwent fret own friend fin red george gog ere inroad ira nod israel ire sal jaunty jut any joanne jan one lounge lug one oriole oil roe oswald owl sad parrot pro art peoria poi era pierre per ire poodle pol ode pounce puc one racial rca ail realty rat ely sordid sri odd spatial sail pta sprain sri pan strain sri tan strait sri tat sturdy sud try sweaty set way tattle ttl ate theorem term hoe though tog huh throaty tray hot triode tid roe triune tin rue troupe top rue truant tun rat twirly til wry

FutureBasic

#plist NSAppTransportSecurity @{NSAllowsArbitraryLoads:YES}

local fn Words as CFArrayRef
  CFURLRef    url = fn URLWithString( @"https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt" )
  CFStringRef string = fn StringWithContentsOfURL( url, NSUTF8StringEncoding, NULL )
end fn = fn StringComponentsSeparatedByCharactersInSet( string, fn CharacterSetNewlineSet )

void local fn DoIt
  text,,,,, 80
  dispatchglobal
    CFArrayRef  words = fn Words
    CFStringRef wd, wd1, wd2
    long length, i
    for wd in words
      length = len(wd)
      if ( length >= 6 )
        wd1 = @"" : wd2 = @""
        for i = 0 to length-1
          if ( i mod 2 == 0 )
            wd1 = fn StringByAppendingString( wd1, mid(wd,i,1) )
          else
            wd2 = fn StringByAppendingString( wd2, mid(wd,i,1) )
          end if
        next
        if ( fn ArrayContainsObject( words, wd1 ) and fn ArrayContainsObject( words, wd2 ) )
          dispatchmain
            print wd,wd1,wd2
          dispatchend
        end if
      end if
    next
  dispatchend
end fn

fn DoIt

HandleEvents
Output:
accost	    acs	    cot
accuse	    acs	    cue
afield	    ail	    fed
agleam	    ala	    gem
alcott	    act	    lot
allele	    all	    lee
allied	    ale	    lid
alpert	    apr	    let
ambient     abet    min
annette     ante    net
apport	    apr	    pot
ariadne     aide    ran
assist      ass     sit
battle	    btl	    ate
blaine	    ban	    lie
brenda	    bed	    rna
calliope    clip    aloe
choose	    cos	    hoe
choosy	    cos	    hoy
claire	    car	    lie
collude     clue    old
effete	    eft	    fee
fabric	    fbi	    arc
fealty	    fat	    ely
fluent	    fun	    let
forwent     fret    own
friend	    fin	    red
george	    gog	    ere
inroad	    ira	    nod
israel	    ire	    sal
jaunty	    jut	    any
joanne	    jan	    one
lounge	    lug	    one
oriole	    oil	    roe
oswald	    owl	    sad
parrot	    pro	    art
peoria	    poi	    era
pierre	    per	    ire
poodle	    pol	    ode
pounce	    puc	    one
racial	    rca	    ail
realty	    rat	    ely
sordid	    sri	    odd
spatial     sail    pta
sprain	    sri     pan
strain	    sri     tan
strait	    sri     tat
sturdy	    sud     try
sweaty	    set     way
tattle      ttl     ate
theorem     term    hoe
though      tog     huh
throaty     tray    hot
triode      tid     roe
triune      tin     rue
troupe      top     rue
truant      tun     rat
twirly      til     wry

Go

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "log"
    "unicode/utf8"
)

func main() {
    b, err := ioutil.ReadFile("unixdict.txt")
    if err != nil {
        log.Fatal("Error reading file")
    }
    bwords := bytes.Fields(b)
    dict := make(map[string]bool, len(bwords))
    words := make([]string, len(bwords))
    for i, bword := range bwords {
        word := string(bword)
        dict[word] = true
        words[i] = word
    }
    fmt.Println("'unixdict.txt' contains the following alternades of length 6 or more:\n")
    count := 0
    for _, word := range words {
        if utf8.RuneCountInString(word) < 6 {
            continue
        }
        var w1 = ""
        var w2 = ""
        for i, c := range word {
            if i%2 == 0 {
                w1 += string(c)
            } else {
                w2 += string(c)
            }
        }
        _, ok1 := dict[w1]
        _, ok2 := dict[w2]
        if ok1 && ok2 {
            count++
            fmt.Printf("%2d: %-8s -> %-4s %-4s\n", count, word, w1, w2)
        }
    }
}
Output:
'unixdict.txt' contains the following alternades of length 6 or more:

 1: accost   -> acs  cot 
 2: accuse   -> acs  cue 
 3: afield   -> ail  fed 
 4: agleam   -> ala  gem 
 5: alcott   -> act  lot 
 6: allele   -> all  lee 
 7: allied   -> ale  lid 
 8: alpert   -> apr  let 
 9: ambient  -> abet min 
10: annette  -> ante net 
11: apport   -> apr  pot 
12: ariadne  -> aide ran 
13: assist   -> ass  sit 
14: battle   -> btl  ate 
15: blaine   -> ban  lie 
16: brenda   -> bed  rna 
17: calliope -> clip aloe
18: choose   -> cos  hoe 
19: choosy   -> cos  hoy 
20: claire   -> car  lie 
21: collude  -> clue old 
22: effete   -> eft  fee 
23: fabric   -> fbi  arc 
24: fealty   -> fat  ely 
25: fluent   -> fun  let 
26: forwent  -> fret own 
27: friend   -> fin  red 
28: george   -> gog  ere 
29: inroad   -> ira  nod 
30: israel   -> ire  sal 
31: jaunty   -> jut  any 
32: joanne   -> jan  one 
33: lounge   -> lug  one 
34: oriole   -> oil  roe 
35: oswald   -> owl  sad 
36: parrot   -> pro  art 
37: peoria   -> poi  era 
38: pierre   -> per  ire 
39: poodle   -> pol  ode 
40: pounce   -> puc  one 
41: racial   -> rca  ail 
42: realty   -> rat  ely 
43: sordid   -> sri  odd 
44: spatial  -> sail pta 
45: sprain   -> sri  pan 
46: strain   -> sri  tan 
47: strait   -> sri  tat 
48: sturdy   -> sud  try 
49: sweaty   -> set  way 
50: tattle   -> ttl  ate 
51: theorem  -> term hoe 
52: though   -> tog  huh 
53: throaty  -> tray hot 
54: triode   -> tid  roe 
55: triune   -> tin  rue 
56: troupe   -> top  rue 
57: truant   -> tun  rat 
58: twirly   -> til  wry 

Haskell

import qualified Data.Set as S
import qualified Data.Text as T
import qualified Data.Text.IO as TIO

-- Two words constructed from the alternating characters of a single word.
alt :: T.Text -> (T.Text, T.Text)
alt = T.foldl' (\(l, r) c -> (r `T.snoc` c, l)) (T.empty, T.empty)

-- The alternades of a list of words.
alternades :: S.Set T.Text -> [T.Text] -> [(T.Text, (T.Text, T.Text))]
alternades dict ws = filter (areMembers . snd) $ zip ws $ map alt ws
  where areMembers (x, y) = S.member x dict && S.member y dict

main :: IO ()
main = TIO.interact $ \txt ->
  let words' = map T.toLower $ T.lines txt
      dict   = S.fromList words'
  in T.unlines $ map alterShow $ alternades dict $ filter longEnough words'
  where longEnough = (>= 6) . T.length
        alterShow (w, (x, y)) = T.unwords [w, x, y]
Output:
$ alternade < unixdict.txt
accost cot acs
accuse cue acs
afield fed ail
agleam gem ala
alcott lot act
allele lee all
allied lid ale
alpert let apr
ambient abet min
annette ante net
apport pot apr
ariadne aide ran
assist sit ass
battle ate btl
blaine lie ban
brenda rna bed
calliope aloe clip
choose hoe cos
choosy hoy cos
claire lie car
collude clue old
effete fee eft
fabric arc fbi
fealty ely fat
fluent let fun
forwent fret own
friend red fin
george ere gog
inroad nod ira
israel sal ire
jaunty any jut
joanne one jan
lounge one lug
oriole roe oil
oswald sad owl
parrot art pro
peoria era poi
pierre ire per
poodle ode pol
pounce one puc
racial ail rca
realty ely rat
sordid odd sri
spatial sail pta
sprain pan sri
strain tan sri
strait tat sri
sturdy try sud
sweaty way set
tattle ate ttl
theorem term hoe
though huh tog
throaty tray hot
triode roe tid
triune rue tin
troupe rue top
truant rat tun
twirly wry til

J

   words=: cutLF fread 'unixdict.txt'
   alts=: <@deb"1@|:@(_2]\])@> ref=: (#~ 5<#@>) words
   ;:inv (ref,.alts) #~ alts */@e."1 words
accost acs cot    
accuse acs cue    
afield ail fed    
agleam ala gem    
alcott act lot    
allele all lee    
allied ale lid    
alpert apr let    
ambient abet min  
annette ante net  
apport apr pot    
ariadne aide ran  
assist ass sit    
battle btl ate    
blaine ban lie    
brenda bed rna    
calliope clip aloe
choose cos hoe    
choosy cos hoy    
claire car lie    
collude clue old  
effete eft fee    
fabric fbi arc    
fealty fat ely    
fluent fun let    
forwent fret own  
friend fin red    
george gog ere    
inroad ira nod    
israel ire sal    
jaunty jut any    
joanne jan one    
lounge lug one    
oriole oil roe    
oswald owl sad    
parrot pro art    
peoria poi era    
pierre per ire    
poodle pol ode    
pounce puc one    
racial rca ail    
realty rat ely    
sordid sri odd    
spatial sail pta  
sprain sri pan    
strain sri tan    
strait sri tat    
sturdy sud try    
sweaty set way    
tattle ttl ate    
theorem term hoe  
though tog huh    
throaty tray hot  
triode tid roe    
triune tin rue    
troupe top rue    
truant tun rat    
twirly til wry

Java

The 'userdict.txt' file is great, except it contains entries like 'mrs' and '1st'.
Testing a word for at least one vowel, and 'a-z' is necessary for this task.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Set;
import java.util.TreeSet;

class AlternadeWords {
    static char[] vowels = "aeiouy".toCharArray();
    static String alphabet;

    static {
        alphabet = "";
        for (int index = 0; index < 26; index++)
            alphabet += (char) (index + 'a');
    }

    boolean alphabetic(String string) {
        for (char character : string.toCharArray()) {
            if (!alphabet.contains(String.valueOf(character)))
                return false;
        }
        return true;
    }

    boolean containsVowel(String string) {
        for (char vowel : vowels) {
            if (string.contains(String.valueOf(vowel)))
                return true;
        }
        return false;
    }

    void alternateWords() throws IOException {
        Set<String> dictionary = new TreeSet<>();
        try (BufferedReader reader = new BufferedReader(new FileReader("unixdict.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                if (!alphabetic(line) || !containsVowel(line))
                    continue;
                dictionary.add(line);
            }
        }
        StringBuilder wordA = new StringBuilder();
        StringBuilder wordB = new StringBuilder();
        for (String word : dictionary) {
            int length = word.length();
            if (length < 6)
                continue;
            wordA.setLength(0);
            wordB.setLength(0);
            for (int index = 0; index < length; index += 2) {
                wordA.append(word.charAt(index));
                if (index + 1 < length)
                    wordB.append(word.charAt(index + 1));
            }
            if (dictionary.contains(wordA.toString()))
                if (dictionary.contains(wordB.toString()))
                    System.out.printf("%-15s%5s %s%n", word, wordA, wordB);
        }
    }
}
accost           acs cot
accuse           acs cue
afield           ail fed
agleam           ala gem
alcott           act lot
allele           all lee
allied           ale lid
alpert           apr let
ambient         abet min
annette         ante net
apport           apr pot
ariadne         aide ran
assist           ass sit
blaine           ban lie
brenda           bed rna
calliope        clip aloe
choose           cos hoe
choosy           cos hoy
claire           car lie
collude         clue old
effete           eft fee
fabric           fbi arc
fealty           fat ely
fluent           fun let
forwent         fret own
friend           fin red
george           gog ere
inroad           ira nod
israel           ire sal
jaunty           jut any
joanne           jan one
lounge           lug one
oriole           oil roe
oswald           owl sad
parrot           pro art
peoria           poi era
pierre           per ire
poodle           pol ode
pounce           puc one
racial           rca ail
realty           rat ely
sordid           sri odd
spatial         sail pta
sprain           sri pan
strain           sri tan
strait           sri tat
sturdy           sud try
sweaty           set way
theorem         term hoe
though           tog huh
throaty         tray hot
triode           tid roe
triune           tin rue
troupe           top rue
truant           tun rat
twirly           til wry

jq

Works with: jq

Works with gojq, the Go implementation of jq

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.
def is_alternade($dict):
  def seconds($start): [.[range($start;length;2)]];
  explode
  | [seconds(0,1)] | map(implode)
  | if $dict[.[0]] and $dict[.[1]] then . else false end;

INDEX( inputs; . )
| . as $dict
| keys_unsorted[]
| select(length>5)
| . as $w
| is_alternade($dict) 
| (select(.) // empty)
| "\($w) → \(.[0]) \(.[1])"

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

Output:
accost → acs cot
accuse → acs cue
afield → ail fed
agleam → ala gem
alcott → act lot
allele → all lee
allied → ale lid
alpert → apr let
ambient → abet min
annette → ante net
apport → apr pot
ariadne → aide ran
assist → ass sit
battle → btl ate
blaine → ban lie
brenda → bed rna
calliope → clip aloe
choose → cos hoe
choosy → cos hoy
claire → car lie
collude → clue old
effete → eft fee
fabric → fbi arc
fealty → fat ely
fluent → fun let
forwent → fret own
friend → fin red
george → gog ere
inroad → ira nod
israel → ire sal
jaunty → jut any
joanne → jan one
lounge → lug one
oriole → oil roe
oswald → owl sad
parrot → pro art
peoria → poi era
pierre → per ire
poodle → pol ode
pounce → puc one
racial → rca ail
realty → rat ely
sordid → sri odd
spatial → sail pta
sprain → sri pan
strain → sri tan
strait → sri tat
sturdy → sud try
sweaty → set way
tattle → ttl ate
theorem → term hoe
though → tog huh
throaty → tray hot
triode → tid roe
triune → tin rue
troupe → top rue
truant → tun rat
twirly → til wry

Julia

function foreachword(wordfile::String, condition::Function; minlen = 0, colwidth = 15, numcols = 6, toshow = 0)
    println("Word source: $wordfile\n")
    words = split(read(wordfile, String), r"\s+")
    dict, shown = Dict(w => 1 for w in words), 0
    for word in words
        if (minlen < 1 || length(word) >= minlen) && (output = condition(word, dict)) != ""
            shown += 1
            print(rpad(output, colwidth), shown % numcols == 0 ? "\n" : "")
            toshow > 0 && toshow < shown && break
        end
    end
end

function isalternade(w, d)
    wodd, weven = (mapreduce(i -> w[i], *, j:2:length(w)) for j in [1,2])
    return haskey(d, wodd) && haskey(d, weven) ? rpad(w, 8) * ": $wodd, $weven" : ""
end

foreachword("unixdict.txt", isalternade, minlen = 6, numcols=1)
Output:
Word source: unixdict.txt

accost  : acs, cot
accuse  : acs, cue
afield  : ail, fed
agleam  : ala, gem
alcott  : act, lot
allele  : all, lee
allied  : ale, lid
alpert  : apr, let
ambient : abet, min
annette : ante, net
apport  : apr, pot
ariadne : aide, ran
assist  : ass, sit
battle  : btl, ate
blaine  : ban, lie
brenda  : bed, rna
calliope: clip, aloe
choose  : cos, hoe
choosy  : cos, hoy
claire  : car, lie
collude : clue, old
effete  : eft, fee
fabric  : fbi, arc
fealty  : fat, ely
fluent  : fun, let
forwent : fret, own
friend  : fin, red
george  : gog, ere
inroad  : ira, nod
israel  : ire, sal
jaunty  : jut, any
joanne  : jan, one
lounge  : lug, one
oriole  : oil, roe
oswald  : owl, sad
parrot  : pro, art
peoria  : poi, era
pierre  : per, ire
poodle  : pol, ode
pounce  : puc, one
racial  : rca, ail
realty  : rat, ely
sordid  : sri, odd
spatial : sail, pta
sprain  : sri, pan
strain  : sri, tan
strait  : sri, tat
sturdy  : sud, try
sweaty  : set, way
tattle  : ttl, ate
theorem : term, hoe
though  : tog, huh
throaty : tray, hot
triode  : tid, roe
triune  : tin, rue
troupe  : top, rue
truant  : tun, rat
twirly  : til, wry

Mathematica /Wolfram Language

dic = Once[Import["https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt"]];
dic = StringSplit[dic, "\n"];
largerthansix = Select[dic, StringLength /* GreaterEqualThan[6]];
smallerthansix = Select[dic, StringLength /* LessEqualThan[5]];
ClearAll[AlternadeQ]
AlternadeQ[w_String, words_List] := Module[{chars, ws, c1, c2},
  chars = Characters[w];
  c1 = StringJoin@chars[[1 ;; ;; 2]];
  c2 = StringJoin@chars[[2 ;; ;; 2]];
  If[MemberQ[words, c1] \[And] MemberQ[words, c2], w -> {c1, c2}, {}]
  ]
all = DeleteCases[Table[AlternadeQ[w, smallerthansix], {w, largerthansix}], {}];
all // Column
Output:
accost->{acs,cot}
accuse->{acs,cue}
afield->{ail,fed}
agleam->{ala,gem}
alcott->{act,lot}
allele->{all,lee}
allied->{ale,lid}
alpert->{apr,let}
ambient->{abet,min}
annette->{ante,net}
apport->{apr,pot}
ariadne->{aide,ran}
assist->{ass,sit}
battle->{btl,ate}
blaine->{ban,lie}
brenda->{bed,rna}
calliope->{clip,aloe}
choose->{cos,hoe}
choosy->{cos,hoy}
claire->{car,lie}
collude->{clue,old}
effete->{eft,fee}
fabric->{fbi,arc}
fealty->{fat,ely}
fluent->{fun,let}
forwent->{fret,own}
friend->{fin,red}
george->{gog,ere}
inroad->{ira,nod}
israel->{ire,sal}
jaunty->{jut,any}
joanne->{jan,one}
lounge->{lug,one}
oriole->{oil,roe}
oswald->{owl,sad}
parrot->{pro,art}
peoria->{poi,era}
pierre->{per,ire}
poodle->{pol,ode}
pounce->{puc,one}
racial->{rca,ail}
realty->{rat,ely}
sordid->{sri,odd}
spatial->{sail,pta}
sprain->{sri,pan}
strain->{sri,tan}
strait->{sri,tat}
sturdy->{sud,try}
sweaty->{set,way}
tattle->{ttl,ate}
theorem->{term,hoe}
though->{tog,huh}
throaty->{tray,hot}
triode->{tid,roe}
triune->{tin,rue}
troupe->{top,rue}
truant->{tun,rat}
twirly->{til,wry}

MiniScript

This implementation is for use with the Mini Micro version of MiniScript. The command-line version does not include a HTTP library. Modify the declaration of wordList object to use the file class to read a local copy of the word list file.

alternateLetters = function(word, ix)
	if ix != 0 then ix = 1
	altWord = ""
	for i in range(ix, word.len - 1, 2)
		altWord += word[i]
	end for
	return altWord
end function

wordList = http.get("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt").split(char(10))
ctr = 0
for word in wordList
	if word.len > 5 then
		word1 = alternateLetters(word, 0)
		word2 = alternateLetters(word, 1)
		if wordList.indexOf(word1) != null and wordList.indexOf(word2) != null then
			ctr += 1
			print [ctr, word, char(18), word1, word2].join(" ")
		end if
	end if
end for
Output:
1 accost : acs cot
2 accuse : acs cue
3 afield : ail fed
4 agleam : ala gem
5 alcott : act lot
6 allele : all lee
7 allied : ale lid
8 alpert : apr let
9 ambient : abet min
10 annette : ante net
11 apport : apr pot
12 ariadne : aide ran
13 assist : ass sit
14 battle : btl ate
15 blaine : ban lie
16 brenda : bed rna
17 calliope : clip aloe
18 choose : cos hoe
19 choosy : cos hoy
20 claire : car lie
21 collude : clue old
22 effete : eft fee
23 fabric : fbi arc
24 fealty : fat ely
25 fluent : fun let
26 forwent : fret own
27 friend : fin red
28 george : gog ere
29 inroad : ira nod
30 israel : ire sal
31 jaunty : jut any
32 joanne : jan one
33 lounge : lug one
34 oriole : oil roe
35 oswald : owl sad
36 parrot : pro art
37 peoria : poi era
38 pierre : per ire
39 poodle : pol ode
40 pounce : puc one
41 racial : rca ail
42 realty : rat ely
43 sordid : sri odd
44 spatial : sail pta
45 sprain : sri pan
46 strain : sri tan
47 strait : sri tat
48 sturdy : sud try
49 sweaty : set way
50 tattle : ttl ate
51 theorem : term hoe
52 though : tog huh
53 throaty : tray hot
54 triode : tid roe
55 triune : tin rue
56 troupe : top rue
57 truant : tun rat
58 twirly : til wry

Nim

import algorithm, sets, strutils, sugar

proc alternatingWords(word: string): array[2, string] =
  ## Return the candidate alternating words of a word.
  for i, c in word:
    result[i and 1].add c

let words = collect(HashSet, for word in "unixdict.txt".lines: {word})

var result: seq[string]
for word in words:
  if word.len >= 6:
    let altWords = alternatingWords(word)
    if altWords[0] in words and altWords[1] in words:
      result.add word.align(8) & " → $1 $2" % altWords
result.sort()
for i, line in result: echo ($(i+1)).align(2), ": ", line
Output:
 1:   accost → acs cot
 2:   accuse → acs cue
 3:   afield → ail fed
 4:   agleam → ala gem
 5:   alcott → act lot
 6:   allele → all lee
 7:   allied → ale lid
 8:   alpert → apr let
 9:   apport → apr pot
10:   assist → ass sit
11:   battle → btl ate
12:   blaine → ban lie
13:   brenda → bed rna
14:   choose → cos hoe
15:   choosy → cos hoy
16:   claire → car lie
17:   effete → eft fee
18:   fabric → fbi arc
19:   fealty → fat ely
20:   fluent → fun let
21:   friend → fin red
22:   george → gog ere
23:   inroad → ira nod
24:   israel → ire sal
25:   jaunty → jut any
26:   joanne → jan one
27:   lounge → lug one
28:   oriole → oil roe
29:   oswald → owl sad
30:   parrot → pro art
31:   peoria → poi era
32:   pierre → per ire
33:   poodle → pol ode
34:   pounce → puc one
35:   racial → rca ail
36:   realty → rat ely
37:   sordid → sri odd
38:   sprain → sri pan
39:   strain → sri tan
40:   strait → sri tat
41:   sturdy → sud try
42:   sweaty → set way
43:   tattle → ttl ate
44:   though → tog huh
45:   triode → tid roe
46:   triune → tin rue
47:   troupe → top rue
48:   truant → tun rat
49:   twirly → til wry
50:  ambient → abet min
51:  annette → ante net
52:  ariadne → aide ran
53:  collude → clue old
54:  forwent → fret own
55:  spatial → sail pta
56:  theorem → term hoe
57:  throaty → tray hot
58: calliope → clip aloe

OCaml

module StrSet = Set.Make(String)

let seq_lines ch =
  let rec repeat () =
    match input_line ch with
    | s -> Seq.Cons (s, repeat)
    | exception End_of_file -> Nil
  in repeat

let min_len l s =
  l <= String.length s

let get_alternade set s =
  let s0 = String.init (succ (String.length s) lsr 1) (fun i -> s.[i + i])
  and s1 = String.init (String.length s lsr 1) (fun i -> s.[i + succ i]) in
  if StrSet.mem s0 set && StrSet.mem s1 set
  then Some (Printf.sprintf "%s | %s %s" s s0 s1) else None

let () =
  let set = seq_lines stdin |> Seq.filter (min_len 3) |> StrSet.of_seq in
  StrSet.to_seq set |> Seq.filter (min_len 6)
  |> Seq.filter_map (get_alternade set) |> Seq.iter print_endline
Output:
accost | acs cot
accuse | acs cue
afield | ail fed
agleam | ala gem
alcott | act lot
allele | all lee
allied | ale lid
alpert | apr let
ambient | abet min
annette | ante net
apport | apr pot
ariadne | aide ran
assist | ass sit
battle | btl ate
blaine | ban lie
brenda | bed rna
calliope | clip aloe
choose | cos hoe
choosy | cos hoy
claire | car lie
collude | clue old
effete | eft fee
fabric | fbi arc
fealty | fat ely
fluent | fun let
forwent | fret own
friend | fin red
george | gog ere
inroad | ira nod
israel | ire sal
jaunty | jut any
joanne | jan one
lounge | lug one
oriole | oil roe
oswald | owl sad
parrot | pro art
peoria | poi era
pierre | per ire
poodle | pol ode
pounce | puc one
racial | rca ail
realty | rat ely
sordid | sri odd
spatial | sail pta
sprain | sri pan
strain | sri tan
strait | sri tat
sturdy | sud try
sweaty | set way
tattle | ttl ate
theorem | term hoe
though | tog huh
throaty | tray hot
triode | tid roe
triune | tin rue
troupe | top rue
truant | tun rat
twirly | til wry

Perl

#!/usr/bin/perl

use strict;
use warnings;

my $words = do { local (@ARGV, $/) = 'unixdict.txt'; <> };
my %words = map { $_, 1 } $words =~ /^.{3,}$/gm;
for ( $words =~ /^.{6,}$/gm )
  {
  my $even = s/(.).?/$1/gr;
  my $odd = s/.(.?)/$1/gr;
  $words{$even} && $words{$odd} and print "$_ => [ $even $odd ]\n";
  }

Phix

with javascript_semantics
sequence words = unix_dict()
constant minlens = {0,6,10,11,12,12}
for n=2 to 6 do
    sequence res = {}
    for i=1 to length(words) do
        string word = words[i]
        if length(word)>=minlens[n] then
            sequence sn = repeat("",n)
            for j=1 to length(word) do
                integer ndx = mod(j-1,n)+1
                sn[ndx] &= word[j]
            end for
            for j=1 to n do
                if binary_search(sn[j],words)<0 then exit end if
                if j=n then
                    sn = prepend(sn,word)
                    res = append(res,sn)
                end if 
            end for
        end if
    end for
    printf(1,"\nEvery %s letter of length>=%d:\n",{ordinal(n),minlens[n]})
    pp(shorten(res,"alternade words found",5),{pp_Nest,1})
end for
Output:
Every second letter of length>=6:
{{`accost`, `acs`, `cot`},
 {`accuse`, `acs`, `cue`},
 {`afield`, `ail`, `fed`},
 {`agleam`, `ala`, `gem`},
 {`alcott`, `act`, `lot`},
 `...`,
 {`triode`, `tid`, `roe`},
 {`triune`, `tin`, `rue`},
 {`troupe`, `top`, `rue`},
 {`truant`, `tun`, `rat`},
 {`twirly`, `til`, `wry`},
 ` (58 alternade words found)`}

Every third letter of length>=10:
{{`benevolent`, `belt`, `eve`, `non`},
 {`rejuvenate`, `rune`, `eva`, `jet`}}

Every fourth letter of length>=11:
{{`meteorology`, `moo`, `erg`, `toy`, `el`},
 {`protectorate`, `per`, `rca`, `ott`, `toe`}}

Every fifth letter of length>=12:
{{`inappropriate`, `ira`, `not`, `ape`, `pr`, `pi`}}

Every sixth letter of length>=12:
{{`aristotelean`, `at`, `re`, `il`, `se`, `ta`, `on`},
 {`warehouseman`, `wu`, `as`, `re`, `em`, `ha`, `on`}}

Picat

Works with: Picat
split_word(Word) = Words =>
    N = len(Word),
    W1 = [Word[I]: I in 1..N, I mod 2 == 1],
    W2 = [Word[I]: I in 1..N, I mod 2 == 0],
    Words = {W1, W2}.

main(Args) =>
    File = Args[1],
    Reader = open(File),
    Dict = new_set(25104, []),
    while (not at_end_of_stream(Reader))
        Word = read_line(Reader),
        put(Dict, Word),
    end,
    DictWords = keys(Dict),
    LongWords = [Long: Long in DictWords, len(Long) >= 6],
    LongSorted = sort(LongWords),
    foreach (Word in LongSorted)
        Words = split_word(Word),
        if (has_key(Dict, Words[1]), has_key(Dict, Words[2])) then
            printf("%w = %w + %w\n", Word, Words[1], Words[2])
        end
    end,
    close(Reader).
Output:
accost = acs + cot
accuse = acs + cue
afield = ail + fed
agleam = ala + gem
alcott = act + lot
allele = all + lee
allied = ale + lid
alpert = apr + let
ambient = abet + min
annette = ante + net
apport = apr + pot
ariadne = aide + ran
assist = ass + sit
battle = btl + ate
blaine = ban + lie
brenda = bed + rna
calliope = clip + aloe
choose = cos + hoe
choosy = cos + hoy
claire = car + lie
collude = clue + old
effete = eft + fee
fabric = fbi + arc
fealty = fat + ely
fluent = fun + let
forwent = fret + own
friend = fin + red
george = gog + ere
inroad = ira + nod
israel = ire + sal
jaunty = jut + any
joanne = jan + one
lounge = lug + one
oriole = oil + roe
oswald = owl + sad
parrot = pro + art
peoria = poi + era
pierre = per + ire
poodle = pol + ode
pounce = puc + one
racial = rca + ail
realty = rat + ely
sordid = sri + odd
spatial = sail + pta
sprain = sri + pan
strain = sri + tan
strait = sri + tat
sturdy = sud + try
sweaty = set + way
tattle = ttl + ate
theorem = term + hoe
though = tog + huh
throaty = tray + hot
triode = tid + roe
triune = tin + rue
troupe = top + rue
truant = tun + rat
twirly = til + wry

Prolog

Works with: SWI Prolog
:- dynamic dictionary_word/1.

main:-
    load_dictionary_from_file("unixdict.txt"),
    print_alternade_words(6).

load_dictionary_from_file(File):-
    open(File, read, Stream),
    retractall(dictionary_word(_)),
    load_dictionary_from_stream(Stream),
    close(Stream).

load_dictionary_from_stream(Stream):-
    read_line_to_string(Stream, String),
    String \= end_of_file,
    !,
    assertz(dictionary_word(String)),
    load_dictionary_from_stream(Stream).
load_dictionary_from_stream(_).

print_alternade_words(Min_length):-
    dictionary_word(Word),
    string_length(Word, Length),
    Length >= Min_length,
    odd_even_words(Word, Word1, Word2),
    dictionary_word(Word1),
    dictionary_word(Word2),
    writef('%10l%6l%w\n', [Word, Word1, Word2]),
    fail.
print_alternade_words(_).

odd_even_words(Word, Word1, Word2):-
    string_chars(Word, Chars),
    odd_even_chars(Chars, Chars1, Chars2),
    string_chars(Word1, Chars1),
    string_chars(Word2, Chars2).

odd_even_chars([], [], []):-!.
odd_even_chars([Ch], [Ch], []):-!.
odd_even_chars([Ch1, Ch2|Chars], [Ch1|Chars1], [Ch2|Chars2]):-
    odd_even_chars(Chars, Chars1, Chars2).
Output:
accost    acs   cot
accuse    acs   cue
afield    ail   fed
agleam    ala   gem
alcott    act   lot
allele    all   lee
allied    ale   lid
alpert    apr   let
ambient   abet  min
annette   ante  net
apport    apr   pot
ariadne   aide  ran
assist    ass   sit
battle    btl   ate
blaine    ban   lie
brenda    bed   rna
calliope  clip  aloe
choose    cos   hoe
choosy    cos   hoy
claire    car   lie
collude   clue  old
effete    eft   fee
fabric    fbi   arc
fealty    fat   ely
fluent    fun   let
forwent   fret  own
friend    fin   red
george    gog   ere
inroad    ira   nod
israel    ire   sal
jaunty    jut   any
joanne    jan   one
lounge    lug   one
oriole    oil   roe
oswald    owl   sad
parrot    pro   art
peoria    poi   era
pierre    per   ire
poodle    pol   ode
pounce    puc   one
racial    rca   ail
realty    rat   ely
sordid    sri   odd
spatial   sail  pta
sprain    sri   pan
strain    sri   tan
strait    sri   tat
sturdy    sud   try
sweaty    set   way
tattle    ttl   ate
theorem   term  hoe
though    tog   huh
throaty   tray  hot
triode    tid   roe
triune    tin   rue
troupe    top   rue
truant    tun   rat
twirly    til   wry

Python

WORDFILE = 'unixdict.txt'
MINLEN = 6

class Trie(object):
    """Trie data structure"""
    class Node(object):
        """A node in the trie"""
        def __init__(self, char='\0', parent=None):
            self.children = {}
            self.char = char
            self.final = False
            self.parent = parent
            
        def descend(self, char, extend=False):
            """Descend into the trie"""
            if not char in self.children:
                if not extend: return None
                self.children[char] = Trie.Node(char,self)
            return self.children[char]
        
    def __init__(self):
        self.root = Trie.Node()
    
    def insert(self, word):
        """Insert a word in the trie"""
        node = self.root
        for char in word: node = node.descend(char, extend=True)
        node.final = True
        return node
    
    def __contains__(self, word):
        """See if the trie contains a word"""
        node = self.root
        for char in word:
            node = node.descend(char)
            if not node: return False
        return node.final 
    
    def words(self):
        """Yield every word in the trie"""
        nodes = [self.root]
        while nodes:
            node = nodes.pop()
            nodes += node.children.values()
            if node.final:
                word = []
                while node:
                    if node.char != '\0': word.append(node.char)
                    node = node.parent
                yield "".join(reversed(word))
    
    def __iter__(self):
        return self.words()
                

words = Trie()
with open(WORDFILE, "rt") as f:
    for word in f.readlines():
        words.insert(word.strip())

for word in words:
    if len(word) < MINLEN: continue
    even = word[::2]
    odd = word[1::2]
    if even in words and odd in words:
        print(word, even, odd)
Output:
twirly til wry
truant tun rat
troupe top rue
triune tin rue
triode tid roe
throaty tray hot
though tog huh
theorem term hoe
tattle ttl ate
sweaty set way
sturdy sud try
strait sri tat
strain sri tan
sprain sri pan
spatial sail pta
sordid sri odd
realty rat ely
racial rca ail
pounce puc one
poodle pol ode
pierre per ire
peoria poi era
parrot pro art
oswald owl sad
oriole oil roe
lounge lug one
joanne jan one
jaunty jut any
israel ire sal
inroad ira nod
george gog ere
friend fin red
forwent fret own
fluent fun let
fealty fat ely
fabric fbi arc
effete eft fee
collude clue old
claire car lie
choosy cos hoy
choose cos hoe
calliope clip aloe
brenda bed rna
blaine ban lie
battle btl ate
assist ass sit
ariadne aide ran
apport apr pot
annette ante net
ambient abet min
alpert apr let
allied ale lid
allele all lee
alcott act lot
agleam ala gem
afield ail fed
accuse acs cue
accost acs cot

Quackery

  [ stack ]                      is sift.test  (     --> s   )
  protect sift.test

  [ ]'[ sift.test put
    [] [] rot 
    witheach
      [ sift.test share do iff
          [ nested join ]
        else 
          [ swap dip 
            [ nested join ] ] ]
     sift.test release ]         is siftwith   (   [ --> [ [ )

  [ 1 & ]                        is odd        (   n --> b   )

  [ stack ]                      is dict       (     --> s   )

  [ dict share
    dup dip find found ]         is indict     (   $ --> b   )

 $ "unixdict.txt" sharefile drop
  nest$ dict put
 
  dict share 
  siftwith [ dup size 6 < ]
  drop witheach
  [ dup siftwith [ i^ odd ]
    dup indict iff
      [ over indict iff
          [ rot echo$ 
            swap sp echo$
            sp echo$ cr ]
          else [ drop 2drop ] ]
      else [ drop 2drop ] ]
 
  dict release
Output:
accost acs cot
accuse acs cue
afield ail fed
agleam ala gem
alcott act lot
allele all lee
allied ale lid
alpert apr let
ambient abet min
annette ante net
apport apr pot
ariadne aide ran
assist ass sit
battle btl ate
blaine ban lie
brenda bed rna
calliope clip aloe
choose cos hoe
choosy cos hoy
claire car lie
collude clue old
effete eft fee
fabric fbi arc
fealty fat ely
fluent fun let
forwent fret own
friend fin red
george gog ere
inroad ira nod
israel ire sal
jaunty jut any
joanne jan one
lounge lug one
oriole oil roe
oswald owl sad
parrot pro art
peoria poi era
pierre per ire
poodle pol ode
pounce puc one
racial rca ail
realty rat ely
sordid sri odd
spatial sail pta
sprain sri pan
strain sri tan
strait sri tat
sturdy sud try
sweaty set way
tattle ttl ate
theorem term hoe
though tog huh
throaty tray hot
triode tid roe
triune tin rue
troupe top rue
truant tun rat
twirly til wry


A more straightforward approach:

  [ [] [] rot witheach [ join swap ] ] is unzip    ( [ --> [ [ )

  [ $ "rosetta/unixdict.txt" sharefile
   drop nest$ 
   [] swap witheach 
      [ [ nested join ]
         else drop ] ]        constant is unixdict (   --> [   )

  unixdict witheach
    [ dup size 6 < iff
        drop done
      dup unzip 
      unixdict find 
      unixdict found iff
        [ unixdict find 
          unixdict found iff 
            [ dup echo$ sp
              unzip echo$ sp
              echo$ cr ] 
            else drop ]
        else 2drop ]
Output:
accost acs cot
accuse acs cue
afield ail fed
agleam ala gem
alcott act lot
allele all lee
allied ale lid
alpert apr let
ambient min abet
annette net ante
apport apr pot
ariadne ran aide
assist ass sit
battle btl ate
blaine ban lie
brenda bed rna
calliope clip aloe
choose cos hoe
choosy cos hoy
claire car lie
collude old clue
effete eft fee
fabric fbi arc
fealty fat ely
fluent fun let
forwent own fret
friend fin red
george gog ere
inroad ira nod
israel ire sal
jaunty jut any
joanne jan one
lounge lug one
oriole oil roe
oswald owl sad
parrot pro art
peoria poi era
pierre per ire
poodle pol ode
pounce puc one
racial rca ail
realty rat ely
sordid sri odd
spatial pta sail
sprain sri pan
strain sri tan
strait sri tat
sturdy sud try
sweaty set way
tattle ttl ate
theorem hoe term
though tog huh
throaty hot tray
triode tid roe
triune tin rue
troupe top rue
truant tun rat
twirly til wry

Raku

unit sub MAIN ($file = 'unixdict.txt', :$min = 6);

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

my @alternades;

for %words {
    next if .key.chars < $min;
    my @letters = .key.comb;
    my @alts = @letters[0,2 … *].join, @letters[1,3 … *].join;
    @alternades.push(.key => @alts) if %words{@alts[0]} && %words{@alts[1]};
}

@alternades.=sort;

say "{+@alternades} alternades longer than {$min-1} characters found in $file:";

.say for @alternades > 10
  ?? (flat @alternades.head(5), '...', @alternades.tail(5))
  !! @alternades;
Output:
58 alternades longer than 5 characters found in unixdict.txt:
accost => [acs cot]
accuse => [acs cue]
afield => [ail fed]
agleam => [ala gem]
alcott => [act lot]
...
triode => [tid roe]
triune => [tin rue]
troupe => [top rue]
truant => [tun rat]
twirly => [til wry]

REXX

version 1, caseless

This REXX version doesn't care what order the words in the dictionary are in,   nor does it care what
case  (lower/upper/mixed)  the words are in,   the search for alternades is   caseless.

It also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.

/*REXX program finds all the caseless alternade words (within an identified dictionary).*/
parse arg minL iFID .                            /*obtain optional arguments from the CL*/
if minL=='' | minL=="," then minL= 6             /*Not specified?  Then use the default.*/
if iFID=='' | iFID=="," then iFID='unixdict.txt' /* "      "         "   "   "     "    */
@.=                                              /*default value of any dictionary word.*/
            do #=1  while lines(iFID)\==0        /*read each word in the file  (word=X).*/
            x= strip( linein( iFID) )            /*pick off a word from the input line. */
            $.#= x;       upper x;       @.x= .  /*save: original case and the semaphore*/
            end   /*#*/                          /* [↑]   semaphore name is uppercased. */
#= # - 1                                         /*adjust word count because of DO loop.*/
finds= 0                                         /*count of the alternade words found.  */
say copies('─', 30)      #      "words in the dictionary file: "       iFID
say
        do j=1  for #;           L= length($.j)  /*process all the words that were found*/
        if L<minL  then iterate                  /*Is word too short?   Then ignore it. */
        p.=                                      /*initialize 2 parts of alternade word.*/
             do k=1  for L;         _= k // 2    /*build the  "   "    "      "      "  */
             p._= p._  ||  substr($.j, k, 1)     /*append to one part of alternade word.*/
             end   /*k*/

        parse upper value  p.0 p.1  with  p0 p1  /*obtain the uppercase alternade parts.*/
        if @.p0=='' | @.p1==''  then iterate     /*either parts of alternade not extant?*/
        finds= finds + 1                         /*bump the  count  of alternades found.*/
        say right(left($.j, 20), 25)    left(p.1, 10)    left(p.0, 10)   /*indent a bit.*/
        end        /*j*/
                                                 /*stick a fork in it,  we're all done. */
say copies('─',30)    finds   '  alternade words found with a minimum length of '    minL
output   when using the default inputs:
────────────────────────────── 25104 words in the dictionary file:  unixdict.txt

     accost               acs        cot
     accuse               acs        cue
     afield               ail        fed
     agleam               ala        gem
     alcott               act        lot
     allele               all        lee
     allied               ale        lid
     alpert               apr        let
     ambient              abet       min
     annette              ante       net
     apport               apr        pot
     ariadne              aide       ran
     assist               ass        sit
     battle               btl        ate
     blaine               ban        lie
     brenda               bed        rna
     calliope             clip       aloe
     choose               cos        hoe
     choosy               cos        hoy
     claire               car        lie
     collude              clue       old
     effete               eft        fee
     fabric               fbi        arc
     fealty               fat        ely
     fluent               fun        let
     forwent              fret       own
     friend               fin        red
     george               gog        ere
     inroad               ira        nod
     israel               ire        sal
     jaunty               jut        any
     joanne               jan        one
     lounge               lug        one
     oriole               oil        roe
     oswald               owl        sad
     parrot               pro        art
     peoria               poi        era
     pierre               per        ire
     poodle               pol        ode
     pounce               puc        one
     racial               rca        ail
     realty               rat        ely
     sordid               sri        odd
     spatial              sail       pta
     sprain               sri        pan
     strain               sri        tan
     strait               sri        tat
     sturdy               sud        try
     sweaty               set        way
     tattle               ttl        ate
     theorem              term       hoe
     though               tog        huh
     throaty              tray       hot
     triode               tid        roe
     triune               tin        rue
     troupe               top        rue
     truant               tun        rat
     twirly               til        wry
────────────────────────────── 58   alternade words found with a minimum length of  6

version 2

This REXX version only handles the case (lowercase) of the dictionary being used,   in this case,   only lowercase words.

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

/* REXX */
fid='d:\unix.txt'
cnt.=0  /* cnt.n -> words of length n         */
ww.=0   /* ww.*  the words to be analyzed     */
w.=0    /* w.word = 1 if word is in unix.txt  */
Do While lines(fid)>0
  l=linein(fid)     /* a word                 */
  ll=length(l)      /* its length             */
  cnt.ll=cnt.ll+1   /* count it               */
  w.l=1             /*  word is in unix.txt   */
  If ll>=6 Then Do  /* worth to be analyzed   */
    z=ww.0+1        /* add it to the list     */
    ww.z=l
    ww.0=z
    End
  End
Say cnt.3 'three letter words'
Say cnt.4 'four letter words'
Say cnt.5 'five letter words'
Say cnt.6 'six letter words'
Say cnt.7 'seven letter words'
Say cnt.8 'eight letter words'
n=0
Do i=1 To ww.0
  Parse Value split(ww.i) With u v
  If w.u & w.v Then Do
    n=n+1
    Say format(n,2) left(ww.i,8) left(u,4) v
    End
  End
Exit
split: Procedure
/* split the word into components */
  Parse Arg w
  s.=''
  Do While w<>''
    Parse Var w uu +1 vv +1 w
    s.u=s.u||uu
    s.v=s.v||vv
    End
  Return s.u s.v

Output:

D:\>rexx alternade
796 three letter words
2187 four letter words
3161 five letter words
3873 six letter words
4060 seven letter words
3618 eight letter words
 1 accost   acs  cot
 2 accuse   acs  cue
 3 afield   ail  fed
 4 agleam   ala  gem
 5 alcott   act  lot
 6 allele   all  lee
 7 allied   ale  lid
 8 alpert   apr  let
 9 ambient  abet min
10 annette  ante net
11 apport   apr  pot
12 ariadne  aide ran
13 assist   ass  sit
14 battle   btl  ate
15 blaine   ban  lie
16 brenda   bed  rna
17 calliope clip aloe
18 choose   cos  hoe
19 choosy   cos  hoy
20 claire   car  lie
21 collude  clue old
22 effete   eft  fee
23 fabric   fbi  arc
24 fealty   fat  ely
25 fluent   fun  let
26 forwent  fret own
27 friend   fin  red
28 george   gog  ere
29 inroad   ira  nod
30 israel   ire  sal
31 jaunty   jut  any
32 joanne   jan  one
33 lounge   lug  one
34 oriole   oil  roe
35 oswald   owl  sad
36 parrot   pro  art
37 peoria   poi  era
38 pierre   per  ire
39 poodle   pol  ode
40 pounce   puc  one
41 racial   rca  ail
42 realty   rat  ely
43 sordid   sri  odd
44 spatial  sail pta
45 sprain   sri  pan
46 strain   sri  tan
47 strait   sri  tat
48 sturdy   sud  try
49 sweaty   set  way
50 tattle   ttl  ate
51 theorem  term hoe
52 though   tog  huh
53 throaty  tray hot
54 triode   tid  roe
55 triune   tin  rue
56 troupe   top  rue
57 truant   tun  rat
58 twirly   til  wry

Ring

load "stdlib.ring"

cStr = read("unixdict.txt")
wordList = str2list(cStr)
sum = 0
see "working..." + nl + nl

for n = 1 to len(wordList) 
    wordOdd = ""
    wordEven = ""
    for m = 1 to len(wordList[n]) step 2
        wordOdd = wordOdd + wordList[n][m] 
    next
    for m = 2 to len(wordList[n]) step 2
        wordEven = wordEven + wordList[n][m] 
    next
    indOdd = find(wordList,wordOdd)
    indEven = find(wordList,wordEven)
    if indOdd > 0 and indEven > 0 and len(wordList[indOdd]) > 2 and len(wordList[indEven]) > 2
       sum = sum + 1 
       see "" + sum + ". "
       see "word = " + wordList[n] + nl
       see "wordOdd = " + wordList[indOdd] + nl
       see "wordEven = " + wordList[indEven] + nl + nl
    ok
next
see "done..." + nl

Output:

working...

1. word = accost
wordOdd = acs
wordEven = cot

2. word = accuse
wordOdd = acs
wordEven = cue

3. word = afield
wordOdd = ail
wordEven = fed

4. word = agleam
wordOdd = ala
wordEven = gem

5. word = alcott
wordOdd = act
wordEven = lot

6. word = allele
wordOdd = all
wordEven = lee

7. word = allied
wordOdd = ale
wordEven = lid

8. word = alpert
wordOdd = apr
wordEven = let

9. word = ambient
wordOdd = abet
wordEven = min

10. word = annette
wordOdd = ante
wordEven = net

11. word = apport
wordOdd = apr
wordEven = pot

12. word = ariadne
wordOdd = aide
wordEven = ran

13. word = assist
wordOdd = ass
wordEven = sit

14. word = battle
wordOdd = btl
wordEven = ate

15. word = blaine
wordOdd = ban
wordEven = lie

16. word = brenda
wordOdd = bed
wordEven = rna

17. word = calliope
wordOdd = clip
wordEven = aloe

18. word = choose
wordOdd = cos
wordEven = hoe

19. word = choosy
wordOdd = cos
wordEven = hoy

20. word = claire
wordOdd = car
wordEven = lie

21. word = collude
wordOdd = clue
wordEven = old

22. word = effete
wordOdd = eft
wordEven = fee

23. word = fabric
wordOdd = fbi
wordEven = arc

24. word = fealty
wordOdd = fat
wordEven = ely

25. word = fluent
wordOdd = fun
wordEven = let

26. word = forwent
wordOdd = fret
wordEven = own

27. word = friend
wordOdd = fin
wordEven = red

28. word = george
wordOdd = gog
wordEven = ere

29. word = inroad
wordOdd = ira
wordEven = nod

30. word = israel
wordOdd = ire
wordEven = sal

31. word = jaunty
wordOdd = jut
wordEven = any

32. word = joanne
wordOdd = jan
wordEven = one

33. word = lounge
wordOdd = lug
wordEven = one

34. word = oriole
wordOdd = oil
wordEven = roe

35. word = oswald
wordOdd = owl
wordEven = sad

36. word = parrot
wordOdd = pro
wordEven = art

37. word = peoria
wordOdd = poi
wordEven = era

38. word = pierre
wordOdd = per
wordEven = ire

39. word = poodle
wordOdd = pol
wordEven = ode

40. word = pounce
wordOdd = puc
wordEven = one

41. word = racial
wordOdd = rca
wordEven = ail

42. word = realty
wordOdd = rat
wordEven = ely

43. word = sordid
wordOdd = sri
wordEven = odd

44. word = spatial
wordOdd = sail
wordEven = pta

45. word = sprain
wordOdd = sri
wordEven = pan

46. word = strain
wordOdd = sri
wordEven = tan

47. word = strait
wordOdd = sri
wordEven = tat

48. word = sturdy
wordOdd = sud
wordEven = try

49. word = sweaty
wordOdd = set
wordEven = way

50. word = tattle
wordOdd = ttl
wordEven = ate

51. word = theorem
wordOdd = term
wordEven = hoe

52. word = though
wordOdd = tog
wordEven = huh

53. word = throaty
wordOdd = tray
wordEven = hot

54. word = triode
wordOdd = tid
wordEven = roe

55. word = triune
wordOdd = tin
wordEven = rue

56. word = troupe
wordOdd = top
wordEven = rue

57. word = truant
wordOdd = tun
wordEven = rat

58. word = twirly
wordOdd = til
wordEven = wry

done...

Ruby

words = File.open("unixdict.txt").map(&:chomp)

res = words.filter_map do |word|
  next if word.size < 6
  splitted = word.each_char.partition.with_index{|_,i| i.even? }.map(&:join)
  next unless splitted.all?{|split| words.bsearch{|w| split <=> w} }
  "#{word}: #{splitted.join(", ")}"
end

puts res
Output:
accost: acs, cot
accuse: acs, cue
afield: ail, fed
agleam: ala, gem
alcott: act, lot
allele: all, lee
allied: ale, lid
alpert: apr, let
ambient: abet, min
annette: ante, net
apport: apr, pot
ariadne: aide, ran
assist: ass, sit
battle: btl, ate
blaine: ban, lie
brenda: bed, rna
calliope: clip, aloe
choose: cos, hoe
choosy: cos, hoy
claire: car, lie
collude: clue, old
effete: eft, fee
fabric: fbi, arc
fealty: fat, ely
fluent: fun, let
forwent: fret, own
friend: fin, red
george: gog, ere
inroad: ira, nod
israel: ire, sal
jaunty: jut, any
joanne: jan, one
lounge: lug, one
oriole: oil, roe
oswald: owl, sad
parrot: pro, art
peoria: poi, era
pierre: per, ire
poodle: pol, ode
pounce: puc, one
racial: rca, ail
realty: rat, ely
sordid: sri, odd
spatial: sail, pta
sprain: sri, pan
strain: sri, tan
strait: sri, tat
sturdy: sud, try
sweaty: set, way
tattle: ttl, ate
theorem: term, hoe
though: tog, huh
throaty: tray, hot
triode: tid, roe
triune: tin, rue
troupe: top, rue
truant: tun, rat
twirly: til, wry

Rust

use std::collections::BTreeSet;
use std::fs::File;
use std::io::{self, BufRead};

fn load_dictionary(filename: &str) -> std::io::Result<BTreeSet<String>> {
    let file = File::open(filename)?;
    let mut dict = BTreeSet::new();
    for line in io::BufReader::new(file).lines() {
        dict.insert(line?);
    }
    Ok(dict)
}

fn main() {
    match load_dictionary("unixdict.txt") {
        Ok(dictionary) => {
            for word in &dictionary {
                if word.len() < 6 {
                    continue;
                }
                let mut odd_word = String::new();
                let mut even_word = String::new();
                for (i, c) in word.chars().enumerate() {
                    if (i & 1) == 0 {
                        odd_word.push(c);
                    } else {
                        even_word.push(c);
                    }
                }
                if dictionary.contains(&odd_word) && dictionary.contains(&even_word) {
                    println!("{:<10}{:<6}{}", word, odd_word, even_word);
                }
            }
        }
        Err(error) => eprintln!("{}", error),
    }
}
Output:
accost    acs   cot
accuse    acs   cue
afield    ail   fed
agleam    ala   gem
alcott    act   lot
allele    all   lee
allied    ale   lid
alpert    apr   let
ambient   abet  min
annette   ante  net
apport    apr   pot
ariadne   aide  ran
assist    ass   sit
battle    btl   ate
blaine    ban   lie
brenda    bed   rna
calliope  clip  aloe
choose    cos   hoe
choosy    cos   hoy
claire    car   lie
collude   clue  old
effete    eft   fee
fabric    fbi   arc
fealty    fat   ely
fluent    fun   let
forwent   fret  own
friend    fin   red
george    gog   ere
inroad    ira   nod
israel    ire   sal
jaunty    jut   any
joanne    jan   one
lounge    lug   one
oriole    oil   roe
oswald    owl   sad
parrot    pro   art
peoria    poi   era
pierre    per   ire
poodle    pol   ode
pounce    puc   one
racial    rca   ail
realty    rat   ely
sordid    sri   odd
spatial   sail  pta
sprain    sri   pan
strain    sri   tan
strait    sri   tat
sturdy    sud   try
sweaty    set   way
tattle    ttl   ate
theorem   term  hoe
though    tog   huh
throaty   tray  hot
triode    tid   roe
triune    tin   rue
troupe    top   rue
truant    tun   rat
twirly    til   wry

Swift

import Foundation

func loadDictionary(_ path: String) throws -> Set<String> {
    let contents = try String(contentsOfFile: path, encoding: String.Encoding.ascii)
    return Set<String>(contents.components(separatedBy: "\n").filter{!$0.isEmpty})
}

func lpad(string: String, width: Int) -> String {
    return string.count >= width ? string
        : string + String(repeating: " ", count: width - string.count)
}

do {
    let dictionary = try loadDictionary("unixdict.txt")
    var alternades: [(String,String,String)] = []
    for word in dictionary {
        if word.count < 6 {
            continue
        }
        var word1 = ""
        var word2 = ""
        for (i, c) in word.enumerated() {
            if (i & 1) == 0 {
                word1.append(c)
            } else {
                word2.append(c)
            }
        }
        if dictionary.contains(word1) && dictionary.contains(word2) {
            alternades.append((word, word1, word2))
        }
    }
    alternades.sort(by: {$0.0 < $1.0})
    for (word, word1, word2) in alternades {
        print("\(lpad(string: word, width: 10))\(lpad(string: word1, width: 6))\(word2)")
    }
} catch {
    print(error.localizedDescription)
}
Output:
accost    acs   cot
accuse    acs   cue
afield    ail   fed
agleam    ala   gem
alcott    act   lot
allele    all   lee
allied    ale   lid
alpert    apr   let
ambient   abet  min
annette   ante  net
apport    apr   pot
ariadne   aide  ran
assist    ass   sit
battle    btl   ate
blaine    ban   lie
brenda    bed   rna
calliope  clip  aloe
choose    cos   hoe
choosy    cos   hoy
claire    car   lie
collude   clue  old
effete    eft   fee
fabric    fbi   arc
fealty    fat   ely
fluent    fun   let
forwent   fret  own
friend    fin   red
george    gog   ere
inroad    ira   nod
israel    ire   sal
jaunty    jut   any
joanne    jan   one
lounge    lug   one
oriole    oil   roe
oswald    owl   sad
parrot    pro   art
peoria    poi   era
pierre    per   ire
poodle    pol   ode
pounce    puc   one
racial    rca   ail
realty    rat   ely
sordid    sri   odd
spatial   sail  pta
sprain    sri   pan
strain    sri   tan
strait    sri   tat
sturdy    sud   try
sweaty    set   way
tattle    ttl   ate
theorem   term  hoe
though    tog   huh
throaty   tray  hot
triode    tid   roe
triune    tin   rue
troupe    top   rue
truant    tun   rat
twirly    til   wry

Tcl

set unixdict [dict create]
foreach word [read [open unixdict.txt]] {
	dict set unixdict $word {}
}

proc is_alt_word word {
	global unixdict
	for {set i 0} {$i < [string length $word]} {incr i} {
		append [expr {$i % 2 ? "odd" : "even"}] [string index $word $i]
	}
	if {[dict exists $unixdict $even] && [dict exists $unixdict $odd]} {
		return [list $even $odd]
	}
}

foreach word [dict keys $unixdict] {
	if {[string length $word] >= 6 && [set oddeven [is_alt_word $word]] ne ""} {
		puts "$word $oddeven"
	}
}
Output:
$ tclsh alternate_words.tcl | column -t
accost    acs   cot
accuse    acs   cue
afield    ail   fed
agleam    ala   gem
alcott    act   lot
allele    all   lee
allied    ale   lid
alpert    apr   let
ambient   abet  min
annette   ante  net
apport    apr   pot
ariadne   aide  ran
assist    ass   sit
battle    btl   ate
blaine    ban   lie
brenda    bed   rna
calliope  clip  aloe
choose    cos   hoe
choosy    cos   hoy
claire    car   lie
collude   clue  old
effete    eft   fee
fabric    fbi   arc
fealty    fat   ely
fluent    fun   let
forwent   fret  own
friend    fin   red
george    gog   ere
inroad    ira   nod
israel    ire   sal
jaunty    jut   any
joanne    jan   one
lounge    lug   one
oriole    oil   roe
oswald    owl   sad
parrot    pro   art
peoria    poi   era
pierre    per   ire
poodle    pol   ode
pounce    puc   one
racial    rca   ail
realty    rat   ely
sordid    sri   odd
spatial   sail  pta
sprain    sri   pan
strain    sri   tan
strait    sri   tat
sturdy    sud   try
sweaty    set   way
tattle    ttl   ate
theorem   term  hoe
though    tog   huh
throaty   tray  hot
triode    tid   roe
triune    tin   rue
troupe    top   rue
truant    tun   rat
twirly    til   wry

V (Vlang)

Translation of: go
import os

fn main() {
    bwords := os.read_lines('unixdict.txt')?//bytes.Fields(b)
    mut dict := map[string]bool{}
    mut words := bwords.clone()
    for bword in bwords {
        dict[bword] = true
    }
    println("'unixdict.txt' contains the following alternades of length 6 or more:\n")
    mut count := 0
    for word in words {
        if word.len < 6 {
            continue
        }
        mut w1 := ""
        mut w2 := ""
        for i, c in word {
            if i%2 == 0 {
                w1 += c.ascii_str()
            } else {
                w2 += c.ascii_str()
            }
        }
        ok1 := w1 in dict
        ok2 := w2 in dict
        if ok1 && ok2 {
            count++
            println("${count:2}: ${word:-8} -> ${w1:-4} ${w2:-4}")
        }
    }
}
Output:
Same as Go entry

Wren

Library: Wren-set
Library: Wren-fmt
import "io" for File
import "./set" for Set
import "./fmt" for Fmt

var wordList = "unixdict.txt" // local copy
var set = Set.new()
var words = File.read(wordList).trimEnd().split("\n")
for (word in words) set.add(word)
System.print("'unixdict.txt' contains the following alternades of length 6 or more:\n")
var count = 0
for (word in words) {
    if (word.count >= 6) {
        var w1 = ""
        var w2 = ""
        var i = 0
        for (c in word) {
           if (i%2 == 0) {
                w1 = w1 + c
           } else {
                w2 = w2 + c
           }
           i = i + 1
        }
        if (set.contains(w1) && set.contains(w2)) {
            count = count + 1
            Fmt.print("$2d: $-8s -> $-4s $-4s", count, word, w1, w2)
        }
    }
}
Output:
'unixdict.txt' contains the following alternades of length 6 or more:

 1: accost   -> acs  cot 
 2: accuse   -> acs  cue 
 3: afield   -> ail  fed 
 4: agleam   -> ala  gem 
 5: alcott   -> act  lot 
 6: allele   -> all  lee 
 7: allied   -> ale  lid 
 8: alpert   -> apr  let 
 9: ambient  -> abet min 
10: annette  -> ante net 
11: apport   -> apr  pot 
12: ariadne  -> aide ran 
13: assist   -> ass  sit 
14: battle   -> btl  ate 
15: blaine   -> ban  lie 
16: brenda   -> bed  rna 
17: calliope -> clip aloe
18: choose   -> cos  hoe 
19: choosy   -> cos  hoy 
20: claire   -> car  lie 
21: collude  -> clue old 
22: effete   -> eft  fee 
23: fabric   -> fbi  arc 
24: fealty   -> fat  ely 
25: fluent   -> fun  let 
26: forwent  -> fret own 
27: friend   -> fin  red 
28: george   -> gog  ere 
29: inroad   -> ira  nod 
30: israel   -> ire  sal 
31: jaunty   -> jut  any 
32: joanne   -> jan  one 
33: lounge   -> lug  one 
34: oriole   -> oil  roe 
35: oswald   -> owl  sad 
36: parrot   -> pro  art 
37: peoria   -> poi  era 
38: pierre   -> per  ire 
39: poodle   -> pol  ode 
40: pounce   -> puc  one 
41: racial   -> rca  ail 
42: realty   -> rat  ely 
43: sordid   -> sri  odd 
44: spatial  -> sail pta 
45: sprain   -> sri  pan 
46: strain   -> sri  tan 
47: strait   -> sri  tat 
48: sturdy   -> sud  try 
49: sweaty   -> set  way 
50: tattle   -> ttl  ate 
51: theorem  -> term hoe 
52: though   -> tog  huh 
53: throaty  -> tray hot 
54: triode   -> tid  roe 
55: triune   -> tin  rue 
56: troupe   -> top  rue 
57: truant   -> tun  rat 
58: twirly   -> til  wry 

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     I, I0, I1, DI, Ch, Count;
char    Word, Alt0(25), Alt1(25);
def     Tab=$09, LF=$0A, CR=$0D, EOF=$1A;

[FSet(FOpen("unixdict.txt", 0), ^I); \load dictionary
OpenI(3);                        \assume alphabetical order and all lowercase
DI:= 0;                          \ignore non-alpha characters: 0..9, ' and &
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;
                ];
        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;
repeat  Word:= Dict(DI);        \print out all alternade words
        I:= 0;  I0:= 0;  I1:= 0;
        loop    [Ch:= Word(I);  \get even and odd alternades
                if Ch = 0 then quit;
                if I&1 then [Alt1(I1):= Ch;  I1:= I1+1]
                       else [Alt0(I0):= Ch;  I0:= I0+1];
                I:= I+1;
                ];
        if I >= 6 then          \Word must have at least 6 chars
                [Alt0(I0):= 0;  Alt1(I1):= 0;
                if LookUp(Alt0) & LookUp(Alt1) then
                        [Count:= Count+1;
                        IntOut(0, Count);  ChOut(0, Tab);
                        Text(0, Word);  ChOut(0, Tab);
                        Text(0, Alt0);  ChOut(0, Tab);
                        Text(0, Alt1);  CrLf(0);
                        ];
                ];
        DI:= DI+1;
until   DI >= DictSize;
]
Output:
1       accost  acs     cot
2       accuse  acs     cue
3       afield  ail     fed
4       agleam  ala     gem
5       alcott  act     lot
6       allele  all     lee
7       allied  ale     lid
8       alpert  apr     let
9       ambient abet    min
10      annette ante    net
11      apport  apr     pot
12      ariadne aide    ran
13      assist  ass     sit
14      battle  btl     ate
15      blaine  ban     lie
16      brenda  bed     rna
17      calliope        clip    aloe
18      choose  cos     hoe
19      choosy  cos     hoy
20      claire  car     lie
21      collude clue    old
22      effete  eft     fee
23      fabric  fbi     arc
24      fealty  fat     ely
25      fluent  fun     let
26      forwent fret    own
27      friend  fin     red
28      george  gog     ere
29      inroad  ira     nod
30      israel  ire     sal
31      jaunty  jut     any
32      joanne  jan     one
33      lounge  lug     one
34      oriole  oil     roe
35      oswald  owl     sad
36      parrot  pro     art
37      peoria  poi     era
38      pierre  per     ire
39      poodle  pol     ode
40      pounce  puc     one
41      racial  rca     ail
42      realty  rat     ely
43      sordid  sri     odd
44      spatial sail    pta
45      sprain  sri     pan
46      strain  sri     tan
47      strait  sri     tat
48      sturdy  sud     try
49      sweaty  set     way
50      tattle  ttl     ate
51      theorem term    hoe
52      though  tog     huh
53      throaty tray    hot
54      triode  tid     roe
55      triune  tin     rue
56      troupe  top     rue
57      truant  tun     rat
58      twirly  til     wry