Data update

Task/Hex-words/APL/hex-words.apl

@@ -0,0 +1,20 @@
+∇HexWords;todec;digroot;displayrow;words;distinct4
+todec←16⊥9+'abcdef'∘⍳
+digroot←(+/10⊥⍣¯1⊢)⍣(10≥⊢)
+displayrow←{⍵ n (digroot⊢n←todec ⍵)}
+
+words←((~∊)∘⎕TC⊆⊢)⊃⎕NGET'unixdict.txt'
+words←(words∧.∊¨⊂⊂'abcdef')/words
+words←(4≤≢¨words)/words
+words←words[⍋digroot∘todec¨words]
+
+distinct4←(4≤≢∘∪¨words)/words
+distinct4←distinct4[⍒todec¨distinct4]
+
+⎕←(⍕≢words),' hex words with at least 4 letters in unixdict.txt:'
+⎕←↑displayrow¨words
+⎕←''
+
+⎕←(⍕≢distinct4),' hex words with at least 4 distinct letters:'
+⎕←↑displayrow¨distinct4
+∇

Task/Hex-words/C++/hex-words.cpp

@@ -0,0 +1,71 @@
+#include <algorithm>
+#include <cstdint>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+struct Item {
+	std::string word;
+	int32_t number;
+	int32_t digital_root;
+};
+
+void display(const std::vector<Item>& items) {
+	std::cout << "  Word      Decimal value   Digital root" << std::endl;
+	std::cout << "----------------------------------------" << std::endl;
+	for ( const Item& item : items ) {
+		std::cout << std::setw(7) << item.word << std::setw(15) << item.number
+				  << std::setw(12) << item.digital_root << std::endl;
+	}
+	std::cout << "\n" << "Total count: " << items.size() << "\n" << std::endl;
+}
+
+int32_t digital_root(int32_t number) {
+	int32_t result = 0;
+	while ( number > 0 ) {
+		result += number % 10;
+		number /= 10;
+	}
+	return ( result <= 9 ) ? result : digital_root(result);
+}
+
+bool contains_only(const std::string& word, const std::unordered_set<char>& acceptable) {
+    return std::all_of(word.begin(), word.end(),
+    	[acceptable](char ch) { return acceptable.find(ch) != acceptable.end(); });
+}
+
+int main() {
+	const std::unordered_set<char> hex_digits{ 'a', 'b', 'c', 'd', 'e', 'f' };
+	std::vector<Item> items;
+
+	std::fstream file_stream;
+	file_stream.open("unixdict.txt");
+	std::string word;
+	while ( file_stream >> word ) {
+		if ( word.length() >= 4 && contains_only(word, hex_digits)) {
+			const int32_t value = std::stoi(word, 0, 16);
+			int32_t root = digital_root(value);
+			items.push_back(Item(word, value, root));
+		}
+	}
+
+	auto compare = [](Item a, Item b) {
+		return ( a.digital_root == b.digital_root ) ? a.word < b.word : a.digital_root < b.digital_root;
+	};
+	std::sort(items.begin(), items.end(), compare);
+	display(items);
+
+	std::vector<Item> filtered_items;
+	for ( const Item& item : items ) {
+		if ( std::unordered_set<char>(item.word.begin(), item.word.end()).size() >= 4 ) {
+			filtered_items.push_back(item);
+		}
+	}
+
+	auto comp = [](Item a, Item b) { return a.number > b.number; };
+	std::sort(filtered_items.begin(), filtered_items.end(), comp);
+	display(filtered_items);
+}

Task/Hex-words/Java/hex-words.java

@@ -0,0 +1,62 @@
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class HexWords {
+
+	public static void main(String[] aArgs) throws IOException {
+		Set<Character> hexDigits = Set.of( 'a', 'b', 'c', 'd', 'e', 'f' );
+		
+		List<Item> items = Files.lines(Path.of("unixdict.txt"))
+								.filter( word -> word.length() >= 4 )
+								.filter( word -> word.chars().allMatch( ch -> hexDigits.contains((char) ch) ) )			
+								.map( word -> { final int value = Integer.parseInt(word, 16);
+												return new Item(word, value, digitalRoot(value));
+											  } )
+								.collect(Collectors.toList());
+
+		Collections.sort(items, Comparator.comparing(Item::getDigitalRoot).thenComparing(Item::getWord));	
+		display(items);		
+		
+		List<Item> filteredItems = items.stream()
+			.filter( item -> item.aWord.chars().mapToObj( ch -> (char) ch ).collect(Collectors.toSet()).size() >= 4 )
+			.collect(Collectors.toList());		
+		
+		Collections.sort(filteredItems, Comparator.comparing(Item::getNumber).reversed());	
+		display(filteredItems);
+	}		
+
+	private static int digitalRoot(int aNumber) {
+	    int result = 0;
+    	while ( aNumber > 0 ) {
+    		result += aNumber % 10;
+    		aNumber /= 10;
+    	}
+	    return ( result <= 9 ) ? result : digitalRoot(result);		
+	}
+	
+	private static void display(List<Item> aItems) {			
+		System.out.println("  Word      Decimal value   Digital root");
+		System.out.println("----------------------------------------");
+		for ( Item item : aItems ) {
+		    System.out.println(String.format("%7s%15d%12d", item.aWord, item.aNumber, item.aDigitalRoot));
+		}
+		System.out.println(System.lineSeparator() + "Total count: " + aItems.size() + System.lineSeparator());
+	}	
+	
+	private static record Item(String aWord, int aNumber, int aDigitalRoot) {
+				
+		public String getWord() { return aWord; }
+		
+		public int getNumber() { return aNumber; }
+		
+		public int getDigitalRoot() { return aDigitalRoot; }
+		
+	}
+
+}

Task/Hex-words/Lua/hex-words.lua

@@ -0,0 +1,89 @@
+-- Import http namespace from socket library
+http = require("socket.http")
+
+-- Download the page at url and return as string
+function getFromWeb (url)
+    local body, statusCode, headers, statusText = http.request(url)
+    if statusCode == 200 then
+        return body
+    else
+        error(statusText)
+    end
+end
+
+-- Return a boolean to show whether word is a hexword
+function isHexWord (word)
+    local hexLetters, ch = "abcdef"
+    for pos = 1, #word do
+        ch = word:sub(pos, pos)
+        if not string.find(hexLetters, ch) then return false end
+    end
+    return true
+end
+
+-- Return the sum of the digits in num
+function sumDigits (num)
+    local sum, nStr, digit = 0, tostring(num)
+    for pos = 1, #nStr do
+        digit = tonumber(nStr:sub(pos, pos))
+        sum = sum + digit
+    end
+    return sum
+end
+
+-- Return the digital root of x
+function digitalRoot (x)
+    while x > 9 do
+        x = sumDigits(x)
+    end
+    return x
+end
+
+-- Return a table from built from the lines of the string dct
+-- Each table entry contains the digital root, word and base 10 conversion
+function buildTable (dct)
+    local t, base10 = {}
+    for line in dct:gmatch("[^\n]+") do
+        if # line > 3 and isHexWord(line) then
+            base10 = (tonumber(line, 16))
+            table.insert(t, {digitalRoot(base10), line, base10})
+        end
+    end
+    table.sort(t, function (a,b) return a[1] < b[1] end)
+    return t
+end
+
+-- Return a boolean to show whether str has at least 4 distinct characters
+function fourDistinct (str)
+    local distinct, ch = ""
+    for pos = 1, #str do
+        ch = str:sub(pos, pos)
+        if not string.match(distinct, ch) then
+            distinct = distinct .. ch
+        end
+    end
+    return #distinct > 3
+end
+
+-- Unpack each entry in t and print to the screen
+function showTable (t)
+    print("\n\nRoot\tWord\tBase 10")
+    print("====\t====\t=======")
+    for i, v in ipairs(t) do
+        print(unpack(v))
+    end
+    print("\nTable length: " .. #t)
+end
+
+-- Main procedure
+local dict = getFromWeb("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")
+local hexWords = buildTable(dict)
+showTable(hexWords)
+local hexWords2 = {}
+for k, v in pairs(hexWords) do
+    if fourDistinct(v[2]) then
+        table.insert(hexWords2, v)
+    end
+end
+table.sort(hexWords2, function (a, b) return a[3] > b[3] end)
+showTable(hexWords2)