ABC words: Difference between revisions

Line 1:

⚫

{{omit from|6502 Assembly|unixdict.txt is much larger than the CPU's address space.}}

⚫

;Definition

Line 19:

Line 16:

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

<syntaxhighlight lang=11l>L(ln) File(‘unixdict.txt’).read().split("\n")

<syntaxhighlight lang="11l">L(ln) File(‘unixdict.txt’).read().split("\n")

V? a = ln.find(‘a’)

I a != N

Line 87:

Line 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.

<syntaxhighlight lang=~~Action~~!>BYTE FUNC FindC(CHAR ARRAY text CHAR c)

<syntaxhighlight lang="action!">BYTE FUNC FindC(CHAR ARRAY text CHAR c)

BYTE i

Line 160:

Line 157:

=={{header|Ada}}==

<syntaxhighlight lang=~~Ada~~>with Ada.Text_Io;

<syntaxhighlight lang="ada">with Ada.Text_Io;

with Ada.Strings.Fixed;

Line 205:

Line 202:

=={{header|ALGOL 68}}==

<syntaxhighlight lang=algol68># find words that have "a", "b" and "C" in order in them #

<syntaxhighlight lang="algol68"># find words that have "a", "b" and "C" in order in them #

IF FILE input file;

STRING file name = "unixdict.txt";

Line 309:

Line 306:

=={{header|APL}}==

<syntaxhighlight lang=apl>abcwords←{

<syntaxhighlight lang="apl">abcwords←{

⍺←'abc'

words←((~∊)∘⎕TC⊆⊢) 80 ¯1⎕MAP ⍵

Line 332:

Line 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.

<syntaxhighlight lang=applescript>on abcWords(wordFile)

<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

Line 353:

Line 350:

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

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

<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

Line 389:

Line 386:

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

<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later

use framework "Foundation"

use scripting additions

Line 432:

Line 429:

=={{header|Arturo}}==

<syntaxhighlight lang=rebol>words: read.lines relative "unixdict.txt"

<syntaxhighlight lang="rebol">words: read.lines relative "unixdict.txt"

isABC?: function [w][

Line 510:

Line 507:

=={{header|AutoHotkey}}==

<syntaxhighlight lang=autohotkey>FileRead, unixdict, unixdict.txt

<syntaxhighlight lang="autohotkey">FileRead, unixdict, unixdict.txt

Loop, Parse, unixdict, `n

if ABCWord(A_LoopField)

Line 595:

Line 592:

The following one-liner entered into a Posix shell returns the same 55 words as other entries.

<syntaxhighlight lang=awk>awk '/^[^bc]*a[^c]*b.*c/' unixdict.txt</syntaxhighlight>

<syntaxhighlight lang="awk">awk '/^[^bc]*a[^c]*b.*c/' unixdict.txt</syntaxhighlight>

=={{header|BASIC}}==

<syntaxhighlight lang=basic>10 DEFINT A,B,C: DEFSTR W

<syntaxhighlight lang="basic">10 DEFINT A,B,C: DEFSTR W

20 OPEN "I",1,"unixdict.txt"

30 IF EOF(1) THEN END

Line 621:

Line 618:

=={{header|BCPL}}==

<syntaxhighlight lang=bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

let find(s, c) = valof

Line 716:

Line 713:

=={{header|C}}==

<syntaxhighlight lang=c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

#include <string.h>

Line 799:

Line 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.

<syntaxhighlight lang=csharp>class Program {

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

Line 828:

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

<syntaxhighlight lang=cpp>#include <cstdlib>

<syntaxhighlight lang="cpp">#include <cstdlib>

#include <fstream>

#include <iostream>

Line 936:

Line 933:

=={{header|CLU}}==

<syntaxhighlight lang=clu>abc_word = proc (s: string) returns (bool)

<syntaxhighlight lang="clu">abc_word = proc (s: string) returns (bool)

a: int := string$indexc('a', s)

b: int := string$indexc('b', s)

Line 1,011:

Line 1,008:

=={{header|COBOL}}==

<syntaxhighlight lang=cobol> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. ABC-WORDS.

Line 1,113:

Line 1,110:

program ABC_words;

Line 1,170:

Line 1,167:

=={{header|Diego}}==

<syntaxhighlight lang=diego>add_ary({str},foundWords);

<syntaxhighlight lang="diego">add_ary({str},foundWords);

with_file()

()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)

Line 1,181:

Line 1,178:

Alternatively...

<syntaxhighlight lang=diego>add_ary({str},foundWords);

<syntaxhighlight lang="diego">add_ary({str},foundWords);

with_file()

()_read⟦{raw},unixdict.txt⟧_splitto(words,⟦\n⟧)

Line 1,203:

Line 1,200:

=={{header|Draco}}==

<syntaxhighlight lang=draco>\util.g

<syntaxhighlight lang="draco">\util.g

proc nonrec abc_word(*char line) bool:

Line 1,286:

Line 1,283:

=={{header|Factor}}==

<syntaxhighlight lang=factor>USING: grouping io.encodings.ascii io.files kernel prettyprint

<syntaxhighlight lang="factor">USING: grouping io.encodings.ascii io.files kernel prettyprint

sequences sets ;

Line 1,309:

Line 1,306:

=={{header|Forth}}==

<syntaxhighlight lang=forth>: abc-word? ( addr u -- ? )

<syntaxhighlight lang="forth">: abc-word? ( addr u -- ? )

false false { a b }

0 do

Line 1,403:

Line 1,400:

=={{header|FreeBASIC}}==

#define NOTINSTRING 9999

Line 1,492:

Line 1,489:

=={{header|Go}}==

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import (

Line 1,582:

Line 1,579:

=={{header|Haskell}}==

<syntaxhighlight lang=haskell>import Data.List (elemIndex)

<syntaxhighlight lang="haskell">import Data.List (elemIndex)

import Data.Maybe (isJust)

Line 1,666:

Line 1,663:

=={{header|Java}}==

<syntaxhighlight lang=java>import java.io.BufferedReader;

<syntaxhighlight lang="java">import java.io.BufferedReader;

import java.io.FileReader;

Line 1,768:

Line 1,765:

=={{header|JavaScript}}==

<syntaxhighlight lang=javascript>(() => {

<syntaxhighlight lang="javascript">(() => {

"use strict";

Line 1,921:

Line 1,918:

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

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

Line 1,981:

Line 1,978:

'''Works with gojq, the Go implementation of jq'''

<syntaxhighlight lang=jq>def is_abc_word:

<syntaxhighlight lang="jq">def is_abc_word:

[index("a", "b", "c")]

| all(.[]; . != null) and .[0] < .[1] and .[1] < .[2] ;

Line 2,000:

Line 1,997:

=={{header|Julia}}==

See [[Alternade_words#Julia]] for the foreachword function.

<syntaxhighlight lang=julia>function isabcword(w, _)

<syntaxhighlight lang="julia">function isabcword(w, _)

positions = [findfirst(c -> c == ch, w) for ch in "abc"]

return all(!isnothing, positions) && issorted(positions) ? w : ""

Line 2,023:

Line 2,020:

=={{header|Lua}}==

<syntaxhighlight lang=~~Lua~~>for word in io.lines('unixdict.txt') do

<syntaxhighlight lang="lua">for word in io.lines('unixdict.txt') do

if string.find(word, "^[^bc]*a[^c]*b.*c") then

print(word)

Line 2,030:

Line 2,027:

=={{header|Modula-2}}==

<syntaxhighlight lang=modula2>MODULE ABCWords;

<syntaxhighlight lang="modula2">MODULE ABCWords;

IMPORT SeqIO;

IMPORT Texts;

Line 2,129:

Line 2,126:

=={{header|Nim}}==

<syntaxhighlight lang=~~Nim~~>import strutils

<syntaxhighlight lang="nim">import strutils

func isAbcWord(word: string): bool =

Line 2,205:

Line 2,202:

=={{header|Perl}}==

Outputs same 55 words everyone else finds.

<syntaxhighlight lang=perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

@ARGV = 'unixdict.txt';

Line 2,211:

Line 2,208:

=={{header|Phix}}==

with javascript_semantics

function abc(string word)

Line 2,226:

Line 2,223:

=={{header|PL/I}}==

<syntaxhighlight lang=pli>abcWords: procedure options(main);

<syntaxhighlight lang="pli">abcWords: procedure options(main);

declare dict file;

open file(dict) title('unixdict.txt');

Line 2,265:

Line 2,262:

=={{header|Processing}}==

<syntaxhighlight lang=processing>String[] words;

<syntaxhighlight lang="processing">String[] words;

void setup() {

Line 2,344:

Line 2,341:

Outputs the same 55 words as other examples when entered in a Posix terminal shell

<syntaxhighlight lang=python>python -c '

<syntaxhighlight lang="python">python -c '

import sys

for ln in sys.stdin:

Line 2,354:

Line 2,351:

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

<syntaxhighlight lang="python">'''ABC Words'''

Line 2,490:

Line 2,487:

Or using a regular expression.

<syntaxhighlight lang=python>import re

<syntaxhighlight lang="python">import re

import textwrap

Line 2,516:

Line 2,513:

=={{header|Quackery}}==

<syntaxhighlight lang=~~Quackery~~> [ true swap

<syntaxhighlight lang="quackery"> [ true swap

behead swap

witheach

Line 2,556:

Line 2,553:

=={{header|Racket}}==

<syntaxhighlight lang=racket>#lang racket

<syntaxhighlight lang="racket">#lang racket

(for ((i (in-naturals 1))

Line 2,587:

Line 2,584:

=={{header|Raku}}==

<syntaxhighlight lang=~~perl6~~>put display 'unixdict.txt'.IO.words».fc.grep({ (.index('a')//next) < (.index('b')//next) < (.index('c')//next) }),

<syntaxhighlight lang="raku" line>put display 'unixdict.txt'.IO.words».fc.grep({ (.index('a')//next) < (.index('b')//next) < (.index('c')//next) }),

:11cols, :fmt('%-12s');

Line 2,607:

Line 2,604:

It also allows the   (ABC)   characters to be specified on the command line (CL) as well as the dictionary file identifier.

<syntaxhighlight lang=rexx>/*REXX program finds all the caseless alternade words (within an identified dictionary).*/

<syntaxhighlight 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 2,704:

Line 2,701:

=={{header|Ring}}==

cStr = read("unixdict.txt")

wordList = str2list(cStr)

Line 2,785:

Line 2,782:

=={{header|Ruby}}==

translation from Perl

<syntaxhighlight lang=ruby>puts File.open("unixdict.txt").grep(/^[^bc]*a[^c]*b.*c/)

<syntaxhighlight lang="ruby">puts File.open("unixdict.txt").grep(/^[^bc]*a[^c]*b.*c/)

</syntaxhighlight>

{{out}}Same 55 words:

Line 2,810:

Line 2,807:

=={{header|Swift}}==

<syntaxhighlight lang=swift>import Foundation

<syntaxhighlight lang="swift">import Foundation

func loadDictionary(_ path: String) throws -> [String] {

Line 2,915:

Line 2,912:

=={{header|Tcl}}==

<syntaxhighlight lang=tcl>proc is_abc_word word {

<syntaxhighlight lang="tcl">proc is_abc_word word {

regexp {^[^bc]*a[^c]*b.*c} $word

}

Line 2,985:

Line 2,982:

=={{header|Transd}}==

<syntaxhighlight lang=scheme>#lang transd

<syntaxhighlight lang="scheme">#lang transd

MainModule : {

Line 3,006:

Line 3,003:

=={{header|Vlang}}==

<syntaxhighlight lang=vlang>import os

<syntaxhighlight lang="vlang">import os

fn main() {

Line 3,082:

Line 3,079:

=={{header|Wren}}==

<syntaxhighlight lang=ecmascript>import "io" for File

<syntaxhighlight lang="ecmascript">import "io" for File

import "/fmt" for Fmt

Line 3,160:

Line 3,157:

=={{header|XPL0}}==

<syntaxhighlight lang=~~XPL0~~>string 0; \use zero-terminated strings

<syntaxhighlight lang="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 3,249:

Line 3,246:

tablecloth

</pre>

⚫

{{omit from|6502 Assembly|unixdict.txt is much larger than the CPU's address space.}}

⚫