Textonyms: Difference between revisions

{{trans|Python}}

 

L(chars) ‘abc def ghi jkl mno pqrs tuv wxyz’.split(‘ ’)

V num = L.index + 2

print(‘ #. maps to: #.’.format(num, wrds.join(‘, ’)))

 

 

{{out}}

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

=={{header|C}}==

{{libheader|GLib}}

#include <stdio.h>

#include <stdlib.h>

}

return EXIT_SUCCESS;

 

{{out}}

 

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

#include <iostream>

#include <unordered_map>

tc.match("27484247");

tc.match("7244967473642");

{{out}}

<pre>Read 25104 words from unixdict.txt

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.

{{libheader| System.Character}}

{{Trans|C++}}

program Textonyms;

 

end.

 

 

{{out}}

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

import Data.List (groupBy, sortBy)

++ fmap

showTextonym

{{out}}

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

Or, in terms of ''Data.Map'' and ''traverse'':

 

import Data.List (groupBy, maximum, sortBy, sortOn)

import qualified Data.Map as M

]

where

{{Out}}

<pre>There are 24978 words in unixdict.txt which can be represented

=={{header|Io}}==

 

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

rls={"A"->2,"B"->2,"C"->2,"D"->3,"E"->3,"F"->3,"G"->4,"H"->4,"I"->4,"J"->5,"K"->5,"L"->5,"M"->6,"N"->6,"O"->6,"P"->7,"Q"->7,"R"->7,"S"->7,"T"->8,"U"->8,"V"->8,"W"->9,"X"->9,"Y"->9,"Z"->9};

Numerify[s_String]:=Characters[ToUpperCase[s]]/.rls

KeyValueMap[List,TakeLargestBy[grouped,Length,1]]//Grid

Print["5 longest words with textonyms:"]

{{out}}

<pre>Number of words from Textonyms/wordlist are: 71125

=={{header|MiniScript}}==

This solution assumes the Mini Micro environment (providing the listUtil and mapUtil modules, as well as the englishWords.txt file).

import "mapUtil"

 

print num + " -> " + numToWords.get(num)

end if

{{out}}

<pre>There are 64664 words in englishWords.txt which can be represented

=={{header|Nim}}==

{{trans|Kotlin}}

 

const

echo &"""{l[0].len:4} {l[0]:>14} {l[1].join(", ")}"""

 

 

{{out}}

 

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">digit</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">255</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" %s encodes %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">words</span><span style="color: #0000FF;">[</span><span style="color: #000000;">long_idx</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]])</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{Out}}

<small>(my unixdict.txt seems to have grown by 4 entries sometime in the past couple of years...)</small>

 

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

<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.*/

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

 

=={{header|Ruby}}==

CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

NUMS = "22233344455566677778889999" * 2

 

puts "\n25287876746242: #{textonyms["25287876746242"].join(", ")}"

{{out}}

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

 

=={{header|Swift}}==

 

func textCharacter(_ ch: Character) -> Character? {

} catch {

print(error.localizedDescription)

 

{{out}}

=={{header|Tcl}}==

 

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.

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

import "/str" for Char, Str

import "/sort" for Sort

System.print("Length Textonym Words")

System.print("====== ============== =====")

 

{{out}}

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