Textonyms: Difference between revisions

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

 

 

E.G.:

;Extra credit:

Use a word list and keypad mapping other than English.

<br><br>

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}} Uses the Algol 68G specific "to upper" procedure.

# use the associative array in the Associate array/iteration task #

PR read "aArray.a68" PR

 

FI

{{out}}

<pre>

Encodings with this length are:

3532876362374256472749 encodes electroencephalography

</pre>

 

=={{header|C}}==

{{libheader|GLib}}

#include <stdio.h>

#include <stdlib.h>

}

return EXIT_SUCCESS;

 

{{out}}

 

=={{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.

The [[Textonyms#Tcl|Tcl example]] counts all the words which share a digit sequence with another word. Like the other

examples, this considers a textonym to be a digit sequence which maps to more than one word.

(def table

{\a 2 \b 2 \c 2 \A 2 \B 2 \C 2

(count mapping) " digit combinations to represent them. "

(count textonyms) " digit combinations represent Textonyms.")))

{{out}}

<pre>

=={{header|D}}==

{{trans|Raku}}

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|Factor}}==

{{works with|Factor|0.99 2020-07-03}}

io.files kernel literals math math.parser prettyprint sequences

unicode ;

${} digit combinations represent Textonyms.I] nl nl

 

{{out}}

<pre>

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>

 

=={{header|Haskell}}==

import Data.Function (on)

 

toKey :: Char -> Maybe Char

 

toKeyString :: String -> Maybe String

 

 

main = do

{{out}}

<pre style="font-size:80%">There are 24978 words in unixdict.txt which can be represented by the digit key mapping.

2668368466 => contention convention </pre>

 

 

setupLetterToDigitMapping

 

)

 

{{output}}

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

 

=={{header|J}}==

 

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',

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}}

 

=={{header|Kotlin}}==

 

import java.io.File

fun main(args: Array<String>) {

processList()

 

{{out}}

 

=={{header|Lua}}==

http = require("socket.http")

keys = {"VOICEMAIL", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}

 

-- Main procedure

{{out}}

<pre>There are 24983 words in http://www.puzzlers.org/pub/wordlists/unixdict.txt

They require 22908 digit combinations to represent them.

1473 digit combinations represent Textonyms.</pre>

 

=={{header|Perl}}==

 

# filter word-file for valid input, transform to low-case

print "There are @{[scalar @words]} words in '$src' which can be represented by the digit key mapping.

They require @{[scalar @dials]} digit combinations to represent them.

{{out}}

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

 

=={{header|Phix}}==

{{Out}}

<pre>

1473 digit combinations represent Textonyms.

The maximum number of textonyms for a particular digit key mapping is 9:

269 encodes amy/any/bmw/bow/box/boy/cow/cox/coy

</pre>

 

=={{header|PowerShell}}==

$url = "http://www.puzzlers.org/pub/wordlists/unixdict.txt"

$file = "$env:TEMP\unixdict.txt"

 

Remove-Item -Path $file -Force -ErrorAction SilentlyContinue

{{Out}}

<pre>

 

=={{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}}

=={{header|Raku}}==

(formerly Perl 6)

 

my @words = slurp($src).lines.grep(/ ^ <alpha>+ $ /);

 

say "\nTop 5 in length:";

{{out}}

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

Extra code was added detect and display a count illegal words &nbsp; (words not representable by the ''key digits''), &nbsp; and

<br>also duplicate words in the dictionary.

parse arg iFID . /*obtain optional fileID from the C.L. */

if iFID=='' | iFID=="," then iFID='UNIXDICT.TXT' /*Not specified? Then use the default.*/

 

do while lines(iFID)\==0; x= linein(iFID) /*keep reading the file until exhausted*/

$.x= . /*indicate that it's a righteous word. */

#word= #word + 1 /*bump the word count (for the file). */

!.z= !.z y; _= words(!.z) /*build list of equivalent digit key(s)*/

 

 

if @.z==2 then do; #= # + 1 /*bump the count of the textonyms. */

if @.z==1 then digKey= digKey + 1 /*bump the count of digit key words. */

end /*while*/

L= length(commas(max(#word,ills,dups,digKey,#))) /*find length of max # being displayed.*/

call tell digKey, 'combination's(digKey) "required to represent them"

call tell #, 'digit combination's(#) "that can represent Textonyms"

exit # /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

commas: parse arg _; do jc=length(_)-3 to 1 by -3; _=insert(',', _, jc); end; return _

tell: arg ##; say 'There are ' right(commas(##), L)' ' arg(2).; return /*commatize #*/

 

{{out|output|text=&nbsp; when using the default input file:}}

<pre>

The dictionary file being used is: UNIXDICT.TXT

There are 24,978 words in the dictionary file which can be represented by digit key mapping.

There are 126 words that contain illegal characters in the dictionary file.

<pre>

The dictionary file being used is: TEXTONYMS.TXT

There are 12,990 words in the dictionary file which can be represented by digit key mapping.

There are 95 duplicate words detected in the dictionary file.

 

=={{header|Ruby}}==

 

 

<pre>

 

</pre>

 

=={{header|Rust}}==

use std::fs::File;

use std::io::{self, BufRead};

Err(error) => eprintln!("{}: {}", args[1], error),

}

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

 

var dials = words.group_by {

 

say "\nTop 5 in length:";

{{out}}

<pre>

</pre>

 

 

2 -> ABC

3 -> DEF

}

 

 

{{out}}

 

=={{header|VBScript}}==

Set objInFile = objFSO.OpenTextFile(objFSO.GetParentFolderName(WScript.ScriptFullName) &_

"\unixdict.txt",1)

objMoreThanOneWord.Count & " digit combinations represent Textonyms."

 

{{out}}

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

They require 22903 digit combinations to represent them.

1473 digit combinations represent Textonyms.</pre>

 

=={{header|zkl}}==

{{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");

var keypad=Dictionary(

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>