Prime words: Difference between revisions
Thundergnat (talk | contribs) m (→{{header|Raku}}: typos, tweaks) |
Thundergnat (talk | contribs) (→{{header|Raku}}: DRY, more concise) |
||
Line 253: | Line 253: | ||
<lang perl6>my @words = 'unixdict.txt'.IO.words».fc; |
<lang perl6>my @words = 'unixdict.txt'.IO.words».fc; |
||
sub display ($n, @n, $s = "First 20: ") {"$n;\n{$s}{@n.join: ', '}"} |
|||
say 'Number of words whose ords are all prime: ', |
say 'Number of words whose ords are all prime: ', |
||
@words.hyper. |
@words.hyper.grep({ all(.comb.».ord).is-prime }).&{display +$_, $_, ''}; |
||
say "\nNumber of words whose ordinal sum is prime: ", |
say "\nNumber of words whose ordinal sum is prime: ", |
||
@words. |
@words.grep({ .comb».ord.sum.is-prime }).&{display +$_,.head(20)}; |
||
say "\n\ |
say "\n\nIterpreting the words as if they were base 36 numbers:"; |
||
say "\nNumber of words that are prime in base 36: ", |
say "\nNumber of words that are prime in base 36: ", |
||
@words. |
@words.grep({ !.contains(/\W/) && :36($_).is-prime }).&{display +$_,.head(20)}; |
||
say "\nNumber of words whose base 36 digital sum is prime: ", |
say "\nNumber of words whose base 36 digital sum is prime: ", |
||
@words. |
@words.grep({ !.contains(/\W/) && .comb».parse-base(36).sum.is-prime }).&{display +$_,.head(20)}; |
||
use Base::Any:ver<0.1.2>; |
use Base::Any:ver<0.1.2>; |
||
Line 274: | Line 276: | ||
say "\nNumber of words whose 'digits' are all prime using a custom base: ", |
say "\nNumber of words whose 'digits' are all prime using a custom base: ", |
||
@words.hyper. |
@words.hyper.grep({ !.contains(/<-alpha>/) && all(.comb».&from-base(26)).is-prime }).&{display +$_, $_, ''}; |
||
say "\nNumber of words that are prime using a custom base: ", |
say "\nNumber of words that are prime using a custom base: ", |
||
@words. |
@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: ", |
say "\nNumber of words whose digital sum is prime using a custom base: ", |
||
@words. |
@words.grep({ !.contains(/<-alpha>/) && .comb».&from-base(26).sum.is-prime }).&{display +$_,.head(20)};</lang> |
||
{{out}} |
{{out}} |
||
<pre>Number of words whose ords are all prime: 36; |
<pre>Number of words whose ords are all prime: 36; |
Revision as of 17:11, 4 December 2020
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.
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
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: ', '}"}
say 'Number of words whose ords are all prime: ',
@words.hyper.grep({ all(.comb.».ord).is-prime }).&{display +$_, $_, };
say "\nNumber of words whose ordinal sum is prime: ",
@words.grep({ .comb».ord.sum.is-prime }).&{display +$_,.head(20)};
say "\n\nIterpreting the words as if they were base 36 numbers:";
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)};
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: ",
@words.hyper.grep({ !.contains(/<-alpha>/) && all(.comb».&from-base(26)).is-prime }).&{display +$_, $_, };
say "\nNumber of words that are prime using a custom base: ",
@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: ",
@words.grep({ !.contains(/<-alpha>/) && .comb».&from-base(26).sum.is-prime }).&{display +$_,.head(20)};</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 ... Interpreting the words as if they were base 36 numbers: 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 ... 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: 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: 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: 5473; First 20: ababa, aback, abacus, abalone, abase, abater, abc, abdicate, abdomen, abe, abelian, abelson, aberrant, abeyant, ablaze, abolish, abominate, aborigine, aboveground, abraham ...
REXX
No attempt was made to exclude any "word" if it contained any non-letter (Latin alphabet) characters. <lang rexx>/*REXX pg finds words whose ASCII code for its letters (within an identified 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 "usable words in the dictionary file: " iFID 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 usable 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
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