Desafio

Dadas duas seqüências, resolva se ambas têm exatamente os mesmos caracteres.

Exemplo

Entrada

palavra, errado

Isso retorna trueporque eles são os mesmos, mas apenas embaralhados.

Entrada

palavra wwro

Isso retorna false.

Entrada

barco, toba

Isso retorna true

Regras

Aqui estão as regras!

• Suponha que a entrada tenha pelo menos 1 caractere e não mais que 8 caracteres.
• Sem caracteres especiais, apenas a-z
• Todas as entradas podem ser consideradas minúsculas

Casos de teste

boat, boat = true
toab, boat = true
oabt, toab = true
a, aa = false
zzz, zzzzzzzz = false
zyyyzzzz, yyzzzzzy = true
sleepy, pyels = false
p,p = true

Python, 32 bytes

f=lambda a,b,S=sorted:S(a)==S(b)

Golfscript, 3 caracteres?

$$=

uso:

'boat'$'baot'$=
1

'toab'$'boat'$=
1

'oabt'$'toab'$=
1

'a'$'aa'$=
0

'zzz'$'zzzzzzzz'$=
0

'zyyyzzzz'$'yyzzzzzy'$=
1

'sleepy'$'pyels'$=
0

'p'$'p'$=
1

J, 8

-:&(/:~)

Literalmente, combine ( -:) em ( &) classifique ( /:~)

Uso da amostra:

   'boat' -:&(/:~) 'boat'
1
   'toab' -:&(/:~) 'boat'
1
   'oabt' -:&(/:~) 'toab'
1
   'a' -:&(/:~) 'aa'
0
   'zzz' -:&(/:~) 'zzzzzzzz'
0
   'zyyyzzzz' -:&(/:~) 'yyzzzzzy'
1
   'sleepy' -:&(/:~) 'pyels'
0
   'p' -:&(/:~) 'p'
1

Onde os números inteiros de 64 bits entram em jogo?

Javascript, 192 157 152 152 147 125 bytes

Ok, algumas dessas línguas são muito mais flexíveis do que eu pensava! Enfim, essa é a maneira mais longa, eu acho, mas pelo menos uma técnica diferente.

Comprimido

Obrigado a Peter e David por espremer mais caracteres!

for(a=[j=p=2];j<123;)a[j]?p%a[++j]<1&&p++&&(j=0):(a[j]=p,j=0);function b(c,i){return c[i=i||0]?a[c.charCodeAt(i)]*b(c,++i):1}

Então faça:

alert(b("hello")==b("elloh"));

Código expandido

O comprimido teve muitas mudanças, mas esta é a teoria básica:

// Define dictionary of primes
a = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101];

// Returns the unique ID of the word (order irrelevant)
function b(c) {
    r = 1;
    for (i = 0; i < c.length; i++)
        r *= a[c[i].charCodeAt(0) - 97];
    return r
}

alert(b("hello") == b("hlleo"));

Golfscript, 8 bytes

Isso define uma função chamada A

{$\$=}:A

Casos de teste

;
'boat' 'boat' A
'toab' 'boat' A
'oabt' 'toab' A
'a' 'aa' A
'zzz' 'zzzzzzzz' A
'zyyyzzzz' 'yyzzzzzy' A
'sleepy' 'pyels' A
'p' 'p' A

Haskell, 31 bytes

função - 31

import List
f=(.sort).(==).sort

programa - 81 58 55

import List
g=sort`fmap`getLine
main=(`fmap`g).(==)=<<g

Uso:

$ runghc anagram.hs
boat
boat
True
$ runghc anagram.hs
toab
boat
True
$ runghc anagram.hs
a
aa
False

Parabéns ao lambdabot e sua refatoração sem pontos .

C #, 129 caracteres

namespace System.Linq{class X{static void Main(string[]a){Console.Write(a[0].OrderBy(_=>_).SequenceEqual(a[1].OrderBy(_=>_)));}}}

Legível:

namespace System.Linq
{
    class X
    {
        static void Main(string[] a)
        {
            Console.Write(a[0].OrderBy(_ => _)
                  .SequenceEqual(a[1].OrderBy(_ => _)));
        }
    }
}

Ruby, 34 bytes

Usando o esquema de E / S da solução Peter Taylors Perl:

p gets.chars.sort==gets.chars.sort

Programa C, 118

t[52],i;main(c){for(;i<52;)(c=getchar())<11?i+=26:t[i+c-97]++;
for(i=27;--i&&t[i-1]==t[i+25];);puts(i?"false":"true");}

Perl, 58 bytes

(programa completo, diferente da outra resposta Perl, que é apenas uma função)

($c,$d)=map{[sort split//]}<>;print"@$c"eq"@$d"?true:false

49 em função

sub f{($c,$d)=map{[sort split//]}<>;"@$c"eq"@$d"}

Clojure - 23 caracteres

Como uma função anônima:

#(apply = (map sort %))

Exemplo de caso de teste:

(#(apply = (map sort %)) ["boat" "boat"])
=> true

Javascript

Com base na solução de @ zzzzBov.

Comparação, 65 caracteres (40 sem função)

function f(a,b){return a.split('').sort()==b.split('').sort()+""}

Comparador, 43 caracteres

function f(a){return a.split('').sort()+""}

C ++ (104 caracteres não-ws)

Com base na classificação da contagem. Nota: assume cadeias do mesmo comprimento, o que parece estar implícito (embora não declarado) pela pergunta.

int u[123], i;

int a(char **c) {
    for(; c[0][i]; ) {
        u[c[0][i]]++;
        u[c[1][i++]]--;
    }

    i=123;
    while(i && !u[--i]);
    return !i;
}

PHP (linha de comando, 87 caracteres)

function d($s){
    return array_count_values(str_split($s));
}

echo d($argv[1]) == d($argv[2]);

Javascript

Uma versão (muito) ligeiramente mais curta da solução do @ zzzzBov, que usa, em .join()vez do boxe String:

function a(b,c){return b.split('').sort().join()==c.split('').sort().join()}
alert(a('abc','bca')); //true

Similarmente:

function a(b){return b.split('').sort().join()}
alert(a('abc')==a('bca')); //true

Clojure REPL 41 chars

(= (sort (read-line)) (sort (read-line)))

Java

(Aparentemente, o idioma favorito de todos!)

173 caracteres:

import java.util.*;class g{public static void main(String[]p){String[]a=p[0].split(""),b=p[1].split("");Arrays.sort(a);Arrays.sort(b);System.out.print(Arrays.equals(a,b));}}

(Não imprime caracteres de nova linha para salvar 2 caracteres de println)

Compile e execute:

javac g.java
java -cp . g abcdef fedcba
true

Amor para ver um mais curto ...

sed, 45 caracteres

É até possível no meu favorito - sed! Apenas uma expressão regular para resolver o anagrama ! Continue removendo as letras correspondentes:

:
s/(.)(.*,.*)\1/\2/
t
/\w/{i\false
d}
i\true

(a ser invocado com -nE)

Perl, 48

1while s/(.)(.*,.*)\1/\2/;$_=/\w/?"false":"true"

Para ser invocado com -p.

Função Perl, 39

sub f{$,while s/(.)(.*,.*)\1/\2/;!/\w/}

APL, 2 caracteres

≡⍦

Essa é a função Multiset Match do Nars2000 , uma das implementações de APL de ponta. Quando aplicado a strings, calcula exatamente a função necessária:

      'elvis' ≡⍦ 'lives'
1
      'alec guinness' ≡⍦ 'genuine class'
1

05AB1E , 6 4 bytes (não concorrente)

{I{Q

Experimente online!

Isso levou um tempo devido a dificuldades de entrada. Golfe devido ao pop.

Explicação:

{I{Q    Original code

{       Takes first input e.g. word and sorts -> 'dorw'
 I      Takes second input e.g. 'wrdo'
  {     Sorts second input -> 'dorw'
   Q    Compare if sorted 1 = sorted 2, then print result. 'dorw' = 'dorw', so prints 1.

Perl, 77 75 caracteres

A E / S do problema não está bem especificada; isso lê duas linhas de stdin e gera true ou false para stdout.

sub p{join'',sort split'',$a}$a=<>;$x=p;$a=<>;print$x eq p()?"true":"false"

(Obrigado a Tim por 77 -> 75)

Perl, 62 bytes

Essa função aceita as seqüências de caracteres como argumentos e retorna verdadeiro ou falso.

sub f{my@a;for$.(1,-1){$a[ord]+=$.for split//,pop}!grep{$_}@a}

Armazena os valores ASCII em uma matriz e verifica se está nivelado. Incrementos para a primeira palavra e decrementos para a segunda palavra.

Python 3, 107 97 76 64

s=sorted;a,b=input().split(', ')
print(str(s(a)==s(b)).lower())

Obviamente, isso pode ser abreviado se não considerarmos literalmente as palavras do OP e em minúsculas "true" e "false" ...

Python, 32 bytes

p=sorted
f=lambda a,b:p(a)==p(b)

Bash, 88 caracteres

diff <(grep -o .<<<$1|sort) <(grep -o .<<<$2|sort)>/dev/null && echo true || echo false

R , 54 bytes

function(x,y,`~`=sort,`+`=utf8ToInt)identical(~+x,~+y)

Experimente online!

Scala em REPL (32)

readLine.sorted==readLine.sorted

Função Scala (43)

def f(a:String,b:String)=a.sorted==b.sorted

Programa Scala (61)

object A extends App{println(args(0).sorted==args(1).sorted)}

Eles utilizam um recurso interessante do Scala, no qual uma String também pode ser tratada como uma sequência de caracteres ( Seq), com todas as operações Seqdisponíveis.

APL - 13 caracteres

{(⍺[⍋⍺])≡⍵[⍋⍵]}

Ligue assim:

      'boat' {(⍺[⍋⍺])≡⍵[⍋⍵]} 'baot'
1
      'baot' {(⍺[⍋⍺])≡⍵[⍋⍵]} 'boat'
1
      (,'a') {(⍺[⍋⍺])≡⍵[⍋⍵]} 'aa'
0

No último exemplo, 'a'representa um único caractere e o prefixo ,o converterá em uma sequência.

Java (134 bytes)

int[][]c=new int[2][26];
for(int i=0;i<2;i++)for(byte a:args[i].getBytes())c[i][a-97]++;
System.out.print(Arrays.equals(c[0],c[1]));`

Isso faz com que uma matriz conte o número de vezes que cada letra aparece e compara as matrizes para verificar se são iguais.

JavaScript, 41

Função de comparação (41) :

a=b=>''+[...b].sort()
b=(c,d)=>a(c)==a(d)

alert(b('abc', 'cba')) // true

Função comparadora (21) :

a=b=>''+[...b].sort()

alert(a('abc') == a('bca')); //true

Função comparadora (48):

function a(b){return String(b.split('').sort())}

alert(a('abc')==a('bca')); //true

Função de comparação (78):

function a(b,c){return String(b.split('').sort())==String(c.split('').sort())}

alert(a('abc','bca')); //true

Assume que Stringtem splite Arraytem sort.