ABC words: Difference between revisions

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

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

I a != N

V b = ln.findi(‘b’)

I a < b & b < ln.findi(‘c’)

{{out}}

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

FindAbcWords(fname)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/ABC_words.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Strings.Fixed;

end loop;

Close (File);

{{out}}

<pre>aback abacus abc abdicate abduct abeyance abject abreact

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

IF FILE input file;

STRING file name = "unixdict.txt";

OD;

close( input file )

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

⍺←'abc'

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

match←∧/∊,2</⍳⍨

(⍺∘match¨words)/words

{{out}}

<pre> 11 5 ⍴ abcwords 'unixdict.txt'

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

end abcWords

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

end abcWords

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

end join

=={{header|Arturo}}==

isABC?: function [w][

if isABC? word ->

print word

{{out}}

=={{header|AutoHotkey}}==

Loop, Parse, unixdict, `n

if ABCWord(A_LoopField)

return false

}

{{out}}

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

70 C = INSTR(W,"c")

80 IF A>0 AND B>0 AND C>0 AND A<B AND B<C THEN PRINT W,

{{out}}

<pre>aback abacus abc abdicate abduct

=={{header|BCPL}}==

let find(s, c) = valof

endread()

$)

{{out}}

<pre style='height:50ex'>aback

=={{header|C}}==

#include <string.h>

}

return 0;

{{out}}

<pre style='height:50ex;'>aback

=={{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")) {

skip: ; } }

}

{{out}}

Without command line arguments:

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

#include <fstream>

#include <iostream>

}

return EXIT_SUCCESS;

{{out}}

=={{header|CLU}}==

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

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

end except when end_of_file: end

stream$close(dict)

{{out}}

<pre style='height:50ex;'>aback

=={{header|COBOL}}==

PROGRAM-ID. ABC-WORDS.

AND B IS LESS THAN C

AND C IS LESS THAN X,

{{out}}

<pre style='height:50ex;'>aback

{{libheader| System.IoUtils}}

{{Trans|C#}}

program ABC_words;

{$IFNDEF UNIX} readln; {$ENDIF}

=={{header|Diego}}==

with_file()

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

;

;

Alternatively...

with_file()

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

;

;

Output:

=={{header|Draco}}==

proc nonrec abc_word(*char line) bool:

close(dict)

{{out}}

<pre style='height:50ex;'>aback

=={{header|Factor}}==

sequences sets ;

"unixdict.txt" ascii file-lines

[ "abc" within members "abc" = ] filter

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth}}

false false { a b }

0 do

main

{{out}}

=={{header|FreeBASIC}}==

#define NOTINSTRING 9999

end if

wend

{{out}}

<pre>

=={{header|Go}}==

import (

}

}

{{out}}

=={{header|Haskell}}==

import Data.Maybe (isJust)

main =

readFile "unixdict.txt"

{{Out}}

<pre>(1,"aback")

=={{header|Java}}==

import java.io.FileReader;

return false;

}

{{out}}

=={{header|JavaScript}}==

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>(1, aback)

=={{header|J}}==

aback

abacus

syllabic

tabernacle

=={{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] ;

Invocation: jq -rR -f abc-words.jq unixdict.txt

{{out}} (synopsis)

=={{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 : ""

foreachword("unixdict.txt", isabcword)

<pre>

Word source: unixdict.txt

=={{header|Lua}}==

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

print(word)

end

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

IMPORT SeqIO;

IMPORT Texts;

ts := Texts.Disconnect(dict);

fs := SeqIO.Close(file);

{{out}}

<pre style='height:50ex;'>aback

=={{header|Nim}}==

func isAbcWord(word: string): bool =

if word.isAbcWord:

inc count

{{out}}

=={{header|Perl}}==

Outputs same 55 words everyone else finds.

@ARGV = 'unixdict.txt';

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

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

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

declare dict file;

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

end;

end;

{{out}}

<pre>aback abacus abc abdicate abduct

=={{header|Processing}}==

void setup() {

}

return false;

{{out}}

<pre>1 aback

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

import sys

for ln in sys.stdin:

print(ln.rstrip())

' < unixdict.txt

Or a functionally composed variant, with a predicate which takes a single recursive pass through the characters of each word:

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>(1, 'aback')

Or using a regular expression.

import textwrap

print(f"found {len(abc_words)} ABC words")

{{out}}

=={{header|Quackery}}==

behead swap

witheach

else drop ]

dup size echo say " words found." cr

{{out}}

=={{header|Racket}}==

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

(w (filter (curry regexp-match #rx"^[^bc]*a[^c]*b.*c.*$")

(file->lines "../../data/unixdict.txt"))))

{{out}}

=={{header|Raku}}==

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

cache $list;

$title ~ $list.batch($cols)».fmt($fmt).join: "\n"

{{out}}

<pre>55 matching:

It also allows the &nbsp; (ABC) &nbsp; 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.*/

end /*j*/

/*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ring}}==

cStr = read("unixdict.txt")

wordList = str2list(cStr)

ok

next

Output:

<pre>

=={{header|Ruby}}==

translation from Perl

{{out}}Same 55 words:

<pre>aback

=={{header|Swift}}==

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

} catch {

print(error)

{{out}}

=={{header|Tcl}}==

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

}

puts "Found [llength $res] words:"

{{out}}

<pre>$ tclsh abc_words.tcl

=={{header|Transd}}==

MainModule : {

(if (match w "^[^bc]*a[^c]*b.*c.*") (lout w))))

)

<pre>

aback

=={{header|Vlang}}==

fn main() {

println(text)

}

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

Fmt.print("$2d: $s", count, word)

}

{{out}}

=={{header|XPL0}}==

int I, J, K, Ch, Len;

char Word(100); \(longest word in unixdict.txt is 22 chars)

];

until Ch = EOF;

{{out}}