ABC words: Difference between revisions
→{{header|Free Pascal}}
| (22 intermediate revisions by 11 users not shown) | |||
Line 1:
{{draft task}}
;Definition
Line 19 ⟶ 16:
=={{header|11l}}==
<
V? a = ln.find(‘a’)
I a != N
V b = ln.findi(‘b’)
I a < b & b < ln.findi(‘c’)
print(ln)</
{{out}}
Line 87 ⟶ 84:
=={{header|Action!}}==
In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/unixdict.txt unixdict.txt] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.
<
BYTE i
Line 137 ⟶ 134:
FindAbcWords(fname)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/ABC_words.png Screenshot from Atari 8-bit computer]
Line 160 ⟶ 157:
=={{header|Ada}}==
<
with Ada.Strings.Fixed;
Line 194 ⟶ 191:
end loop;
Close (File);
end Abc_Words;</
{{out}}
<pre>aback abacus abc abdicate abduct abeyance abject abreact
Line 205 ⟶ 202:
=={{header|ALGOL 68}}==
<
IF FILE input file;
STRING file name = "unixdict.txt";
Line 247 ⟶ 244:
OD;
close( input file )
FI</
{{out}}
<pre>
Line 309 ⟶ 306:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
⍺←'abc'
words←((~∊)∘⎕TC⊆⊢) 80 ¯1⎕MAP ⍵
match←∧/∊,2</⍳⍨
(⍺∘match¨words)/words
}</
{{out}}
<pre> 11 5 ⍴ abcwords 'unixdict.txt'
Line 332 ⟶ 329:
===Core language===
This is a fairly simple solution, hard-coded for "a", "b", and "c". The 'offset' commands are performed by AppleScript's StandardAdditions OSAX, so the time taken by the multiple communications between the script and the OSAX makes the code comparatively slow. Still, the overall running time with the specified file on my current machine is less than 1.5 seconds.
<
-- The word file text is assumed to be UTF-8 encoded and to have one word per line.
script o
Line 350 ⟶ 347:
end abcWords
return abcWords(((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as alias)</
{{output}}
<
The following alternative uses delimiters and text items instead and is considerably faster at around 0.25 seconds. Also, for the hell of it, it takes the characters (or even longer substrings) that the returned words must contain as a parameter. Same output here as above.
<
-- The word file text is assumed to be UTF-8 encoded and to have one word per line.
script o
Line 385 ⟶ 382:
end abcWords
return abcWords(((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as alias, {"a", "b", "c"})</
===AppleScriptObjC===
This is faster still at 0.01 seconds and uses AppleScriptObjC to access the regex facilities provided by macOS's Foundation framework. It too takes the characters the returned words must contain as a parameter, but, unlike the script above, doesn't recognise longer substring inputs as units in themselves. Same output as with the two "Core language" scripts above.
<
use framework "Foundation"
use scripting additions
Line 428 ⟶ 425:
end join
return abcWords(((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as alias, {"a", "b", "c"})</
=={{header|Arturo}}==
<
isABC?: function [w][
Line 449 ⟶ 446:
if isABC? word ->
print word
]</
{{out}}
Line 510 ⟶ 507:
=={{header|AutoHotkey}}==
<
Loop, Parse, unixdict, `n
if ABCWord(A_LoopField)
Line 531 ⟶ 528:
return false
}
</syntaxhighlight>
{{out}}
Line 595 ⟶ 592:
The following one-liner entered into a Posix shell returns the same 55 words as other entries.
<
=={{header|BASIC}}==
<
20 OPEN "I",1,"unixdict.txt"
30 IF EOF(1) THEN END
Line 606 ⟶ 603:
70 C = INSTR(W,"c")
80 IF A>0 AND B>0 AND C>0 AND A<B AND B<C THEN PRINT W,
90 GOTO 30</
{{out}}
<pre>aback abacus abc abdicate abduct
Line 621 ⟶ 618:
=={{header|BCPL}}==
<
let find(s, c) = valof
Line 657 ⟶ 654:
endread()
$)
$)</
{{out}}
<pre style='height:50ex'>aback
Line 716 ⟶ 713:
=={{header|C}}==
<
#include <string.h>
Line 739 ⟶ 736:
}
return 0;
}</
{{out}}
<pre style='height:50ex;'>aback
Line 799 ⟶ 796:
=={{header|C sharp|C#}}==
Takes an optional command line for other character combinations. User can specify any reasonable number of unique characters. Caveat: see discussion page for issue about specifying repeated characters.
<
static void Main(string[] args) { int bi, i = 0; string chars = args.Length < 1 ? "abc" : args[0];
foreach (var item in System.IO.File.ReadAllLines("unixdict.txt")) {
Line 807 ⟶ 804:
skip: ; } }
}
</syntaxhighlight>
{{out}}
Without command line arguments:
Line 831 ⟶ 828:
=={{header|C++}}==
<
#include <fstream>
#include <iostream>
Line 874 ⟶ 871:
}
return EXIT_SUCCESS;
}</
{{out}}
Line 936 ⟶ 933:
=={{header|CLU}}==
<
a: int := string$indexc('a', s)
b: int := string$indexc('b', s)
Line 952 ⟶ 949:
end except when end_of_file: end
stream$close(dict)
end start_up</
{{out}}
<pre style='height:50ex;'>aback
Line 1,011 ⟶ 1,008:
=={{header|COBOL}}==
<
PROGRAM-ID. ABC-WORDS.
Line 1,051 ⟶ 1,048:
AND B IS LESS THAN C
AND C IS LESS THAN X,
DISPLAY WORD.</
{{out}}
<pre style='height:50ex;'>aback
Line 1,113 ⟶ 1,110:
{{libheader| System.IoUtils}}
{{Trans|C#}}
<syntaxhighlight lang="delphi">
program ABC_words;
Line 1,167 ⟶ 1,164:
{$IFNDEF UNIX} readln; {$ENDIF}
end.</
=={{header|Diego}}==
<
with_file()
()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)
(words)_if⟦[posA]<[posB]<[posC]⟧)_findto(posA,⟦a⟧)
?_(foundWords)
;
;
;
log_console()_(foundWords);</
Alternatively...
<
with_file()
()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)
(words)_foreach(word)
?_(word)_findto(posA,⟦a⟧)
?_(word)_sliceto(foundA,⟦[posA]⟧)
?_(foundA)_findto(posB,⟦b⟧)
?_(foundA)_sliceto(foundB,⟦[posB]⟧)
?_(foundB)_find⟦c⟧
Line 1,197 ⟶ 1,194:
;
;
log_console()_(foundWords);</
Output:
Line 1,203 ⟶ 1,200:
=={{header|Draco}}==
<
proc nonrec abc_word(*char line) bool:
Line 1,227 ⟶ 1,224:
close(dict)
corp</
{{out}}
<pre style='height:50ex;'>aback
Line 1,286 ⟶ 1,283:
=={{header|Factor}}==
<
sequences sets ;
"unixdict.txt" ascii file-lines
[ "abc" within members "abc" = ] filter
5 group simple-table.</
{{out}}
<pre>
Line 1,309 ⟶ 1,306:
=={{header|Forth}}==
{{works with|Gforth}}
<
false false { a b }
0 do
Line 1,341 ⟶ 1,338:
main
bye</
{{out}}
Line 1,403 ⟶ 1,400:
=={{header|FreeBASIC}}==
<
#define NOTINSTRING 9999
Line 1,432 ⟶ 1,429:
end if
wend
close #1</
{{out}}
<pre>
Line 1,490 ⟶ 1,487:
54. tabernacle
55. tablecloth</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
local fn WordList as CFArrayRef
CFArrayRef wordList = NULL
CFURLRef url = fn URLWithString( @"http://wiki.puzzlers.org/pub/wordlists/unixdict.txt" )
CFStringRef string = fn StringWithContentsOfURL( url, NSUTF8StringEncoding, NULL )
if ( string ) then wordList = fn StringComponentsSeparatedByCharactersInSet( string, fn CharacterSetNewlineSet )
end fn = wordList
void local fn ABCWords
CFArrayRef list = fn WordList
CFStringRef string
long abc
if ( list ) == NULL then NSLog(@"Unable to load word list") : exit fn
for string in list
abc = instr( 0, string, @"a")
if ( abc == NSNotFound ) then continue
abc = instr( abc, string, @"b")
if ( abc == NSNotFound ) then continue
abc = instr( abc, string, @"c")
if ( abc != NSNotFound ) then NSLog(@"%@",string)
next
end fn
fn ABCWords
HandleEvents
</syntaxhighlight>
{{out}}
<pre style='height:20ex;'>
aback
abacus
abc
abdicate
abduct
abeyance
abject
abreact
abscess
abscissa
abscissae
absence
abstract
abstracter
abstractor
adiabatic
aerobacter
aerobic
albacore
alberich
albrecht
algebraic
alphabetic
ambiance
ambuscade
aminobenzoic
anaerobic
arabic
athabascan
auerbach
diabetic
diabolic
drawback
fabric
fabricate
flashback
halfback
iambic
lampblack
leatherback
metabolic
nabisco
paperback
parabolic
playback
prefabricate
quarterback
razorback
roadblock
sabbatical
snapback
strabismic
syllabic
tabernacle
tablecloth
</pre>
=={{header|Go}}==
<
import (
Line 1,519 ⟶ 1,607:
}
}
}</
{{out}}
Line 1,582 ⟶ 1,670:
=={{header|Haskell}}==
<
import Data.Maybe (isJust)
Line 1,590 ⟶ 1,678:
isABC s =
isJust $
residue
>>= residue "c" 'b'
>>= elemIndex 'c'
residue ::
residue
where
go [] = Nothing
Line 1,607 ⟶ 1,695:
main =
readFile "unixdict.txt"
>>= mapM_ print . zip [1 ..] . filter isABC . lines</
{{Out}}
<pre>(1,"aback")
Line 1,666 ⟶ 1,754:
=={{header|Java}}==
<
import java.io.FileReader;
Line 1,729 ⟶ 1,817:
return false;
}
}</
{{out}}
Line 1,766 ⟶ 1,854:
25: pummel 26: supremum
</pre>
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">(() => {
"use strict";
// -------------------- ABC WORDS --------------------
// isABC :: String -> Bool
const isABC = s =>
// True if the string contains each of 'a' 'b' 'c',
// and their first occurrences in the string are
// in that alphabetical order.
bind(
bind(
residue("a")("bc")(s)
)(
residue("b")("c")
)
)(
r => r.includes("c") || null
) !== null;
// residue :: Char -> String -> String -> Maybe String
const residue = c =>
// Any characters remaining in a given string
// after the first occurrence of c, or null
// if c is not found, or is preceded by any
// excluded characters.
excluded => {
const go = t =>
(0 < t.length) ? (() => {
const x = t[0];
return excluded.includes(x) ? (
null
) : c === x ? (
t.slice(1)
) : go(t.slice(1));
})() : null;
return go;
};
// ---------------------- TEST -----------------------
const main = () =>
lines(readFile("~/unixdict.txt"))
.filter(isABC)
.map((x, i) => `(${1 + i}, ${x})`)
.join("\n");
// --------------------- GENERIC ---------------------
// bind (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
const bind = mb =>
// Null if mb is null, or the application of the
// (a -> Maybe b) function mf to the contents of mb.
mf => null === mb ? (
mb
) : mf(mb);
// lines :: String -> [String]
const lines = s =>
// A list of strings derived from a single string
// which is delimited by \n or by \r\n or \r.
Boolean(s.length) ? (
s.split(/\r\n|\n|\r/u)
) : [];
// readFile :: FilePath -> IO String
const readFile = fp => {
// The contents of a text file at the
// given file path.
const
e = $(),
ns = $.NSString
.stringWithContentsOfFileEncodingError(
$(fp).stringByStandardizingPath,
$.NSUTF8StringEncoding,
e
);
return ObjC.unwrap(
ns.isNil() ? (
e.localizedDescription
) : ns
);
};
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre>(1, aback)
(2, abacus)
(3, abc)
(4, abdicate)
(5, abduct)
(6, abeyance)
(7, abject)
(8, abreact)
(9, abscess)
(10, abscissa)
(11, abscissae)
(12, absence)
(13, abstract)
(14, abstracter)
(15, abstractor)
(16, adiabatic)
(17, aerobacter)
(18, aerobic)
(19, albacore)
(20, alberich)
(21, albrecht)
(22, algebraic)
(23, alphabetic)
(24, ambiance)
(25, ambuscade)
(26, aminobenzoic)
(27, anaerobic)
(28, arabic)
(29, athabascan)
(30, auerbach)
(31, diabetic)
(32, diabolic)
(33, drawback)
(34, fabric)
(35, fabricate)
(36, flashback)
(37, halfback)
(38, iambic)
(39, lampblack)
(40, leatherback)
(41, metabolic)
(42, nabisco)
(43, paperback)
(44, parabolic)
(45, playback)
(46, prefabricate)
(47, quarterback)
(48, razorback)
(49, roadblock)
(50, sabbatical)
(51, snapback)
(52, strabismic)
(53, syllabic)
(54, tabernacle)
(55, tablecloth)</pre>
=={{header|J}}==
A word is an abc word if the order of the indices of 'a', 'b' and 'c' and the final letter of the word are unchanged by sorting. (The index of 'a' would be the length of the word -- one greater than the last index into the word -- if 'a' was missing from the word. So by including that last index in our list of indices to be sorted, we eliminate all words which are missing an 'a', 'b' or 'c'.)<
aback
abacus
Line 1,823 ⟶ 2,064:
syllabic
tabernacle
tablecloth</
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<
[index("a", "b", "c")]
| all(.[]; . != null) and .[0] < .[1] and .[1] < .[2] ;
select(is_abc_word)</
Invocation: jq -rR -f abc-words.jq unixdict.txt
{{out}} (synopsis)
Line 1,846 ⟶ 2,088:
=={{header|Julia}}==
See [[Alternade_words#Julia]] for the foreachword function.
<
positions = [findfirst(c -> c == ch, w) for ch in "abc"]
return all(!isnothing, positions) && issorted(positions) ? w : ""
Line 1,852 ⟶ 2,094:
foreachword("unixdict.txt", isabcword)
</
<pre>
Word source: unixdict.txt
Line 1,869 ⟶ 2,111:
=={{header|Lua}}==
<
if string.find(word, "^[^bc]*a[^c]*b.*c") then
print(word)
end
end</
=={{header|Modula-2}}==
<
IMPORT SeqIO;
IMPORT Texts;
Line 1,916 ⟶ 2,158:
ts := Texts.Disconnect(dict);
fs := SeqIO.Close(file);
END ABCWords.</
{{out}}
<pre style='height:50ex;'>aback
Line 1,975 ⟶ 2,217:
=={{header|Nim}}==
<
func isAbcWord(word: string): bool =
Line 1,990 ⟶ 2,232:
if word.isAbcWord:
inc count
echo ($count).align(2), ' ', word</
{{out}}
Line 2,048 ⟶ 2,290:
54 tabernacle
55 tablecloth</pre>
=={{header|Pascal}}==
==={{header|Free Pascal}}===
<syntaxhighlight lang="pascal">
Program abcwords;
uses Classes;
const
FNAME = 'unixdict.txt';
var
list: TStringList;
str : string;
a,b,c : integer;
begin
list := TStringList.Create;
list.LoadFromFile(FNAME);
for str in list do
begin
a := pos('a',str);
b := pos('b',str);
c := pos('c',str);
if (a>0) and (b>a) and (c > b) then writeln(str);
end;
end.
</syntaxhighlight>
{{out}}
<pre>
aback
abacus
abc
abdicate
abduct
abeyance
abject
abreact
abscess
abscissa
abscissae
absence
abstract
abstracter
abstractor
adiabatic
aerobacter
aerobic
albacore
alberich
albrecht
algebraic
alphabetic
ambiance
ambuscade
aminobenzoic
anaerobic
arabic
athabascan
auerbach
diabetic
diabolic
drawback
fabric
fabricate
flashback
halfback
iambic
lampblack
leatherback
metabolic
nabisco
paperback
parabolic
playback
prefabricate
quarterback
razorback
roadblock
sabbatical
snapback
strabismic
syllabic
tabernacle
tablecloth
</pre>
=={{header|Perl}}==
Outputs same 55 words everyone else finds.
<
@ARGV = 'unixdict.txt';
print grep /^[^bc]*a[^c]*b.*c/, <>;</
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">abc</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">)</span>
Line 2,065 ⟶ 2,393:
<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">abc</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 abc words found: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">words</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">words</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">),</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)})</span>
<!--</
{{out}}
<pre>
Line 2,072 ⟶ 2,400:
=={{header|PL/I}}==
<
declare dict file;
open file(dict) title('unixdict.txt');
Line 2,096 ⟶ 2,424:
end;
end;
end abcWords;</
{{out}}
<pre>aback abacus abc abdicate abduct
Line 2,111 ⟶ 2,439:
=={{header|Processing}}==
<
void setup() {
Line 2,129 ⟶ 2,457:
}
return false;
}</
{{out}}
<pre>1 aback
Line 2,190 ⟶ 2,518:
Outputs the same 55 words as other examples when entered in a Posix terminal shell
<
import sys
for ln in sys.stdin:
Line 2,196 ⟶ 2,524:
print(ln.rstrip())
' < unixdict.txt
</syntaxhighlight>
Or a functionally composed variant, with a predicate which takes a single recursive pass through the characters of each word:
<
Line 2,208 ⟶ 2,536:
first occurrences of each in that order.
'''
return
bind(
residue('
)(
residue('
)
)(
)
# residue (String, Char
def residue(disallowed, c):
'''Any characters remaining in s after c, unless
c is preceded by excluded characters.
'''
def
return None
Line 2,278 ⟶ 2,604:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>(1, 'aback')
Line 2,335 ⟶ 2,661:
(54, 'tabernacle')
(55, 'tablecloth')</pre>
Or using a regular expression.
<syntaxhighlight lang="python">import re
import textwrap
RE = re.compile(r"^([^bc\r\n]*a[^c\r\n]*b.*c.*)$", re.M)
with open("unixdict.txt") as fd:
abc_words = RE.findall(fd.read())
print(f"found {len(abc_words)} ABC words")
print(textwrap.fill(" ".join(abc_words)))</syntaxhighlight>
{{out}}
<pre>
found 55 ABC words
aback abacus abc abdicate abduct abeyance abject abreact abscess
abscissa abscissae absence abstract abstracter abstractor adiabatic
aerobacter aerobic albacore alberich albrecht algebraic alphabetic
ambiance ambuscade aminobenzoic anaerobic arabic athabascan auerbach
diabetic diabolic drawback fabric fabricate flashback halfback iambic
lampblack leatherback metabolic nabisco paperback parabolic playback
prefabricate quarterback razorback roadblock sabbatical snapback
strabismic syllabic tabernacle tablecloth
</pre>
=={{header|Quackery}}==
<
behead swap
witheach
Line 2,360 ⟶ 2,712:
else drop ]
dup size echo say " words found." cr
70 wrap$</
{{out}}
Line 2,374 ⟶ 2,726:
prefabricate quarterback razorback roadblock sabbatical snapback
strabismic syllabic tabernacle tablecloth
</pre>
=={{header|R}}==
<syntaxhighlight lang="R">
library(stringi)
library(dplyr)
check_abc <- function(w) {
char_list <- stri_split_boundaries(w, type='character')[[1]]
fpos <- lapply(c("a","b","c"),\(x) grep(x,char_list)) %>% sapply(\(x) x[1])
if (any(is.na(fpos)==T)) return(F)
ifelse(all(sort(fpos) == fpos),T,F)
}
rep <- sapply(readLines("unixdict.txt"), \(x) check_abc(x))
print(names(rep[rep == T]))
</syntaxhighlight>
{{out}}
<pre>
[1] "aback" "abacus" "abc" "abdicate" "abduct" "abeyance"
[7] "abject" "abreact" "abscess" "abscissa" "abscissae" "absence"
[13] "abstract" "abstracter" "abstractor" "adiabatic" "aerobacter" "aerobic"
[19] "albacore" "alberich" "albrecht" "algebraic" "alphabetic" "ambiance"
[25] "ambuscade" "aminobenzoic" "anaerobic" "arabic" "athabascan" "auerbach"
[31] "diabetic" "diabolic" "drawback" "fabric" "fabricate" "flashback"
[37] "halfback" "iambic" "lampblack" "leatherback" "metabolic" "nabisco"
[43] "paperback" "parabolic" "playback" "prefabricate" "quarterback" "razorback"
[49] "roadblock" "sabbatical" "snapback" "strabismic" "syllabic" "tabernacle"
[55] "tablecloth"
</pre>
=={{header|Racket}}==
<
(for ((i (in-naturals 1))
(w (filter (curry regexp-match #rx"^[^bc]*a[^c]*b.*c.*$")
(file->lines "../../data/unixdict.txt"))))
(printf "~a\t~a~%" i w))</
{{out}}
Line 2,409 ⟶ 2,792:
=={{header|Raku}}==
<syntaxhighlight lang="raku"
:11cols, :fmt('%-12s');
Line 2,415 ⟶ 2,798:
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</
{{out}}
<pre>55 matching:
Line 2,429 ⟶ 2,812:
It also allows the (ABC) characters to be specified on the command line (CL) as well as the dictionary file identifier.
<
parse arg minL iFID . /*obtain optional arguments from the CL*/
if minL=='' | minL=="," then minL= 6 /*Not specified? Then use the default.*/
Line 2,455 ⟶ 2,838:
end /*j*/
/*stick a fork in it, we're all done. */
say copies('─',30) finds ' alternade words found with a minimum length of ' minL</
{{out|output|text= when using the default input:}}
<pre>
Line 2,526 ⟶ 2,909:
=={{header|Ring}}==
<
cStr = read("unixdict.txt")
wordList = str2list(cStr)
Line 2,544 ⟶ 2,927:
ok
next
</syntaxhighlight>
Output:
<pre>
Line 2,607 ⟶ 2,990:
=={{header|Ruby}}==
translation from Perl
<
</syntaxhighlight>
{{out}}Same 55 words:
<pre>aback
Line 2,632 ⟶ 3,015:
=={{header|Swift}}==
<
func loadDictionary(_ path: String) throws -> [String] {
Line 2,675 ⟶ 3,058:
} catch {
print(error)
}</
{{out}}
Line 2,737 ⟶ 3,120:
=={{header|Tcl}}==
<
regexp {^[^bc]*a[^c]*b.*c} $word
}
Line 2,746 ⟶ 3,129:
puts "Found [llength $res] words:"
puts [join $res \n]</
{{out}}
<pre>$ tclsh abc_words.tcl
Line 2,807 ⟶ 3,190:
=={{header|Transd}}==
<
MainModule : {
Line 2,816 ⟶ 3,199:
(if (match w "^[^bc]*a[^c]*b.*c.*") (lout w))))
)
}</
<pre>
aback
Line 2,827 ⟶ 3,210:
</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">
import os
fn main() {
mut count := 1
mut text :=''
unixdict := os.read_file('./unixdict.txt') or {
for word in unixdict.
if word.contains('a')
&& word.index_any('a') < word.index_any('b')
&& word.index_any('b') < word.index_any('c') {
text += count++.str() + ': $word \n'
}
Line 2,841 ⟶ 3,227:
println(text)
}
</syntaxhighlight>
{{out}}
Line 2,904 ⟶ 3,290:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
var wordList = "unixdict.txt" // local copy
Line 2,919 ⟶ 3,305:
Fmt.print("$2d: $s", count, word)
}
}</
{{out}}
Line 2,982 ⟶ 3,368:
=={{header|XPL0}}==
<
int I, J, K, Ch, Len;
char Word(100); \(longest word in unixdict.txt is 22 chars)
Line 3,011 ⟶ 3,397:
];
until Ch = EOF;
]</
{{out}}
Line 3,071 ⟶ 3,457:
tablecloth
</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.}}
| |||