挑战

给定两个字符串，算出它们中是否都具有完全相同的字符。

例

输入值

单词，wrdo

true之所以返回，是因为它们相同，但只是被打乱了。

输入值

单词，写

这返回false。

输入值

船，鸟羽

这返回 true

规则

这是规则！

• 假设输入将至少为1个字符长，并且不超过8个字符。
• 没有特殊字符，只有a–z
• 所有输入都可以假定为小写

测试用例

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个字节

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

Golfscript，3个字符？

$$=

用法：

'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

-:&(/:~)

从字面上看，将（-:）上的（&）匹配（/:~）

样品使用：

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

64位整数在哪里起作用？

的Javascript，192个 157 152 147 125字节

好的，其中一些语言比我想象的要灵活得多！无论如何，这是我猜测的较长方法，但至少是另一种方法。

压缩的

感谢Peter和David挤出更多的字符！

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}

然后做：

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

扩展代码

压缩程序已经发生了很多变化，但这是基本理论：

// 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个字节

这定义了一个称为 A

{$\$=}:A

测试用例

;
'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个字节

功能-31

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

程序-81 58 55

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

用法：

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

Lambdabot的荣誉及其无点重构。

C＃，129个字符

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

可读性：

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

Ruby，34个字节

使用Peter Taylors Perl解决方案的IO方案：

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

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个字节

（完整的程序，不同于其他Perl答案，后者只是一个功能）

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

49个功能

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

Clojure-23个字符

作为匿名函数：

#(apply = (map sort %))

测试用例示例：

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

的JavaScript

基于@zzzzBov的解决方案。

比较，65个字符（40个不带功能）

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

比较器，43个字符

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

C ++（104个非ws字符）

基于计数排序。注意：假定长度相同的字符串，该字符串似乎由问题暗示（尽管未说明）。

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（命令行，87个字符）

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

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

Java脚本

@zzzzBov解决方案的（非常）短一点的版本，它使用.join()而不是String boxing：

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

类似地：

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

Clojure REPL 41个字符

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

爪哇

（显然每个人都喜欢的语言！）

173个字符：

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

（不打印换行符以从println中保存2个字符）

编译并运行：

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

喜欢看一个较短的...

sed，45个字符

在我最喜欢的地方-甚至有可能sed！只需一个正则表达式即可解决字谜！只需继续删除相应的字母：

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

（由调用-nE）

Perl，48岁

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

与一起调用-p。

Perl函数，39

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

APL，2个字符

≡⍦

这是Nars2000的Multiset Match函数，它是最先进的APL实现之一。当应用于字符串时，它将精确计算所需的函数：

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

05AB1E，6 4个字节（非竞争）

{I{Q

在线尝试！

由于输入困难，花了一段时间。由于流行而打高尔夫球。

说明：

{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个字符

问题的I / O指定不充分；这将从stdin读取两行，并将true或false输出到stdout。

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

（感谢Tim的77-> 75）

Perl，62个字节

此函数将字符串作为参数，并返回true或false。

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

将ASCII值存储在数组中，并检查其是否均匀。第一个单词递增，第二个单词递减。

Python 3、107 97 76 64

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

显然，如果我们不按字面意思采用OP的措词，而将小写的“ true”和“ false”小写，则可以缩短此时间...

Python，32个字节

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

重击，88个字符

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

R，54个字节

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

在线尝试！

REPL中的Scala（32）

readLine.sorted==readLine.sorted

Scala功能（43）

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

Scala程序（61）

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

它们利用了Scala的简洁功能，即字符串也可以被视为字符序列（Seq），并且所有操作Seq都可用。

APL-13个字符

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

像这样打电话：

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

在最后一个示例中，'a'代表一个字符，前缀,会将其转换为字符串。

Java（134字节）

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

这使数组可以计算每个字母出现的次数，然后比较数组以检查它们是否相等。

JavaScript，41

比较功能（41）：

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

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

比较器功能（21）：

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

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

比较器功能（48）：

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

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

比较功能（78）：

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

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

假设String有split和Array有sort。