Textonyms: Difference between revisions

9 -> WXYZ

 

 

The task should produce a report:

#{3} is the number of #{2} which represent more than one word.

 

 

2748424767 -> "Briticisms", "criticisms"

 

 

Use a word list and keypad mapping other than English.

 

=={{header|C++}}==

#include <iostream>

#include <unordered_map>

 

public:

 

 

void add(const std::string &str) {

std::string mapping;

 

if (!get_mapping(mapping, str)) return;

const int num_strings = values[mapping].size();

 

 

if (num_strings > max_found) {

max_found = num_strings;

}

max_strings.push_back(mapping);

 

values[mapping].push_back(str);

std::cout << max_found + 1 << " words each:\n";

 

}

std::cout << '\n';

else {

std::cout << "Key '" << str << "' matches: ";

std::cout << '\n';

}

};

 

{

std::ifstream input(filename);

Textonym_Checker tc;

tc.match("27484247");

tc.match("7244967473642");

{{out}}

 

There are 24988 words in unixdict.txt which can be represented by the digit key mapping.

Key '27484247' not found

Key '7244967473642' matches: schizophrenia schizophrenic

</pre>

 

=={{header|D}}==

import std.stdio, std.string, std.range, std.algorithm, std.ascii;

 

foreach (p; textonyms.schwartzSort!(p => -p[0].length).take(5))

writefln(" %s => %-(%s %)", p[]);

{{out}}

<pre>There are 24978 words in unixdict.txt which can be represented by the digit key mapping.

49376746242 => hydrophobia hydrophobic

6388537663 => mettlesome nettlesome</pre>

 

=={{header|Go}}==

Like the [[Textonyms#Python|Phython example]],

the examples shown are the numbers that map to the most words.

 

import (

fmt.Fprintln(w, "\t", k, "maps to:", strings.Join(v, ", "))

}

{{out}}

<pre>

</pre>

 

 

 

strip=:dyad define

reps=. {&digits@(letters&i.)&.> valid NB. reps is digit seq

reporttext report (#valid);y;(#~.reps);+/(1<#)/.~reps

 

Required example:

 

There are 13085 words in http://rosettacode.org/wiki/Textonyms/wordlist which can be represented by the digit key mapping.

They require 11932 digit combinations to represent them.

 

In this example, the intermediate results in textonymrpt would look like this (just looking at the first 5 elements of the really big values:

 

22233344455566677778889999

letters

┌─┬──┬───┬───┬──┐

│2│22│222│226│22│

 

Here's another example:

 

There are 24978 words in http://www.puzzlers.org/pub/wordlists/unixdict.txt which can be represnted by the digit key mapping.

They require 22903 digit combinations to represent them.

 

=={{header|Java}}==

{{trans|c++}}

import java.io.IOException;

import java.nio.charset.StandardCharsets;

}

}

{{out|Output with "java RTextonyms ./unixdict.txt"}}

<pre>

=={{header|jq}}==

The following requires a version of jq with "gsub".

gsub("a|b|c|A|B|C"; "2")

| gsub("d|e|f|D|E|F"; "3")

;

 

{{out}}

There are 13085 words in the Textonyms/wordlist word list that can be represented by the digit-key mapping.

They require 11932 digit combinations to represent them.

The longest Textonyms in the word list have length 11:

26456746242 maps to: ["Anglophobia","Anglophobic"]

 

=={{header|Julia}}==

This solution uses an <tt>aspell</tt> dictionary on the local machine as its word source. The character to number mapping is done via regular expressions and Julia's <tt>replace</tt> function. Because this list contains accented characters, the matching expressions were expanded to include such characters. Words are case sensitive, but the mapping is not, so for example both "Homer" and "homer" are included in the tabulation, each coded as "46637".

'''Function'''

const tcode = (Regex=>Char)[r"A|B|C|Ä|Å|Á|Â|Ç" => '2',

r"D|E|F|È|Ê|É" => '3',

return tnym

end

 

'''Main'''

dname = "/usr/share/dict/american-english"

DF = open(dname, "r")

println(@sprintf "%7s (%2d) %s" k length(v) join(v, ", "))

end

 

{{out}}

</pre>

 

}

 

<pre>

 

 

</pre>

<pre>

 

</pre>

 

 

 

}

 

 

 

 

They require 22903 digit combinations to represent them.

1473 digit combinations represent Textonyms.

 

Top 5 in ambiguity:

 

Top 5 in length:

 

=={{header|Python}}==

import urllib.request

 

print(" %s maps to: %s" % (num, ', '.join(wrds)))

 

 

{{out}}

 

=={{header|Racket}}==

This version allows digits to be used (since you can usually enter them through an SMS-style keypad).

 

<code>unixdict.txt</code> has words like <q>2nd</q> which would not be valid using letters only, but is textable.

 

(module+ test (require tests/eli-tester))

(module+ test

 

(module+ main

 

{{out}}

3 tests passed

3 tests passed</pre>

 

=={{header|REXX}}==

say

<pre>

 

first digit key= aaa aba abc cab

numerous digit key= amy any bmw bow box boy cow cox coy (9 words)

</pre>

<pre>

 

first digit key= AA AB AC BA BB BC CA CB

 

=={{header|Ruby}}==

{{out}}

<pre>

 

</pre>

<pre>

 

</pre>

<pre>

 

</pre>

 

 

 

 

{{out}}

They require 22903 digit combinations to represent them.

 

 

2 -> ABC

3 -> DEF

}

 

 

{{out}}

 

able bake bald bale cake calf

</pre>

 

{{trans|Python}}

Like the Python example, this solution uses the Unix Dictionary, rather than the textonyms word list as I don't want to parse the HTML.

var ZC=Import("zklCurl");

//fcn numerate(word){ word.toLower().apply(keypad.find.fp1("")) }

fcn numerate(word){ word.toLower().apply(keypad.get) } //-->textonym or error

println("Read %d words from %s".fmt(words.len(1),URL));

 

foreach word in (words.walker(11)){ // iterate over stripped lines

w2n:=try{ numerate(word) }catch(NotFoundError){ continue };

foreach k,v in (wcnt.filter('wrap([(k,v)]){ v.len()==maxWordPerNum })){

println(" %s is the textonym of: %s".fmt(k,v.concat(", ")));

{{out}}

<pre>