Anagrams/Deranged anagrams: Difference between revisions

By analogy with [[Permutations/Derangements|derangements]] we define a ''deranged anagram'' as two words with the same characters, but in which the same character does ''not'' appear in the same position in both words.

 

 

Use the word list at [http://wiki.puzzlers.org/pub/wordlists/unixdict.txt unixdict] to find and display the longest deranged anagram.

 

 

* [[Permutations/Derangements]]

* [[Best_shuffle|Best shuffle]]

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

{{trans|Kotlin}}

L(i) 0 .< s1.len

I s1[i] == s2[i]

V count = 0

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

I a !C anagram

anagram[a] = [word]

{{out}}

<pre>[excitation, intoxicate]</pre>

=={{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 anaderan64.s */

=={{header|Ada}}==

{{Works with|Ada 2005}}

with Ada.Containers.Generic_Array_Sort;

with Ada.Containers.Indefinite_Vectors;

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

 

=={{header|AppleScript}}==

 

 

on longestDerangedAnagrams(listOfWords)

script o

property wordList : listOfWords

property output : {}

-- Test for any deranged pairs amongst the words of an anagram group.

on testPairs(a, b)

set wordLength to (count beginning of anagramGroup)

set areDeranged to true

repeat with c from 1 to wordLength

set areDeranged to false

exit repeat

end if

end repeat

if (areDeranged) then

end if

end repeat

end repeat

end testPairs

end script

ignoring case

end repeat

set i to 1

if (thisText is not currentText) then

if (j - i > 1) then tell o to testPairs(i, j - 1)

set i to j

end if

end repeat

if (j > i) then tell o to testPairs(i, j)

end longestDerangedAnagrams

 

local wordFile, wordList

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

return longestDerangedAnagrams(wordList)</syntaxhighlight>

 

{{output}}

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

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

/* ARM assembly Raspberry PI */

/* program anaderan.s */

=={{header|Arturo}}==

 

[a,b]: p

loop 0..dec size a 'i [

 

=={{header|AutoHotkey}}==

SetWorkingDir %A_ScriptDir% ; Ensures a consistent starting directory.

SetBatchLines -1

{{works with|GNU awk (gawk) 3.1.5}}

 

BEGIN{

FS=""

 

Regular invocation would be:

{{out}}

<pre>

</pre>

 

 

FUNCTION Deranged(a$, b$)

</pre>

 

{{works with|BBC BASIC for Windows}}

Sort% = FN_sortinit(0,0)

Bracmat shuffles each new factor into place to keep the growing product normalized before continuing with the next word from the list.

The result is exactly the same, but the running time becomes much longer.

& 1:?product

& :?unsorted

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

{{libheader|System.IO}}

{{works with|C sharp|6}}

{

var lookupTable = File.ReadLines("unixdict.txt").ToLookup(line => AnagramKey(line));

 

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

#include <fstream>

#include <functional>

 

=={{header|Clojure}}==

(re-seq #"\w+") ; |

(group-by sort) ; anagrams

 

=={{header|COBOL}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

</syntaxhighlight>

 

=={{header|CoffeeScript}}==

This example was tested with node.js.

 

is_derangement = (word1, word2) ->

 

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

(with-open-file (stream file)

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

=={{header|D}}==

===Short Version===

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

 

 

Using const(ubytes)[] instead of dstrings gives a runtime of about 0.07 seconds:

foreach (const w; "unixdict.txt".readText.split)

anags[w.dup.representation.sort().release.assumeUnique] ~= w;</syntaxhighlight>

 

===Faster Version===

std.functional, std.exception;

 

{{libheader| System.Classes}}

{{libheader| System.Diagnostics}}

 

{$APPTYPE CONSOLE}

=={{header|EchoLisp}}==

For a change, we use the french dictionary included in EchoLisp package.

(lib 'struct)

(lib 'sql)

</syntaxhighlight>

{{out}}

(lib 'dico.fr.no-accent) ;; 209315 words into *words* table

(task)

 

=={{header|Eiffel}}==

ANAGRAMS_DERANGED

 

=={{header|Elixir}}==

{{trans|Ruby}}

def deranged(fname) do

File.read!(fname)

=={{header|Erlang}}==

Using anagrams:fetch/2 from [[Anagrams]] and init_http/0 from [[Rosetta_Code/Find_unimplemented_tasks]]. Exporting words_from_url/1 to [[Ordered_words]].

-export( [task/0, words_from_url/1] ).

 

 

=={{header|F_Sharp|F#}}==

 

let keyIsSortedWord = Seq.sort >> Seq.toArray >> String

 

=={{header|Factor}}==

math.combinatorics sequences sorting strings ;

IN: rosettacode.deranged-anagrams

 

=={{header|FreeBASIC}}==

 

Type IndexedWord

Took 0.089 seconds on i3 @ 2.13 GHz

</pre>

 

=={{header|GAP}}==

Using function [[Anagrams#GAP|Anagrams]].

local i, n;

for i in [1 .. Size(a)] do

 

=={{header|Go}}==

import (

"fmt"

=={{header|Groovy}}==

Solution:

 

new URL('http://www.puzzlers.org/pub/wordlists/unixdict.txt').eachLine { word ->

=={{header|Haskell}}==

If the longest deranged anagram includes three or more words we'll only print two of them. We also correctly handle duplicate words in the input.

 

import Data.List (maximumBy, sort, unfoldr)

{{out}}

<pre>Longest deranged anagrams: excitation and intoxicate</pre>

 

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

This solution (which works in both languages) does a strict interpretation of the problem and ignores the fact that there may be multiple derangements that are the same length (including ignoring multiple derangements arising from the same set of words that are all anagrams).

 

procedure main()

=={{header|J}}==

This assumes that [http://www.puzzlers.org/pub/wordlists/unixdict.txt unixdict.txt] has been saved in the current directory.

25104

#anagrams=: (#~ 1 < #@>) (</.~ /:~&>) words

=={{header|Java}}==

{{works with|Java|8}}

import java.io.IOException;

import java.nio.file.Files;

brevity.

 

 

function main() {

=== Gecko ===

Word file is saved locally because browser won't fetch it cross-site. Tested on Gecko.

<body><pre id='x'></pre>

<script type="application/javascript">

This solution allows for the possibility of more than one answer.

 

# Output: a stream of arrays

def anagrams:

=={{header|Julia}}==

 

# Let's define the less than operator for any two vectors that have the same type:

# This does lexicographic comparison, we use it on vectors of chars in this task.

 

=={{header|K}}==

a:{x g@&1<#:'g:={x@<x}'x}@0:"unixdict.txt";

 

=={{header|Kotlin}}==

 

import java.io.BufferedReader

 

=={{header|Lasso}}==

anagrams = map,

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

 

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

open "unixdict.txt" for input as #1

a$=input$(#1,lof(#1))

 

=={{header|Lua}}==

local arr={}

for ch in str:gmatch(".") do arr[#arr+1]=ch end

 

=={{header|Maple}}==

dict:=Split([HTTP:-Get("www.puzzlers.org/pub/wordlists/unixdict.txt")][2]):

L:=[seq(select(t->HammingDistance(t,w)=length(w),[Anagrams(w,dict)])[],w=dict)]:

 

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

anagramDegrangement=Function[{w1,w2},

Module[{c1=ToCharacterCode@w1,c2=ToCharacterCode@w2},

 

A similar approach using Mathematica 10:

MaximalBy[

Select[GatherBy[list, Sort@*Characters],

 

=={{header|Nim}}==

import tables

import times

 

=={{header|OCaml}}==

let r = String.copy s in

for i = 0 to (String.length r) - 2 do

 

=={{header|ooRexx}}==

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

 

 

=={{header|PARI/GP}}==

len=apply(s->#s, dict);

getLen(L)=my(v=List()); for(i=1,#dict, if(len[i]==L, listput(v, dict[i]))); Vec(v);

Using extra Stringlist for sorted by character words and insertion sort.<BR>

Runtime 153 ms -> 35 ms (Free Pascal Compiler version 3.3.1-r20:47268 [2020/11/02] for x86_64)

{$IFDEF FPC}

{$MODE Delphi}

 

=={{header|Perl}}==

my @a = split('', shift); # split word into letters

my @b = split('', shift);

keys %letter_list )

{

last if find_deranged(@{ $letter_list{$_} });

}</syntaxhighlight>

{{out}}

use warnings;

 

local (@ARGV, $/) = 'unixdict.txt';

{

my $key = join '', sort +split //, $word;

push @{ $anagrams{$key} }, $word;

}</syntaxhighlight>

{{out}}

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">deranged</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">word2</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sq_eq</span><span style="color: #0000FF;">(</span><span style="color: #000000;">word1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">word2</span><span style="color: #0000FF;">))=</span><span style="color: #000000;">0</span>

 

=={{header|Phixmonti}}==

by Galileo, 06/2022 #/

 

 

=={{header|PHP}}==

$words = file(

'http://www.puzzlers.org/pub/wordlists/unixdict.txt',

 

=={{header|Picat}}==

M = [W:W in read_file_lines("unixdict.txt")].group(sort),

Deranged = [Value : _Key=Value in M, Value.length > 1, allderanged(Value)],

 

=={{header|PicoLisp}}==

(in "unixdict.txt"

(while (line)

 

=={{header|PowerShell}}==

{

$array1 = $Strings[0].ToCharArray()

=={{header|Prolog}}==

{{Works with|SWI Prolog}}

http_open('http://www.puzzlers.org/pub/wordlists/unixdict.txt',In,[]),

read_file(In, [], Out),

 

=={{header|PureBasic}}==

word.s

letters.s

 

=={{header|Python}}==

from collections import defaultdict

from itertools import combinations

 

Append the following to the previous code:

ordered_anagrams = sorted(anagrams.items(),

key=lambda x:(-len(x[0]), x[0]))

 

===Python: Faster Version===

from itertools import combinations

from pathlib import Path

=={{header|Quackery}}==

 

[ 2drop false ] done

over sort over sort != iff

 

=={{header|R}}==

 

longest.deranged.anagram <- function(dict=puzzlers.dict) {

{{out}}

 

a b

3 excitation intoxicate</syntaxhighlight>

 

=={{header|Racket}}==

(define word-list-file "data/unixdict.txt")

 

{{works with|Rakudo|2016.08}}

 

.map(*.comb.cache) # explode words into lists of characters

.classify(*.sort.join).values # group words with the same characters

 

=={{header|REXX}}==

iFID= 'unixdict.txt'; words=0 /*input file ID; number of words so far*/

wL.=0 /*number of words of length L. so far*/

 

=={{header|Ring}}==

 

load "stdlib.ring"

 

=={{header|Ruby}}==

a.chars.zip(b.chars).all? {|char_a, char_b| char_a != char_b}

end

 

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

dim theWord$(30000)

dim ssWord$(30000)

 

=={{header|Rust}}==

use std::cmp::Ordering;

use std::collections::HashMap;

 

=={{header|Scala}}==

 

/** Returns a map of anagrams keyed by the sorted characters */

=={{header|Scheme}}==

 

(scheme char)

(scheme cxr)

 

=={{header|Sidef}}==

for i in (^a) {

for j in (i+1 .. a.end) {

 

=={{header|Simula}}==

BEGIN

 

 

=={{header|Tcl}}==

package require http

 

 

=={{header|TUSCRIPT}}==

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

 

=={{header|UNIX Shell}}==

{{works with|ksh93}}

typeset host=www.puzzlers.org

typeset page=/pub/wordlists/unixdict.txt

=={{header|Ursala}}==

This solution assumes the file <code>unixdict.txt</code> is passed to the compiler as a command line parameter.

 

anagrams = |=tK33lrDSL2SL ~=&& ==+ ~~ -<&

main = leql$^&l deranged anagrams unixdict_dot_txt</syntaxhighlight>

The <code>anagrams</code> function is a little slow as defined above, but can be sped up by at least two orders of magnitude by grouping the words into classes of equal length, and sorting each word once in advance instead of each time a comparison is made as shown below.

We can speed it up by about another factor of 5 by starting from the group of longest words and stopping as soon as a deranged anagram is found instead of generating all anagrams.

 

longest_deranged_anagram =

 

=={{header|VBA}}==

Dim ListeWords() As String, Book As String, i As Long, j As Long, tempLen As Integer, MaxLen As Integer, tempStr As String, IsDeranged As Boolean, count As Integer, bAnag As Boolean

Dim t As Single

Time to compute : 97,00781 sec.</pre>

 

{{trans|Go}}

 

fn deranged(a string, b string) bool {

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

// assumes w1 and w2 are anagrams of each other

 

=={{header|zkl}}==

File("unixdict.txt").read().pump(Void,'wrap(w){

w=w.strip(); key:=w.sort(); words[key]=words.find(key,T).append(w);

</pre>

Replace the center section with the following for smaller code (3 lines shorter!) that is twice as slow:

if(ws.len()>1){ // two or more anagrams

n:=ws[0].len(); // length of these anagrams