Prime words
A word is a prime word if all its individual letters (expressed as an ASCII decimal code) are primes.
A ASCII decimal code is: 65
B ASCII decimal code is: 66
C ASCII decimal code is: 67
X ASCII decimal code is: 88
Y ASCII decimal code is: 89
Z ASCII decimal code is: 90
a ASCII decimal code is: 97
b ASCII decimal code is: 98
c ASCII decimal code is: 99
x ASCII decimal code is: 120
y ASCII decimal code is: 121
z ASCII decimal code is: 122
- Task
Show here on this page every prime word in unixdict.txt.
ALGOL 68
Does not distinguish between letters and non-letter ASCII codes (as with the REXX sample). <lang algol68># find words whose character codes are primes # IF FILE input file;
STRING file name = "unixdict.txt"; open( input file, file name, stand in channel ) /= 0
THEN
# failed to open the file # print( ( "Unable to open """ + file name + """", newline ) )
ELSE
# file opened OK #
BOOL at eof := FALSE;
# set the EOF handler for the file #
on logical file end( input file, ( REF FILE f )BOOL:
BEGIN
# note that we reached EOF on the #
# latest read #
at eof := TRUE;
# return TRUE so processing can continue #
TRUE
END
);
# construct a sieve of primes up to the maximum character #
[ 0 : max abs char ]BOOL s;
FOR i TO UPB s DO s[ i ] := TRUE OD;
s[ 0 ] := s[ 1 ] := FALSE;
FOR i FROM 2 TO ENTIER sqrt( UPB s ) DO
IF s[ i ] THEN FOR p FROM i * i BY i TO UPB s DO s[ p ] := FALSE OD FI
OD;
# find the prime words #
INT prime count := 0;
WHILE STRING word;
get( input file, ( word, newline ) );
NOT at eof
DO
BOOL is prime := FALSE;
FOR w pos FROM LWB word TO UPB word WHILE ( is prime := s[ ABS word[ w pos ] ] ) DO SKIP OD;
IF is prime THEN
prime count +:= 1;
print( ( whole( prime count, -5 ), ": ", word, newline ) )
FI
OD;
close( input file )
FI</lang>
- Output:
1: a
2: aaa
3: age
4: agee
5: ak
6: am
7: ama
8: e
9: egg
10: eke
11: em
12: emma
13: g
14: ga
15: gag
16: gage
17: gam
18: game
19: gamma
20: ge
21: gee
22: gem
23: gemma
24: gm
25: k
26: keg
27: m
28: ma
29: mae
30: magma
31: make
32: mamma
33: me
34: meek
35: meg
36: q
AWK
<lang AWK>
- syntax: GAWK -f PRIME_WORDS.AWK unixdict.txt
BEGIN {
for (i=0; i<=255; i++) {
if (is_prime(i)) {
prime_chars = sprintf("%s%c",prime_chars,i)
}
}
pattern = sprintf("^[%s]+$",prime_chars)
} { if ($0 ~ pattern) {
printf("%s ",$0)
}
} END {
printf("\n")
exit(0)
} function is_prime(x, i) {
if (x <= 1) {
return(0)
}
for (i=2; i<=int(sqrt(x)); i++) {
if (x % i == 0) {
return(0)
}
}
return(1)
} </lang>
- Output:
a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
C++
<lang cpp>#include <algorithm>
- include <cstdlib>
- include <fstream>
- include <iomanip>
- include <iostream>
- include <string>
- include "prime_sieve.hpp"
int main(int argc, char** argv) {
const char* filename(argc < 2 ? "unixdict.txt" : argv[1]);
std::ifstream in(filename);
if (!in) {
std::cerr << "Cannot open file '" << filename << "'.\n";
return EXIT_FAILURE;
}
std::string line;
prime_sieve sieve(UCHAR_MAX);
auto is_prime = [&sieve](unsigned char c){ return sieve.is_prime(c); };
int n = 0;
while (getline(in, line)) {
if (std::all_of(line.begin(), line.end(), is_prime)) {
++n;
std::cout << std::right << std::setw(2) << n << ": "
<< std::left << std::setw(10) << line;
if (n % 4 == 0)
std::cout << '\n';
}
}
return EXIT_SUCCESS;
}</lang>
Contents of prime_sieve.hpp: <lang cpp>#ifndef PRIME_SIEVE_HPP
- define PRIME_SIEVE_HPP
- include <algorithm>
- include <vector>
/**
* A simple implementation of the Sieve of Eratosthenes. * See https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes. */
class prime_sieve { public:
explicit prime_sieve(size_t); bool is_prime(size_t) const;
private:
std::vector<bool> is_prime_;
};
/**
* Constructs a sieve with the given limit. * * @param limit the maximum integer that can be tested for primality */
inline prime_sieve::prime_sieve(size_t limit) {
limit = std::max(size_t(3), limit);
is_prime_.resize(limit/2, true);
for (size_t p = 3; p * p <= limit; p += 2) {
if (is_prime_[p/2 - 1]) {
size_t inc = 2 * p;
for (size_t q = p * p; q <= limit; q += inc)
is_prime_[q/2 - 1] = false;
}
}
}
/**
* Returns true if the given integer is a prime number. The integer * must be less than or equal to the limit passed to the constructor. * * @param n an integer less than or equal to the limit passed to the * constructor * @return true if the integer is prime */
inline bool prime_sieve::is_prime(size_t n) const {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
return is_prime_.at(n/2 - 1);
}
- endif</lang>
- Output:
1: a 2: aaa 3: age 4: agee 5: ak 6: am 7: ama 8: e 9: egg 10: eke 11: em 12: emma 13: g 14: ga 15: gag 16: gage 17: gam 18: game 19: gamma 20: ge 21: gee 22: gem 23: gemma 24: gm 25: k 26: keg 27: m 28: ma 29: mae 30: magma 31: make 32: mamma 33: me 34: meek 35: meg 36: q
Factor
<lang factor>USING: io.encodings.ascii io.files math.primes prettyprint sequences ;
"unixdict.txt" ascii file-lines [ [ prime? ] all? ] filter .</lang>
- Output:
{
"a"
"aaa"
"age"
"agee"
"ak"
"am"
"ama"
"e"
"egg"
"eke"
"em"
"emma"
"g"
"ga"
"gag"
"gage"
"gam"
"game"
"gamma"
"ge"
"gee"
"gem"
"gemma"
"gm"
"k"
"keg"
"m"
"ma"
"mae"
"magma"
"make"
"mamma"
"me"
"meek"
"meg"
"q"
}
FreeBASIC
<lang freebasic> dim shared as boolean prime(0 to 29) =_
{false, true, false, true, true, false, false, true, false, true, false, false, true, false,_
false, false, true, false, true, true, false, true, true, false, true, false, false, false, false}
function isprimeletter( s as string ) as boolean
dim as ubyte n = asc(s) if n mod 2 = 0 then return false return prime( (n-65)/2 )
end function
function isprimeword( s as string ) as boolean
for i as uinteger = 1 to len(s)
if not isprimeletter( mid(s,i,1) ) then return false
next i
return true
end function
dim as string word
open "unixdict.txt" for input as #1 while true
line input #1, word if word = "" then exit while if isprimeword( word ) then print word
wend close #1 end </lang>
- Output:
a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Go
<lang go>package main
import (
"bytes" "fmt" "io/ioutil" "log" "strings"
)
func isPrime(n int) bool {
if n < 2 {
return false
}
if n%2 == 0 {
return n == 2
}
if n%3 == 0 {
return n == 3
}
d := 5
for d*d <= n {
if n%d == 0 {
return false
}
d += 2
if n%d == 0 {
return false
}
d += 4
}
return true
}
func main() {
// cache prime runes with codepoints between 33 and 255 say
var primeRunes []rune
for i := 33; i < 256; i += 2 {
if isPrime(i) {
primeRunes = append(primeRunes, rune(i))
}
}
primeString := string(primeRunes)
wordList := "unixdict.txt"
b, err := ioutil.ReadFile(wordList)
if err != nil {
log.Fatal("Error reading file")
}
bwords := bytes.Fields(b)
fmt.Println("Prime words in", wordList, "are:")
for _, bword := range bwords {
word := string(bword)
ok := true
for _, c := range word {
if !strings.ContainsRune(primeString, c) {
ok = false
break
}
}
if ok {
fmt.Println(word)
}
}
}</lang>
- Output:
Prime words in unixdict.txt are: a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Julia
See Alternade_words#Julia for the foreachword function. <lang julia>const primelettervalues = [67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113] isprimeword(w, _) = all(c -> Int(c) in primelettervalues, collect(w)) ? w : "" foreachword("unixdict.txt", isprimeword, colwidth=10, numcols=9)
</lang>
- Output:
Word source: unixdict.txt a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Perl
<lang perl>#!/usr/bin/perl
use strict; use warnings;
my $pat = join , grep +(1 x ord) !~ /^(11+)\1+$/, 'a'..'z', 'A'..'Z'; @ARGV = 'unixdict.txt'; print join(, grep /^[$pat]+$/, <>) =~ tr/\n/ /r =~ s/.{1,71}\K /\n/gr;</lang>
- Output:
a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Phix
<lang Phix>function sap(string word) return sum(apply(word,is_prime))==length(word) end function sequence words = filter(get_text("demo/unixdict.txt",GT_LF_STRIPPED),sap) printf(1,"%d prime words found: %s\n",{length(words),join(shorten(words,"",3),", ")})</lang>
- Output:
36 prime words found: a, aaa, age, ..., meek, meg, q
Plain English
<lang plainenglish>To run: Start up. Put "c:\unixdict.txt" into a path. Read the path into a buffer. Slap a rider on the buffer. Loop. Move the rider (text file rules). Subtract 1 from the rider's token's last. \newline Put the rider's token into a word string. If the word is blank, break. If the word is composed of prime letters, write the word on the console. Repeat. Wait for the escape key. Shut down.
To decide if a byte is prime: If the byte is in "aegkmq", say yes. Say no.
To decide if a string is composed of prime letters: Slap a substring on the string. Loop. If the substring is blank, say yes. If the substring's first's target is not prime, say no. Add 1 to the substring's first. Repeat.</lang>
- Output:
a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Raku
Another in a continuing series of tasks that are a minimal variation of previous ones. This is essentially Smarandache prime-digital sequence using ords instead of numerical digits. Sigh.
In an effort to anticipate / head-off a rash of tiny variant tasks, a series of one-liners:
<lang perl6>my @words = 'unixdict.txt'.IO.words».fc;
sub display ($n, @n, $s = "First 20: ") {"$n;\n{$s}{@n.join: ', '}"}
- The task
say 'Number of words whose ords are all prime: ',
@words.hyper.grep({ .ords.all.is-prime }).&{display +$_, $_, };
- Twelve other minor variants
say "\nNumber of words whose ordinal sum is prime: ",
@words.grep({ .ords.sum.is-prime }).&{display +$_, .head(20)};
say "\nNumber of words whose ords are all prime, and whose ordinal sum is prime: ",
@words.hyper.grep({ .ords.all.is-prime && .ords.sum.is-prime }).&{display +$_, $_, };
say "\n\nInterpreting the words as if they were base 36 numbers:";
say "\nNumber of words whose 'digits' are all prime in base 36: ",
@words.hyper.grep({ !.contains(/\W/) && all(.comb».parse-base(36)).is-prime }).&{display +$_, $_, };
say "\nNumber of words that are prime in base 36: ",
@words.grep({ !.contains(/\W/) && :36($_).is-prime }).&{display +$_, .head(20)};
say "\nNumber of words whose base 36 digital sum is prime: ",
@words.grep({ !.contains(/\W/) && .comb».parse-base(36).sum.is-prime }).&{display +$_, .head(20)};
say "\nNumber of words that are prime in base 36, and whose digital sum is prime: ",
@words.grep({ !.contains(/\W/) && :36($_).is-prime && .comb».parse-base(36).sum.is-prime }).&{display +$_, .head(20)};
say "\nNumber of words that are prime in base 36, whose digits are all prime, and whose digital sum is prime: ",
@words.hyper.grep({ !.contains(/\W/) && all(.comb».parse-base(36)).is-prime && :36($_).is-prime && .comb».parse-base(36).sum.is-prime }).&{display +$_, $_, };
use Base::Any:ver<0.1.2+>; set-digits('a'..'z');
say "\n\nTests using a custom base 26 where 'a' through 'z' is 0 through 25 and words are case folded:";
say "\nNumber of words whose 'digits' are all prime using a custom base 26: ",
@words.hyper.grep({ !.contains(/<-alpha>/) && all(.comb».&from-base(26)).is-prime }).&{display +$_, $_, };
say "\nNumber of words that are prime using a custom base 26: ",
@words.grep({ !.contains(/<-alpha>/) && .&from-base(26).is-prime }).&{display +$_, .head(20)};
say "\nNumber of words whose digital sum is prime using a custom base 26: ",
@words.grep({ !.contains(/<-alpha>/) && .comb».&from-base(26).sum.is-prime }).&{display +$_, .head(20)};
say "\nNumber of words that are prime in a custom base 26 and whose digital sum is prime in that base: ",
@words.grep({ !.contains(/<-alpha>/) && .&from-base(26).is-prime && .comb».&from-base(26).sum.is-prime }).&{display +$_, .head(20)};
say "\nNumber of words that are prime in custom base 26, whose digits are all prime, and whose digital sum is prime: ",
@words.hyper.grep({ !.contains(/<-alpha>/) && all(.comb».&from-base(26)).is-prime && .&from-base(26).is-prime && .comb».&from-base(26).sum.is-prime }).&{display +$_, $_, };</lang>
- Output:
Number of words whose ords are all prime: 36; a, aaa, age, agee, ak, am, ama, e, egg, eke, em, emma, g, ga, gag, gage, gam, game, gamma, ge, gee, gem, gemma, gm, k, keg, m, ma, mae, magma, make, mamma, me, meek, meg, q Number of words whose ordinal sum is prime: 3778; First 20: 10th, 9th, a, a's, aau, ababa, abate, abhorred, abject, ablate, aboard, abrade, abroad, absentee, absentia, absolute, absorptive, absurd, abusive, accelerate Number of words whose ords are all prime, and whose ordinal sum is prime: 12; a, e, egg, g, gem, k, keg, m, mae, mamma, meg, q Interpreting the words as if they were base 36 numbers: Number of words whose 'digits' are all prime in base 36: 18; 2nd, 5th, 7th, b, d, h, j, n, nd, nh, nj, nv, t, tn, tnt, tv, v, vt Number of words that are prime in base 36: 1106; First 20: 10th, 1st, 2nd, 5th, 6th, 7th, abandon, abbott, abdomen, ablution, abolish, abort, abrupt, absorb, abstention, abstract, abutted, accept, accident, acid Number of words whose base 36 digital sum is prime: 4740; First 20: 10th, 3rd, 7th, aba, abacus, abalone, abase, abater, abelian, abelson, aberrant, abeyant, ablaze, abort, aboveground, abraham, abrasion, abrasive, abreact, abridge Number of words that are prime in base 36, and whose digital sum is prime: 300; First 20: 10th, 7th, abort, accident, acid, ad, adorn, adulthood, afterthought, albeit, alvin, armload, around, arragon, arraign, assassin, asteroid, astound, augean, avocation Number of words that are prime in base 36, whose digits are all prime, and whose digital sum is prime: 8; 7th, b, d, h, j, n, t, v Tests using a custom base 26 where 'a' through 'z' is 0 through 25 and words are case folded: Number of words whose 'digits' are all prime using a custom base 26: 30; c, cdc, cf, crt, ct, d, dc, dr, f, fcc, fl, ft, ftc, h, l, ltd, n, nc, ncr, nd, nh, nrc, r, rd, t, tn, tnt, ttl, tx, x Number of words that are prime using a custom base 26: 987; First 20: abhorrent, abolish, abreact, absurd, ac, act, actual, actuarial, ad, adjutant, adult, advisor, aerosol, aft, agent, agricultural, ah, aid, ajar, al Number of words whose digital sum is prime using a custom base 26: 5473; First 20: ababa, aback, abacus, abalone, abase, abater, abc, abdicate, abdomen, abe, abelian, abelson, aberrant, abeyant, ablaze, abolish, abominate, aborigine, aboveground, abraham Number of words that are prime in a custom base 26 and whose digital sum is prime in that base: 292; First 20: abolish, abreact, absurd, ac, ad, adjutant, adult, agricultural, ah, aid, al, allah, allied, altar, an, annal, ar, arclength, argonaut, asocial Number of words that are prime in custom base 26, whose digits are all prime, and whose digital sum is prime: 9; c, d, f, h, l, n, r, t, x
REXX
No attempt was made to exclude any "word" if it contained any non-letter (Latin alphabet) characters. <lang rexx>/*REXX program finds words whose ASCII code for its letters are prime (in a dictionary).*/ parse arg iFID . /*obtain optional arguments from the CL*/ if iFID== | iFID=="," then iFID='unixdict.txt' /*Not specified? Then use the default.*/ call genPrimes /*generate all primes less than 256. */ say 'reading the dictionary file: ' iFID /*show which dictionary is being read. */ say
- = 0 /*count of prime words found (so far).*/
do recs=0 while lines(iFID)\==0 /*read each word in the file (word=X).*/
x= strip( linein( iFID) ) /*pick off a word from the input line. */
do j=1 for length(x) /*examine each letter (char) in word. */
_= c2d( substr(x, j, 1) ) /*convert each letter to a decimal num.*/
if \@._ then iterate recs /*is this ASCII code letter a prime ? */
end /*j*/
say x /*display a prime word to the terminal.*/
#= # + 1 /*bump the count of prime words. */
end /*recs*/ /* [↑] semaphore name is uppercased. */
say say copies("─", 30) recs " words in the dictionary file: " iFID say say 'found ' # " prime words in the dictionary." exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ genPrimes: p= 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 ,
67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 ,
157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251
@.= 0; do j=1 for words(p); _= word(p, j); @._= 1; end /*j*/; return</lang>
- output when using the default input:
reading the dictionary file: unixdict.txt a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q ────────────────────────────── 25104 words in the dictionary file: unixdict.txt found 36 prime words in the dictionary.
Ring
<lang ring> load "stdlib.ring"
cStr = read("unixdict.txt") wordList = str2list(cStr) Words = []
for n = 1 to len(wordList)
num = 0
len = len(wordList[n])
for m = 1 to len
asc = ascii(wordList[n][m])
if isprime(asc)
num = num + 1
else
exit
ok
next
if num = len
add(Words,wordList[n])
ok
next
see "Prime words are:" + nl see Words </lang> Output:
Prime words are: a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Ruby
<lang ruby>require 'prime'
puts File.open("unixdict.txt").select{|line| line.chomp.chars.all?{|c| c.ord.prime?} } </lang>
- Output:
a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Rust
<lang rust>// [dependencies] // primal = "0.3"
use std::fs::File; use std::io::{self, BufRead};
fn print_prime_words(filename: &str) -> std::io::Result<()> {
let sieve = primal::Sieve::new(std::char::MAX as usize);
let file = File::open(filename)?;
let mut n = 0;
for line in io::BufReader::new(file).lines() {
let word = line?;
if word.chars().all(|c| sieve.is_prime(c as usize)) {
n += 1;
print!("{:2}: {:<10}", n, word);
if n % 4 == 0 {
println!();
}
}
}
Ok(())
}
fn main() {
match print_prime_words("unixdict.txt") {
Ok(()) => {}
Err(error) => eprintln!("{}", error),
}
}</lang>
- Output:
1: a 2: aaa 3: age 4: agee 5: ak 6: am 7: ama 8: e 9: egg 10: eke 11: em 12: emma 13: g 14: ga 15: gag 16: gage 17: gam 18: game 19: gamma 20: ge 21: gee 22: gem 23: gemma 24: gm 25: k 26: keg 27: m 28: ma 29: mae 30: magma 31: make 32: mamma 33: me 34: meek 35: meg 36: q
Swift
<lang swift>import Foundation
class BitArray {
var array: [UInt32]
init(size: Int) {
array = Array(repeating: 0, count: (size + 31)/32)
}
func get(index: Int) -> Bool {
let bit = UInt32(1) << (index & 31)
return (array[index >> 5] & bit) != 0
}
func set(index: Int, value: Bool) {
let bit = UInt32(1) << (index & 31)
if value {
array[index >> 5] |= bit
} else {
array[index >> 5] &= ~bit
}
}
}
class PrimeSieve {
let composite: BitArray
init(size: Int) {
composite = BitArray(size: size/2)
var p = 3
while p * p <= size {
if !composite.get(index: p/2 - 1) {
let inc = p * 2
var q = p * p
while q <= size {
composite.set(index: q/2 - 1, value: true)
q += inc
}
}
p += 2
}
}
func isPrime(number: Int) -> Bool {
if number < 2 {
return false
}
if (number & 1) == 0 {
return number == 2
}
return !composite.get(index: number/2 - 1)
}
}
func loadDictionary(_ path: String) throws -> [String] {
let contents = try String(contentsOfFile: path, encoding: String.Encoding.ascii)
return contents.components(separatedBy: "\n").filter{!$0.isEmpty}
}
do {
let dictionary = try loadDictionary("unixdict.txt")
let sieve = PrimeSieve(size: 255)
for word in dictionary {
if word.allSatisfy({$0.isASCII && sieve.isPrime(number: Int($0.asciiValue!))}) {
print(word)
}
}
} catch {
print(error.localizedDescription)
}</lang>
- Output:
a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q
Wren
<lang ecmascript>import "io" for File import "/math" for Int import "/trait" for Stepped
// cache prime characters with codepoints between 33 and 255 say var primeChars = [] for (i in Stepped.new(33..255, 2)) {
if (Int.isPrime(i)) primeChars.add(String.fromCodePoint(i))
} var wordList = "unixdict.txt" // local copy var words = File.read(wordList).trimEnd().split("\n") System.print("Prime words in %(wordList) are:") for (word in words) {
if (word.all { |c| primeChars.contains(c) }) System.print(word)
}</lang>
- Output:
Prime words in unixdict.txt are: a aaa age agee ak am ama e egg eke em emma g ga gag gage gam game gamma ge gee gem gemma gm k keg m ma mae magma make mamma me meek meg q