Change e letters to i in words: Difference between revisions

{{Draft task}}

;Task:

Use the dictionary   [https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt unixdict.txt]

{{Template:Strings}}

<br><br>

=={{header|11l}}==

{{trans|Nim}}

 

V words_set = Set(words)

 

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

I new_word != word & new_word C words_set

 

{{out}}

welles -> willis

</pre>

=={{header|Ada}}==

with Ada.Strings.Fixed;

with Ada.Strings.Maps;

end;

end loop;

{{out}}

<pre>analyses -> analysis

vector -> victor

welles -> willis</pre>

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

welles -> willis

</pre>

=={{header|AppleScript}}==

use scripting additions

 

repeat until (l = r)

set m to (l + r) div 2

set l to m + 1

else

end repeat

return 0

end binarySearch

 

on task(minWordLength)

set wordCount to (count o's wordList)

end if

return o's output

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

vector => victor

welles => willis</pre>

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

vector : victor

welles : willis</pre>

=={{header|AWK}}==

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

#

exit(0)

}

{{out}}

<pre>

welles willis

</pre>

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

free_dictionary(dictionary, size);

return EXIT_SUCCESS;

 

{{out}}

26. welles -> willis

</pre>

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

#include <cstdlib>

#include <fstream>

 

return EXIT_SUCCESS;

 

{{out}}

26. welles -> willis

</pre>

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.Classes}}

program Change_e_letters_to_i_in_words;

 

 

readln;

{{out}}

<pre>analyses ──► analysis

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)

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

welles -> willis

</pre>

=={{header|FreeBASIC}}==

 

type node

end if

curr = curr->nxt

{{out}}<pre>

analyses analysis

vector victor

welles willis</pre>

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

26: welles -> willis

</pre>

=={{header|Haskell}}==

 

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

main =

readFile "unixdict.txt"

{{Out}}

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

("vector","victor")

("welles","willis")</pre>

=={{header|J}}==

analysis

atlantis

synopsis

victor

=={{header|JavaScript}}==

{{Works with| macOS}}

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

["vector","victor"]

["welles","willis"]</pre>

=={{header|jq}}==

{{works with|jq}}

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

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

vector => victor welles => willis

</pre>

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

vector → victor

welles → willis</pre>

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

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>

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

replace(Ch1, Ch2, Chars1, Chars2).

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

 

{{out}}

welles -> willis

</pre>

=={{header|Python}}==

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

('vector', 'victor')

('welles', 'willis')</pre>

=={{header|Quackery}}==

 

witheach [

dup nested

[ swap echo$ cr ]

else nip ]

 

{{out}}

victor

willis</pre>

=={{header|R}}==

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

{{out}}

<pre> Before After

[25,] "vector" "victor"

[26,] "welles" "willis"</pre>

=={{header|Raku}}==

 

{{out}}

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, &nbsp; nor does it care what

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>

────────────────────────────── 26 words found that were changed with E ──► I, and with a minimum length of 6

</pre>

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done..." + nl

{{out}}

<pre>

26. welles => willis

done...

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

26. welles -> willis

</pre>

 

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

26. welles -> willis

</pre>

=={{header|VBScript}}==

Run it in CScript.

with createobject("ADODB.Stream")

.charset ="UTF-8"

next

 

{{out}}

<pre>

welles -> willis

</pre>

=={{header|Wren}}==

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var wordList = "unixdict.txt" // local copy

}

}

 

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

welles -> willis

</pre>