Tornou-se uma tradição no PPCG que alguns usuários alterem temporariamente seus nomes por um anagrama (um novo nome formado por reordenar as letras do antigo).

Às vezes fica difícil descobrir quem é quem. Eu poderia usar um programa ou função para dizer se duas frases são anagramas uma da outra.

O desafio

O programa ou função deve pegar duas strings e produzir um resultado verdadeiro, se forem anagramas uma da outra, e falsificar o contrário.

Regras

• A entrada conterá apenas letras (ASCII 65 a 90 e 97 a 122), dígitos (ASCII 48 a 57) ou espaço (ASCII 32).
• A relação do anagrama é independente do caso. Então "Arm" e "RAM" são anagramas.
• Os espaços também não contam. Então "teclado" e "Barked Yo" são anagramas
• Todos os embutidos permitidos
• O formato de entrada é flexível (duas strings, uma matriz de duas strings, uma string contendo as duas frases com um separador adequado ...)

Código de golfe. Menos bytes ganha.

Casos de teste

Verdade:

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

Falsy

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

Explicação:

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

Experimente online!

Retina, 25

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

Experimente Online! Além disso, você pode executar uma versão multilinha modificada .

Exclua as letras anteriores à vírgula e suas correspondências após a vírgula. Se não temos mais letras, era um anagrama.

Pitão, 11 10 bytes

Obrigado a @FryAmTheEggman por me ensinar o poder de ;!

qFmSr-d;0Q

Experimente aqui!

Leva uma lista de duas seqüências de caracteres como entrada.

Explicação

qFmSr-d; 0Q # Q = entrada

  m Q # map Q com d como variável lambda
     -d; # filtrar espaços fora da string
    r 0 # converter para minúsculas
   S # classifica todos os caracteres na string
qF # Desdobre a lista resultante e verifique a igualdade

Python 2, 63 61 bytes

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

Uma função anônima que, de fato, toma n argumentos e determina se todos n deles são palíndromos mútuos! f("Lynn", "Nyl N")retorna True.

Esse truque de compreensão de conjunto é do xnor. Ele salvou dois bytes, mas a abordagem antiga parecia muito elegante:

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

Gelatina, 12 bytes

ḟ€⁶O&95Ṣ€QLḂ

Experimente online!

Como 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).

Versão alternativa, não concorrente (9 bytes)

O átomo maiúsculo de Jelly tinha um bug, e Jelly ainda não tinha construído para testar listas de igualdade ...

ḟ⁶ŒuṢµ€⁼/

Experimente online!

Como 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 removidos graças a @FryAmTheEggman

{lelS-$}2*=

Experimente online!

{      }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 de desconto, obrigado @ ӍѲꝆΛҐӍΛПҒЦꝆ . 1 byte com curry ( apontado 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=

EDIT (20 de maio de 2016) O código no link usa, em Xzvez de Xv, devido a alterações recentes no idioma.

Experimente online!

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

Sério, 11 9 bytes

2`,ùSô`n=

Experimente Online!

Todo mundo parece estar usando o mesmo algoritmo. Aqui está mais uma vez.

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

Edit: a classificação realizada funciona corretamente nas strings e classifica os espaços à frente, para que strip () 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);}

Legível e no contexto de trabalho,

#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 linha de comando, saída como código de retorno.

A forsintaxe torna esse Bash incompatível.

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

Japonês, 12 bytes

N®v ¬n ¬xÃä¥

Teste online!

Como 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

A pontuação inclui +2 para -rnopções para sed.

Esta é quase uma porta direta da resposta Retina de @ FryAmTheEggman :

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

Ideone.

Perl, 34 33 + 1 = 34 bytes

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

Requer a -nbandeira e o livre -M5.010| -E:

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

Como 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

Obrigado ao msh210 por sugerir o uso de operadores ternários para economizar um byte

Baloch Gyr , 9 bytes

{ṇ₁cḷ}ᵐpᵈ

Experimente online!

A saída de verdade / falsidade é alcançada através do sucesso / fracasso do predicado, sendo este Brachylog.

Anteriormente, salvei um byte usando, em cṇ₁cḷḍvez de, {ṇ₁cḷ}ᵐsob a suposição de que as duas seqüências de entrada teriam o mesmo comprimento, menos espaço em branco, mas percebi que seria bem-sucedido onde deveria falhar 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, os dois function/returnestão me matando aqui.

Retorna a diferença entre duas stringentradas como um arraydos caracteres. O PHP considera []falso, satisfazendo os returnrequisitos.

Utilitários Bash + GNU, 51

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

• Defina uma função f()que:
  • ${@^^} converte todos os parâmetros em maiúsculas
  • fold -1 divide caracteres - um por linha
  • sorts linhas
• chame diffcom -qpara suprimir a saída diff completa e -Bwignorar alterações de espaço em branco

Pyke (commit 30, não competitivo), 9 bytes

Fl1dk:S)q

Explicação:

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

Mathematica, 77 76 bytes

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

A primeira parte é na verdade uma das minhas respostas para outra pergunta!

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]);}

mixedpassa a ser mais curto que array(string).

sretorna 1se seus argumentos são anagramas.

Q, 25 bytes

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

NOTA.- a contagem inclui o nome da função f: para facilitar os testes (como lambda, podemos decrementar 2 bytes)

Versão legível

coincidir com {ascendente não 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)

Teste

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

gera (1b = verdadeiro, 0b = falso)

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

Sobre Q

Linguagem de uso geral (derivada da APL, especializada em processamento de dados) desenvolvida pela kx.com. Versão completa gratuita de avaliação funcional para Windows / Linux / MacOS.

APL, 31 caracteres

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

Para ser usado assim:

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

Em inglês:

• { ... }¨⍵: para cada um dos dois elementos do argumento
• x←('.'⎕R'\u0')⍵~' ': transforme em maiúsculas (usando um regex ...) a sequência sem os espaços e atribua o resultado temporário a x
• x[⍋x]: classificar x
• ≡/: compare os dois resultados da classificação: se eles corresponderem, retorne 1.

Java, 218 bytes

Primeira vez que escrevi Java ...

Golfe:

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);}

Ungolfed:

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);
   }
}

Teste:

    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"));

Japonês , 10 bytes

v á øVrS v

Tente

Ruby, 50 bytes

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

Escrever f=->{...}e f[]==f[]é tão longo. :(

PowerShell, 81 bytes

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

Uma leve reescrita da minha resposta no desafio anagrama vinculado.

Pega entrada como matrizes de caracteres, executa uma -replaceoperação para remover espaços, classifica- sortos (que são classificados em ordem alfabética, não pelo valor ASCII) e, em seguida, classifica- -joinos novamente em uma string. O -eqPowerShell, por padrão, não faz distinção entre maiúsculas e minúsculas, mas aqui deve ser executado em cadeias de caracteres, como [char]'a'não é igual a [char]'A', daí o motivo -join.

Perl, 35 bytes

Incluir +1 para -p

Um pouco abusivo, pois depende do programa ser fornecido na linha de comando.

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

Em seguida, forneça as cordas como 2 linhas consecutivas em STDIN

Uma solução muito abusiva é de 30 bytes:

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

Isso trava se as seqüências de caracteres não são anagramas e, portanto, fornece um código de saída falso do ponto de vista do shell. Também fornece lixo no STDERR para esse caso. Se as strings são anagramas, o programa é silencioso e fornece um código de saída "true"

PHP , 89 bytes

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

Experimente online!

PHP , 94 bytes

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

Experimente online!

Excel VBA, 122 bytes

Janela imediata do VBE anônimo Função que leva as entradas do intervalo [A1:B1]e as saídas para a janela imediata do 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

Eu preciso de uma desvantagem !!

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));"));

    }

}