Sfida

Dato due stringhe, risolvi se entrambi hanno esattamente gli stessi caratteri.

Esempio

Ingresso

parola, wrdo

Questo ritorna trueperché sono gli stessi ma sono semplicemente criptati.

Ingresso

parola, wwro

Questo ritorna false.

Ingresso

barca, toba

Questo ritorna true

Regole

Ecco le regole!

• Supponiamo che l'input abbia una lunghezza di almeno 1 carattere e non più di 8 caratteri.
• Nessun carattere speciale, solo a-z
• Tutti gli ingressi possono essere considerati in minuscolo

Casi test

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 byte

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

Golfscript, 3 caratteri?

$$=

utilizzo:

'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

-:&(/:~)

Literaly, match ( -:) on ( &) sort up ( /:~)

Esempio di utilizzo:

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

Dove entrano in gioco gli interi a 64 bit?

Javascript, 192 157 152 147 125 byte

Ok alcune di queste lingue sono molto più flessibili di quanto pensassi! Comunque questo è il modo più lungo immagino, ma almeno una tecnica diversa.

compressa

Grazie a Peter e David per aver spremuto più caratteri!

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}

Quindi fa:

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

Codice espanso

Il compresso ha avuto molti cambiamenti, ma questa è la teoria di base:

// 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 byte

Questo definisce una funzione chiamata A

{$\$=}:A

Casi test

;
'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 byte

funzione - 31

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

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

Complimenti per Lambdabot e il suo refactoring inutile .

C #, 129 caratteri

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

Leggibile:

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

Rubino, 34 byte

Utilizzando lo schema IO della soluzione Peter Taylors Perl:

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

Programma 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 byte

(programma completo, a differenza dell'altra risposta Perl che è solo una funzione)

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

49 in funzione

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

Clojure - 23 caratteri

Come una funzione anonima:

#(apply = (map sort %))

Esempio di test case:

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

JavaScript

Basato sulla soluzione di @ zzzzBov.

Confronto, 65 caratteri (40 senza funzione)

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

Comparatore, 43 caratteri

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

C ++ (104 caratteri non-ws)

Basato sul conteggio dell'ordinamento. Nota: presuppone stringhe della stessa lunghezza, che sembrano implicite (sebbene non dichiarate) dalla domanda.

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 (riga di comando, 87 caratteri)

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

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

Javascript

Una versione (molto) leggermente più corta della soluzione di @ zzzzBov, che utilizza al .join()posto del boxe String:

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

Allo stesso modo:

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

Clojure REPL 41 caratteri

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

Giava

(apparentemente la lingua preferita di tutti!)

173 caratteri:

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

(Non stampa il carattere newline per salvare 2 caratteri da println)

Compila ed esegui:

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

Adoro vederne uno più corto ...

sed, 45 caratteri

È persino possibile nel mio preferito - sed! Solo una espressione regolare per risolvere l'anagramma ! Continua a rimuovere le lettere corrispondenti:

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

(da invocare con -nE)

Perl, 48

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

Da invocare con -p.

Funzione Perl, 39

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

APL, 2 caratteri

≡⍦

Questa è la funzione Match multiset di Nars2000 , una delle implementazioni APL all'avanguardia. Quando applicato alle stringhe, calcola esattamente la funzione richiesta:

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

05AB1E , 6 4 byte (non concorrenti)

{I{Q

Provalo online!

Ciò ha richiesto del tempo a causa di difficoltà di input. Abbattuto a causa del pop.

Spiegazione:

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

L'I / O del problema non è ben specificato; questo legge due righe da stdin e restituisce true o false a stdout.

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

(Grazie a Tim per 77 -> 75)

Perl, 62 byte

Questa funzione accetta le stringhe come argomenti e restituisce vero o falso.

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

Memorizza i valori ASCII in un array e verifica se uniforma. Incrementi per la prima parola e decrementi per la seconda parola.

Python 3, 107 97 76 64

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

Ovviamente questo può essere abbreviato se non prendiamo letteralmente le parole del PO e minuscole "vero" e "falso" ...

Python, 32 byte

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

Bash, 88 caratteri

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

R , 54 byte

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

Provalo online!

Scala in REPL (32)

readLine.sorted==readLine.sorted

Scala (43)

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

Programma Scala (61)

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

Questi sfruttano una caratteristica ordinata di Scala in base alla quale una stringa può anche essere trattata come una sequenza di caratteri ( Seq), con tutte le operazioni Seqdisponibili.

APL - 13 caratteri

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

Chiama in questo modo:

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

Nell'ultimo esempio, 'a'rappresenta un singolo carattere e il prefisso ,lo convertirà in una stringa.

Java (134 byte)

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

Ciò crea un array per contare il numero di volte in cui appare ciascuna lettera, quindi confronta gli array per verificare che siano uguali.

JavaScript, 41

Funzione di confronto (41) :

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

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

Funzione comparatore (21) :

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

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

Funzione comparatore (48):

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

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

Funzione di confronto (78):

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

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

Presuppone Stringha splite Arrayha sort.