ABC words: Difference between revisions

53,574 bytes added ,  2 months ago
 
(76 intermediate revisions by 33 users not shown)
Line 1:
{{draft task}}
 
 
;Definition
A word is an   ''ABC word''   if the letters  "'''a'''",  "'''b'''"  and  "'''c'''"  appear in the word in alphabetical order.
Line 12 ⟶ 14:
{{Template:Strings}}
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">L(ln) File(‘unixdict.txt’).read().split("\n")
V? a = ln.find(‘a’)
I a != N
V b = ln.findi(‘b’)
I a < b & b < ln.findi(‘c’)
print(ln)</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|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.
<syntaxhighlight lang="action!">BYTE FUNC FindC(CHAR ARRAY text CHAR c)
BYTE i
 
i=1
WHILE i<=text(0)
DO
IF text(i)=c THEN
RETURN (i)
FI
i==+1
OD
RETURN (0)
 
BYTE FUNC IsAbcWord(CHAR ARRAY word)
BYTE a,b,c
 
a=FindC(word,'a)
IF a=0 THEN RETURN (0) FI
b=FindC(word,'b)
IF b<a THEN RETURN (0) FI
c=FindC(word,'c)
IF c<b THEN RETURN (0) FI
RETURN (1)
 
PROC FindAbcWords(CHAR ARRAY fname)
CHAR ARRAY line(256)
CHAR ARRAY tmp(256)
BYTE pos,dev=[1]
 
pos=2
Close(dev)
Open(dev,fname,4)
WHILE Eof(dev)=0
DO
InputSD(dev,line)
IF IsAbcWord(line) THEN
IF pos+line(0)>=40 THEN
PutE() pos=2
FI
Print(line) Put(32)
pos==+line(0)+1
FI
OD
Close(dev)
RETURN
 
PROC Main()
CHAR ARRAY fname="H6:UNIXDICT.TXT"
 
FindAbcWords(fname)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/ABC_words.png Screenshot from Atari 8-bit computer]
<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|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_Io;
with Ada.Strings.Fixed;
 
procedure Abc_Words is
use Ada.Text_Io;
 
function Is_Abc_Word (Word : String) return Boolean is
use Ada.Strings.Fixed;
Pos_A : constant Natural := Index (Word, "a");
Pos_B : constant Natural := Index (Word, "b");
Pos_C : constant Natural := Index (Word, "c");
begin
return
Pos_B > Pos_A and Pos_C > Pos_B and
Pos_A /= 0 and Pos_B /= 0 and Pos_C /= 0;
end Is_Abc_Word;
 
Filename : constant String := "unixdict.txt";
File : File_Type;
Column : Ada.Text_Io.Count := 0;
begin
Open (File, In_File, Filename);
while not End_Of_File (File) loop
declare
Word : constant String := Get_Line (File);
begin
if Is_Abc_Word (Word) then
Set_Col (1 + Column);
Column := (Column + 15) mod 120;
Put (Word);
end if;
end;
end loop;
Close (File);
end Abc_Words;</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|ALGOL 68}}==
<langsyntaxhighlight lang="algol68"># find words that have "a", "b" and "C" in order in them #
IF FILE input file;
STRING file name = "unixdict.txt";
Line 55 ⟶ 244:
OD;
close( input file )
FI</langsyntaxhighlight>
{{out}}
<pre>
Line 113 ⟶ 302:
54: tabernacle
55: tablecloth
</pre>
 
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">abcwords←{
⍺←'abc'
words←((~∊)∘⎕TC⊆⊢) 80 ¯1⎕MAP ⍵
match←∧/∊,2</⍳⍨
(⍺∘match¨words)/words
}</syntaxhighlight>
{{out}}
<pre> 11 5 ⍴ abcwords 'unixdict.txt'
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|AppleScript}}==
===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.
<syntaxhighlight lang="applescript">on abcWords(wordFile)
-- The word file text is assumed to be UTF-8 encoded and to have one word per line.
script o
property wordList : paragraphs of (read wordFile as «class utf8»)
end script
set output to {}
repeat with thisWord in o's wordList
set thisWord to thisWord's contents
if ((thisWord contains "c") and ¬
(text 1 thru (offset of "c" in thisWord) of thisWord contains "b") and ¬
(text 1 thru (offset of "b" in thisWord) of thisWord contains "a")) then ¬
set end of output to thisWord
end repeat
return output
end abcWords
 
return abcWords(((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as alias)</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">{"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"}</syntaxhighlight>
 
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.
 
<syntaxhighlight lang="applescript">on abcWords(wordFile, theLetters)
-- The word file text is assumed to be UTF-8 encoded and to have one word per line.
script o
property wordList : paragraphs of (read wordFile as «class utf8»)
end script
set output to {}
set letterCount to (count theLetters)
set astid to AppleScript's text item delimiters
repeat with thisWord in o's wordList
set thisWord to thisWord's contents
set thisLetter to end of theLetters
if (thisWord contains thisLetter) then
set matched to true
repeat with c from (letterCount - 1) to 1 by -1
set AppleScript's text item delimiters to thisLetter
set thisLetter to item c of theLetters
set matched to (thisWord's first text item contains thisLetter)
if (not matched) then exit repeat
end repeat
if (matched) then set end of output to thisWord
end if
end repeat
set AppleScript's text item delimiters to astid
return output
end abcWords
 
return abcWords(((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as alias, {"a", "b", "c"})</syntaxhighlight>
 
===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.
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
use scripting additions
 
on abcWords(wordFile, theLetters)
-- This NSString method used here guesses the word file's text encoding itself.
set wordText to current application's class "NSString"'s stringWithContentsOfFile:(POSIX path of wordFile) ¬
usedEncoding:(missing value) |error|:(missing value)
-- Assuming one word per line, build a regex pattern to match words containing the specified letters in the given order.
set theLetters to join(theLetters, "")
set pattern to "(?mi)^"
repeat with c from 1 to (count theLetters)
set pattern to pattern & (("[^" & text c thru end of theLetters) & ("\\v]*+" & character c of theLetters))
end repeat
set pattern to pattern & ".*+$"
set regexObj to current application's class "NSRegularExpression"'s ¬
regularExpressionWithPattern:(pattern) options:(0) |error|:(missing value)
set wordMatches to regexObj's matchesInString:(wordText) options:(0) range:({0, wordText's |length|()})
set matchRanges to wordMatches's valueForKey:("range")
set output to {}
repeat with thisRange in matchRanges
set end of output to (wordText's substringWithRange:(thisRange)) as text
end repeat
return output
end abcWords
 
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
 
return abcWords(((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as alias, {"a", "b", "c"})</syntaxhighlight>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">words: read.lines relative "unixdict.txt"
 
isABC?: function [w][
a: index w "a"
if null? a -> return false
b: index w "b"
if null? b -> return false
if b < a -> return false
c: index w "c"
if null? c -> return false
if c < b -> return false
return true
]
 
loop words 'word [
if isABC? word ->
print word
]</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|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">FileRead, unixdict, unixdict.txt
Loop, Parse, unixdict, `n
if ABCWord(A_LoopField)
{
count++
text .= count ": " A_LoopField "`n"
}
Msgbox, %text%
 
ABCWord(Word) {
if InStr(Word, "a")
if InStr(Word, "b") > InStr(Word, "a")
if InStr(Word, "c") > InStr(Word, "b")
return true
else
return false
else
return false
else
return false
}
</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>
 
Line 118 ⟶ 592:
The following one-liner entered into a Posix shell returns the same 55 words as other entries.
 
<langsyntaxhighlight lang="awk">awk '/^[^bc]*a[^c]*b.*c/' unixdict.txt</langsyntaxhighlight>
 
=={{header|BASIC}}==
<syntaxhighlight lang="basic">10 DEFINT A,B,C: DEFSTR W
20 OPEN "I",1,"unixdict.txt"
30 IF EOF(1) THEN END
40 LINE INPUT #1, W
50 A = INSTR(W,"a")
60 B = INSTR(W,"b")
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</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|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
 
let find(s, c) = valof
$( for i=1 to s%0
if s%i=c then resultis i
resultis -1
$)
 
let match(word) = valof
$( let a = find(word, 'a')
let b = find(word, 'b')
let c = find(word, 'c')
resultis a ~= -1 & b ~= -1 & c ~= -1 & a<b & b<c
$)
 
let read(word) = valof
$( let ch = ?
word%0 := 0
$( ch := rdch()
if ch = endstreamch then resultis false
word%0 := word%0 + 1
word%(word%0) := ch
$) repeatuntil ch = '*N'
resultis true
$)
 
let start() be
$( let word = vec 63
let file = findinput("unixdict.txt")
test file = 0 then
writes("Cannot open unixdict.txt*N")
else
$( selectinput(file)
while read(word) if match(word) do writes(word)
endread()
$)
$)</syntaxhighlight>
{{out}}
<pre style='height:50ex'>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|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
 
int match(const char *word) {
const char *a = strchr(word, 'a');
const char *b = strchr(word, 'b');
const char *c = strchr(word, 'c');
return a && b && c && a<b && b<c;
}
 
int main() {
char word[80];
FILE *file = fopen("unixdict.txt", "r");
if (!file) {
fprintf(stderr, "Cannot open unixdict.txt");
return -1;
}
while (!feof(file)) {
fgets(word, sizeof(word), file);
if(match(word)) printf("%s", word);
}
return 0;
}</syntaxhighlight>
{{out}}
<pre style='height:50ex;'>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|C# sharp|CSharpC#}}==
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.
<langsyntaxhighlight lang="csharp">class Program {
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 130 ⟶ 804:
skip: ; } }
}
</syntaxhighlight>
</lang>
{{out}}
Without command line arguments:
Line 154 ⟶ 828:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <cstdlib>
#include <fstream>
#include <iostream>
Line 197 ⟶ 871:
}
return EXIT_SUCCESS;
}</langsyntaxhighlight>
 
{{out}}
Line 210 ⟶ 884:
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|CLU}}==
<syntaxhighlight lang="clu">abc_word = proc (s: string) returns (bool)
a: int := string$indexc('a', s)
b: int := string$indexc('b', s)
c: int := string$indexc('c', s)
return(a>0 cand b>a cand c>b)
end abc_word
 
start_up = proc ()
po: stream := stream$primary_output()
dict: stream := stream$open(file_name$parse("unixdict.txt"), "read")
while true do
word: string := stream$getl(dict)
if abc_word(word) then stream$putl(po, word) end
end except when end_of_file: end
stream$close(dict)
end start_up</syntaxhighlight>
{{out}}
<pre style='height:50ex;'>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|COBOL}}==
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. ABC-WORDS.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT DICT ASSIGN TO DISK
ORGANIZATION LINE SEQUENTIAL.
DATA DIVISION.
FILE SECTION.
FD DICT
LABEL RECORD STANDARD
VALUE OF FILE-ID IS "unixdict.txt".
01 WORD PIC X(32).
WORKING-STORAGE SECTION.
01 A PIC 99.
01 B PIC 99.
01 C PIC 99.
01 X PIC 99.
PROCEDURE DIVISION.
BEGIN.
OPEN INPUT DICT.
READ-WORD.
READ DICT, AT END CLOSE DICT, STOP RUN.
PERFORM CHECK-WORD.
GO TO READ-WORD.
CHECK-WORD.
MOVE ZERO TO A, B, C, X.
INSPECT WORD TALLYING A FOR CHARACTERS BEFORE INITIAL 'a'.
INSPECT WORD TALLYING B FOR CHARACTERS BEFORE INITIAL 'b'.
INSPECT WORD TALLYING C FOR CHARACTERS BEFORE INITIAL 'c'.
INSPECT WORD TALLYING X FOR CHARACTERS BEFORE INITIAL ' '.
IF A IS LESS THAN B
AND B IS LESS THAN C
AND C IS LESS THAN X,
DISPLAY WORD.</syntaxhighlight>
{{out}}
<pre style='height:50ex;'>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|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.IoUtils}}
{{Trans|C#}}
<syntaxhighlight lang="delphi">
program ABC_words;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils,
System.IoUtils;
 
var
bi, ai, i: Integer;
chars, item: string;
ch: char;
skip: boolean;
 
begin
bi := 0;
i := 0;
chars := 'abc';
 
if ParamCount > 0 then
chars := ParamStr(1);
 
writeln('Search words with letters "', chars, '" in alphabetical order'#10);
 
for item in TFile.ReadAllLines('unixdict.txt') do
begin
ai := -1;
skip := false;
for ch in chars do
begin
bi := item.IndexOf(ch);
if bi > ai then
begin
ai := bi;
end
else
begin
skip := true;
Break;
end;
end;
 
if not skip then
begin
inc(i);
write(i: 3, ' ', item.PadRight(18));
if i mod 5 = 0 then
writeln;
end;
end;
 
{$IFNDEF UNIX} readln; {$ENDIF}
end.</syntaxhighlight>
 
=={{header|Diego}}==
<syntaxhighlight lang="diego">add_ary({str},foundWords);
with_file()
()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)
(words)_if⟦[posA]<[posB]<[posC]⟧)_findto(posA,⟦a⟧)_i⟪0⟫_findto(posB,⟦b⟧)_i⟪0⟫_findto(posC,⟦c⟧)_i⟪0⟫
?_(foundWords)_add⟦words⟪⟫⟧;
;
;
;
log_console()_(foundWords);</syntaxhighlight>
 
Alternatively...
<syntaxhighlight lang="diego">add_ary({str},foundWords);
with_file()
()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)
(words)_foreach(word)
?_(word)_findto(posA,⟦a⟧)_i⟪0⟫;
?_(word)_sliceto(foundA,⟦[posA]⟧)
?_(foundA)_findto(posB,⟦b⟧)_i⟪0⟫;
?_(foundA)_sliceto(foundB,⟦[posB]⟧)
?_(foundB)_find⟦c⟧
?_(foundWords)_add[word];
;
;
;
;
;
;
log_console()_(foundWords);</syntaxhighlight>
 
Output:
<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|Draco}}==
<syntaxhighlight lang="draco">\util.g
 
proc nonrec abc_word(*char line) bool:
int a, b, c;
a := CharsIndex(line, "a");
b := CharsIndex(line, "b");
c := CharsIndex(line, "c");
a ~= -1 and a < b and b < c
corp
 
proc nonrec main() void:
file(1024) dictfile;
[32] char buf;
*char line;
channel input text dict;
open(dict, dictfile, "unixdict.txt");
line := &buf[0];
while readln(dict; line) do
if abc_word(line) then writeln(line) fi
od;
close(dict)
corp</syntaxhighlight>
{{out}}
<pre style='height:50ex;'>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|Factor}}==
<syntaxhighlight lang="factor">USING: grouping io.encodings.ascii io.files kernel prettyprint
sequences sets ;
 
"unixdict.txt" ascii file-lines
[ "abc" within members "abc" = ] filter
5 group simple-table.</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|Forth}}==
{{works with|Gforth}}
<syntaxhighlight lang="forth">: abc-word? ( addr u -- ? )
false false { a b }
0 do
dup c@ case
'a' of true to a endof
'b' of a invert if unloop drop false exit then true to b endof
'c' of unloop drop b exit endof
endcase
1+
loop
drop
false ;
 
256 constant max-line
 
: main
0 0 { count fd-in }
s" unixdict.txt" r/o open-file throw to fd-in
begin
here max-line fd-in read-line throw
while
here swap 2dup abc-word? if
count 1+ to count
count 2 .r ." : " type cr
else
2drop
then
repeat
drop
fd-in close-file throw ;
 
main
bye</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
Line 259 ⟶ 1,400:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">
#define NOTINSTRING 9999
 
Line 288 ⟶ 1,429:
end if
wend
close #1</langsyntaxhighlight>
{{out}}
<pre>
Line 346 ⟶ 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}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 375 ⟶ 1,607:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 436 ⟶ 1,668:
55: tablecloth
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.List (elemIndex)
import Data.Maybe (isJust)
 
------------------------ ABC WORDS -----------------------
 
isABC :: String -> Bool
isABC s =
isJust $
residue "bc" 'a' s
>>= residue "c" 'b'
>>= elemIndex 'c'
 
residue :: String -> Char -> String -> Maybe String
residue except c = go
where
go [] = Nothing
go (x : xs)
| x `elem` except = Nothing
| c == x = Just xs
| otherwise = go xs
 
--------------------------- TEST -------------------------
main :: IO ()
main =
readFile "unixdict.txt"
>>= mapM_ print . zip [1 ..] . filter isABC . lines</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|Java}}==
<langsyntaxhighlight lang="java">import java.io.BufferedReader;
import java.io.FileReader;
 
Line 457 ⟶ 1,773:
}
}
try {
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
int n = 0;
while ((line = reader.readLine()) != null) {
if (match(line, chars)) {
++n;
System.out.print(String.formatprintf("%3d: %-20s", n, line));
if (n % 3 == 0)
System.out.println();
}
}
if (n > 0 && n % 3 != 0)
System.out.println();
}
if (n > 0 && n % 3 != 0)
System.out.println();
} catch (Exception e) {
e.printStackTrace();
Line 502 ⟶ 1,817:
return false;
}
}</langsyntaxhighlight>
 
{{out}}
Line 538 ⟶ 1,853:
22: programmer 23: programming 24: promethium
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'.)<syntaxhighlight lang="j"> >(#~ (-: /:~)@(<:@#,~i.&'abc')@>) cutLF tolower fread 'unixdict.txt'
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</syntaxhighlight>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">def is_abc_word:
[index("a", "b", "c")]
| all(.[]; . != null) and .[0] < .[1] and .[1] < .[2] ;
 
select(is_abc_word)</syntaxhighlight>
Invocation: jq -rR -f abc-words.jq unixdict.txt
{{out}} (synopsis)
<pre>
aback
abacus
abc
...
aback
abacus
abc
</pre>
 
=={{header|Julia}}==
See [[Alternade_words#Julia]] for the foreachword function.
<langsyntaxhighlight lang="julia">function isabcword(w, _)
positions = [findfirst(c -> c == ch, w) for ch in "abc"]
return all(!isnothing, positions) && issorted(positions) ? w : ""
Line 548 ⟶ 2,094:
 
foreachword("unixdict.txt", isabcword)
</langsyntaxhighlight>{{out}}
<pre>
Word source: unixdict.txt
Line 561 ⟶ 2,107:
paperback parabolic playback prefabricate quarterback razorback
roadblock sabbatical snapback strabismic syllabic tabernacle
tablecloth
</pre>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">for word in io.lines('unixdict.txt') do
if string.find(word, "^[^bc]*a[^c]*b.*c") then
print(word)
end
end</syntaxhighlight>
 
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE ABCWords;
IMPORT SeqIO;
IMPORT Texts;
FROM InOut IMPORT WriteString, WriteLn;
FROM Strings IMPORT Pos;
 
VAR file: SeqIO.FILE;
dict: Texts.TEXT;
word: ARRAY [0..63] OF CHAR;
fs: SeqIO.FileState;
ts: Texts.TextState;
PROCEDURE IsABCWord(word: ARRAY OF CHAR): BOOLEAN;
VAR a, b, c, missing: CARDINAL;
BEGIN
missing := Pos("", word);
a := Pos("a", word);
b := Pos("b", word);
c := Pos("c", word);
RETURN (a # missing)
AND (b # missing)
AND (c # missing)
AND (a < b)
AND (b < c);
END IsABCWord;
 
BEGIN
fs := SeqIO.Open(file, "unixdict.txt");
ts := Texts.Connect(dict, file);
WHILE NOT Texts.EOT(dict) DO
Texts.ReadLn(dict, word);
IF IsABCWord(word) THEN
WriteString(word);
WriteLn();
END;
END;
ts := Texts.Disconnect(dict);
fs := SeqIO.Close(file);
END ABCWords.</syntaxhighlight>
{{out}}
<pre style='height:50ex;'>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|Nim}}==
<syntaxhighlight lang="nim">import strutils
 
func isAbcWord(word: string): bool =
let ia = word.find('a')
if ia < 0: return false
let ib = word.find('b')
if ib < ia: return false
let ic = word.find('c')
if ic < ib: return false
result = true
 
var count = 0
for word in "unixdict.txt".lines:
if word.isAbcWord:
inc count
echo ($count).align(2), ' ', word</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|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>
Line 566 ⟶ 2,379:
=={{header|Perl}}==
Outputs same 55 words everyone else finds.
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
@ARGV = 'unixdict.txt';
print grep /^[^bc]*a[^c]*b.*c/, <>;</langsyntaxhighlight>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>function abc(string word)
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
sequence idii = apply(true,find,{"abc",{word}})
<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>
return find(0,idii)==0 and idii==sort(idii)
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">ia</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ib</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ic</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">find</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"abc"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">word</span><span style="color: #0000FF;">}})</span>
end function
<span style="color: #008080;">return</span> <span style="color: #000000;">ia</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ib</span><span style="color: #0000FF;">></span><span style="color: #000000;">ia</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ic</span><span style="color: #0000FF;">></span><span style="color: #000000;">ib</span>
sequence words = filter(get_text("demo/unixdict.txt",GT_LF_STRIPPED),abc)
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
printf(1,"%d abc words found: %s\n",{length(words),join(shorten(words,"",3),", ")})</lang>
<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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
55 abc words found: aback, abacus, abc, ..., syllabic, tabernacle, tablecloth
</pre>
 
=={{header|PL/I}}==
<syntaxhighlight lang="pli">abcWords: procedure options(main);
declare dict file;
open file(dict) title('unixdict.txt');
on endfile(dict) stop;
declare word char(32) varying, col fixed;
col = 0;
do while('1'b);
get file(dict) list(word);
declare (a, b, c) fixed;
a = index(word, 'a');
b = index(word, 'b');
c = index(word, 'c');
if a ^= 0 & b ^= 0 & c ^= 0 & a < b & b < c then do;
put edit(word) (A(15));
col = col + 1;
if col = 5 then do;
put skip;
col = 0;
end;
end;
end;
end abcWords;</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|Processing}}==
<syntaxhighlight lang="processing">String[] words;
 
void setup() {
words = loadStrings("unixdict.txt");
int count = 1;
for (int i = 0; i < words.length; i++) {
if (isAbcWord(words[i])) {
println(count + " " + words[i]);
count++;
}
}
}
 
boolean isAbcWord(String word) {
if (word.contains("a") && word.indexOf("a") < word.indexOf("b") && word.indexOf("b") < word.indexOf("c")) {
return true;
}
return false;
}</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|Python}}==
Outputs the same 55 words as other examples when entered in a Posix terminal shell
 
<langsyntaxhighlight lang="python">python -c '
import sys
for ln in sys.stdin:
Line 592 ⟶ 2,524:
print(ln.rstrip())
' < unixdict.txt
</syntaxhighlight>
</lang>
 
Or a functionally composed variant, with a predicate which takes a single recursive pass through the characters of each word:
 
<syntaxhighlight lang="python">'''ABC Words'''
 
 
# isABC :: String -> Bool
def isABC(s):
'''True if s contains 'a', 'b' and 'c', with the
first occurrences of each in that order.
'''
return bind(
bind(
residue('bc', 'a')(s)
)(
residue('c', 'b')
)
)(
lambda r: 'c' in r
)
 
 
# residue (String, Char) -> String -> Maybe String
def residue(disallowed, c):
'''Any characters remaining in s after c, unless
c is preceded by excluded characters.
'''
def go(s):
if s:
x = s[0]
return None if x in disallowed else (
s[1:] if c == x else go(s[1:])
)
else:
return None
return go
 
 
# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''All words matching the isABC predicate
in a local copy of unixdict.txt
'''
for x in enumerate(
filter(
isABC,
readFile('unixdict.txt').splitlines()
),
start=1
):
print(x)
 
 
# ----------------------- GENERIC ------------------------
 
# bind (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
def bind(m):
'''Composition of a sequence of (a -> None | b) functions.
If m is None, it is passed straight through.
If m is x, the result is an application
of the (a -> None | b) function (mf) to x.
'''
def go(mf):
return m if None is m else mf(m)
return go
 
 
# readFile :: FilePath -> IO String
def readFile(fp):
'''The contents of any file at the path
derived by expanding any ~ in fp.
'''
with open(fp, 'r', encoding='utf-8') as f:
return f.read()
 
 
# MAIN ---
if __name__ == '__main__':
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>
 
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}}==
 
<syntaxhighlight lang="quackery"> [ true swap
behead swap
witheach
[ tuck < not if
[ dip not
conclude ] ]
drop ] is ascending ( [ --> b )
 
[ [] swap
$ "abc" witheach
[ over find
swap dip join ]
size join
ascending ] is abcword ( $ --> b )
[]
$ "rosetta/unixdict.txt" sharefile drop nest$
witheach
[ dup abcword iff
[ nested join ]
else drop ]
dup size echo say " words found." cr
70 wrap$</syntaxhighlight>
 
{{out}}
 
<pre>55 words found.
 
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|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}}==
 
<syntaxhighlight lang="racket">#lang 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))</syntaxhighlight>
 
{{out}}
Output is elided... it's the same list of words in every other implementation
<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
...
50 sabbatical
51 snapback
52 strabismic
53 syllabic
54 tabernacle
55 tablecloth
</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>put display 'unixdict.txt'.IO.words».fc.grep({ (.index('a')//next) < (.index('b')//next) < (.index('c')//next) })\,
.&{"{+$_} words:\n11cols, " ~ .batch(11)».:fmt('%-12s').join: "\n "};</lang>
 
sub display ($list, :$cols = 10, :$fmt = '%6d', :$title = "{+$list} matching:\n" ) {
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</syntaxhighlight>
{{out}}
<pre>55 wordsmatching:
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|REXX}}==
Line 610 ⟶ 2,812:
 
It also allows the &nbsp; (ABC) &nbsp; characters to be specified on the command line (CL) as well as the dictionary file identifier.
<langsyntaxhighlight lang="rexx">/*REXX program finds all the caseless alternade words (within an identified dictionary).*/
parse arg minL iFID . /*obtain optional arguments from the CL*/
if minL=='' | minL=="," then minL= 6 /*Not specified? Then use the default.*/
Line 636 ⟶ 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</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 707 ⟶ 2,909:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
cStr = read("unixdict.txt")
wordList = str2list(cStr)
Line 725 ⟶ 2,927:
ok
next
</syntaxhighlight>
</lang>
Output:
<pre>
Line 784 ⟶ 2,986:
54. tabernacle
55. tablecloth
</pre>
 
=={{header|Ruby}}==
translation from Perl
<syntaxhighlight lang="ruby">puts File.open("unixdict.txt").grep(/^[^bc]*a[^c]*b.*c/)
</syntaxhighlight>
{{out}}Same 55 words:
<pre>aback
abacus
abc
abdicate
abduct
abeyance
abject
abreact
abscess
...
quarterback
razorback
roadblock
sabbatical
snapback
strabismic
syllabic
tabernacle
tablecloth
</pre>
 
=={{header|Swift}}==
<langsyntaxhighlight lang="swift">import Foundation
 
func loadDictionary(_ path: String) throws -> [String] {
Line 830 ⟶ 3,058:
} catch {
print(error)
}</langsyntaxhighlight>
 
{{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|Tcl}}==
<syntaxhighlight lang="tcl">proc is_abc_word word {
regexp {^[^bc]*a[^c]*b.*c} $word
}
 
set res [lmap w [read [open unixdict.txt]] {
if {[is_abc_word $w]} {set w} else continue
}]
 
puts "Found [llength $res] words:"
puts [join $res \n]</syntaxhighlight>
{{out}}
<pre>$ tclsh abc_words.tcl
Found 55 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|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
 
MainModule : {
_start: (lambda
(with fs FileStream()
(open-r fs "/mnt/tmp/unixdict.txt") )
(for w in (read-lines fs) do
(if (match w "^[^bc]*a[^c]*b.*c.*") (lout w))))
)
}</syntaxhighlight>{{out}}
<pre>
aback
abacus
abc
... 55 words in total ...
syllabic
tabernacle
tablecloth
</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">
import os
 
fn main() {
mut count := 1
mut text :=''
unixdict := os.read_file('./unixdict.txt') or {println('Error: file not found') exit(1)}
for word in unixdict.split_into_lines() {
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'
}
}
println(text)
}
</syntaxhighlight>
 
{{out}}
Line 893 ⟶ 3,290:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "io" for File
import "./fmt" for Fmt
 
var wordList = "unixdict.txt" // local copy
Line 908 ⟶ 3,305:
Fmt.print("$2d: $s", count, word)
}
}</langsyntaxhighlight>
 
{{out}}
Line 971 ⟶ 3,368:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">string 0; \use zero-terminated strings
int I, J, K, Ch, Len;
char Word(100); \(longest word in unixdict.txt is 22 chars)
Line 1,000 ⟶ 3,397:
];
until Ch = EOF;
]</langsyntaxhighlight>
 
{{out}}
Line 1,060 ⟶ 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.}}
46

edits