Change e letters to i in words: Difference between revisions

{{trans|Nim}}

V words_set = Set(words)

V new_word = word.replace(‘e’, ‘i’)

I new_word != word & new_word C words_set

{{out}}

=={{header|Ada}}==

with Ada.Strings.Fixed;

with Ada.Strings.Maps;

end;

end loop;

{{out}}

<pre>analyses -> analysis

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

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

PR read "aArray.a68" PR

e := NEXT words

OD

{{out}}

Note, the associative array is not traversed in lexicographical order, the output here has been sorted for ease of comparison with other samples.

Because of the huge size of the original word list and the number of changed words to check, it's nearly 100 times as fast to ensure the list is sorted and to use a binary search handler as it is to use the language's built-in '''is in''' command! (1.17 seconds instead of 110 on my current machine.) A further, lesser but interesting optimisation is to work through the sorted list in reverse, storing possible "i" word candidates encountered before getting to any "e" words from which they can be derived. Changed "e" words then only need to be checked against this smaller collection.

use sorter : script "Custom Iterative Ternary Merge Sort" -- <https://macscripter.net/viewtopic.php?pid=194430#p194430>

use scripting additions

end task

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

end task

===Functional===

and defining the list of twins as an intersection of sets.

set my text item delimiters to dlm

s

{{Out}}

<pre>analysis <- analyses

=={{header|Arturo}}==

loop words 'word [

if and? [contains? word "e"][contains? words iw] ->

print [word "=>" iw]

{{out}}

=={{header|AutoHotkey}}==

oWord := []

for i, word in StrSplit(db, "`n", "`r")

result .= word . (StrLen(word) > 8 ? "`t" : "`t`t") . ": " StrReplace(word, "e", "i") "`n"

{{out}}

<pre>analyses : analysis

=={{header|AWK}}==

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

#

exit(0)

}

{{out}}

<pre>

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

free_dictionary(dictionary, size);

return EXIT_SUCCESS;

{{out}}

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

#include <cstdlib>

#include <fstream>

return EXIT_SUCCESS;

{{out}}

{{libheader| System.SysUtils}}

{{libheader| System.Classes}}

program Change_e_letters_to_i_in_words;

readln;

{{out}}

<pre>analyses ──► analysis

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

{{out}}

<pre>

</pre>

=={{header|Factor}}==

io.files kernel literals math sequences splitting ;

[ dup "e" "i" replace ] map>alist

[ nip words sorted-member? ] assoc-filter ! binary search

{{out}}

<pre>

=={{header|FreeBASIC}}==

type node

end if

curr = curr->nxt

{{out}}<pre>

analyses analysis

=={{header|Go}}==

import (

}

}

{{out}}

=={{header|Haskell}}==

------ DICTIONARY WORDS TWINNED BY e -> i REPLACEMENT ----

main =

readFile "unixdict.txt"

{{Out}}

<pre>("analyses","analysis")

=={{header|J}}==

analysis

atlantis

synopsis

victor

=={{header|JavaScript}}==

Here we use the ObjC interface of macOS ''JavaScript for Automation'' to define a '''readFile''' function.

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>["analyses","analysis"]

For the sake of brevity, we confine attention to words longer than 6 characters.

def e2i($dict):

select(index("e"))

| e2i($dict)

| "\($w) → \(.)"

Invocation: jq -n -rR -f e2i.jq unixdict.txt

{{out}}

=={{header|Julia}}==

See [[Alternade_words]] for the foreachword function.

foreachword("unixdict.txt", e2i, minlen=6, colwidth=23, numcols=4)

<pre>

Word source: unixdict.txt

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

dict //= StringSplit[#, "\n"] &;

dict //= Select[StringLength /* GreaterThan[5]];

sel = Select[dict, StringContainsQ["e"]];

sel = Select[sel, MemberQ[dict, StringReplace[#, "e" -> "i"]] &];

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

let newWord = word.replace('e', 'i')

if newWord.len > 5 and newWord != word and newWord in wordSet:

{{out}}

=={{header|Perl}}==

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

my %i = map { tr/i/e/r => sprintf "%30s %s\n", tr/i/e/r, $_ }

grep !/e/, grep 5 <= length, $file =~ /^.*i.*$/gm;

{{out}}

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

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

=={{header|Prolog}}==

{{works with|SWI Prolog}}

main:-

replace(Ch1, Ch2, Chars1, Chars2).

replace(Ch1, Ch2, [Ch|Chars1], [Ch|Chars2]):-

{{out}}

Needs Python 3.8 or above for the assignment operator in the list comprehension.

{{Works with|Python|3.8}}

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>('analyses', 'analysis')

=={{header|Quackery}}==

witheach [

dup nested

[ swap echo$ cr ]

else nip ]

{{out}}

=={{header|R}}==

changed <- chartr("e", "i", dict)

{{out}}

<pre> Before After

=={{header|Raku}}==

{{out}}

It also allows the minimum length to be specified on the command line (CL), &nbsp; as well as the old character &nbsp; (that is

<br>to be changed), &nbsp; the new character &nbsp; (that is to be changed into), &nbsp; 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.*/

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

say copies('─',30) finds " words found that were changed with " oldC '──►' ,

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

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see "done..." + nl

{{out}}

<pre>

=={{header|Ruby}}==

words.each do |word|

next if word.size < 6

puts "#{word.ljust(10)} -> #{e2i}"

end

{{out}}

<pre style="height: 30ex">analyses -> analysis

=={{header|Rust}}==

use std::fs::File;

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

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

}

{{out}}

=={{header|Sidef}}==

if (!file.exists) {

printf("%2d: %20s <-> %s\n", ++count, word, changed)

}

{{out}}

<pre>

=={{header|Swift}}==

func loadDictionary(path: String, minLength: Int) throws -> Set<String> {

} catch {

print(error.localizedDescription)

{{out}}

=={{header|VBScript}}==

Run it in CScript.

with createobject("ADODB.Stream")

.charset ="UTF-8"

next

{{out}}

<pre>

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

import "/sort" for Find

import "/fmt" for Fmt

}

}

{{out}}

=={{header|XPL0}}==

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

int DictSize; \actual number of pointers in Dict

DI:= DI+1;

until DI >= DictSize;

{{out}}