Se ha convertido en una tradición en PPCG que algunos usuarios cambian temporalmente sus nombres por un anagrama (un nuevo nombre formado reordenando las letras de los antiguos).

A veces se hace difícil descubrir quién es quién. Podría usar un programa o función para saber si dos frases son anagramas entre sí.

El reto

El programa o función debe tomar dos cadenas y producir un resultado verdadero si son anagramas entre sí, y falso de lo contrario.

Reglas

• La entrada solo contendrá letras (ASCII 65 a 90 y 97 a 122), dígitos (ASCII 48 a 57) o espacio (ASCII 32).
• La relación anagrama es independiente del caso. Entonces "Brazo" y "RAM" son anagramas.
• Los espacios tampoco cuentan. Entonces "teclado" y "Yo ladrado" son anagramas
• Todas las construcciones permitidas
• El formato de entrada es flexible (dos cadenas, una matriz de dos cadenas, una cadena que contiene ambas frases con un separador adecuado ...)

Código de golf. Pocos bytes ganan.

Casos de prueba

Verdad:

Lynn, Nyl N
Digital Trauma, Tau Digital Arm
Sp3000, P S 3000
Manage Trash So, Those anagrams

Falsa

Calvins Hobbies, Helka Homba
Android, rains odd
In between days, bayed entwine
Code golf, cod elf got

05AB1E , 9 8 bytes

Código:

lvyð-{}Q

Explicación:

l         # Lowercase the strings
 vy   }   # Map over the list, for each...
   ð-     #   remove spaces
     {    #   and sort
       Q  # Check equality

Pruébalo en línea!

Retina, 25

i+`(\w)(.*,.*)\1
$2
^\W*$

Pruébalo en línea! Además, puede ejecutar una versión modificada de varias líneas .

Elimine letras de antes de la coma junto con sus coincidencias después de la coma. Si no nos quedan letras, entonces fue un anagrama.

Pyth, 11 10 bytes

¡Gracias a @FryAmTheEggman por enseñarme el poder de ;!

qFmSr-d;0Q

Pruébalo aquí!

Toma una lista de dos cadenas como entrada.

Explicación

qFmSr-d; 0Q # Q = entrada

  m Q # mapa Q con d como variable lambda
     -re; # espacios de filtro fuera de la cadena
    r 0 # convertir a minúsculas
   S # ordena todos los caracteres en cadena
qF # Desplegar la lista resultante y verificar la igualdad

Python 2, 63 61 bytes

lambda*l:len({`sorted(s.lower())`[2::5].strip()for s in l})<2

¡Una función anónima que, de hecho, toma n argumentos y determina si todos n son palíndromos mutuos! f("Lynn", "Nyl N")vuelve True.

Este truco de comprensión es de xnor. Ahorró dos bytes, pero el viejo enfoque parecía muy ordenado:

exec"a=`sorted(input().lower())`[2::5].strip();a"*2;print a==aa

Jalea, 12 bytes

ḟ€⁶O&95Ṣ€QLḂ

Pruébalo en línea!

Cómo funciona

ḟ€⁶O&95Ṣ€QLḂ  Main link. Input: A (list of strings)

  ⁶           Yield ' '.
ḟ€            Filter it from each string.
   O          Apply ordinal to all characters.
    &95       Take bitwise AND with 95 to make the ordinals case-insensitive.
       Ṣ€     Sort each list of ordinals.
         Q    Deduplicate the list.
          L   Get the length.
           Ḃ  Compute the length's parity (1 -> 1, 2 -> 0).

Versión alternativa, no competitiva (9 bytes)

El átomo en mayúscula de Jelly tenía un error, y Jelly todavía no tenía incorporado para probar las listas de igualdad ...

ḟ⁶ŒuṢµ€⁼/

Pruébalo en línea!

Cómo funciona

ḟ⁶ŒuṢµ€⁼/     Main link. Input: A (list of strings)

     µ€       Map the chain to the left over A.
 ⁶            Yield ' '.
ḟ             Filter it from the string.
  Œu          Cast to uppercase.
    Ṣ         Sort.
       ⁼/     Reduce by equality.

CJam, 11 12 14 bytes

3 2 bytes eliminados gracias a @FryAmTheEggman

{lelS-$}2*=

Pruébalo en línea!

{      }2*       e# do this twice
 l               e# read line as a string
  el             e# make lowercase
    S-           e# remove spaces from string
      $          e# sort
          =      e# compare strings

Javascript, 69 61 60 59 bytes

1 byte off gracias @ ӍѲꝆΛҐӍΛПҒЦꝆ . 1 byte apagado con curry ( señalado por @apsillers )

n=>m=>(G=s=>[]+s.toLowerCase().split(/ */).sort())(n)==G(m)

f=n=>m=>
    (G=s=>[]+s.toLowerCase()
        .split(/ */)
        .sort()
    )(n)==G(m)

F=(n,m)=>document.body.innerHTML+=`<pre>f('${n}')('${m}') -> ${f(n)(m)}</pre>`

F('Luis Mendo','Don Muesli')
F('Calvins Hobbies','Helka Homba')
F('Android','rains odd')
F('In between days','bayed entwine')
F('Code golf','cod elf got')
F('Lynn','Nyl N')
F('Digital Trauma','Tau Digital Arm')
F('Sp3000','P S 3000')
F('Manage Trash So','Those anagrams')

MATL , 11 bytes

2:"jkXvS]X=

EDITAR (20 de mayo de 2016) El código en el enlace se usa en Xzlugar de Xv, debido a cambios recientes en el idioma.

Pruébalo en línea!

2:"     ]       % do this twice
   j            % read input line as a string
    k           % convert to lowercase
     Xv         % remove spaces
       S        % sort
         X=     % are they equal?

En serio, 11 9 bytes

2`,ùSô`n=

¡Pruébelo en línea!

Todos parecen estar usando el mismo algoritmo. Aquí está de nuevo.

2`    `n          Do it twice
  ,               Read a string
   ù              Make it lowercase
    S             Sort
     ô            Strip spaces.
        =         Check equality.

Editar: la clasificación realizada funciona correctamente en las cadenas y ordena los espacios al frente para que la tira () funcione.

C, 165 bytes

#define d(x) int x(char*a,char*b){
d(q)return*a&224-*b&224;}
#define n(x) for(qsort(x,strlen(x),1,(__compar_fn_t)q);*x<33;x++);
d(s)n(a)n(b)return strcasecmp(a,b);}

Legible y en contexto de trabajo,

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// start of comparison
int q(char *a, char *b){
     return ((*a)&0xdf)-((*b)&0xdf); // case-insensitive
}
int s(char *a, char *b){
    for(qsort(a,strlen(a),1,(__compar_fn_t)q); *a<33; a++) /**/;
    for(qsort(b,strlen(b),1,(__compar_fn_t)q); *b<33; b++) /**/;
    return strcasecmp(a,b);
}
// end of comparison

int main(int i, char **v){
    printf("'%s' '%s'", v[1], v[2]);
    printf("=> %d\n", s(v[1], v[2])); // 0 if equalish
    return 0;
}

zsh, 85 bytes

[ $(for x in $@;{tr -d \ <<<$x|tr A-Z a-z|fold -1|sort|paste -sd x}|uniq|wc -l) = 1 ]

Entrada como argumentos de línea de comando, salida como código de retorno.

La forsintaxis hace que este Bash sea incompatible.

[               # test...
$(for x in $@;  # map over arguments
{tr -d \ <<<$x  # remove spaces
|tr A-Z a-z     # lowercase
|fold -1        # put each character on its own line
|sort           # sort lines
|paste -sd x    # remove all newlines except last
}|uniq          # take only unique lines
|wc -l          # how many lines remain?
) = 1 ]         # if only 1 line left, it must have been an anagram

Japt, 12 bytes

N®v ¬n ¬xÃä¥

¡Pruébelo en línea!

Cómo funciona

        // Implicit: N = array of input strings
N®    Ã // Take N, and map each item Z to:
v ¬n    //  Take Z.toLowerCase(), split into chars, and sort.
¬x      //  Join and trim off whitespace.
ä¥      // Reduce each pair of items (that's exactly one pair) X and Y to X == Y.

GNU Sed, 33

La puntuación incluye +2 para las -rnopciones de sed.

Esto es casi un puerto directo de la respuesta de Retina de @ FryAmTheEggman :

:
s/(\w)(.*,.*)\1/\2/i
t
/\w/Q1

Ideona

Perl, 34 33 + 1 = 34 bytes

s/(.)(.*,.*)\1/$2/i?redo:say!/\w/

Requiere la -nbandera y la libre -M5.010| -E:

$ perl -M5.010 -ne's/(.)(.*,.*)\1/$2/i?redo:say!/\w/' <<< 'hello, lloeh'
1

Cómo funciona:

                                   # '-n' make a implicit while loop around the code
 s/(.)(.*,.*)\1/$2/i               # Remove a letter that occurs on both sides of the comma.
                    ?
                     redo:         # Redo is a glorified goto statement that goes to the top of the while loop
                          say!/\w/ # Check to see if any letter is left

Gracias a msh210 por sugerir el uso de operadores ternarios para guardar un byte

Baloch Gyr , 9 bytes

{ṇ₁cḷ}ᵐpᵈ

Pruébalo en línea!

La salida de verdad / falsedad se logra a través del éxito / fracaso del predicado, siendo Brachylog.

Anteriormente guardé un byte usando en cṇ₁cḷḍlugar de {ṇ₁cḷ}ᵐbajo el supuesto de que las dos cadenas de entrada tendrían la misma longitud menos el espacio en blanco, pero me di cuenta de que tendría éxito donde debería fallar Ah Hass, haha.

{    }ᵐ      For both strings in the input,
 ṇ₁          split on spaces,
   c         concatenate,
    ḷ        and lowercase.
       pᵈ    The strings are permutations of each other.

PHP, 109 94 bytes

function f($x){return str_split((trim($x));}function g($x,$y){return array_diff(f($x),f($y));}

Blech, los dos function/returns me están matando aquí.

Devuelve la diferencia entre dos stringentradas como un arrayde caracteres. PHP considera []falsa, satisfaciendo los returnrequisitos.

Bash + utilidades GNU, 51

f()(fold -1<<<${@^^}|sort)
f $1|diff -qBw - <(f $2)

• Defina una función f()que:
  • ${@^^} convierte todos los parámetros a mayúsculas
  • fold -1 divide caracteres - uno por línea
  • sortlíneas s
• llame diffcon -qpara suprimir la salida de diferencias completas e -Bwignorar los cambios de espacios en blanco

Pyke (commit 30, no competitivo), 9 bytes

Fl1dk:S)q

Explicación:

F      )  -  for _ in eval_or_not(input())
 l1       -     ^.lower()
   dk:    -    ^.replace(" ", "")
      S   -   sorted(^)
        q - ^==^

Mathematica, 77 76 bytes

StringMatchQ[##,IgnoreCase->1>0]&@@(""<>Sort[Characters@#/." "->""]&/@{##})&

¡La primera parte es en realidad una de mis respuestas a otra pregunta!

Pike, 54 112 109 109 96 bytes

#define a(x) sort((array)replace(lower_case(x)," ",""))
int s(mixed i){return a(i[0])==a(i[1]);}

mixedpasa a ser más corto que array(string).

sdevuelve 1si sus argumentos son anagramas.

Q, 25 bytes

f:{~/{x@<x:x@&~^x:_x}'x}

NOTA.- el conteo incluye el nombre de la función f: para facilitar las pruebas (como lambda podemos disminuir 2 Bytes)

Versión legible

coincidir sobre {ascendente no nulo inferior x} cada x

{.. x ..} is an anonymous function with arg x
_x        lowers string x
&~^x      where not null x (space is considered null)
x@..      selects elements of x according to indexes .. 
<x        ascending indexes of x (not values). Ex <"cab" is 1 2 0
x@<x      ascending values of x (x at ascending indexes of x)
~         match (diad function). Ex "one"~"one" is true
f'..      applies function f for each argument ..
f/..      applies function f over elements of sequence (fold)

Prueba

f("Lynn";"Nyl N")                       
f("Digital Trauma";"Tau Digital Arm")   
f("Sp3000";"P S 3000")                  
f("Manage Trash So";"Those anagrams")   
f("Calvins Hobbies";"Helka Homba")      
f("Android";"rains odd")                
f("In between days";"bayed entwine")    
f("Code golf";"cod elf got")    

genera (1b = verdadero, 0b = falso)

1b
1b
1b
1b
0b
0b
0b
0b

Acerca de Q

Lenguaje de propósito general (derivado de APL, especializado en procesamiento de datos) desarrollado por kx.com. Versión gratuita de evaluación funcional completa para Windows / Linux / MacOS.

APL, 31 caracteres

{≡/{x[⍋x←('.'⎕R'\u0')⍵~' ']}¨⍵}

Para ser utilizado así:

    {≡/{x[⍋x←('.'⎕R'\u0')⍵~' ']}¨⍵}'Sp3000' 'P S 3000' 
1

En inglés:

• { ... }¨⍵: para cada uno de los dos elementos del argumento
• x←('.'⎕R'\u0')⍵~' ': transforma a mayúsculas (usando una expresión regular ...) la cadena sin espacios y asigna el resultado temporal a x
• x[⍋x]: ordenar x
• ≡/: compara los dos resultados de la clasificación: si coinciden, devuelve 1.

Java, 218 bytes

Primera vez que escribo Java ...

Golfizado:

import java.util.Arrays;boolean M(String a,String b){char[]A=a.toUpperCase().replace(" ","").toCharArray();char[]B=b.toUpperCase().replace(" ","").toCharArray();Arrays.sort(A);Arrays.sort(B);return Arrays.equals(A,B);}

Sin golf:

import java.util.Arrays;
public class ManageTrashSo {
    public boolean M(String a, String b) {
    char[] A = a.toUpperCase().replace(" ", "").toCharArray();
    char[] B = b.toUpperCase().replace(" ", "").toCharArray();
    Arrays.sort(A);
    Arrays.sort(B);
    return Arrays.equals(A, B);
   }
}

Pruebas:

    ManageTrashSo manageTrashSo = new ManageTrashSo();

    //True
    System.out.println(manageTrashSo.M("Lynn", "Nyl N"));
    System.out.println(manageTrashSo.M("Digital Trauma", "Tau Digital Arm"));

    //False
    System.out.println(manageTrashSo.M("Android", "rains odd"));
    System.out.println(manageTrashSo.M("In between days", "bayed entwine"));

Japt , 10 bytes

v á øVrS v

Intentalo

Ruby, 50 bytes.

def f;gets.upcase.chars.sort.join.strip;end
p f==f

Escribir f=->{...}y f[]==f[]es igual de largo. :(

PowerShell, 81 bytes

param([char[]]$a,[char[]]$b)-join($a-replace' '|sort)-eq-join($b-replace' '|sort)

Una ligera reescritura de mi respuesta sobre el desafío Anagrama vinculado.

Toma datos como matrices de caracteres, realiza una -replaceoperación para eliminar espacios, sortlos ordena (que se ordena alfabéticamente, no por valor ASCII), luego -joinlos vuelve a formar una cadena. En -eqPowerShell, por defecto, no distingue entre mayúsculas y minúsculas, pero aquí debe realizarse en cadenas, ya [char]'a'que no es igual [char]'A', de ahí la razón -join.

Perl, 35 bytes

Incluye +1 para -p

Algo abusivo ya que depende del programa que se da en la línea de comandos.

perl -pe'<>=~s%\S%*_=s/$&//i?_:0%reg;$_=!//'

Luego dé las cuerdas como 2 líneas consecutivas en STDIN

Una solución muy abusiva es de 30 bytes:

perl -ne'<>=~s%\w%1/!s/$&//i%reg;1/!//'

Esto se bloquea si las cadenas no son anagramas y, por lo tanto, proporciona un código de salida falso desde el punto de vista del shell. También da basura en STDERR para ese caso. Si las cadenas son anagramas, el programa es silencioso y proporciona un código de salida "verdadero"

PHP , 89 bytes

for(;$i++<2;)$r[]=count_chars(join(explode(" ",strtolower($argv[$i]))));echo$r[0]==$r[1];

Pruébalo en línea!

PHP , 94 bytes

for(;$i++<2;sort($x),$r[]=trim(join($x)))$x=str_split(strtolower($argv[$i]));echo$r[0]==$r[1];

Pruébalo en línea!

Excel VBA, 122 bytes

Ventana inmediata anónima de VBE Función que toma la entrada del rango [A1:B1]y las salidas a la ventana inmediata de VBE

a=Replace([A1]," ",""):b=Replace([B1]," ",""):For i=1To Len(a):b=Replace(b,Mid(a,i,1),"|",,1,1):Next:?b=String(len(a),"|")

C #, 378 bytes

Necesito una discapacidad!

https://dotnetfiddle.net/FNDt0E

using System;
using System.Linq;
using System.Text;

public class Program
{

    public static void Main()
    {
        var l = "Hello World";

        var r = "Red Who Loll";

        var y = new Func<string,string>(s => new String(s.ToLower().Replace(" ","").OrderBy(v => v).ToArray()));
        var z = new Func<string,string,Func<string,string>,bool>((w,x,f) => f(w) == f(x));
        var o = z(l, r, y);


        Console.WriteLine("{0} & {1} are anagram: {2}",l, r, o);


                Console.WriteLine("C#, {0} bytes", Encoding.Unicode.GetByteCount(@"var y = new Func<string,string>(s => new String(s.ToLower().Replace("" "","""").OrderBy(v => v).ToArray()));
    var z = new Func<string,string,Func<string,string>,bool>((w,x,f) => f(w) == f(x));"));

    }

}