Hex words: Difference between revisions

From Rosetta Code
Content added Content deleted
(Added AutoHotkey)
(Added Arturo implementation)
Line 260: Line 260:
Found 13 hex words with 4 or more distinct digits
Found 13 hex words with 4 or more distinct digits
</pre>
</pre>

=={{header|Arturo}}==

<lang rebol>words: map read.lines relative "unixdict.txt" => strip
hexWords: new []

digRoot: function [num][
res: num
while [1 < size digits res][
res: sum digits res
]
return res
]

printTable: function [wrds][
print [pad.center "Root" 10 pad.right "Word" 10 pad "Base-10" 15]
print repeat "-" 38
loop wrds 'wrd [
print [pad.center to :string wrd\root 10 pad.right wrd\hex 10 pad to :string wrd\decimal 15]
]
print repeat "-" 38
print [" Total count:" size wrds "\n"]
]

loop words 'word [
if 4 > size word ->
continue

if not? empty? match word {/^[a-f]+$/} [
base10: from.hex word
droot: digRoot base10
'hexWords ++ #[
root: droot
hex: word
decimal: base10
]
]
]

printTable sort.by:'root hexWords
printTable sort.descending.by:'decimal select hexWords 'h ->
4 =< size unique split h\hex</lang>

{{out}}

<pre> Root Word Base-10
--------------------------------------
1 ababa 703162
1 abbe 43966
1 dada 56026
1 deaf 57007
1 decade 14600926
2 cede 52958
2 feed 65261
3 abed 44013
3 added 712173
3 bade 47838
4 beebe 782014
4 decca 912586
5 dade 56030
6 bead 48813
6 deface 14613198
7 babe 47806
7 fade 64222
8 dead 57005
8 efface 15727310
8 facade 16435934
9 accede 11325150
9 beef 48879
9 cafe 51966
9 dacca 896202
9 deed 57069
9 face 64206
--------------------------------------
Total count: 26
Root Word Base-10
--------------------------------------
8 facade 16435934
8 efface 15727310
6 deface 14613198
1 decade 14600926
9 accede 11325150
4 decca 912586
7 fade 64222
9 face 64206
1 deaf 57007
9 cafe 51966
6 bead 48813
3 bade 47838
3 abed 44013
--------------------------------------
Total count: 13</pre>


=={{header|AutoHotkey}}==
=={{header|AutoHotkey}}==

Revision as of 09:55, 16 April 2022

Hex words is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Definition

For the purposes of this task a hex word means a word which (in lower case form) consists entirely of the letters a, b, c, d, e and f.

Task

Using unixdict.txt, find all hex words with 4 letters or more.

Convert each such word to its decimal equivalent and compute its base 10 digital root.

Display all three in increasing order of digital root and show the total count of such words.

Also filter out all such words which contain at least 4 distinct letters and display the same statistics but in decreasing order of decimal equivalent together with their total count.

11l

Translation of: Python

<lang 11l>F digroot(=n) 

  L n > 9
     n = sum(String(n).map(d -> Int(d)))
  R n

V lines = File(‘unixdict.txt’).read().split("\n") V words = lines.filter(w -> w.len >= 4 & all(w.map(c -> c C ‘abcdef’))) V results = words.map(w -> (w, Int(w, radix' 16), digroot(Int(w, radix' 16))))

print("Hex words in unixdict.txt:\nRoot Word Base 10\n "(‘-’ * 22)) L(a) sorted(results, key' x -> x[2]) 

  print(f:‘{a[2]}     {a[0]:<6}{a[1]:10}’)

print(‘Total count of these words: ’results.len) print("\nHex words with > 3 distinct letters:\nRoot Word Base 10\n "(‘-’ * 22)) results = results.filter(a -> Set(Array(String(a[0]))).len > 3) L(a) sorted(results, key' x -> x[2]) 

  print(f:‘{a[2]}     {a[0]:<6}{a[1]:10}’)

print(‘Total count of those words: ’results.len)</lang>

Output:
Hex words in unixdict.txt:
Root  Word      Base 10
 ----------------------
1     ababa     703162
1     abbe       43966
1     dada       56026
1     deaf       57007
1     decade  14600926
2     cede       52958
2     feed       65261
3     abed       44013
3     added     712173
3     bade       47838
4     beebe     782014
4     decca     912586
5     dade       56030
6     bead       48813
6     deface  14613198
7     babe       47806
7     fade       64222
8     dead       57005
8     efface  15727310
8     facade  16435934
9     accede  11325150
9     beef       48879
9     cafe       51966
9     dacca     896202
9     deed       57069
9     face       64206
Total count of these words: 26

Hex words with > 3 distinct letters:
Root  Word      Base 10
 ----------------------
1     deaf       57007
1     decade  14600926
3     abed       44013
3     bade       47838
4     decca     912586
6     bead       48813
6     deface  14613198
7     fade       64222
8     efface  15727310
8     facade  16435934
9     accede  11325150
9     cafe       51966
9     face       64206
Total count of those words: 13

ALGOL 68

<lang algol68># find words that contain only hex digits a-f # 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
                      );
   INT count := 0;
   INT max words = 100; # guess at the maximum number of words #
   MODE HEXWORD = STRUCT( STRING word, LONG INT value, INT root, INT len );
   [ 1 : max words ]HEXWORD hw;
   WHILE STRING word;
         get( input file, ( word, newline ) );
         NOT at eof
   DO
       # check the word contains only a-f and compute its decimal value #
       IF  INT word len = ( UPB word + 1 ) - LWB word;
           word len >= 4
       THEN
           # the word is at least 4 characters long #
           BOOL is hex word := word /= "";
           LONG INT  int word    := 0;
           FOR i FROM LWB word TO UPB word
           WHILE is hex word := word[ i ] >= "a" AND word[ i ] <= "f"
           DO
               int word *:= 16;
               int word +:= ( ABS word[ i ] - ABS "a" ) + 10
           OD;
           IF is hex word
           THEN
               # have a hex word #
               count +:= 1;
               # compute the digital root #
               LONG INT r := int word;
               WHILE r > 9 DO
                   LONG INT dr := r MOD 10;
                   WHILE ( r OVERAB 10 ) > 0 DO dr +:= r MOD 10 OD;
                   r := dr
               OD;
               word  OF hw[ count ] := word;
               value OF hw[ count ] := int word;
               root  OF hw[ count ] := SHORTEN r;
               len   OF hw[ count ] := word len
           FI
       FI
   OD;
   close( input file );
   # prints the HEXWORD hw #
   PROC show = ( HEXWORD hw )VOID:
   BEGIN
       STRING pad = IF len OF hw >= 12 THEN "" ELSE ( 12 - len OF hw ) * " " FI;
       print( ( word OF hw, ": ", pad, whole( value OF hw, -10 ), " [ ", whole( root OF hw, 0 ), " ]", newline ) )
   END # show # ;
   # Quicksorts in-place the array of HEXWORDS a, from lb to ub on ascending value #
   PROC quicksort = ( REF[]HEXWORD a, INT lb, ub )VOID:
        IF ub > lb THEN
           # more than one element, so must sort #
           INT left   := lb;
           INT right  := ub;
           # choosing the middle element of the array as the pivot #
           LONG INT pivot  := value OF a[ left + ( ( right + 1 ) - left ) OVER 2 ];
           WHILE
               WHILE IF left  <= ub THEN value OF a[ left  ] < pivot ELSE FALSE FI DO left  +:= 1 OD;
               WHILE IF right >= lb THEN value OF a[ right ] > pivot ELSE FALSE FI DO right -:= 1 OD;
               left <= right
           DO
               HEXWORD t  := a[ left  ];
               a[ left  ] := a[ right ];
               a[ right ] := t;
               left      +:= 1;
               right     -:= 1
           OD;
           quicksort( a, lb,   right );
           quicksort( a, left, ub    )
        FI # quicksort # ;
   # show the hex words in ascending order of digital root #
   FOR r FROM 1 TO 9 DO
       FOR i FROM 1 TO count DO
           IF root OF hw[ i ] = r THEN show( hw[ i ] ) FI
       OD
   OD;
   print( ( "Found ", whole( count, 0 ), " hex words", newline, newline ) );
   # show the words in descending value order excluding those with less than 4 unique letters #
   quicksort( hw, 1, count );
   INT count 4 := 0;
   FOR i FROM count BY -1 TO 1 DO
       # check the word has at least four different digits #
       INT a := 0, b := 0, c := 0, d := 0, e := 0, f := 0;
       FOR c pos FROM LWB word OF hw[ i ] TO UPB word OF hw[ i ] DO
           IF   CHAR ch = ( word OF hw[ i ] )[ c pos ];
                ch = "a"
           THEN a := 1
           ELIF ch = "b"
           THEN b := 1
           ELIF ch = "c"
           THEN c := 1
           ELIF ch = "d"
           THEN d := 1
           ELIF ch = "e"
           THEN e := 1
           ELSE f := 1
           FI
       OD;
       IF a + b + c + d + e + f >= 4
       THEN
           # have a hex word with at least 4 different digits #
           count 4 +:= 1;
           show( hw[ i ] )
       FI
   OD;
   print( ( "Found ", whole( count 4, 0 ), " hex words with 4 or more distinct digits", newline ) )

FI</lang>

Output:
ababa:            703162 [ 1 ]
abbe:              43966 [ 1 ]
dada:              56026 [ 1 ]
deaf:              57007 [ 1 ]
decade:         14600926 [ 1 ]
cede:              52958 [ 2 ]
feed:              65261 [ 2 ]
abed:              44013 [ 3 ]
added:            712173 [ 3 ]
bade:              47838 [ 3 ]
beebe:            782014 [ 4 ]
decca:            912586 [ 4 ]
dade:              56030 [ 5 ]
bead:              48813 [ 6 ]
deface:         14613198 [ 6 ]
babe:              47806 [ 7 ]
fade:              64222 [ 7 ]
dead:              57005 [ 8 ]
efface:         15727310 [ 8 ]
facade:         16435934 [ 8 ]
accede:         11325150 [ 9 ]
beef:              48879 [ 9 ]
cafe:              51966 [ 9 ]
dacca:            896202 [ 9 ]
deed:              57069 [ 9 ]
face:              64206 [ 9 ]
Found 26 hex words

facade:         16435934 [ 8 ]
efface:         15727310 [ 8 ]
deface:         14613198 [ 6 ]
decade:         14600926 [ 1 ]
accede:         11325150 [ 9 ]
decca:            912586 [ 4 ]
fade:              64222 [ 7 ]
face:              64206 [ 9 ]
deaf:              57007 [ 1 ]
cafe:              51966 [ 9 ]
bead:              48813 [ 6 ]
bade:              47838 [ 3 ]
abed:              44013 [ 3 ]
Found 13 hex words with 4 or more distinct digits

Arturo

<lang rebol>words: map read.lines relative "unixdict.txt" => strip hexWords: new []

digRoot: function [num][ 

   res: num
   while [1 < size digits res][
       res: sum digits res
   ]
   return res

]

printTable: function [wrds][ 

   print [pad.center "Root" 10 pad.right "Word" 10 pad "Base-10" 15]
   print repeat "-" 38
   loop wrds 'wrd [
       print [pad.center to :string wrd\root 10 pad.right wrd\hex 10 pad to :string wrd\decimal 15]
   ]
   print repeat "-" 38
   print ["   Total count:" size wrds "\n"]

]

loop words 'word [ 

   if 4 > size word ->
       continue

   if not? empty? match word {/^[a-f]+$/} [
       base10: from.hex word
       droot: digRoot base10
       'hexWords ++ #[
           root: droot
           hex: word
           decimal: base10
       ]
   ]

]

printTable sort.by:'root hexWords printTable sort.descending.by:'decimal select hexWords 'h -> 

   4 =< size unique split h\hex</lang>
Output:
   Root    Word               Base-10 
--------------------------------------
    1      ababa               703162 
    1      abbe                 43966 
    1      dada                 56026 
    1      deaf                 57007 
    1      decade            14600926 
    2      cede                 52958 
    2      feed                 65261 
    3      abed                 44013 
    3      added               712173 
    3      bade                 47838 
    4      beebe               782014 
    4      decca               912586 
    5      dade                 56030 
    6      bead                 48813 
    6      deface            14613198 
    7      babe                 47806 
    7      fade                 64222 
    8      dead                 57005 
    8      efface            15727310 
    8      facade            16435934 
    9      accede            11325150 
    9      beef                 48879 
    9      cafe                 51966 
    9      dacca               896202 
    9      deed                 57069 
    9      face                 64206 
--------------------------------------
   Total count: 26 
 
   Root    Word               Base-10 
--------------------------------------
    8      facade            16435934 
    8      efface            15727310 
    6      deface            14613198 
    1      decade            14600926 
    9      accede            11325150 
    4      decca               912586 
    7      fade                 64222 
    9      face                 64206 
    1      deaf                 57007 
    9      cafe                 51966 
    6      bead                 48813 
    3      bade                 47838 
    3      abed                 44013 
--------------------------------------
   Total count: 13

AutoHotkey

<lang AutoHotkey>FileRead, wList, % A_Desktop "\unixdict.txt" hexWords := Hex_words(wList) Header := "Base 10`t`tWord`tRoot`n" for dr, obj in hexWords 

   for word, dec in obj
       result .= dec "`t" (StrLen(dec) < 8 ? "`t" : "") word "`t" dr "`n"

MsgBox, 262144, ,% result := Header . result . "`n4 distinct letter words:`n" . Header . filter(result, "abcdef", 4) return

-------------------------------------------

filter(result, letters, Count){ 

   for i, line in StrSplit(result, "`n", "`r") {
       counter := 0
       for j, letter in StrSplit(letters)
           StrReplace(line, letter, letter, cnt, 1), counter += cnt
       if (counter >= Count)
           filtered .= line "`n"
   }
   Sort, filtered, RN
   return filtered

}

-------------------------------------------

Hex_words(wList){ 

   hexWords := []
   for i, w in StrSplit(wList, "`n", "`r") {
       if (StrLen(w) < 4 || w ~= "i)[^abcdef]")
           continue
       dec := hex2dec(w)
       dr := digital_root(dec)
       hexWords[dr, w] := dec
   }
   return hexWords

}

-------------------------------------------

digital_root(n){ 

   loop {
       sum := 0, i := 1
       while (i <= StrLen(n))
           sum += SubStr(n, i++, 1)
       n := sum
   }
   until (sum < 10)
   return sum

}</lang>

Output:
Base 10		Word	Root
703162		ababa	1
43966		abbe	1
56026		dada	1
57007		deaf	1
14600926	decade	1
52958		cede	2
65261		feed	2
44013		abed	3
712173		added	3
47838		bade	3
782014		beebe	4
912586		decca	4
56030		dade	5
48813		bead	6
14613198	deface	6
47806		babe	7
64222		fade	7
57005		dead	8
15727310	efface	8
16435934	facade	8
11325150	accede	9
48879		beef	9
51966		cafe	9
896202		dacca	9
57069		deed	9
64206		face	9

4 distinct letter words:
Base 10		Word	Root
16435934	facade	8
15727310	efface	8
14613198	deface	6
14600926	decade	1
11325150	accede	9
912586		decca	4
64222		fade	7
64206		face	9
57007		deaf	1
51966		cafe	9
48813		bead	6
47838		bade	3
44013		abed	3

AWK

<lang AWK>

  1. syntax: GAWK -f HEX_WORDS.AWK unixdict.txt

{ nf += NF 

   if (length($1) >= 4) {
     if ($0 ~ /^[a-fA-F]{4,}$/) {
       base10 = hex2dec($1)
       dr = digital_root(base10)
       arr[dr " " $1] = base10
     }
   }

} ENDFILE { 

   printf("%s: %d records, %d fields\n\n",FILENAME,FNR,nf)

} END { 

   PROCINFO["sorted_in"] = "@ind_str_asc"
   for (i in arr) {
     printf("%-8s %10d \n",i,arr[i])
     count1++
   }
   printf("Found %d hex words\n\n",count1)
   PROCINFO["sorted_in"] = "@val_num_desc"
   for (i in arr) {
     if (distinct(substr(i,3)) >= 4) {
       printf("%-8s %10d \n",i,arr[i])
       count2++
     }
   }
   printf("Found %d hex words with 4 or more distinct\n\n",count2)
   exit(0)

} function digital_root(n, i,sum) { 

   while (1) {
     sum = 0
     for (i=1; i<=length(n); i++) {
       sum += substr(n,i,1)
     }
     if (sum < 10) {
       break
     }
     n = sum
   }
   return(sum)

} function distinct(str, arr,i) { 

   for (i=1; i<=length(str); i++) {
     arr[substr(str,i,1)]++
   }
   return(length(arr))

} function hex2dec(s, num) { 

   num = index("0123456789ABCDEF",toupper(substr(s,length(s)))) - 1
   sub(/.$/,"",s)
   return num + (length(s) ? 16*hex2dec(s) : 0)

} </lang>

Output:
unixdict.txt: 25104 records, 25104 fields

1 ababa      703162
1 abbe        43966
1 dada        56026
1 deaf        57007
1 decade   14600926
2 cede        52958
2 feed        65261
3 abed        44013
3 added      712173
3 bade        47838
4 beebe      782014
4 decca      912586
5 dade        56030
6 bead        48813
6 deface   14613198
7 babe        47806
7 fade        64222
8 dead        57005
8 efface   15727310
8 facade   16435934
9 accede   11325150
9 beef        48879
9 cafe        51966
9 dacca      896202
9 deed        57069
9 face        64206
Found 26 hex words

8 facade   16435934
8 efface   15727310
6 deface   14613198
1 decade   14600926
9 accede   11325150
4 decca      912586
7 fade        64222
9 face        64206
1 deaf        57007
9 cafe        51966
6 bead        48813
3 bade        47838
3 abed        44013
Found 13 hex words with 4 or more distinct

Factor

Works with: Factor version 0.99 2021-06-02

<lang factor>USING: formatting io io.encodings.ascii io.files kernel literals math math.parser prettyprint sequences sets sorting ;

CONSTANT: words $[ 

   "unixdict.txt" ascii file-lines
   [ length 3 > ] filter
   [ "abcdef" subset? ] filter

]

droot ( m -- n ) 1 - 9 mod 1 + ;
info. ( str -- ) dup hex> dup droot "%-8s-> %-10d-> %d\n" printf ;
info-by ( quot ? -- )
   [ sort-with ] [ inv-sort-with ] if [ length ] keep
   [ info. ] each pprint ; inline

words [ hex> droot ] t info-by " hex words with 4 or more letters found." print nl

words [ cardinality 3 > ] filter [ hex> ] f info-by " such words found which contain 4 or more different digits." print</lang>

Output:
ababa   -> 703162    -> 1
abbe    -> 43966     -> 1
dada    -> 56026     -> 1
deaf    -> 57007     -> 1
decade  -> 14600926  -> 1
cede    -> 52958     -> 2
feed    -> 65261     -> 2
abed    -> 44013     -> 3
added   -> 712173    -> 3
bade    -> 47838     -> 3
beebe   -> 782014    -> 4
decca   -> 912586    -> 4
dade    -> 56030     -> 5
bead    -> 48813     -> 6
deface  -> 14613198  -> 6
babe    -> 47806     -> 7
fade    -> 64222     -> 7
dead    -> 57005     -> 8
efface  -> 15727310  -> 8
facade  -> 16435934  -> 8
accede  -> 11325150  -> 9
beef    -> 48879     -> 9
cafe    -> 51966     -> 9
dacca   -> 896202    -> 9
deed    -> 57069     -> 9
face    -> 64206     -> 9
26 hex words with 4 or more letters found.

facade  -> 16435934  -> 8
efface  -> 15727310  -> 8
deface  -> 14613198  -> 6
decade  -> 14600926  -> 1
accede  -> 11325150  -> 9
decca   -> 912586    -> 4
fade    -> 64222     -> 7
face    -> 64206     -> 9
deaf    -> 57007     -> 1
cafe    -> 51966     -> 9
bead    -> 48813     -> 6
bade    -> 47838     -> 3
abed    -> 44013     -> 3
13 such words found which contain 4 or more different digits.

jq

Works with: jq

Works with gojq, the Go implementation of jq

Preliminaries <lang jq>def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

  1. . may be a decimal number or a string representing a decimal number

def digital_root: 

 # string-only version
 def dr:
   # state: [mdr, persist]
   until( .[0] | length == 1;
             [ (.[0] | explode | map(.-48) | add | tostring), .[1] + 1 ]
             );
 [tostring, 0] | dr | .[0] | tonumber;
  1. lowercase a-f

def isHexWord: 

 all(explode[]; 97 <= . and . <= 102);
  1. Input: a valid hex number (all lowercase)

def hex2i: 

 def toi: if . >= 87 then .-87 else . - 48 end;
 reduce (explode | map(toi) | reverse[]) as $i ([1, 0]; # [power, sum]
   .[1] += $i * .[0]
   | .[0] *= 16 )
 | .[1]; </lang>

The Task <lang jq>def task: 

 def format: "\(.[0]|lpad(8)) -> \(.[1]|lpad(9)) -> \(.[2])";
 
 INDEX(inputs | select(length>=4 and isHexWord); .)
 | reduce keys_unsorted[] as $word ([];
       ($word | hex2i) as $num
       | ($num | digital_root) as $dr
       | . + $word, $num, $dr)
 | sort_by( .[-1] )
 | . as $details

 | (reduce .[] as $line ([];
      if $line[0] | explode | unique | length >= 4
      then . + [$line] else . end)) as $digits4

 | "\($details|length) hex words with 4 or more letters were found:",
   ($details[] | format),
   "",
   "\($digits4|length) such words contain 4 or more different letters:",
    (($digits4|sort_by(.[1])|reverse[] ) | format) ;

task</lang>

Output:

Invocation 

< unixdict.txt jq -Rrn -f rc-hex-words.jq

26 hex words with 4 or more letters were found:
   ababa ->    703162 -> 1
    abbe ->     43966 -> 1
    dada ->     56026 -> 1
    deaf ->     57007 -> 1
  decade ->  14600926 -> 1
    cede ->     52958 -> 2
    feed ->     65261 -> 2
    abed ->     44013 -> 3
   added ->    712173 -> 3
    bade ->     47838 -> 3
   beebe ->    782014 -> 4
   decca ->    912586 -> 4
    dade ->     56030 -> 5
    bead ->     48813 -> 6
  deface ->  14613198 -> 6
    babe ->     47806 -> 7
    fade ->     64222 -> 7
    dead ->     57005 -> 8
  efface ->  15727310 -> 8
  facade ->  16435934 -> 8
  accede ->  11325150 -> 9
    beef ->     48879 -> 9
    cafe ->     51966 -> 9
   dacca ->    896202 -> 9
    deed ->     57069 -> 9
    face ->     64206 -> 9

13 such words contain 4 or more different letters:
  facade ->  16435934 -> 8
  efface ->  15727310 -> 8
  deface ->  14613198 -> 6
  decade ->  14600926 -> 1
  accede ->  11325150 -> 9
   decca ->    912586 -> 4
    fade ->     64222 -> 7
    face ->     64206 -> 9
    deaf ->     57007 -> 1
    cafe ->     51966 -> 9
    bead ->     48813 -> 6
    bade ->     47838 -> 3
    abed ->     44013 -> 3

Julia

<lang julia>digroot(n) = (while n > 9 n = sum(digits(n)) end; n)

function hexwords(wordfile = "unixdict.txt") 

   words = lowercase.(split(read(wordfile, String), r"\s+"))
   filter!(w -> length(w) >= 4 && all(c -> c in "abcdef", w), words)
   results = [[w, parse(Int, w, base = 16)] for w in words]
   for a in results
       pushfirst!(a, digroot(a[2]))
   end
   println("Hex words in $wordfile:\nRoot  Word      Base 10\n", "-"^30)
   for a in sort!(results)
       println(rpad(a[1], 6), rpad(a[2], 10), a[3])
   end
   println("Total count of these words: $(length(results)).")
   println("\nHex words with > 3 distinct letters:\nRoot  Word      Base 10\n", "-"^30)
   filter!(a -> length(unique(a[2])) > 3, results)
   for a in results
       println(rpad(a[1], 6), rpad(a[2], 10), a[3])
   end
   println("Total count of those words: $(length(results)).")

end

hexwords()

</lang>

Output:
Hex words in unixdict.txt:
Root  Word      Base 10
------------------------------
1     ababa     703162
1     abbe      43966
1     dada      56026
1     deaf      57007
1     decade    14600926
2     cede      52958
2     feed      65261
3     abed      44013
3     added     712173
3     bade      47838
4     beebe     782014
4     decca     912586
5     dade      56030
6     bead      48813
6     deface    14613198
7     babe      47806
7     fade      64222
8     dead      57005
8     efface    15727310
8     facade    16435934
9     accede    11325150
9     beef      48879
9     cafe      51966
9     dacca     896202
9     deed      57069
9     face      64206
Total count of these words: 26.

Hex words with > 3 distinct letters:
Root  Word      Base 10
------------------------------
1     deaf      57007
1     decade    14600926
3     abed      44013
3     bade      47838
4     decca     912586
6     bead      48813
6     deface    14613198
7     fade      64222
8     efface    15727310
8     facade    16435934
9     accede    11325150
9     cafe      51966
9     face      64206
Total count of those words: 13.

Perl

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

use strict; # https://rosettacode.org/wiki/Hex_words use warnings; use List::AllUtils qw( nsort_by uniq );

sub root 

 {
 local $_ = shift;
 $_ = eval while s/\B/+/g;
 return $_;
 }

my @bydecimal = grep +(uniq /[a-f]/g)[3], 

 my @byroot = map { sprintf "%10s %10d %3d\n", $_, hex $_, root hex $_
 } do { local(@ARGV, $/) = 'unixdict.txt'; <> =~ /^[a-f]{4,}$/gm };

print +(nsort_by { (split ' ')[2] } @byroot), 

 "total count = @{[ scalar @byroot ]} and @{[ scalar @bydecimal
 ]} have at least 4 distinct digits\n",
 reverse nsort_by { (split ' ')[1] } @bydecimal;</lang>
Output:
     ababa     703162   1
      abbe      43966   1
      dada      56026   1
      deaf      57007   1
    decade   14600926   1
      cede      52958   2
      feed      65261   2
      abed      44013   3
     added     712173   3
      bade      47838   3
     beebe     782014   4
     decca     912586   4
      dade      56030   5
      bead      48813   6
    deface   14613198   6
      babe      47806   7
      fade      64222   7
      dead      57005   8
    efface   15727310   8
    facade   16435934   8
    accede   11325150   9
      beef      48879   9
      cafe      51966   9
     dacca     896202   9
      deed      57069   9
      face      64206   9
total count = 26 and 13 have at least 4 distinct digits
    facade   16435934   8
    efface   15727310   8
    deface   14613198   6
    decade   14600926   1
    accede   11325150   9
     decca     912586   4
      fade      64222   7
      face      64206   9
      deaf      57007   1
      cafe      51966   9
      bead      48813   6
      bade      47838   3
      abed      44013   3

Phix

with javascript_semantics
function af(string s) return max(s)<='f' and min(s)>='a' end function
function digital_root(integer n)
    assert(n>=0)
    while n>9 do
        integer tot = 0
        while n>0 do
            tot += remainder(n,10)
            n = floor(n/10)
        end while
        n = tot
    end while
    return n
end function
sequence words = filter(unix_dict(4),af),
         decml = apply(true,to_integer,{words,0,16}),
         roots = apply(decml,digital_root),
         tags = custom_sort(roots,tagset(length(roots)))

function caejasp() -- columnize/apply/extract/join/apply/sprint(...)
    sequence s = columnize(apply(true,extract,{{words,decml,roots},{tags}}))
    return join(apply(true,sprintf,{{"%6s -> %8d -> %d\n"},s}))
end function
printf(1," %s\n %d hex words with 4 or more letters found,\n",{caejasp(),length(tags)})
function ge4(integer t) return length(unique(words[t]))>=4 end function
tags = filter(tags,ge4)
tags = extract(tags,reverse(custom_sort(extract(decml,tags),tagset(length(tags)))))
printf(1," %d with 4 or more distinct characters:\n\n %s\n",{length(tags),caejasp()})
Output:
  ababa ->   703162 -> 1
   abbe ->    43966 -> 1
   dada ->    56026 -> 1
   deaf ->    57007 -> 1
 decade -> 14600926 -> 1
   cede ->    52958 -> 2
   feed ->    65261 -> 2
   abed ->    44013 -> 3
  added ->   712173 -> 3
   bade ->    47838 -> 3
  beebe ->   782014 -> 4
  decca ->   912586 -> 4
   dade ->    56030 -> 5
   bead ->    48813 -> 6
 deface -> 14613198 -> 6
   babe ->    47806 -> 7
   fade ->    64222 -> 7
   dead ->    57005 -> 8
 efface -> 15727310 -> 8
 facade -> 16435934 -> 8
 accede -> 11325150 -> 9
   beef ->    48879 -> 9
   cafe ->    51966 -> 9
  dacca ->   896202 -> 9
   deed ->    57069 -> 9
   face ->    64206 -> 9

 26 hex words with 4 or more letters found,
 13 with 4 or more distinct characters:

 facade -> 16435934 -> 8
 efface -> 15727310 -> 8
 deface -> 14613198 -> 6
 decade -> 14600926 -> 1
 accede -> 11325150 -> 9
  decca ->   912586 -> 4
   fade ->    64222 -> 7
   face ->    64206 -> 9
   deaf ->    57007 -> 1
   cafe ->    51966 -> 9
   bead ->    48813 -> 6
   bade ->    47838 -> 3
   abed ->    44013 -> 3

Python

<lang python>def digroot(n): 

   while n > 9:
       n = sum([int(d) for d in str(n)])
   return n

with open('unixdict.txt') as f: 

   lines = [w.strip() for w in f.readlines()]
   words = [w for w in lines if len(w) >= 4 and all(c in 'abcdef' for c in w)]
   results = [[w, int(w, 16)] for w in words]
   for a in results:
       a.append(digroot(a[1]))
       
   print(f"Hex words in unixdict.txt:\nRoot  Word      Base 10\n", "-"*22)
   for a in sorted(results, key=lambda x:x[2]):
       print(f"{a[2]}     {a[0]:6}{a[1]:10}")
       
   print("Total count of these words:", len(results))
   print("\nHex words with > 3 distinct letters:\nRoot  Word      Base 10\n", "-"*22)
   results = [a for a in results if len(set(str(a[0]))) > 3]
   for a in sorted(results, key=lambda x:x[2]):
       print(f"{a[2]}     {a[0]:6}{a[1]:10}")
       
   print("Total count of those words:", len(results))

</lang>

Output:
Hex words in unixdict.txt:
Root  Word      Base 10
 ----------------------
1     ababa     703162
1     abbe       43966
1     dada       56026
1     deaf       57007
1     decade  14600926
2     cede       52958
2     feed       65261
3     abed       44013
3     added     712173
3     bade       47838
4     beebe     782014
4     decca     912586
5     dade       56030
6     bead       48813
6     deface  14613198
7     babe       47806
7     fade       64222
8     dead       57005
8     efface  15727310
8     facade  16435934
9     accede  11325150
9     beef       48879
9     cafe       51966
9     dacca     896202
9     deed       57069
9     face       64206
Total count of these words: 26

Hex words with > 3 distinct letters:
Root  Word      Base 10
 ----------------------
1     deaf       57007
1     decade  14600926
3     abed       44013
3     bade       47838
4     decca     912586
6     bead       48813
6     deface  14613198
7     fade       64222
8     efface  15727310
8     facade  16435934
9     accede  11325150
9     cafe       51966
9     face       64206
Total count of those words: 13

Raku

Sorted by digital root with a secondary alphabetical sort. <lang perl6>sub dr (Int $_ is copy) { $_ = dr(.comb.sum) while .chars > 1; $_ }

my %hex = './unixdict.txt'.IO.slurp.words.grep( *.chars > 3 )\ 

 .grep({ not / <-[abcdef]> / }).map: { $_ => dr :16($_).comb.sum }

say "{+%hex} hex words longer than 3 characters found in unixdict.txt:"; printf "%6s ➡ %8d ➡ %d\n", .key, :16(.key), .value for %hex.sort: { .value, .key }

my %many = %hex.grep: +*.key.comb.Set > 3;

say "\nOf which {+%many} contain at least four distinct characters:"; printf "%6s ➡ %8d ➡ %d\n", .key, :16(.key), .value for %many.sort: { -:16(.key) }</lang>

Output:
26 hex words longer than 3 characters found in unixdict.txt:
 ababa ➡   703162 ➡ 1
  abbe ➡    43966 ➡ 1
  dada ➡    56026 ➡ 1
  deaf ➡    57007 ➡ 1
decade ➡ 14600926 ➡ 1
  cede ➡    52958 ➡ 2
  feed ➡    65261 ➡ 2
  abed ➡    44013 ➡ 3
 added ➡   712173 ➡ 3
  bade ➡    47838 ➡ 3
 beebe ➡   782014 ➡ 4
 decca ➡   912586 ➡ 4
  dade ➡    56030 ➡ 5
  bead ➡    48813 ➡ 6
deface ➡ 14613198 ➡ 6
  babe ➡    47806 ➡ 7
  fade ➡    64222 ➡ 7
  dead ➡    57005 ➡ 8
efface ➡ 15727310 ➡ 8
facade ➡ 16435934 ➡ 8
accede ➡ 11325150 ➡ 9
  beef ➡    48879 ➡ 9
  cafe ➡    51966 ➡ 9
 dacca ➡   896202 ➡ 9
  deed ➡    57069 ➡ 9
  face ➡    64206 ➡ 9

Of which 13 contain at least four distinct characters:
facade ➡ 16435934 ➡ 8
efface ➡ 15727310 ➡ 8
deface ➡ 14613198 ➡ 6
decade ➡ 14600926 ➡ 1
accede ➡ 11325150 ➡ 9
 decca ➡   912586 ➡ 4
  fade ➡    64222 ➡ 7
  face ➡    64206 ➡ 9
  deaf ➡    57007 ➡ 1
  cafe ➡    51966 ➡ 9
  bead ➡    48813 ➡ 6
  bade ➡    47838 ➡ 3
  abed ➡    44013 ➡ 3

Wren

Library: Wren-ioutil
Library: Wren-fmt
Library: Wren-math
Library: Wren-seq

<lang ecmascript>import "./ioutil" for FileUtil import "./fmt" for Conv, Fmt import "./math" for Int import "./seq" for Lst

var words = FileUtil.readLines("unixdict.txt").where { |w| w.count > 0 && w[0].bytes[0] < 103 } var hexDigits = "abcdef" var lines = [] for (word in words) { 

   if (word.count < 4) continue
   if (word.all { |c| hexDigits.contains(c) }) {
       var num = Conv.atoi(word, 16)
       var dr = Int.digitalRoot(num)[0] 
       lines.add(Fmt.swrite("$-7s -> $-9s -> $d", word, num, dr))
   }

} lines.sort { |a, b| a[-1].bytes[0] < b[-1].bytes[0] } System.print(lines.join("\n")) System.print("\n%(lines.count) hex words with 4 or more letters found.\n") var digits4 = [] for (line in lines) { 

   var word = line.split("->")[0].trimEnd()
   if (Lst.distinct(word.toList).count >= 4) digits4.add(line)

} digits4.sort { |a, b| Num.fromString(a.split("->")[1]) > Num.fromString(b.split("->")[1]) } System.print(digits4.join("\n")) System.print("\n%(digits4.count) such words found which contain 4 or more different digits.")</lang>

Output:
decade  -> 14600926  -> 1
ababa   -> 703162    -> 1
abbe    -> 43966     -> 1
dada    -> 56026     -> 1
deaf    -> 57007     -> 1
feed    -> 65261     -> 2
cede    -> 52958     -> 2
added   -> 712173    -> 3
bade    -> 47838     -> 3
abed    -> 44013     -> 3
decca   -> 912586    -> 4
beebe   -> 782014    -> 4
dade    -> 56030     -> 5
deface  -> 14613198  -> 6
bead    -> 48813     -> 6
babe    -> 47806     -> 7
fade    -> 64222     -> 7
dead    -> 57005     -> 8
facade  -> 16435934  -> 8
efface  -> 15727310  -> 8
dacca   -> 896202    -> 9
beef    -> 48879     -> 9
cafe    -> 51966     -> 9
deed    -> 57069     -> 9
face    -> 64206     -> 9
accede  -> 11325150  -> 9

26 hex words with 4 or more letters found.

facade  -> 16435934  -> 8
efface  -> 15727310  -> 8
deface  -> 14613198  -> 6
decade  -> 14600926  -> 1
accede  -> 11325150  -> 9
decca   -> 912586    -> 4
fade    -> 64222     -> 7
face    -> 64206     -> 9
deaf    -> 57007     -> 1
cafe    -> 51966     -> 9
bead    -> 48813     -> 6
bade    -> 47838     -> 3
abed    -> 44013     -> 3

13 such words found which contain 4 or more different digits.
Retrieved from "https://rosettacode.org/wiki/Hex_words?oldid=317422"