ABC words: Difference between revisions
m
syntax highlighting fixup automation
(Python alternative) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 19:
=={{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:
=={{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:
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:
=={{header|Ada}}==
<
with Ada.Strings.Fixed;
Line 194:
end loop;
Close (File);
end Abc_Words;</
{{out}}
<pre>aback abacus abc abdicate abduct abeyance abject abreact
Line 205:
=={{header|ALGOL 68}}==
<
IF FILE input file;
STRING file name = "unixdict.txt";
Line 247:
OD;
close( input file )
FI</
{{out}}
<pre>
Line 309:
=={{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:
===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:
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:
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:
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:
if isABC? word ->
print word
]</
{{out}}
Line 510:
=={{header|AutoHotkey}}==
<
Loop, Parse, unixdict, `n
if ABCWord(A_LoopField)
Line 531:
return false
}
</syntaxhighlight>
{{out}}
Line 595:
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:
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:
=={{header|BCPL}}==
<
let find(s, c) = valof
Line 657:
endread()
$)
$)</
{{out}}
<pre style='height:50ex'>aback
Line 716:
=={{header|C}}==
<
#include <string.h>
Line 739:
}
return 0;
}</
{{out}}
<pre style='height:50ex;'>aback
Line 799:
=={{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:
skip: ; } }
}
</syntaxhighlight>
{{out}}
Without command line arguments:
Line 831:
=={{header|C++}}==
<
#include <fstream>
#include <iostream>
Line 874:
}
return EXIT_SUCCESS;
}</
{{out}}
Line 936:
=={{header|CLU}}==
<
a: int := string$indexc('a', s)
b: int := string$indexc('b', s)
Line 952:
end except when end_of_file: end
stream$close(dict)
end start_up</
{{out}}
<pre style='height:50ex;'>aback
Line 1,011:
=={{header|COBOL}}==
<
PROGRAM-ID. ABC-WORDS.
Line 1,051:
AND B IS LESS THAN C
AND C IS LESS THAN X,
DISPLAY WORD.</
{{out}}
<pre style='height:50ex;'>aback
Line 1,113:
{{libheader| System.IoUtils}}
{{Trans|C#}}
<
program ABC_words;
Line 1,167:
{$IFNDEF UNIX} readln; {$ENDIF}
end.</
=={{header|Diego}}==
<
with_file()
()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)
Line 1,178:
;
;
log_console()_(foundWords);</
Alternatively...
<
with_file()
()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)
Line 1,197:
;
;
log_console()_(foundWords);</
Output:
Line 1,203:
=={{header|Draco}}==
<
proc nonrec abc_word(*char line) bool:
Line 1,227:
close(dict)
corp</
{{out}}
<pre style='height:50ex;'>aback
Line 1,286:
=={{header|Factor}}==
<
sequences sets ;
"unixdict.txt" ascii file-lines
[ "abc" within members "abc" = ] filter
5 group simple-table.</
{{out}}
<pre>
Line 1,309:
=={{header|Forth}}==
{{works with|Gforth}}
<
false false { a b }
0 do
Line 1,341:
main
bye</
{{out}}
Line 1,403:
=={{header|FreeBASIC}}==
<
#define NOTINSTRING 9999
Line 1,432:
end if
wend
close #1</
{{out}}
<pre>
Line 1,492:
=={{header|Go}}==
<
import (
Line 1,519:
}
}
}</
{{out}}
Line 1,582:
=={{header|Haskell}}==
<
import Data.Maybe (isJust)
Line 1,607:
main =
readFile "unixdict.txt"
>>= mapM_ print . zip [1 ..] . filter isABC . lines</
{{Out}}
<pre>(1,"aback")
Line 1,666:
=={{header|Java}}==
<
import java.io.FileReader;
Line 1,729:
return false;
}
}</
{{out}}
Line 1,768:
=={{header|JavaScript}}==
<
"use strict";
Line 1,862:
// MAIN ---
return main();
})();</
{{Out}}
<pre>(1, aback)
Line 1,921:
=={{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,976:
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 2,000:
=={{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 2,006:
foreachword("unixdict.txt", isabcword)
</
<pre>
Word source: unixdict.txt
Line 2,023:
=={{header|Lua}}==
<
if string.find(word, "^[^bc]*a[^c]*b.*c") then
print(word)
end
end</
=={{header|Modula-2}}==
<
IMPORT SeqIO;
IMPORT Texts;
Line 2,070:
ts := Texts.Disconnect(dict);
fs := SeqIO.Close(file);
END ABCWords.</
{{out}}
<pre style='height:50ex;'>aback
Line 2,129:
=={{header|Nim}}==
<
func isAbcWord(word: string): bool =
Line 2,144:
if word.isAbcWord:
inc count
echo ($count).align(2), ' ', word</
{{out}}
Line 2,205:
=={{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,219:
<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,226:
=={{header|PL/I}}==
<
declare dict file;
open file(dict) title('unixdict.txt');
Line 2,250:
end;
end;
end abcWords;</
{{out}}
<pre>aback abacus abc abdicate abduct
Line 2,265:
=={{header|Processing}}==
<
void setup() {
Line 2,283:
}
return false;
}</
{{out}}
<pre>1 aback
Line 2,344:
Outputs the same 55 words as other examples when entered in a Posix terminal shell
<
import sys
for ln in sys.stdin:
Line 2,350:
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,430:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>(1, 'aback')
Line 2,490:
Or using a regular expression.
<
import textwrap
Line 2,499:
print(f"found {len(abc_words)} ABC words")
print(textwrap.fill(" ".join(abc_words)))</
{{out}}
Line 2,516:
=={{header|Quackery}}==
<
behead swap
witheach
Line 2,538:
else drop ]
dup size echo say " words found." cr
70 wrap$</
{{out}}
Line 2,556:
=={{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,587:
=={{header|Raku}}==
<
:11cols, :fmt('%-12s');
Line 2,593:
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</
{{out}}
<pre>55 matching:
Line 2,607:
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,633:
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,704:
=={{header|Ring}}==
<
cStr = read("unixdict.txt")
wordList = str2list(cStr)
Line 2,722:
ok
next
</syntaxhighlight>
Output:
<pre>
Line 2,785:
=={{header|Ruby}}==
translation from Perl
<
</syntaxhighlight>
{{out}}Same 55 words:
<pre>aback
Line 2,810:
=={{header|Swift}}==
<
func loadDictionary(_ path: String) throws -> [String] {
Line 2,853:
} catch {
print(error)
}</
{{out}}
Line 2,915:
=={{header|Tcl}}==
<
regexp {^[^bc]*a[^c]*b.*c} $word
}
Line 2,924:
puts "Found [llength $res] words:"
puts [join $res \n]</
{{out}}
<pre>$ tclsh abc_words.tcl
Line 2,985:
=={{header|Transd}}==
<
MainModule : {
Line 2,994:
(if (match w "^[^bc]*a[^c]*b.*c.*") (lout w))))
)
}</
<pre>
aback
Line 3,006:
=={{header|Vlang}}==
<
fn main() {
Line 3,019:
println(text)
}
</syntaxhighlight>
{{out}}
Line 3,082:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
import "/fmt" for Fmt
Line 3,097:
Fmt.print("$2d: $s", count, word)
}
}</
{{out}}
Line 3,160:
=={{header|XPL0}}==
<
int I, J, K, Ch, Len;
char Word(100); \(longest word in unixdict.txt is 22 chars)
Line 3,189:
];
until Ch = EOF;
]</
{{out}}
|