Change e letters to i in words: Difference between revisions
Content deleted Content added
Added Vim Script solution |
|||
(34 intermediate revisions by 17 users not shown) | |||
Line 1:
{{Draft task}}
;Task:
Use the dictionary [https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt unixdict.txt]
Line 13 ⟶ 12:
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Nim}}
<syntaxhighlight lang="11l">V words = File(‘unixdict.txt’).read().split("\n")
V words_set = Set(words)
L(word) words
I word.len > 5
V new_word = word.replace(‘e’, ‘i’)
I new_word != word & new_word C words_set
print(word‘ -> ’new_word)</syntaxhighlight>
{{out}}
<pre>
analyses -> analysis
atlantes -> atlantis
bellow -> billow
breton -> briton
clench -> clinch
convect -> convict
crises -> crisis
diagnoses -> diagnosis
enfant -> infant
enquiry -> inquiry
frances -> francis
galatea -> galatia
harden -> hardin
heckman -> hickman
inequity -> iniquity
inflect -> inflict
jacobean -> jacobian
marten -> martin
module -> moduli
pegging -> pigging
psychoses -> psychosis
rabbet -> rabbit
sterling -> stirling
synopses -> synopsis
vector -> victor
welles -> willis
</pre>
=={{header|Ada}}==
<
with Ada.Strings.Fixed;
with Ada.Strings.Maps;
Line 55 ⟶ 94:
end;
end loop;
end Change_E_To_I;</
{{out}}
<pre>analyses -> analysis
Line 83 ⟶ 122:
vector -> victor
welles -> willis</pre>
=={{header|ALGOL 68}}==
<
# use the associative array in the Associate array/iteration task #
PR read "aArray.a68" PR
Line 142 ⟶ 180:
e := NEXT words
OD
FI</
{{out}}
Note, the associative array is not traversed in lexicographical order, the output here has been sorted for ease of comparison with other samples.
Line 173 ⟶ 211:
welles -> willis
</pre>
=={{header|AppleScript}}==
===Core language
<syntaxhighlight lang="applescript">use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later.
use sorter : script "Insertion sort" -- <https://rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript>
use scripting additions
Line 189 ⟶ 224:
repeat until (l = r)
set m to (l + r) div 2
if (
set l to m + 1
else
Line 196 ⟶ 231:
end repeat
if (
return 0
end binarySearch
on replace(a, b, txt)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to a
set txt to txt's text items
set AppleScript's text item delimiters to b
set txt to txt as text
set AppleScript's text item delimiters to astid
return txt
end replace
on task(minWordLength)
Line 209 ⟶ 254:
set wordCount to (count o's wordList)
ignoring case
tell sorter to sort(o's wordList, 1, wordCount) -- Not actually needed with unixdict.txt.
set iWordCount to 0
repeat with i from wordCount to 1 by -1
if ((count thisWord) < minWordLength) then
else if ((thisWord contains "e") and (iWordCount > 0)) then
set
else if (
set beginning of o's
set iWordCount to iWordCount + 1
end if
end ignoring
return o's output
end task
task(6)</
{{output}}
<
===AppleScriptObjC===
The Foundation framework has very fast array filters, but reducing the checklist size and checking with the same binary search handler as above are also effective. This version takes about 0.37 seconds. As above, the case-sensitivity and sorting arrangements are superfluous with unixdict.txt, but are included for interest. Same result.
<
use framework "Foundation"
use scripting additions
Line 304 ⟶ 346:
end task
task(6)</
===Functional===
Line 313 ⟶ 355:
and defining the list of twins as an intersection of sets.
<
Line 320 ⟶ 362:
-- ieTwins :: String -> [(String, String)]
on ieTwins(s)
-- Pairs of dictionary words in s which
-- are twinned by (e -> i) replacement
set ca to current application
set
set eWords to
filteredArrayUsingPredicate:(
set
filteredArrayUsingPredicate:(containsString("i")))
set possibles to (allReplaced("e", "i", ¬
(eWords's componentsJoinedByString:(linefeed))))'s ¬
componentsSeparatedByString:(linefeed)
set possibleSet to ca's NSMutableSet's setWithArray:(possibles)
possibleSet's intersectSet:(lexicon)
-- Dictionary of possible words and their sources
set dict to
-- Listing of candidate words which are found in the dictionary
Line 350 ⟶ 389:
script pair
on |λ|(k)
{
end |λ|
end script
Line 364 ⟶ 403:
set {e, i} to ei
end |λ|
end script
Line 371 ⟶ 410:
ieTwins(readFile("~/Desktop/unixdict.txt"))))
end run
------------------------- GENERIC ------------------------
-- allRplaced :: String -> String -> NSString -> NSString
on allReplaced(needle, replacement, haystack)
haystack's stringByReplacingOccurrencesOfString:(needle) ¬
withString:(replacement)
end allReplaced
-- containsString :: String -> NSPredicate
on containsString(s)
tell current application
its (NSPredicate's ¬
predicateWithFormat:("self contains '" &
end tell
end containsString
-- dictFromZip :: NSArray -> NSArray -> NSDictionary
on dictFromZip(ks, vs)
tell current application
its (NSDictionary's ¬
dictionaryWithObjects:vs forKeys:ks)
end tell
end
-- filteredLines :: String ->
on filteredLines(predicateString, s)
-- A list of lines filtered by an NSPredicate string
Line 392 ⟶ 446:
predicateWithFormat:predicateString)
set array to its (NSArray's ¬
arrayWithArray:(s's componentsSeparatedByString:(
end tell
Line 453 ⟶ 507:
set my text item delimiters to dlm
s
end unlines</
{{Out}}
<pre>
atlantis <- atlantes
billow <- bellow
briton <- breton
clinch <- clench
convict <- convect
crisis <- crises
diagnosis <- diagnoses
francis <- frances
galatia <- galatea
hardin <- harden
hickman <- heckman
infant <- enfant
inflict <- inflect
iniquity <- inequity
inquiry <- enquiry
jacobian <- jacobean
martin <- marten
moduli <- module
pigging <- pegging
psychosis <- psychoses
rabbit <- rabbet
stirling <- sterling
synopsis <- synopses
victor <- vector
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">words: map read.lines relative "unixdict.txt" => strip
loop words 'word [
sw: new size word
if 6 > size word ->
continue
iw: replace word "e" "i"
if and? [contains? word "e"][contains? words iw] ->
print [word "=>" iw]
]</syntaxhighlight>
{{out}}
<pre>analyses => analysis
atlantes => atlantis
bellow => billow
breton => briton
clench => clinch
convect => convict
crises => crisis
diagnoses => diagnosis
enfant => infant
enquiry => inquiry
frances => francis
galatea => galatia
harden => hardin
heckman => hickman
inequity => iniquity
inflect => inflict
jacobean => jacobian
marten => martin
module => moduli
pegging => pigging
psychoses => psychosis
rabbet => rabbit
sterling => stirling
synopses => synopsis
vector => victor
welles => willis</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">FileRead, db, % A_Desktop "\unixdict.txt"
oWord := []
for i, word in StrSplit(db, "`n", "`r")
if (StrLen(word) > 5)
oWord[word] := true
for word in oWord
if InStr(word, "e") && oWord[StrReplace(word, "e", "i")]
result .= word . (StrLen(word) > 8 ? "`t" : "`t`t") . ": " StrReplace(word, "e", "i") "`n"
MsgBox, 262144, , % result</syntaxhighlight>
{{out}}
<pre>analyses : analysis
atlantes : atlantis
bellow : billow
breton : briton
clench : clinch
convect : convict
crises : crisis
diagnoses : diagnosis
enfant : infant
enquiry : inquiry
frances : francis
galatea : galatia
harden : hardin
heckman : hickman
inequity : iniquity
inflect : inflict
jacobean : jacobian
marten : martin
module : moduli
pegging : pigging
psychoses : psychosis
rabbet : rabbit
sterling : stirling
synopses : synopsis
vector : victor
welles : willis</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f CHANGE_E_LETTERS_TO_I_IN_WORDS.AWK unixdict.txt
#
Line 510 ⟶ 645:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 540 ⟶ 675:
welles willis
</pre>
=={{header|C}}==
<
#include <stdio.h>
#include <stdlib.h>
Line 642 ⟶ 776:
free_dictionary(dictionary, size);
return EXIT_SUCCESS;
}</
{{out}}
Line 673 ⟶ 807:
26. welles -> willis
</pre>
=={{header|C++}}==
<
#include <cstdlib>
#include <fstream>
Line 711 ⟶ 844:
return EXIT_SUCCESS;
}</
{{out}}
Line 742 ⟶ 875:
26. welles -> willis
</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Classes}}
<syntaxhighlight lang="delphi">
program Change_e_letters_to_i_in_words;
Line 786 ⟶ 918:
readln;
end.</
{{out}}
<pre>analyses ──► analysis
Line 814 ⟶ 946:
vector ──► victor
welles ──► willis</pre>
=={{header|F_Sharp|F#}}==
<
// Change 'e' to 'i' in words. Nigel Galloway: February 18th., 2021
let g=[|use n=System.IO.File.OpenText("unixdict.txt") in while not n.EndOfStream do yield n.ReadLine()|]|>Array.filter(fun n->n.Length>5)
let fN g=(g,(Seq.map(fun n->if n='e' then 'i' else n)>>Array.ofSeq>>System.String)g)
g|>Array.filter(Seq.contains 'e')|>Array.map fN|>Array.filter(fun(_,n)-> Array.contains n g)|>Array.iter(fun(n,g)->printfn "%s -> %s" n g)
</syntaxhighlight>
{{out}}
<pre>
Line 852 ⟶ 983:
</pre>
=={{header|Factor}}==
<
io.files kernel literals math sequences splitting ;
Line 862 ⟶ 993:
[ dup "e" "i" replace ] map>alist
[ nip words sorted-member? ] assoc-filter ! binary search
[ "%-9s -> %s\n" printf ] assoc-each</
{{out}}
<pre>
Line 892 ⟶ 1,023:
welles -> willis
</pre>
=={{header|FreeBASIC}}==
<
type node
Line 954 ⟶ 1,084:
end if
curr = curr->nxt
wend</
{{out}}<pre>
analyses analysis
Line 982 ⟶ 1,112:
vector victor
welles willis</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
#plist NSAppTransportSecurity @{NSAllowsArbitraryLoads:YES}
void local fn DoIt
CFURLRef url
CFStringRef string, wd
ErrorRef err = NULL
CFArrayRef array
CFMutableArrayRef mutArray
url = fn URLWithString( @"https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt" )
string = fn StringWithContentsOfURL( url, NSUTF8StringEncoding, @err )
if ( string )
array = fn StringComponentsSeparatedByCharactersInSet( string, fn CharacterSetNewlineSet )
mutArray = fn MutableArrayWithCapacity(0)
for wd in array
if ( len(wd) > 5 and fn StringContainsString( wd, @"e" ) )
wd = fn StringByReplacingOccurrencesOfString( wd, @"e", @"i" )
if ( fn ArrayContainsObject( array, wd ) )
MutableArrayAddObject( mutArray, wd )
end if
end if
next
string = fn ArrayComponentsJoinedByString( mutArray, @"\n" )
NSLog(@"%@",string)
else
NSLog(@"%@",err)
end if
end fn
fn DoIt
HandleEvents</syntaxhighlight>
{{out}}
<pre>
analysis
atlantis
billow
briton
clinch
convict
crisis
diagnosis
infant
inquiry
francis
galatia
hardin
hickman
iniquity
inflict
jacobian
martin
moduli
pigging
psychosis
rabbit
stirling
synopsis
victor
willis
</pre>
=={{header|Go}}==
<
import (
Line 1,022 ⟶ 1,221:
}
}
}</
{{out}}
Line 1,053 ⟶ 1,252:
26: welles -> willis
</pre>
=={{header|Haskell}}==
<
------ DICTIONARY WORDS TWINNED BY e -> i REPLACEMENT ----
Line 1,062 ⟶ 1,260:
ieTwins s =
[ (w, twin)
| w <-
let twin = iForE w,
S.member twin lexicon
]
where
lexicon = S.fromList
iForE :: String -> String
Line 1,079 ⟶ 1,277:
main =
readFile "unixdict.txt"
>>= (mapM_ print . ieTwins)</
{{Out}}
<pre>("analyses","analysis")
Line 1,107 ⟶ 1,305:
("vector","victor")
("welles","willis")</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> >(([-.-.)rplc&'ei'&.>@(#~ ('e'&e. * 5<#)@>)) cutLF fread 'unixdict.txt'
analysis
atlantis
billow
briton
clinch
convict
crisis
diagnosis
francis
galatia
hardin
hickman
infant
inflict
iniquity
inquiry
jacobian
martin
moduli
pigging
psychosis
rabbit
stirling
synopsis
victor
willis</syntaxhighlight>
=={{header|JavaScript}}==
{{Works with| macOS}}
Line 1,115 ⟶ 1,340:
Here we use the ObjC interface of macOS ''JavaScript for Automation'' to define a '''readFile''' function.
<
"use strict";
// ieTwins :: String -> [(String, String)]
const ieTwins = s => {
const
.filter(x => 5 < x.length),
lexicon = new Set(
),
rgx = /e/gu;
return
w => w.includes("e") ? (() => {
const x = w.replace(rgx, "i");
return lexicon.has(x) ? [
[w, x]
Line 1,138 ⟶ 1,363:
);
};
// ---------------------- TEST -----------------------
// main :: IO ()
const main = () => {
const s = readFile("unixdict.txt");
return ieTwins(s)
.map(JSON.stringify)
.join("\n");
};
// --------------------- GENERIC ---------------------
// readFile :: FilePath -> IO String
const readFile = fp => {
Line 1,163 ⟶ 1,388:
e
);
return ObjC.unwrap(
ns.isNil() ? (
Line 1,170 ⟶ 1,395:
);
};
// MAIN ---
return main();
})();</
{{Out}}
<pre>["analyses","analysis"]
Line 1,201 ⟶ 1,426:
["vector","victor"]
["welles","willis"]</pre>
=={{header|jq}}==
{{works with|jq}}
Line 1,208 ⟶ 1,432:
For the sake of brevity, we confine attention to words longer than 6 characters.
<syntaxhighlight lang="jq">
def e2i($dict):
select(index("e"))
Line 1,221 ⟶ 1,445:
| e2i($dict)
| "\($w) → \(.)"
</syntaxhighlight>
Invocation: jq -n -rR -f e2i.jq unixdict.txt
{{out}}
Line 1,241 ⟶ 1,465:
synopses → synopsis
</pre>
=={{header|Julia}}==
See [[Alternade_words]] for the foreachword function.
<
foreachword("unixdict.txt", e2i, minlen=6, colwidth=23, numcols=4)
</
<pre>
Word source: unixdict.txt
Line 1,258 ⟶ 1,481:
vector => victor welles => willis
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">dict = Once[Import["https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt"]];
dict //= StringSplit[#, "\n"] &;
dict //= Select[StringLength /* GreaterThan[5]];
sel = Select[dict, StringContainsQ["e"]];
sel = Select[sel, MemberQ[dict, StringReplace[#, "e" -> "i"]] &];
{#, StringReplace[#, "e" -> "i"]} & /@ sel</syntaxhighlight>
{{out}}
<pre>{{analyses,analysis},{atlantes,atlantis},{bellow,billow},{breton,briton},{clench,clinch},{convect,convict},{crises,crisis},{diagnoses,diagnosis},{enfant,infant},{enquiry,inquiry},{frances,francis},{galatea,galatia},{harden,hardin},{heckman,hickman},{inequity,iniquity},{inflect,inflict},{jacobean,jacobian},{marten,martin},{module,moduli},{pegging,pigging},{psychoses,psychosis},{rabbet,rabbit},{sterling,stirling},{synopses,synopsis},{vector,victor},{welles,willis}}</pre>
=={{header|Nim}}==
<
# Build a set of words to speed up membership check.
Line 1,268 ⟶ 1,499:
let newWord = word.replace('e', 'i')
if newWord.len > 5 and newWord != word and newWord in wordSet:
echo word, " → ", newWord</
{{out}}
Line 1,297 ⟶ 1,528:
vector → victor
welles → willis</pre>
=={{header|Perl}}==
<
use strict; # https://rosettacode.org/wiki/Change_e_letters_to_i_in_words
Line 1,308 ⟶ 1,538:
my %i = map { tr/i/e/r => sprintf "%30s %s\n", tr/i/e/r, $_ }
grep !/e/, grep 5 <= length, $file =~ /^.*i.*$/gm;
print @i{ split ' ', $file };</
{{out}}
<pre>
Line 1,356 ⟶ 1,586:
wrest wrist
</pre>
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">()</span>
Line 1,365 ⟶ 1,594:
<span style="color: #004080;">sequence</span> <span style="color: #000000;">chetie</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #000000;">words</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cheti</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">chetei</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({</span><span style="color: #000000;">chetie</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">chetie</span><span style="color: #0000FF;">,</span><span style="color: #000000;">chei</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d words: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">chetei</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">chetei</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)})</span>
<!--</
{{out}}
<pre>
26 words: {{"analyses","analysis"},{"atlantes","atlantis"},"...",{"vector","victor"},{"welles","willis"}}
</pre>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
main:-
Line 1,405 ⟶ 1,633:
replace(Ch1, Ch2, Chars1, Chars2).
replace(Ch1, Ch2, [Ch|Chars1], [Ch|Chars2]):-
replace(Ch1, Ch2, Chars1, Chars2).</
{{out}}
Line 1,436 ⟶ 1,664:
welles -> willis
</pre>
=={{header|Python}}==
Needs Python 3.8 or above for the assignment operator in the list comprehension.
{{Works with|Python|3.8}}
<
Line 1,450 ⟶ 1,676:
'e' by 'i'.
'''
w for w in s.splitlines()
if 5 < len(w)
]
lexicon = {
w for w in longWords
if 'i' in w
}
return [
(w, twin) for w in
if
twin := w.replace('e', 'i')
) in lexicon
Line 1,485 ⟶ 1,717:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>('analyses', 'analysis')
Line 1,513 ⟶ 1,745:
('vector', 'victor')
('welles', 'willis')</pre>
=={{header|Quackery}}==
<
witheach [
dup nested
Line 1,543 ⟶ 1,774:
[ swap echo$ cr ]
else nip ]
drop</
{{out}}
Line 1,573 ⟶ 1,804:
victor
willis</pre>
=={{header|R}}==
<syntaxhighlight lang="rsplus">dict <- scan("https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt", what = character())
changed <- chartr("e", "i", dict)
cbind(Before = dict, After = changed)[changed != dict & changed %in% dict & nchar(changed) > 5, ]</syntaxhighlight>
{{out}}
<pre> Before After
[1,] "analyses" "analysis"
[2,] "atlantes" "atlantis"
[3,] "bellow" "billow"
[4,] "breton" "briton"
[5,] "clench" "clinch"
[6,] "convect" "convict"
[7,] "crises" "crisis"
[8,] "diagnoses" "diagnosis"
[9,] "enfant" "infant"
[10,] "enquiry" "inquiry"
[11,] "frances" "francis"
[12,] "galatea" "galatia"
[13,] "harden" "hardin"
[14,] "heckman" "hickman"
[15,] "inequity" "iniquity"
[16,] "inflect" "inflict"
[17,] "jacobean" "jacobian"
[18,] "marten" "martin"
[19,] "module" "moduli"
[20,] "pegging" "pigging"
[21,] "psychoses" "psychosis"
[22,] "rabbet" "rabbit"
[23,] "sterling" "stirling"
[24,] "synopses" "synopsis"
[25,] "vector" "victor"
[26,] "welles" "willis"</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
put %ei.grep( *.key.contains: 'e' ).grep({ %ei{.value}:exists }).sort.batch(4)».gist».fmt('%-22s').join: "\n";</
{{out}}
Line 1,586 ⟶ 1,848:
psychoses => psychosis rabbet => rabbit sterling => stirling synopses => synopsis
vector => victor welles => willis</pre>
=={{header|REXX}}==
This REXX version doesn't care what order the words in the dictionary are in, nor does it care what
Line 1,593 ⟶ 1,854:
It also allows the minimum length to be specified on the command line (CL), as well as the old character (that is
<br>to be changed), the new character (that is to be changed into), and as well as the dictionary file identifier.
<
parse arg minL oldC newC iFID . /*obtain optional arguments from the CL*/
if minL=='' | minL=="," then minL= 6 /*Not specified? Then use the default.*/
Line 1,620 ⟶ 1,881:
say /*stick a fork in it, we're all done. */
say copies('─',30) finds " words found that were changed with " oldC '──►' ,
newC", and with a minimum length of " minL</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,654 ⟶ 1,915:
────────────────────────────── 26 words found that were changed with E ──► I, and with a minimum length of 6
</pre>
=={{header|Ring}}==
<
load "stdlib.ring"
Line 1,686 ⟶ 1,946:
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
Line 1,718 ⟶ 1,978:
26. welles => willis
done...
</pre>
=={{header|RPL}}==
The only way to use <code>unixdict.txt</code> as input is to convert it into a list of 25104 strings. Fortunately, emulators can handle such a big data structure in RAM.
{{works with|Halcyon Calc|4.2.7}}
≪ → words
≪ { }
<span style="color:red">1</span> words EVAL SIZE '''FOR''' j
words j GET
'''IF''' DUP SIZE <span style="color:red">5</span> ≤ OVER <span style="color:red">"e"</span> POS NOT OR '''THEN''' DROP '''ELSE'''
<span style="color:red">""</span>
<span style="color:red">1 3</span> PICK SIZE '''FOR''' j
OVER j DUP SUB
NUM R→B <span style="color:red">#20h</span> OR B→R CHR <span style="color:grey">@turn into lowercase</span>
DUP <span style="color:red">"e"</span> == <span style="color:red">"i"</span> ROT IFTE +
'''NEXT'''
'''IF''' words EVAL OVER POS '''THEN''' <span style="color:red">" → "</span> SWAP + + + '''ELSE''' DROP2 '''END'''
'''END NEXT'''
≫ ≫ ‘<span style="color:blue">E→I</span>’ STO
{{out}}
<pre>
1: { "analyses → analysis" "atlantes → atlantis" "bellow → billow" "breton → briton" "clench → clinch" "convect → convict" "crises → crisis" "diagnoses → diagnosis" "enfant → infant" "enquiry → inquiry" "frances → francis" "galatea → galatia" "harden → hardin" "heckman → hickman" "inequity → iniquity" "inflect → inflict" "jacobean → jacobian" "marten → martin" "module → moduli" "pegging → pigging" "psychoses → psychosis" "rabbet → rabbit" "sterling → stirling" "synopses → synopsis" "vector → victor" "welles → willis" }
</pre>
=={{header|Ruby}}==
<
words.each do |word|
next if word.size < 6
Line 1,729 ⟶ 2,010:
puts "#{word.ljust(10)} -> #{e2i}"
end
</syntaxhighlight>
{{out}}
<pre style="height: 30ex">analyses -> analysis
Line 1,760 ⟶ 2,041:
=={{header|Rust}}==
<
use std::fs::File;
use std::io::{self, BufRead};
Line 1,790 ⟶ 2,071:
Err(error) => eprintln!("{}", error),
}
}</
{{out}}
Line 1,821 ⟶ 2,102:
26. welles -> willis
</pre>
=={{header|SETL}}==
<syntaxhighlight lang="setl">program change_e_letters_to_i_in_words;
dictfile := open("unixdict.txt", "r");
dict := {getline(dictfile) : until eof(dictfile)};
close(dictfile);
loop for word in dict | #word > 5 do
if "e" notin word then continue; end if;
iword := replaceall(word, "e", "i");
if iword notin dict then continue; end if;
print([word, iword]);
end loop;
proc replaceall(word, x, y);
loop while x in word do
word(x) := y;
end loop;
return word;
end proc;
end program;</syntaxhighlight>
{{out}}
<pre>[analyses analysis]
[atlantes atlantis]
[bellow billow]
[breton briton]
[clench clinch]
[convect convict]
[crises crisis]
[diagnoses diagnosis]
[enfant infant]
[enquiry inquiry]
[frances francis]
[galatea galatia]
[harden hardin]
[heckman hickman]
[inequity iniquity]
[inflect inflict]
[jacobean jacobian]
[marten martin]
[module moduli]
[pegging pigging]
[psychoses psychosis]
[rabbet rabbit]
[sterling stirling]
[synopses synopsis]
[vector victor]
[welles willis]</pre>
=={{header|Sidef}}==
<
if (!file.exists) {
Line 1,848 ⟶ 2,176:
printf("%2d: %20s <-> %s\n", ++count, word, changed)
}
}</
{{out}}
<pre>
Line 1,880 ⟶ 2,208:
=={{header|Swift}}==
<
func loadDictionary(path: String, minLength: Int) throws -> Set<String> {
Line 1,907 ⟶ 2,235:
} catch {
print(error.localizedDescription)
}</
{{out}}
Line 1,937 ⟶ 2,265:
25. vector -> victor
26. welles -> willis
</pre>
=={{header|VBScript}}==
Run it in CScript.
<syntaxhighlight lang="vb">
with createobject("ADODB.Stream")
.charset ="UTF-8"
.open
.loadfromfile("unixdict.txt")
s=.readtext
end with
a=split (s,vblf)
set d=createobject("scripting.dictionary")
redim b(ubound(a))
i=0
for each x in a
s=trim(x)
if len(s)>5 then
if instr(s,"i") then d.add s,""
if instr(s,"e") then b(i)=s: i=i+1
end if
next
redim preserve b(i-1)
for i=0 to ubound(b)
s=trim(b(i))
s2=replace(s,"e","i")
if d.exists(s2) then
wscript.echo left(s& space(10),10) & "-> " & s2
end if
next
</syntaxhighlight>
{{out}}
<pre>
analyses -> analysis
atlantes -> atlantis
bellow -> billow
breton -> briton
clench -> clinch
convect -> convict
crises -> crisis
diagnoses -> diagnosis
enfant -> infant
enquiry -> inquiry
frances -> francis
galatea -> galatia
harden -> hardin
heckman -> hickman
inequity -> iniquity
inflect -> inflict
jacobean -> jacobian
marten -> martin
module -> moduli
pegging -> pigging
psychoses -> psychosis
rabbet -> rabbit
sterling -> stirling
synopses -> synopsis
vector -> victor
welles -> willis
</pre>
=={{header|Vim Script}}==
In Vim, a [https://vimhelp.org/eval.txt.html#Dictionary dictionary] is an associative array with the entries not stored in a specific order. So, for this task, the output is put into a [https://vimhelp.org/eval.txt.html#List list], which enables it to be sorted with the builtin [https://vimhelp.org/builtin.txt.html#sort%28%29 sort()] function and output to the end of the current buffer. If only the unsorted words identified were wanted, the list-related lines could be omitted and one [https://vimhelp.org/builtin.txt.html#append%28%29 append] line used to ouput the matches (within the second 'for' loop). Although the problem does not say the output must be sorted, it's been done to allow for easier comparison of the output with other solutions.
<syntaxhighlight lang="vim">
let s:word_dict = {}
for word in readfile('unixdict.txt')
if strlen(word) > 5
let s:word_dict[word] = substitute(word, 'e', 'i', 'g')
endif
endfor
let s:word_list = []
for [key, value] in items(s:word_dict)
if key != value && s:word_dict->has_key(value)
call add(s:word_list, value .. " <- " .. key)
endif
endfor
call append(line('$'), sort(s:word_list))
</syntaxhighlight>
{{out}}
<pre>
analysis <- analyses
atlantis <- atlantes
billow <- bellow
briton <- breton
clinch <- clench
convict <- convect
crisis <- crises
diagnosis <- diagnoses
francis <- frances
galatia <- galatea
hardin <- harden
hickman <- heckman
infant <- enfant
inflict <- inflect
iniquity <- inequity
inquiry <- enquiry
jacobian <- jacobean
martin <- marten
moduli <- module
pigging <- pegging
psychosis <- psychoses
rabbit <- rabbet
stirling <- sterling
synopsis <- synopses
victor <- vector
willis <- welles
</pre>
Line 1,942 ⟶ 2,380:
{{libheader|Wren-sort}}
{{libheader|Wren-fmt}}
<
import "./sort" for Find
import "./fmt" for Fmt
var wordList = "unixdict.txt" // local copy
Line 1,958 ⟶ 2,396:
}
}
}</
{{out}}
Line 1,989 ⟶ 2,427:
26: welles -> willis
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">string 0; \use zero-terminated strings
int Dict(26000); \pointers to words (enough for unixdict.txt)
int DictSize; \actual number of pointers in Dict
func StrCmp(A, B); \Compare string A to B
char A, B; \Returns: >0 if A>B, =0 if A=B, and <0 if A<B
int I;
[for I:= 0 to -1>>1 do
[if A(I) # B(I) then return A(I) - B(I);
if A(I) = 0 then return 0;
];
]; \StrCmp
func LookUp(Word); \Return 'true' if Word is in Dict
char Word;
int Lo, Hi, I, Cmp;
[Lo:= 0; Hi:= DictSize-1;
loop [I:= (Lo+Hi) / 2; \binary search
Cmp:= StrCmp(Word, Dict(I));
if Cmp < 0 then Hi:= I-1 else Lo:= I+1;
if Cmp = 0 then return true;
if Lo > Hi then return false;
];
]; \LookUp
int I, DI, Ch, HasE;
char Word, AltWord(25); \(longest word in unixdict is 22 chars)
def LF=$0A, CR=$0D, EOF=$1A;
[FSet(FOpen("unixdict.txt", 0), ^I); \load dictionary into Dict
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;
repeat Word:= Dict(DI);
I:= 0; HasE:= false;
loop [Ch:= Word(I);
AltWord(I):= Ch;
if Ch = 0 then quit;
if Ch = ^e then
[HasE:= true;
AltWord(I):= ^i;
];
I:= I+1;
];
if HasE & I>5 then \Word must be greater than 5 chars
[if LookUp(AltWord) then
[Text(0, Word);
Text(0, " -> ");
Text(0, AltWord);
CrLf(0);
];
];
DI:= DI+1;
until DI >= DictSize;
]</syntaxhighlight>
{{out}}
<pre>
analyses -> analysis
atlantes -> atlantis
bellow -> billow
breton -> briton
clench -> clinch
convect -> convict
crises -> crisis
diagnoses -> diagnosis
enfant -> infant
enquiry -> inquiry
frances -> francis
galatea -> galatia
harden -> hardin
heckman -> hickman
inequity -> iniquity
inflect -> inflict
jacobean -> jacobian
marten -> martin
module -> moduli
pegging -> pigging
psychoses -> psychosis
rabbet -> rabbit
sterling -> stirling
synopses -> synopsis
vector -> victor
welles -> willis
</pre>
{{omit from|6502 Assembly|unixdict.txt is much larger than the CPU's address space.}}
{{omit from|8080 Assembly|See 6502 Assembly.}}
{{omit from|Z80 Assembly|See 6502 Assembly.}}
|