Herausforderung

Berechnen Sie bei zwei gegebenen Zeichenfolgen, ob beide genau die gleichen Zeichen enthalten.

Beispiel

Eingang

Wort, wrdo

Dies kehrt zurück, trueweil sie gleich sind, aber nur verschlüsselt.

Eingang

Wort, wwro

Dies kehrt zurück false.

Eingang

Boot, toba

Dies kehrt zurück true

Regeln

Hier sind die Regeln!

• Angenommen, die Eingabe ist mindestens 1 Zeichen lang und nicht länger als 8 Zeichen.
• Nur keine Sonderzeichen a-z
• Alle Eingaben können als Kleinbuchstaben angenommen werden

Testfälle

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 Zeichen?

$$=

Verwendungszweck:

'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 ( /:~)

Beispielgebrauch:

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

Wo kommen die 64-Bit-Ganzzahlen ins Spiel?

Javascript, 192 157 152 147 125 Bytes

Ok, einige dieser Sprachen sind viel flexibler als ich dachte! Auf jeden Fall ist dies der längere Weg, aber zumindest eine andere Technik.

Komprimiert

Vielen Dank an Peter und David, die mehr Zeichen herausgedrückt haben!

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}

Dann mach:

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

Erweiterter Code

Das komprimierte hat viele Änderungen gehabt, aber das ist die Grundtheorie:

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

Dies definiert eine aufgerufene Funktion A

{$\$=}:A

Testfälle

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

Funktion - 31

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

Programm - 81 58 55

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

Verwendungszweck:

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

Ein großes Lob an Lambdabot und seine sinnlose Umgestaltung .

129 Zeichen

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

Lesbar:

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

Ruby, 34 Bytes

Verwenden des IO-Schemas der Peter Taylors Perl-Lösung:

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

C-Programm, 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

(komplettes Programm, im Gegensatz zu der anderen Perl-Antwort, die nur eine Funktion ist)

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

49 als Funktion

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

Clojure - 23 Zeichen

Als anonyme Funktion:

#(apply = (map sort %))

Testfallbeispiel:

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

JavaScript

Basierend auf der @ zzzzBov-Lösung.

Vergleich, 65 Zeichen (40 ohne Funktion)

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

Komparator, 43 Zeichen

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

C ++ (104 Nicht-WS-Zeichen)

Basierend auf der Zählart. Hinweis: Es wird von Zeichenfolgen gleicher Länge ausgegangen, was von der Frage impliziert (wenn auch nicht angegeben) zu sein scheint.

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 (Befehlszeile, 87 Zeichen)

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

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

Javascript

Eine (sehr) etwas kürzere Version der @ zzzzBov-Lösung, die .join()anstelle von String-Boxing verwendet:

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

Ähnlich:

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

Clojure REPL 41 Zeichen

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

Java

(Offenbar die Lieblingssprache aller!)

173 Zeichen:

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

(Gibt kein Zeilenumbruchzeichen aus, um 2 Zeichen von println zu sparen.)

Kompilieren und ausführen:

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

Ich liebe es, einen kürzeren zu sehen ...

sed, 45 Zeichen

Es ist sogar in meinem Favoriten möglich - sed! Nur ein regulärer Ausdruck, um das Anagramm zu lösen ! Entferne einfach die entsprechenden Buchstaben:

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

(aufzurufen mit -nE)

Perl, 48

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

Aufruf mit -p.

Perl-Funktion, 39

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

APL, 2 Zeichen

≡⍦

Dies ist die Multiset Match- Funktion von Nars2000 , einer der führenden APL-Implementierungen. Wenn es auf Zeichenfolgen angewendet wird, berechnet es genau die erforderliche Funktion:

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

05AB1E , 6 4 Bytes (nicht konkurrierend)

{I{Q

Probieren Sie es online!

Dies dauerte aufgrund von Eingabeschwierigkeiten eine Weile. Golf wegen Pop.

Erläuterung:

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

Die E / A des Problems sind nicht genau angegeben. Dies liest zwei Zeilen von stdin und gibt true oder false an stdout aus.

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

(Danke an Tim für 77 -> 75)

Perl, 62 Bytes

Diese Funktion nimmt die Zeichenfolgen als Argumente und gibt true oder false zurück.

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

Speichert die ASCII-Werte in einem Array und prüft, ob sie ausgeglichen sind. Inkremente für das erste Wort und Dekremente für das zweite Wort.

Python 3, 107 97 76 64

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

Offensichtlich kann dies verkürzt werden, wenn wir den Wortlaut des OP nicht wörtlich und in Kleinbuchstaben "wahr" und "falsch" nehmen ...

Python, 32 Bytes

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

Bash, 88 Zeichen

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)

Probieren Sie es online!

Scala in REPL (32)

readLine.sorted==readLine.sorted

Skalafunktion (43)

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

Scala-Programm (61)

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

Diese nutzen eine nette Funktion von Scala, mit der ein String auch als Folge von Zeichen ( Seq) behandelt werden kann, wobei alle Operationen Seqverfügbar sind.

APL - 13 Zeichen

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

Rufen Sie wie folgt an:

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

Im letzten Beispiel wird 'a'ein einzelnes Zeichen dargestellt, und das Präfix ,konvertiert es in eine Zeichenfolge.

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

Dadurch wird in einem Array die Häufigkeit gezählt, mit der jeder Buchstabe angezeigt wird. Anschließend werden die Arrays verglichen, um zu überprüfen, ob sie gleich sind.

JavaScript, 41

Vergleichsfunktion (41) :

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

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

Komparatorfunktion (21) :

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

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

Komparatorfunktion (48):

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

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

Vergleichsfunktion (78):

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

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

Angenommen Stringhat splitund Arrayhat sort.