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]

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

This can now return all the co-longest deranged anagrams when there are more than one. However it turns out that unixdict.txt only contains one. :)

 

-- Uses the customisable AppleScript-coded sort shown at <https://macscripter.net/viewtopic.php?pid=194430#p194430>.

-- It's assumed scripters will know how and where to install it as a library.

 

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

 

=={{header|BaCon}}==

 

FUNCTION Deranged(a$, b$)

=={{header|BBC BASIC}}==

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

******************************************************************

* COBOL solution to Anagrams Deranged challange

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

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

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

</pre>

===Alternate===

 

use strict; # https://rosettacode.org/wiki/Anagrams/Deranged_anagrams

 

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

=={{header|Vlang}}==

{{trans|Go}}

 

fn deranged(a string, b string) bool {

=={{header|Wren}}==

{{libheader|Wren-sort}}

import "/sort" for Sort

 

 

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