Anagrams: Difference between revisions

When two or more words are composed of the same characters, but in a different order, they are called [[wp:Anagram|anagrams]].

 

Using the word list at   http://wiki.puzzlers.org/pub/wordlists/unixdict.txt,

<br>find the sets of words that share the same characters that contain the most words in them.

 

{{Related tasks/Word plays}}

 

=={{header|11l}}==

{{trans|Python}}

L(word) File(‘unixdict.txt’).read().split("\n")

 

V count = max(anagram.values().map(ana -> ana.len))

 

=={{header|8th}}==

\

\ anagrams.8th

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program anagram64.s */

</pre>

=={{header|ABAP}}==

define update_progress.

call function 'SAPGUI_PROGRESS_INDICATOR'

 

=={{header|Ada}}==

 

with Ada.Containers.Indefinite_Ordered_Maps;

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}} Uses the "read" PRAGMA of Algol 68 G to include the associative array code from the [[Associative_array/Iteration]] task.

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

PR read "aArray.a68" PR

alger|glare|lager|large|regal

caret|carte|cater|crate|trace

</pre>

 

This is a rough translation of the J version, intermediate values are kept and verb trains are not used for clarity of data flow.

 

anagrams←{

tie←⍵ ⎕NTIE 0

 

'''Example:'''

⎕SH'wget http://wiki.puzzlers.org/pub/wordlists/unixdict.txt'

]display anagrams 'unixdict.txt'

 

=={{header|AppleScript}}==

use scripting additions

 

on largestAnagramGroups(listOfWords)

script o

property wordList : listOfWords

end script

ignoring case

end repeat

set i to 1

if (thisText is not currentText) then

set currentText to thisText

set i to j

end if

end repeat

set {i, j} to thisRange

end repeat

end ignoring

end largestAnagramGroups

 

local wordFile, wordList

set wordList to paragraphs of (read wordFile as «class utf8»)

return largestAnagramGroups(wordList)</syntaxhighlight>

 

{{output}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program anagram.s */

=={{header|Arturo}}==

 

 

anagrams: #[]

=={{header|AutoHotkey}}==

Following code should work for AHK 1.0.* and 1.1* versions:

Loop, Parse, Contents, % "`n", % "`r"

{ ; parsing each line of the file we just read

 

=={{header|AWK}}==

# syntax: GAWK -f JUMBLEA.AWK UNIXDICT.TXT

{ for (i=1; i<=NF; i++) {

Alternatively, non-POSIX version:

{{works with|gawk}}

 

{ patsplit($0, chars, ".")

}</syntaxhighlight>

 

 

DECLARE idx$ ASSOC STRING

</pre>

 

{{works with|BBC BASIC for Windows}}

sort% = FN_sortinit(0,0)

=={{header|BQN}}==

 

•Show¨{𝕩/˜(⊢=⌈´)≠¨𝕩} (⊐∧¨)⊸⊔ words</syntaxhighlight>

⟨ "alger" "glare" "lager" "large" "regal" ⟩

⟨ "angel" "angle" "galen" "glean" "lange" ⟩

This solution makes extensive use of Bracmat's computer algebra mechanisms. A trick is needed to handle words that are merely repetitions of a single letter, such as <code>iii</code>. That's why the variabe <code>sum</code> isn't initialised with <code>0</code>, but with a non-number, in this case the empty string. Also te correct handling of characters 0-9 needs a trick so that they are not numerically added: they are prepended with a non-digit, an <code>N</code> in this case. After completely traversing the word list, the program writes a file <code>product.txt</code> that can be visually inspected.

The program is not fast. (Minutes rather than seconds.)

& 1:?product

& whl

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

</pre>

A much shorter version with no fancy data structures:

#include <stdlib.h>

#include <string.h>

 

=={{header|C sharp|C#}}==

using System.IO;

using System.Linq;

 

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

#include <fstream>

#include <string>

=={{header|Clojure}}==

Assume ''wordfile'' is the path of the local file containing the words. This code makes a map (''groups'') whose keys are sorted letters and values are lists of the key's anagrams. It then determines the length of the longest list, and prints out all the lists of that length.

 

(def groups

(println wordlist))</syntaxhighlight>

 

(->> (slurp "http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")

clojure.string/split-lines

 

=={{header|CLU}}==

anagrams = cluster is new, add, largest_size, sets

anagram_set = struct[letters: string, words: array[string]]

Tested with GnuCOBOL 2.0. ALLWORDS output display trimmed for width.

 

*> wget http://wiki.puzzlers.org/pub/wordlists/unixdict.txt

*> or visit https://sourceforge.net/projects/souptonuts/files

 

=={{header|CoffeeScript}}==

 

show_large_anagram_sets = (word_lst) ->

get_word_list show_large_anagram_sets</syntaxhighlight>

{{out}}

[ 'abel', 'able', 'bale', 'bela', 'elba' ]

[ 'alger', 'glare', 'lager', 'large', 'regal' ]

=={{header|Common Lisp}}==

{{libheader|DRAKMA}} to retrieve the wordlist.

(let ((words (drakma:http-request url :want-stream t))

(wordsets (make-hash-table :test 'equalp)))

finally (return (values maxwordsets maxcount)))))</syntaxhighlight>

Evalutating

(pprint wordsets)

(print count))</syntaxhighlight>

5</pre>

Another method, assuming file is local:

(with-open-file (stream file)

(loop with w = "" while w collect (setf w (read-line stream nil)))))

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE BbtAnagrams;

IMPORT StdLog,Files,Strings,Args;

=={{header|Crystal}}==

{{trans|Ruby}}

 

response = HTTP::Client.get("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")

=={{header|D}}==

===Short Functional Version===

 

void main() {

===Faster Version===

Less safe, same output.

import std.stdio, std.algorithm, std.file, std.string;

 

{{libheader| System.Classes}}

{{libheader| System.Diagnostics}}

program AnagramsTest;

 

 

=={{header|E}}==

when (def wordText := <http://wiki.puzzlers.org/pub/wordlists/unixdict.txt> <- getText()) -> {

def words := wordText.split("\n")

=={{header|EchoLisp}}==

For a change, we will use the french dictionary - '''(lib 'dico.fr)''' - delivered within EchoLisp.

(require 'struct)

(require 'hash)

</syntaxhighlight>

{{out}}

(length mots-français)

→ 209315

 

=={{header|Eiffel}}==

class

ANAGRAMS

=={{header|Ela}}==

{{trans|Haskell}}

 

groupon f x y = f x == f y

 

=={{header|Elena}}==

import system'calendar;

import system'io;

import extensions'routines;

import extensions'text;

 

extension op

auto dictionary := new Map<string,object>();

 

{

var key := word.normalized();

};

};

 

dictionary.Values

var end := now;

{{out}}

<pre>

abel,able,bale,bela,elba

evil,levi,live,veil,vile

elan,lane,lean,lena,neal

emit,item,mite,time

amen,mane,mean,name

hare,hear,hera,rhea

keats,skate,stake,steak

</pre>

 

=={{header|Elixir}}==

def find(file) do

File.read!(file)

 

The same output, using <code>File.Stream!</code> to generate <code>tuples</code> containing the word and it's sorted value as <code>strings</code>.

|> Stream.map(&String.strip &1)

|> Enum.group_by(&String.codepoints(&1) |> Enum.sort)

=={{header|Erlang}}==

The function fetch/2 is used to solve [[Anagrams/Deranged_anagrams]]. Please keep backwards compatibility when editing. Or update the other module, too.

-compile(export_all).

 

 

=={{header|Euphoria}}==

 

function compare_keys(sequence a, sequence b)

=={{header|F Sharp|F#}}==

Read the lines in the dictionary, group by the sorted letters in each word, find the length of the longest sets of anagrams, extract the longest sequences of words sharing the same letters (i.e. anagrams):

Seq.map snd xss |> Seq.filter (Seq.length >> ( = ) (Seq.map (snd >> Seq.length) xss |> Seq.max))</syntaxhighlight>

Note that it is necessary to convert the sorted letters in each word from sequences to arrays because the groupBy function uses the default comparison and sequences do not compare structurally (but arrays do in F#).

 

Takes 0.8s to return:

seq

[seq ["abel"; "able"; "bale"; "bela"; "elba"];

 

=={{header|Fantom}}==

{

// take given word and return a string rearranging characters in order

=={{header|Fortran}}==

This program:

module anagram_routines

!***************************************************************************************

=={{header|FBSL}}==

'''A little bit of cheating: literatim re-implementation of C solution in FBSL's Dynamic C layer.'''

 

DIM gtc = GetTickCount()

 

=={{header|Factor}}==

[ [ natural-sort >string ] keep ] { } map>assoc sort-keys

[ [ first ] compare +eq+ = ] monotonic-split

dup 0 [ length max ] reduce '[ length _ = ] filter [ values ] map .</syntaxhighlight>

{ "abel" "able" "bale" "bela" "elba" }

{ "caret" "carte" "cater" "crate" "trace" }

 

=={{header|FreeBASIC}}==

 

Type IndexedWord

 

=={{header|Frink}}==

d = new dict

for w = lines["http://wiki.puzzlers.org/pub/wordlists/unixdict.txt"]

 

=={{header|FutureBasic}}==

 

 

 

next

end fn = result

 

end fn

 

end fn

 

 

</syntaxhighlight>

Output:

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

<pre>

 

</pre>

 

=={{header|GAP}}==

local f, p, L, line, word, words, swords, res, cur, r;

words := [ ];

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

This program:

def groups = words.groupBy{ it.toList().sort() }

def bigGroupSize = groups.collect{ it.value.size() }.max()

 

=={{header|Haskell}}==

 

groupon f x y = f x == f y

mapM_ (print . map snd) . filter ((==mxl).length) $ wix</syntaxhighlight>

{{out}}

["abel","able","bale","bela","elba"]

["caret","carte","cater","crate","trace"]

and we can noticeably speed up the second stage sorting and grouping by packing the String lists of Chars to the Text type:

 

import Data.Ord (comparing)

import Data.Function (on)

 

=={{header|Icon}} and {{header|Unicon}}==

every writeSet(!getLongestAnagramSets())

end

=={{header|J}}==

If the unixdict file has been retrieved and saved in the current directory (for example, using wget):

+-----+-----+-----+-----+-----+

|abel |able |bale |bela |elba |

+-----+-----+-----+-----+-----+</syntaxhighlight>

Explanation:

This reads in the dictionary and produces a list of boxes. Each box contains one line (one word) from the dictionary.

This groups the words into rows where anagram equivalents appear in the same row. In other words, creates a copy of the original list where the characters contained in each box have been sorted. Then it organizes the contents of the original list in rows, with each new row keyed by the values in the new list.

This selects rows whose last element is not an empty box.<br>

(In the previous step we created an array of rows of boxes. The short rows were automatically padded with empty boxes so that all rows would be the same length.)

The key to this algorithm is the sorting of the characters in each word from the dictionary. The line <tt>Arrays.sort(chars);</tt> sorts all of the letters in the word in ascending order using a built-in [[quicksort]], so all of the words in the first group in the result end up under the key "aegln" in the anagrams map.

{{works with|Java|1.5+}}

import java.io.*;

import java.util.*;

}</syntaxhighlight>

{{works with|Java|1.8+}}

import java.io.*;

import java.util.*;

===ES5===

{{Works with|Node.js}}

var words = fs.readFileSync('unixdict.txt', 'UTF-8').split('\n');

 

 

Alternative using reduce:

var dictionary = fs.readFileSync('unixdict.txt', 'UTF-8').split('\n');

 

Using JavaScript for Automation

(A JavaScriptCore interpreter on macOS with an Automation library).

'use strict';

 

 

=={{header|jq}}==

(reduce .[] as $word (

{table: {}, max: 0}; # state

</syntaxhighlight>

{{Out}}

$ jq -M -s -c -R -f anagrams.jq unixdict.txt

["abel","able","bale","bela","elba"]

=={{header|Jsish}}==

From Javascript, nodejs entry.

var datafile = 'unixdict.txt';

if (console.args[0] == '-more' && Interp.conf('maxArrayList') > 500000)

=={{header|Julia}}==

{{works with|Julia|1.6}}

wordlist = open(readlines, download(url))

 

 

=={{header|K}}==

 

=={{header|Kotlin}}==

{{trans|Java}}

import java.io.InputStreamReader

import java.net.URL

 

=={{header|Lasso}}==

anagrams = map,

words = include_url('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt')->split('\n'),

 

=={{header|Liberty BASIC}}==

open "unixdict.txt" for input as #1

while not(eof(#1))

LiveCode could definitely use a sort characters command. As it is this code converts the letters into items and then sorts that. I wrote a merge sort for characters, but the conversion to items, built-in-sort, conversion back to string is about 10% faster, and certainly easier to write.

 

put mostCommonAnagrams(url "http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")

end mouseUp

=={{header|Lua}}==

Lua's core library is very small and does not include built-in network functionality. If a networking library were imported, the local file in the following script could be replaced with the remote dictionary file.

local bytes = {word:byte(1, -1)}

table.sort(bytes)

 

=={{header|M4}}==

changequote(`[',`]')

define([for],

The convert call discards the hashes, which have done their job, and leaves us with a list L of anagram sets.

Finally, we just note the size of the largest sets of anagrams, and pick those off.

words := HTTP:-Get( "http://wiki.puzzlers.org/pub/wordlists/unixdict.txt" )[2]: # ignore errors

use StringTools, ListTools in

</syntaxhighlight>

The result of running this code is

A := [{"abel", "able", "bale", "bela", "elba"}, {"angel", "angle", "galen",

"glean", "lange"}, {"alger", "glare", "lager", "large", "regal"}, {"evil",

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

Download the dictionary, split the lines, split the word in characters and sort them. Now sort by those words, and find sequences of equal 'letter-hashes'. Return the longest sequences:

text={#,StringJoin@@Sort[Characters[#]]}&/@list;

text=SortBy[text,#[[2]]&];

Select[splits,Length[#]==maxlen&]</syntaxhighlight>

gives back:

An alternative is faster, but requires version 7 (for <code>Gather</code>):

maxlen = Max[Length /@ splits];

Select[splits, Length[#] == maxlen &]</syntaxhighlight>

 

Or using build-in functions for sorting and gathering elements in lists it can be implimented as:

anagramGroups[[-1]]</syntaxhighlight>

Also, Mathematica's own word list is available; replacing the list definition with <code>list = WordData[];</code> and forcing <code>maxlen</code> to 5 yields instead this result:

 

Also if using Mathematica 10 it gets really concise:

MaximalBy[GatherBy[list, Sort@*Characters], Length]</syntaxhighlight>

 

=={{header|Maxima}}==

while stringp(s: readline(file)) do L: cons(s, L), close(file), L)$

 

["caret", "carte", "cater", "crate", "trace"],

["abel", "able", "bale", "bela", "elba"]] */</syntaxhighlight>

 

=={{header|MUMPS}}==

Set file="unixdict.txt"

Open file:"r" Use file

===Java&ndash;Like===

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

===Rexx&ndash;Like===

Implemented with more NetRexx idioms such as indexed strings, <tt>PARSE</tt> and the NetRexx &quot;built&ndash;in functions&quot;.

options replace format comments java crossref symbols nobinary

 

 

=={{header|NewLisp}}==

;;; Get the words as a list, splitting at newline

(setq data

 

=={{header|Nim}}==

import tables, strutils, algorithm

 

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE Anagrams;

IMPORT Files,Out,In,Strings;

 

=={{header|Objeck}}==

use Collection;

 

 

=={{header|OCaml}}==

let l = ref [] in

let n = String.length str in

=={{header|Oforth}}==

 

import: collect

import: quicksort

Two versions of this, using different collection classes.

===Version 1: Directory of arrays===

-- This assumes you've already downloaded the following file and placed it

-- in the current directory: http://wiki.puzzlers.org/pub/wordlists/unixdict.txt

===Version 2: Using the relation class===

This version appears to be the fastest.

-- This assumes you've already downloaded the following file and placed it

-- in the current directory: http://wiki.puzzlers.org/pub/wordlists/unixdict.txt

 

=={{header|Oz}}==

%% Helper function

fun {ReadLines Filename}

 

=={{header|Pascal}}==

 

// assumes a local file

 

=={{header|Perl}}==

 

my @words = split "\n", do { local( @ARGV, $/ ) = ( 'unixdict.txt' ); <> };

}</syntaxhighlight>

If we calculate <code>$max</code>, then we don't need the CPAN module:

$max > @$_ or $max = @$_ for values %anagram;

@$_ == $max and print "@$_\n" for values %anagram;</syntaxhighlight>

=={{header|Phix}}==

copied from Euphoria and cleaned up slightly

<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"demo/unixdict.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"r"</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">anagrams</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">last</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">letters</span>

 

=={{header|Phixmonti}}==

 

"unixdict.txt" "r" fopen var f

Other solution

 

 

( )

 

=={{header|PHP}}==

$words = explode("\n", file_get_contents('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt'));

foreach ($words as $word) {

=={{header|Picat}}==

Using foreach loop:

Dict = new_map(),

foreach(Line in read_file_lines("unixdict.txt"))

 

Same idea, but shorter version by (mis)using list comprehensions.

M = new_map(),

_ = [_:W in read_file_lines("unixdict.txt"),S=sort(W),M.put(S,M.get(S,"")++[W])],

=={{header|PicoLisp}}==

A straight-forward implementation using 'group' takes 48 seconds on a 1.7 GHz Pentium:

(by length sort

(by '((L) (sort (copy L))) group

(in "unixdict.txt" (make (while (line) (link @)))) ) ) )</syntaxhighlight>

Using a binary tree with the 'idx' function, it takes only 0.42 seconds on the same machine, a factor of 100 faster:

(in "unixdict.txt"

(while (line)

 

=={{header|PL/I}}==

 

word_test: proc options (main);

 

=={{header|Pointless}}==

readFileLines("unixdict.txt")

|> reduce(logWord, {})

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

$words = -split ($c.DownloadString('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt'))

$top_anagrams = $words `

evil, levi, live, veil, vile</pre>

Another way with more .Net methods is quite a different style, but drops the runtime from 2 minutes to 1.5 seconds:

 

$uri = 'http://wiki.puzzlers.org/pub/wordlists/unixdict.txt'

 

=={{header|Processing}}==

 

void setup() {

=={{header|Prolog}}==

{{works with|SWI-Prolog|5.10.0}}

 

anagrams:-

=={{header|PureBasic}}==

{{works with|PureBasic|4.4}}

OpenConsole()

===Python 3.X Using defaultdict===

Python 3.2 shell input (IDLE)

>>> from collections import defaultdict

>>> words = urllib.request.urlopen('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt').read().split()

===Python 2.7 version===

Python 2.7 shell input (IDLE)

>>> from collections import defaultdict

>>> words = urllib.urlopen('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt').read().split()

{{trans|Haskell}}

{{works with|Python|2.6}} sort and then group using groupby()

>>> words = urllib.urlopen('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt').read().split()

>>> len(words)

Or, disaggregating, speeding up a bit by avoiding the slightly expensive use of ''sorted'' as a key, updating for Python 3, and using a local ''unixdict.txt'':

{{Works with|Python|3.7}}

 

from os.path import expanduser

 

=={{header|QB64}}==

$CHECKING:OFF

' Warning: Keep the above line commented out until you know your newly edited code works.

 

'''2nd solution (by Steve McNeill):'''

$CHECKING:OFF

SCREEN _NEWIMAGE(640, 480, 32)

 

'''Output:'''

LOOPER: 7134 executions from start to finish, in one second.

Note, this is including disk access for new data each time.

=={{header|Quackery}}==

 

[] swap witheach

[ dup sort

 

=={{header|R}}==

word_group <- sapply(

strsplit(words, split=""), # this will split all words to single letters...

 

=={{header|Racket}}==

#lang racket

 

 

{{works with|Rakudo|2016.08}}

my $max = @anagrams».elems.max;

 

{{works with|Rakudo|2016.08}}

'unixdict.txt'.IO.words # load words from file

.classify(*.comb.sort.join) # group by common anagram

 

=={{header|RapidQ}}==

dim x as integer, y as integer

dim SortX as integer

 

=={{header|Rascal}}==

 

list[str] OrderedRep(str word){

}</syntaxhighlight>

Returns:

{"glean","galen","lange","angle","angel"},

{"glare","lager","regal","large","alger"},

 

=={{header|Red}}==

 

m: make map! [] 25000

This version doesn't assume that the dictionary is in alphabetical order, &nbsp; nor does it assume the

<br>words are in any specific case &nbsp; (lower/upper/mixed).

iFID= 'unixdict.txt' /*the dictionary input File IDentifier.*/

$=; !.=; ww=0; uw=0; most=0 /*initialize a bunch of REXX variables.*/

===version 1.2, optimized===

This optimized version eliminates the &nbsp; '''sortA''' &nbsp; subroutine and puts that subroutine's code in-line.

iFID= 'unixdict.txt' /*the dictionary input File IDentifier.*/

$=; !.=; ww=0; uw=0; most=0 /*initialize a bunch of REXX variables.*/

===annotated version using &nbsp; PARSE===

(This algorithm actually utilizes a &nbsp; ''bin'' &nbsp; sort, &nbsp; one bin for each Latin letter.)

upper u /*fast method to uppercase a variable. */

/*another: u = translate(u) */

 

===annotated version using a &nbsp; DO &nbsp; loop===

upper u /*fast method to uppercase a variable. */

L=length(u) /*get the length of the word (in bytes)*/

 

===version 2===

* 07.08.2013 Walter Pachl

* sorta for word compression courtesy Gerard Schildberger,

 

=={{header|Ring}}==

# Project : Anagrams

 

 

=={{header|Ruby}}==

 

anagram = Hash.new {|hash, key| hash[key] = []} # map sorted chars to anagrams

 

Short version (with lexical ordered result).

 

anagrams = open('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt'){|f| f.read.split.group_by{|w| w.each_char.sort} }

 

=={{header|Run BASIC}}==

mem$ = "CREATE TABLE anti(gram,ordr);

CREATE INDEX ord ON anti(ordr)"

Unicode is hard so the solution depends on what you consider to be an anagram: two strings that have the same bytes, the same codepoints, or the same graphemes. The first two are easily accomplished in Rust proper, but the latter requires an external library. Graphemes are probably the most correct way, but it is also the least efficient since graphemes are variable size and thus require a heap allocation per grapheme.

 

use std::fs::File;

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

If we assume an ASCII string, we can map each character to a prime number and multiply these together to create a number which uniquely maps to each anagram.

 

use std::path::Path;

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

 

=={{header|Scala}}==

val vls = src.getLines.toList.groupBy(_.sorted).values

val max = vls.map(_.size).max

----

Another take:

.fromURL("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt").getLines.toList

.groupBy(_.sorted).values

Uses two SRFI libraries: SRFI 125 for hash tables and SRFI 132 for sorting.

 

(import (scheme base)

(scheme char)

 

=={{header|Seed7}}==

include "gethttp.s7i";

include "strifile.s7i";

var integer: maxLength is 0;

begin

while hasNext(dictFile) do

readln(dictFile, word);

 

=={{header|SETL}}==

anagrams := {};

while not eof(h) loop

 

=={{header|Sidef}}==

file.open_r(\var fh, \var err) ->

|| die "Can't open file `#{file}' for reading: #{err}\n";

 

=={{header|Simula}}==

$ cim -m64 anagrams-hashmap.sim

;

 

=={{header|Smalltalk}}==

dict:= Dictionary new.

list do: [:val|

{{works with|Smalltalk/X}}

instead of asking for the strings, read the file:

'unixdict.txt' asFilename

readingLinesDo:[:eachWord |

...</pre>

not sure if getting the dictionary via http is part of the task; if so, replace the file-reading with:

 

=={{header|SNOBOL4}}==

{{works with|Macro Spitbol}}

Note: unixdict.txt is passed in locally via STDIN. Newlines must be converted for Win/DOS environment.

define('sortw(str)a,i,j') :(sortw_end)

sortw a = array(size(str))

 

=={{header|Stata}}==

mata

a=st_sdata(.,.)

 

=={{header|SuperCollider}}==

var text, words, sorted, dict = IdentityDictionary.new, findMax;

File.use("unixdict.txt".resolveRelative, "r", { |f| text = f.readAllString });

 

Answers:

 

=={{header|Swift}}==

{{works with|Swift 2.0}}

 

 

let wordsURL = NSURL(string: "http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")!

 

=={{header|Tcl}}==

package require http

 

 

=={{header|Transd}}==

 

 

MainModule: {

_start: (λ

(with fs FileStream() words String()

(textin fs words)

( -|

 

=={{header|TUSCRIPT}}==

requestdata = REQUEST ("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")

 

Process substitutions eliminate the need for command pipelines.

 

local host=$1

local uri=$2

The algorithm is to group the words together that are made from the same unordered lists of letters, then collect the groups together that have the same number of words in

them, and then show the collection associated with the highest number.

 

#show+

 

=={{header|VBA}}==

Option Explicit

 

=={{header|VBScript}}==

A little convoluted, uses a dictionary and a recordset...

Const adInteger = 3

Const adVarChar = 200

 

The word list is expected to be in the same directory as the script.

 

Repeat(ALL) {

evil levi live veil vile

</pre>

 

=={{header|Visual Basic .NET}}==

Imports System.Collections.ObjectModel

 

</PRE>

 

{{trans|Wren}}

 

fn main(){

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

var words = File.read("unixdict.txt").split("\n").map { |w| w.trim() }

 

=={{header|Yabasic}}==

maxw = 0 : c = 0 : dimens(c)

i = 0

 

=={{header|zkl}}==

// blob to dictionary: key is word "fuzzed", values are anagram words

.pump(Void,T(fcn(w,d){

</pre>

In the case where it is desirable to get the dictionary from the web, use this code:

var ZC=Import("zklCurl");

unixdict:=ZC().get(URL); //--> T(Data,bytes of header, bytes of trailer)

{{omit from|6502 Assembly|unixdict.txt is much larger than the CPU's address space.}}

{{omit from|8080 Assembly|See 6502 Assembly.}}

{{omit from|Z80 Assembly|See 6502 Assembly.}}