Rosetta Code

Change e letters to i in words: Difference between revisions

Page Discussion

Change e letters to i in words (view source)

Revision as of 14:15, 14 November 2023

3,742 bytes added ,  6 months ago
add SETL
m (syntax highlighting fixup automation)
(add SETL)
 
(6 intermediate revisions by 6 users not shown)
Line 1:
{{Draft task}}
{{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.}}
;Task:
Use the dictionary   [https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt unixdict.txt]
Line 15 ⟶ 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)
 
Line 57 ⟶ 53:
welles -> willis
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang=Ada"ada">with Ada.Text_Io;
with Ada.Strings.Fixed;
with Ada.Strings.Maps;
Line 127 ⟶ 122:
vector -> victor
welles -> willis</pre>
 
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68"># find words where replacing "e" with "i" results in another word #
# use the associative array in the Associate array/iteration task #
PR read "aArray.a68" PR
Line 217 ⟶ 211:
welles -> willis
</pre>
 
=={{header|AppleScript}}==
===Core language only===
<syntaxhighlight lang="applescript">use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later.
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 "Insertion sort" -- <https://rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript>
 
<syntaxhighlight lang=applescript>use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later.
use sorter : script "Custom Iterative Ternary Merge Sort" -- <https://macscripter.net/viewtopic.php?pid=194430#p194430>
use scripting additions
 
Line 233 ⟶ 224:
repeat until (l = r)
set m to (l + r) div 2
if (item m of o's lst's item m < v) then
set l to m + 1
else
Line 240 ⟶ 231:
end repeat
if (item l of o's lst's item l is= v) then return l
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 253 ⟶ 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.
tell sorter to sort(o's wordList, 1, wordCount) -- Not actually needed with unixdict.txt.
set iWordCount to 0
set iWordCount to 0
set astid to AppleScript's text item delimiters
repeat with i from wordCount to 1 by -1
set thisWord to item iset ofthisWord to o's wordList's item i
if ((count thisWord) < minWordLength) then
else if ((thisWord contains "e") and (iWordCount > 0)) then
set AppleScript's text item delimitersset changedWord to replace("e", "i", thisWord)
set tis to thisWord if (binarySearch(changedWord, o's textiWords, 1, iWordCount) > 0) itemsthen
set AppleScriptbeginning of o's text item delimitersoutput to "i"{thisWord, changedWord}
set changedWord to tis asend textif
else if (binarySearch(changedWord, o's iWords, 1, iWordCount)thisWord >contains 0"i") then
set beginning of o's outputiWords to {thisWord, changedWord}
set iWordCount to iWordCount + 1
end if
elseend if (thisWord contains "i") thenrepeat
end ignoring
set beginning of o's iWords to thisWord
set iWordCount to iWordCount + 1
end if
end repeat
set AppleScript's text item delimiters to astid
return o's output
Line 281 ⟶ 279:
 
{{output}}
<syntaxhighlight lang="applescript">{{"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"}}</syntaxhighlight>
 
===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.
 
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
use scripting additions
Line 357 ⟶ 355:
and defining the list of twins as an intersection of sets.
 
<syntaxhighlight lang="applescript">use framework "Foundation"
 
 
Line 540 ⟶ 538:
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">words: map read.lines relative "unixdict.txt" => strip
 
loop words 'word [
Line 580 ⟶ 578:
vector => victor
welles => willis</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang=AutoHotkey"autohotkey">FileRead, db, % A_Desktop "\unixdict.txt"
oWord := []
for i, word in StrSplit(db, "`n", "`r")
Line 620 ⟶ 617:
vector : victor
welles : willis</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang=AWK"awk">
# syntax: GAWK -f CHANGE_E_LETTERS_TO_I_IN_WORDS.AWK unixdict.txt
#
Line 679 ⟶ 675:
welles willis
</pre>
 
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
Line 812 ⟶ 807:
26. welles -> willis
</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <algorithm>
#include <cstdlib>
#include <fstream>
Line 881 ⟶ 875:
26. welles -> willis
</pre>
 
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Classes}}
<syntaxhighlight lang=Delphi"delphi">
program Change_e_letters_to_i_in_words;
 
Line 953 ⟶ 946:
vector ──► victor
welles ──► willis</pre>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// 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)
Line 991 ⟶ 983:
</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: assocs binary-search formatting io.encodings.ascii
io.files kernel literals math sequences splitting ;
 
Line 1,031 ⟶ 1,023:
welles -> willis
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#define NULL 0
 
type node
Line 1,121 ⟶ 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}}==
<syntaxhighlight lang="go">package main
 
import (
Line 1,192 ⟶ 1,252:
26: welles -> willis
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import qualified Data.Set as S
 
------ DICTIONARY WORDS TWINNED BY e -> i REPLACEMENT ----
Line 1,246 ⟶ 1,305:
("vector","victor")
("welles","willis")</pre>
 
=={{header|J}}==
<syntaxhighlight lang=J"j"> >(([-.-.)rplc&'ei'&.>@(#~ ('e'&e. * 5<#)@>)) cutLF fread 'unixdict.txt'
analysis
atlantis
Line 1,275 ⟶ 1,333:
victor
willis</syntaxhighlight>
 
=={{header|JavaScript}}==
{{Works with| macOS}}
Line 1,283 ⟶ 1,340:
Here we use the ObjC interface of macOS ''JavaScript for Automation'' to define a '''readFile''' function.
 
<syntaxhighlight lang="javascript">(() => {
"use strict";
Line 1,369 ⟶ 1,426:
["vector","victor"]
["welles","willis"]</pre>
 
=={{header|jq}}==
{{works with|jq}}
Line 1,376 ⟶ 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,409 ⟶ 1,465:
synopses → synopsis
</pre>
 
=={{header|Julia}}==
See [[Alternade_words]] for the foreachword function.
<syntaxhighlight lang="julia">e2i(w, d) = (if 'e' in w s = replace(w, "e" => "i"); haskey(d, s) && return "$w => $s" end; "")
foreachword("unixdict.txt", e2i, minlen=6, colwidth=23, numcols=4)
</syntaxhighlight>{{out}}
Line 1,426 ⟶ 1,481:
vector => victor welles => willis
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang=Mathematica"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]];
Line 1,436 ⟶ 1,490:
{{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}}==
<syntaxhighlight lang=Nim"nim">import sets, strutils, sugar
 
# Build a set of words to speed up membership check.
Line 1,475 ⟶ 1,528:
vector → victor
welles → willis</pre>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Change_e_letters_to_i_in_words
Line 1,534 ⟶ 1,586:
wrest wrist
</pre>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang=Phix"phix">(phixonline)-->
<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,548 ⟶ 1,599:
26 words: {{"analyses","analysis"},{"atlantes","atlantis"},"...",{"vector","victor"},{"welles","willis"}}
</pre>
 
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">:- dynamic dictionary_word/1.
 
main:-
Line 1,614 ⟶ 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}}
<syntaxhighlight lang="python">'''Dictionary words twinned by (e -> i) replacement'''
 
 
Line 1,697 ⟶ 1,745:
('vector', 'victor')
('welles', 'willis')</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang=Quackery"quackery"> [ [] swap ]'[ swap
witheach [
dup nested
Line 1,757 ⟶ 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>
Line 1,790 ⟶ 1,836:
[25,] "vector" "victor"
[26,] "welles" "willis"</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" line>my %ei = 'unixdict.txt'.IO.words.grep({ .chars > 5 and /<[ie]>/ }).map: { $_ => .subst('e', 'i', :g) };
put %ei.grep( *.key.contains: 'e' ).grep({ %ei{.value}:exists }).sort.batch(4)».gist».fmt('%-22s').join: "\n";</syntaxhighlight>
 
Line 1,803 ⟶ 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, &nbsp; nor does it care what
Line 1,810 ⟶ 1,854:
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.
<syntaxhighlight lang="rexx">/*REXX pgm finds words with changed letter E──►I and is a word (in a specified dict).*/
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,871 ⟶ 1,915:
────────────────────────────── 26 words found that were changed with E ──► I, and with a minimum length of 6
</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 1,935 ⟶ 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}}==
<syntaxhighlight lang="ruby">words = File.readlines("unixdict.txt").map(&:chomp)
words.each do |word|
next if word.size < 6
Line 1,977 ⟶ 2,041:
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::collections::BTreeSet;
use std::fs::File;
use std::io::{self, BufRead};
Line 2,038 ⟶ 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}}==
<syntaxhighlight lang="ruby">var file = File("unixdict.txt")
 
if (!file.exists) {
Line 2,097 ⟶ 2,208:
 
=={{header|Swift}}==
<syntaxhighlight lang="swift">import Foundation
 
func loadDictionary(path: String, minLength: Int) throws -> Set<String> {
Line 2,155 ⟶ 2,266:
26. welles -> willis
</pre>
 
=={{header|VBScript}}==
Run it in CScript.
<syntaxhighlight lang="vb">
with createobject("ADODB.Stream")
.charset ="UTF-8"
Line 2,216 ⟶ 2,326:
welles -> willis
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-sort}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang=ecmascript"wren">import "io" for File
import "./sort" for Find
import "./fmt" for Fmt
 
var wordList = "unixdict.txt" // local copy
Line 2,269 ⟶ 2,378:
 
=={{header|XPL0}}==
<syntaxhighlight lang=XPL0"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
Line 2,368 ⟶ 2,477:
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.}}
Not a robot
2,093

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327194...354559"