ABC words: Difference between revisions

{{draft task}}

 

;Definition

 

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

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

I a != N

V b = ln.findi(‘b’)

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

 

{{out}}

syllabic

tabernacle

tablecloth

</pre>

 

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

prefabricate quarterback razorback roadblock sabbatical

snapback strabismic syllabic tabernacle tablecloth </pre>

 

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

tablecloth</pre>

 

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

55: tablecloth

</pre>

 

=={{header|Delphi}}==

{{libheader| System.IoUtils}}

{{Trans|C#}}

program ABC_words;

 

 

{$IFNDEF UNIX} readln; {$ENDIF}

 

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

54. tabernacle

55. tablecloth</pre>

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

 

=={{header|Haskell}}==

 

------------------------ ABC WORDS -----------------------

isABC s =

isJust $

 

where

go [] = Nothing

main =

readFile "unixdict.txt"

{{Out}}

<pre>(1,"aback")

 

=={{header|Java}}==

import java.io.FileReader;

 

return false;

}

 

{{out}}

25: pummel 26: supremum

</pre>

 

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

abc

</pre>

 

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

 

func isAbcWord(word: string): bool =

if word.isAbcWord:

inc count

 

{{out}}

54 tabernacle

55 tablecloth</pre>

 

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

 

 

 

first occurrences of each in that order.

'''

bind(

)(

)

)(

)

 

 

'''Any characters remaining in s after c, unless

c is preceded by excluded characters.

'''

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>(1, 'aback')

(54, 'tabernacle')

(55, 'tablecloth')</pre>

 

=={{header|Quackery}}==

 

behead swap

witheach

else drop ]

dup size echo say " words found." cr

 

{{out}}

prefabricate quarterback razorback roadblock sabbatical snapback

strabismic syllabic tabernacle tablecloth

</pre>

 

=={{header|Racket}}==

 

 

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

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

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

 

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

tabernacle

tablecloth</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var wordList = "unixdict.txt" // local copy

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

tablecloth

</pre>