如果每个字符串的字符出现相同的次数并且至少出现两次，那么我们说该字符串是不歧视的。

例子

• "aa!1 1 !a !1"是非歧视性的，因为每个字符 ，!，a和1出现三次。
• "abbaabb"是不是 不歧视的，因为b往往会出现a。
• "abc"也不会造成 歧视，因为字符不会出现至少两次。

任务

写一个非歧视性的程序或函数返回一个truthy如果给定的字符串值，非歧视的和falsy否则值。

也就是说，以自己的源代码运行的程序应返回真实值。

每个提交都必须能够处理包含可打印ASCII的非空字符串，以及出现在提交源代码中的所有字符。

测试用例

真相：

<your program's source code>
"aaaa"
"aa!1 1 !a !1"
"aabbccddeeffgg"
"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW<P)l}WP>F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E<OFwX(;@yu]+z7/pdqUD"

虚假：

"a"
"abbaabb"
"abc"
"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX<S/OA7NtB'}c u'V$L,YlYp{#[..j&gTk8jp-6RlGUL#_<^0CCZKPQfD2%s)he-BMRu1n?qdi/!5q=wn$ora+X,POzzHNh=(4{m`39I|s[+E@&y>"

Brachylog，10个字节

=ᵍbᵐbᵐlᵍ=l

在线尝试！

说明

=ᵍ                Group all equal elements together
  bᵐbᵐ            Remove the first element of each group twice. This fails if
                  there are fewer than 2 elements
      lᵍ          Group elements together that have the same length
        =         Are all elements of that list equal? This only succeeds if the
                  list has one element
         l        Length. This will always succeed

Java 8，198 192 186 174 168 165 160字节（字符数6 5）

o->{byte x[]=new byte[+333-3|2],u=-0,i,fe,fi,w; s:w:no0r3sswwyyy:for(int s:o){{u=++x[s];}};for(int b:x){if(!!!(2>b||u==b)|2>u|2>2){x[0]++;}}return!!(0>--x[0]);}

在线尝试。
用来验证字符出现的代码，这是我应对这一挑战的答案。

-5字节再次感谢@OlivierGrégoire，因为它摆脱了注释并弄得一团糟。;）

旧的168个字节（字符计数6）答案：

o->{int w[]=new int[2222],u=0,f=0;for(int r:o)u=++w[r];for(int e:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]]  !!!!e(i)++,,,,-----oo////000tuww::::{{{{{;;||||}}}}}>>

在线尝试。
用来验证除注释之外的字符的出现的代码，这是我对这一挑战的回答。

-6个字节，感谢@OliverGrégoire<通过将支票换成来删除>。

基本高尔夫程序的说明（98字节）：
在线尝试。

s->{                     // Method with character-array parameter and boolean return-type
  int a[]=new int[256],  //  Occurrences integer-array containing 256 zeroes
      t=0,               //  Temp integer, starting at 0
      f=0;               //  Flag integer, starting at 0
  for(int c:s)           //  Loop over the input
    t=++a[c];            //   Increase the occurrence-counter of the current character
                         //   And set the temp integer to this value
  for(int i:a)           //  Loop over the integer-array
    if(i>1               //   If the value is filled (not 0) and at least 2,
       &i!=t             //   and it's not equal to the temp integer
       |t<2)             //   Or the temp integer is lower than 2
      f++;               //    Increase the flag-integer by 1
  return f<1;}           //  Return whether the flag integer is still 0

我做了一些减少字符使用量的事情：

• 变量名o，w，u，f，r，和e被选择的目的，我们已经不得不重新使用的字符（但不超过6）。
• 2222用于代替256。
• 改变了，如果检查e>0&u!=e|u<2到!(e<2|u==e)|u<2，除去6倍&。
• 删除了两倍地分居的回报和使用的标志f，我们返回是否仍为0到底（这意味着我可以删除6X by从byte现在我们只用n在int6次，而不是8）。
• e<2并u<2更改为2>e和2>u删除6x <。

我为减少字符数6到5所做的事情：

• 2倍int，byte因此使用量n是4而不是6。
• 使用x[0]而不是新变量，f=0因此使用的数量=是5而不是6。
• 更改2222为，3333因此使用量2为2而不是6。
• 更改了变量f，r再次更改为6。

@OlivierGrégoire为摆脱评论而做了什么，因此摆脱了5x /：

• 添加未使用的变量,i,fe,fi,w;。
• 添加未使用的标签：s:w:no0r3sswwyyy:。
• 添加未使用的 |2>2
• {}在for循环和ifs周围添加，并添加未使用的{}-block。
• 更改!为!!!。
• 更改|为||。
• 更改333为+333-3|2摆脱剩余的算术运算符+-|和2。
• 更改!(x[0]>0)为!!(0>--x[0])。

果冻，18 16 12 10字节

Ġ¬zḊḊ¬zĠȦȦ

在线尝试！

这个怎么运作

Ġ¬zḊḊ¬zĠȦȦ  Main link. Argument: s (string)

Ġ           Group the indices of s by their corresponding elements.
            "abcba" -> [[1, 5], [2, 4], [3]]

 ¬          Take the logical NOT of each 1-based(!) index.
            [[1, 5], [2, 4], [3]] -> [[0, 0], [0, 0], [0]]

   Ḋ        Dequeue; yield s without its fist element.
            "abcba" -> "bcba"

  z         Zip-longest; zip the elements of the array to the left, using the
            string to the right as filler.
            ([[0, 0], [0, 0], [0]], "bcba") -> [[0, 0, 0], [0, 0, "bcba"]]

    Ḋ       Dequeue; remove the first array of the result.
            This yields an empty array if s does not contain duplicates.
            [[0, 0, 0], [0, 0, "bcba"]] -> [[0, 0, "bcba"]]

    ¬       Take the logical NOT of all zeros and characters.
            [[0, 0, "bcba"]] -> [[1, 1, [0, 0, 0, 0]]]

      Ġ     Group.

     z      Zip-longest. Since all arrays in the result to the left have the same
            number of elements, this is just a regular zip.
            [[1, 1, [0, 0, 0, 0]]] -> [[1], [1], [[0, 0, 0, 0]]

       Ȧ    Any and all; test if the result is non-empty and contains no zeroes,
            at any depth. Yield 1 if so, 0 if not.
            [[1], [1], [[0, 0, 0, 0]] -> 0

        Ȧ   Any and all.
            0 -> 0

Brachylog，14 12字节

ọtᵐℕ₂ᵐ==tℕ₂ọ

在线尝试！

说明

ọ   Occurrences. Gives a list of [char, count] pairs for the entire input.
tᵐ  Map "tail" over this list, giving each character count.
ℕ₂ᵐ Make sure that each count is at least 2.
=   Make sure that all counts are equal.
    At this point we're done with the actual code, but we need another copy
    of each character (except ᵐ). We can just put them after this, as long as
    we make sure that they can never cause the predicate to fail.
=   Make sure that all counts are equal, again...
t   Extract the last count.
ℕ₂  Make sure that it's at least 2, again...
ọ   Get the digit occurrences in that count, this can't fail.

可重用的替代12字节解决方案，t而不是ᵐ：

ọtᵐ==tℕ₂ℕ₂ọᵐ

T-SQL，320个字节（32个字符x每个10个字符）

根据我们的IO标准，通过FILL带有varchar字段的预先存在的表进行输入。STEW

WITH BUMPF AS(SeLeCT GYP=1
UNION ALL
SeLeCT GYP+1FROM BUMPF
WHeRe GYP<=1000)SeLeCT
IIF(MIN(WAXBY)<MAX(WAXBY)OR
MAX(WAXBY)<=1,+0,+1)FROM(SeLeCT
WAXBY=COUNT(1),WHICH=+1+0,HEXCHANGE=+01,HUNG=+0+1,CHLUB=+0,GEFF=+0FROM
BUMPF,FILL WHERE
GYP<=LEN(STEW)GROUP BY
SUBSTRING(STEW,GYP,1))CHEXX
OPTION(MAXRECURSION 0)----------<<<<<<

一段代码使我从未感到如此高兴，却感到震惊。

必须在设置为区分大小写的排序规则的服务器或数据库上运行。共有32个不同的字符，每个有10个，包括大写和小写E（SQL命令不区分大小写，因此需要根据需要翻转一些），空格和制表符（为了便于阅读，制表符在上面的代码中显示为换行符）。

我找到+ = ,了在代码中包含10个其他符号的方法，但不幸的是找不到这种方法<，因此我不得不添加注释字符-。

这是在我塞满所有其他填充符之前的格式化代码：

WITH b AS (SELECT g=1 UNION ALL SELECT g+1 FROM b WHERE g<1000)
SELECT IIF(MIN(w)<MAX(w) OR MAX(w)<1+1,0,1)
FROM(
    SELECT w=COUNT(1), --extra constant fields here are ignored
    FROM b, fill
    WHERE g < 1+LEN(stew)
    GROUP BY SUBSTRING(stew,g,1)
)a OPTION(MAXRECURSION 0)

第一行是一个递归CTE，它生成一个数字表b，我们将其连接到源字符串以按字符分隔。这些字符被分组并计数，并且该IIF语句返回0或1，具体取决于输入字符串是否是非歧视性的。

C（gcc）， 333168 字节

感谢@Kevin Cruijssen保存9个字节，感谢@Laikoni保存45个字节！

f(r,h,a){char*o=r,c[222]={!o};for(a=!o;*o;)++c[*o++];for(h=!o;222/++h;c[h]&&c[h]!=a&&(a=!*c))!a&&c[h]&&(a=c[h]);r=!(2/2/a);}/////!(())****++,,,,,[[]]fffffrr{{{{{{}}}}}}

在线尝试！

C，333字节

i,v;f(S){char*s=S,L[128]={0};for(v=0;*s;)++L[*s++];for(i=-1;++i<128;L[i]&&L[i]-v?v=-1:0)!v&&L[i]?v=L[i]:0;return-v<-1;}/////////!!!!!!!!&&&&&(((((())))))******+++,,,,,,,----00000111122222228888888:::::::<<<<<<<===???????LLLSSSSSSS[[[]]]aaaaaaaacccccccceeeeeeeeffffffhhhhhhhhiinnnnnnnnooooooorrrrssssssttttttttuuuuuuuuvv{{{{{{{}}}}}}}

甚至字节数也没有区别！

在线尝试！

05AB1E，20 18 16 14字节

S¢Z≠sË*sZ¢≠SË*

在线尝试！

该程序基本上分为两部分，其中第一部分的目标是执行实际的任务，而第二部分的目标是使用与第一部分相同的功能而不改变结果。

说明（第一部分）

S          # push input split into list of chars
 ¢         # count the occurrence of each char in input
  Z≠       # check that the max count is not 1
    sË     # check if all counts are equal
      *    # multiply

说明（第二部分）

s          # swap input to top of stack
 Z¢        # count the number of occurrences of the largest element
   ≠       # check that the count isn't 1
    SË     # split into list and check that each element are equal (always true)
      *    # multiply (as it is with 1, the original result is left unchanged)

外壳，14个字节

§<ε#εu§m#u
m
<

在线尝试！

说明

两条短线是无操作的，因为main函数从不调用它们。

§<ε#εu§m#u  Implicit input, say S = "asasdd"
         u  Remove duplicates: "asd"
      §m#   For each, get number of occurrences in S: [2,2,2]
     u      Remove duplicates: L = [2]
   #ε       Number of elements in L that are at most 1: 0
  ε         1 if L is a singleton, 0 otherwise: 1
§<          Is the former value smaller than the latter?

Python 2中，75 69个字节

def f(s):len({2<<s.count(c)-2for c,in s})<2or{{e.dil:-tu,r.dil:-tu,}}

通过存在或不存在错误进行输出。错误可能是ValueError（一个或多个字符仅出现一次）或NameError（字符计数不相等）。

在线尝试！

Brachylog v2，8个字节（使用Brachylog的字符集）

oḅ\k\koḅ

在线尝试！

看起来在Brachylog上，这个问题一直在打一场高尔夫大战，所以我想我会加入，在下一个最佳答案上节省几个字节。

这是一个完整的程序，将输入作为字符代码列表。（部分原因是Brachylog似乎存在一些与字符串中的反斜杠有关的异常怪异的错误，部分原因是该\命令不适用于字符串列表。）

说明

oḅ\k\koḅ
o          Sort {standard input}
 ḅ         Group identical adjacent values
  \        Assert rectangular; if it is, swap rows and columns
   k       Delete last element
    \      Assert rectangular; (rest of the program is irrelevant)

所述koḅ在端部是不相关的; k将始终具有要操作的元素，o并且ḅ如果给出列表作为输入，则不会失败。

开始的原因oḅ应该很清楚；它将输入列表按值划分，例如[1,2,1,2,4,1]将变为[[1,1,1],[2,2],[4]]。为了使每个字符出现相同的次数，这些列表中的每个列表必须具有相同的长度，即结果列表为矩形。我们可以使用来声明此矩形性\，这也将行和列作为转置而产生副作用。

现在，我们有了一个由字符集的多个副本组成的当前值，例如，如果输入为[4,2,1,2,4,1]当前值，则为[[1,2,4],[1,2,4]]。如果我们删除副本，则生成的矩阵仍为矩形，因此可以使用将其转回\。然而，如果基质是矩形的原因是所有输入的字符是不同的，所得到的矩阵将没有留下的元件，并且\也未治疗“0×0”矩阵为矩形（更确切地说，它失败）。因此oḅ\k\有效地断言输入中出现的每个字符出现的次数相同，而该次数不是1。

那就是我们程序的全部功能（作为一个完整的程序，true如果没有断言失败发生，false如果有断言失败，我们得到）。我们必须服从源布局的限制，虽然，所以我加了一个附加koḅ有没有用，而且不能失败（不像\，o并ḅ高兴地作用于空列表）。

Python 2中，84 80个字节

x=input()
c=map(x.count,x)
print max(c)==min(c)>1
1. or our>ram>>utopia,
1., 1.,

在线尝试！

JavaScript（Node.js），144 ... 100 96字节

o=>!(a=o.split``.map(i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1)).some(g=>![g>1][-!1]||a[-!1]-g)

在线尝试！

24个不同的字符*每次6次

28个不同的字符*每个5次

27个不同的字符*每个5次

27个不同的字符*每次4次

26个不同的字符*每次4次

25个不同的字符*每次4次

24个不同的字符*每次4次

说明

o=>!(
 a=o.split``.map(                            // Split the input into character array and
  i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1 // count the occurrences of each character.
 )
).some(                                      // Then check
 g=>![g>1][-!1]                              // If each character appears at least twice
 ||a[-!1]-g                                  // and the counts are all the same number.
)                                            

More to add:
1. Using {s.split``} instead of {[...s]} is to reduce the number of {.} that dominates
   the count.
2. Using {!c.some} instead of {c.every} to reduce the number of inefficient characters 
   (v,r,y in every)
3. Still one unavoidable inefficient character left ({h}).

Update:
1. Got rid of one {.} by replacing {.length} by {["length"]}.
2. Got rid of one {=} by replacing {c[-!1]!=g} by {c[-!1]-g}.
3. Got rid of one {()} by replacing {!(g>1)} by {![g>1][-!1]}.
4. Finally, because count per character is now 4, the backslashes can be taken out.

Update:
1. Got rid of all {"} by replacing {"length"} by {`length`} and exploiting shortcut
   evaluation. 
   {aaaeehhhlmmnnnpst} is not defined but is not evaluated either because of {c} which
   must be evaluated to true.

Update:
1. Got rid of all {c} by shortcutting the undefined variable at {split(i)} and replacing 
   all {c} by {a}.
   Since {i} is never an empty string, it is always evaluated true (except compared 
   directly to true).

Update:
1. Got rid of all {,} by moving the assignment after the argument list. The {()} at the
   front can therefore be moved to the assignment, retaining same number of {()}s.

的PowerShell，104字节

($qe=$args[0]| group |sort count|% count)[0]-eq$qe[-1]-and$qe[0]-gt1####((()))%%%pppddd===aaccss11nu|0gr

在线尝试！

高尔夫很有趣。限制是$，我们最少需要四个（输入$args一个，分配计算结果的$qe一个，检查最后一个字符的$qe[-1]一个，检查第一个字符的一个$qe[0]，所以这是最大工作字符数）。

从那里开始，打高尔夫球（而不是打高尔夫球，就像有一个两个字母的变量名）就可以使程序很好地被四除。请注意，我们有一条简短的注释（后面的所有内容#）来说明缺少的一些元素，但是我尝试使注释尽可能小。

Haskell，90 75 72字节

a[i]|d:n<-[[i|n<-i,n==a]|a<-i]=and[[i]<d,[d|i<-n]==n]--aadd,,,,:::::<=||

每个字符出现6次。输入的字符串作为单例列表。

在线尝试！

作为参考，旧版本：

75个字节，每个字符5次

n(l)|d<-[[0|n<-l,n==a]|a<-l]=and[[0]<d!!0,all(==d!!0)d]--an!((())),,,0<[]||

在线尝试！

90个字节，每个字符3次：

a x|h:u<-[sum[1|d<-x,not(d/=c)]|c<-x],"  \"\\&,../1::>acdlmmnosst">[]=h>1&&all(not.(/=h))u

在线尝试！

Python 2中，108个 104 92 88字节

-12字节归功于Rod
-4字节归功于Kevin Cruijssen

s=input();c=s.count;print[all(c(s[[]>[1]])==c(o)>1. for o in s)];aaafffillpprrtuu>1.>1.;

在线尝试！

MATL，12字节

q&=sqt&=tsvv

输入是用单引号引起来的字符串。字符串中的单引号通过重复进行转义。

输出是一个非空的矩阵，这是truthy，如果它不包含零，并且是falsy它是否包含至少一个为零。

在线尝试！或者，为了方便起见，请验证所有测试用例，包括标准的真假测试。

这个怎么运作

标(*)有的声明既没有必要也没有害处，并且仅包括在内是为了使源代码具有非歧视性。

q     % Implicit input. Convert chars to code points and subtract 1 from each (*)
&=    % Square matrix of all pairwise equality comparisons
s     % Sum of each column. Gives a row vector
q     % Subtract 1 from each value. An entry equal to 0 indicates the input string
      % is discriminating because some character appears only once
t     % Duplicate
&=    % Square matrix of all pairwise equality comparisons. An entry equal to 0
      % indicates the input string is discriminating because some character is
      % more repeated than some other
t     % Duplicate (*)
s     % Sum of each column (*) (all those sums will be positive if the previous
      % matrix doesn't contain zeros)
v     % Vertically concatenate the matrix and the vector of its column sums
v     % Vertically concatenate the resulting matrix with nothing (*)
      % Implicit display

Perl 5中，-p57个字节

每个字符出现3次。只有一个1人什么都不做

在基本的45个字符的解决方案中增加了12个字节，以实现不歧视

s{.}[@m[@1{$&}+=$.].=g]eg;$\=s()(e@m;1)&&m[e(\sg+)\1+;]}{

在线尝试！

R，90字节

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{y<-xtabs(~?readLines())}%in%{z<-y[1]}&z>T##&[]>~48bEfILpu

在线尝试！

输出TRUE一个非歧视性的字符串，FALSE为区分字符串。我已经在该网站上编写了很多丑陋的代码来应对挑战，但是我认为这是迄今为止最丑陋的代码。

45个字符，每个字符使用两次（包括注释中的一些字符）。先前的最佳R答案是116个字节，每个29个字符使用4次。我将其单独发布，因为它有很大不同。

该代码等效于

y = table(utf8ToInt(readLines()))
z = y[1]
all(y == z) & (z > 1)

它将输入转换为整数向量，计算y值的列联表，然后检查该表中的所有计数是否等于第一个计数，并且第一个计数大于1。

最初的困难是仅使用2对括号。这是通过重新定义一元函数!和?to utf8ToInt和be来实现的prod。（我不能使用，all因为我需要a）。共有四个分配：两个带有=和，两个带有<-。这意味着y和之间z不能使用y==znor 进行相等性测试y-z；y%in%z来救援。

定义这些功能会用尽所有可能的引号：两个双引号，两个单引号，并且在下一段中我将需要两个反引号，因此我不得不求助于readLines()而不是scan(,"")。（其他选项，例如scan(,letters)或scan(,month.abb)全部使用了t 我无法幸免的珍贵。）

在这一点上，我才是最积木：utf8ToInt，prod，table，readLines，%in%。在这些名称中，三个字符出现了3次：ent。首先，我发现这table(foo)等效于xtabs(~foo)保存e。我可以使用十六进制/八进制代码技巧来拯救nand the ; 最高尔夫的解决方案是使用（反引号）。tu\164f8ToI\x6Etutf8ToInt

Brachylog，18个字节

oḅlᵐ=h≥2
oḅlᵐ=h≥2

在线尝试！

不幸的是，我无法删除换行符，因为ḅ数字触发失败。

红宝石，87 78字节

c=->m{y=m.chars;x=y.map{|d|y.count d}|[];x[-1]>1and not x[1]};->{pushrortpush}

26个字符，每个重复3次

在线尝试！

R，132116字节

crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;"";{1<{f<<-table(strsplit(b,"",,,)[[1]])}}&&!!!sd(-f)}}

它也不包含任何注释或多余的字符串，尽管这可能是我在代码高尔夫中唯一一次调用function的时间crudcardounenforceableuploads。函数名称中可能有一个很棒的七字谜！感谢约翰·德沃夏克（John Dvorak）指出了一个很好的字谜解算器，我用它来命名。

字符表：

- , ; ! " ( ) [ ] { } & < 1 a b c d e f i l n o p r s t u 
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4

例子：

> crudcardounenforceableuploads("aaabbbccc")
[1] TRUE
> crudcardounenforceableuploads("aaabbbcc")
[1] FALSE
> crudcardounenforceableuploads("abc")
[1] FALSE
> crudcardounenforceableuploads("crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;\"\";{1<{f<<-table(strsplit(b,\"\",,,)[[1]])}}&&!!!sd(-f)}}")
[1] TRUE

BASH 144字节

grep -o .|sort|uniq -c|awk '{s=$1}{e[s]=1}END{print((s>1)*(length(e)==1))}##>>>#|'#wwwuuutrqqqppooNNNnlllkkkiihhhggEEEDDDcccaaa1***{}[[[]]]...--''

此行代码将stdin字符串作为输入。“ grep -o。” 将每个字符放在新行上。“ uniq -c”计算每个角色的使用情况。awk脚本创建一个数组，每个用法都作为一个不同的元素，并在只有1个数组索引且值至少为2时输出true，每个字符使用4次，因此此源返回true

Stax，26 24 18字节

:u{m*_{y#m:u_hy#h*

在线尝试！

迄今为止最短的解决方案，仅使用由MATL 打败的可打印ASCII。

猜猜我是错误地解决了这个问题。重复一个工作块既不打高尔夫球也不有趣。现在至少看起来更好了...

说明

:u{m* 产生一些不影响输出的垃圾。

_{y#m:u_hy#h*
_{y#m           map each character to its number of occurences in the string
     :u         all counts are equal (result 1)
       _hy#     get the count of appearance for the first character
           h    halve it and take the floor, so that 1 becomes 0(result 2)
            *   multiply the two results

点，22字节

I1&MY$=_Y_NaMa$=y&1NIy

在线尝试！

说明

每个字符出现两次。

                        a is first command-line argument
I1&MY$=_                No-ops to make the program non-discriminating
            Ma          Map this function to the characters of a:
         _Na             Count occurrences of each character in a
        Y               Yank the result into y
              $=y       Fold y on equals: truthy if all elements are equal
                 &      Logical and
                  1NIy  1 is not in y
                        Autoprint the result of the last expression

备用22字节版本，其无操作次数较少：

$&MY_Y_NaMa$=y&--1=1Ny

SmileBASIC，164 152 148 140个字节

DeF M(X)DIM W[#R]WHILE""<X
INC w[ASC(x)]X[n]=""wEND
FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U<MAx(W)neXT-!!!AASSS#&&Oxx||CCLL<<wIM#
RETURN!H
enD

35个不同的字符，每个字符重复4次。

没有使用任何注释（但之后的表达式neXT从未被实际求值）

检查答案的脚本：

//javascript is a convenient language that I love using!
var input=document.getElementById("input");
var button=document.getElementById("button");
var output=document.getElementById("output");

button.onclick=function(){
  var text=input.value;
  var freqs={};
  for(var i=0;i<text.length;i++){
    var letter=text.charAt(i);
    if (freqs[letter]==undefined) freqs[letter]=0
    freqs[letter]++
  }
  sorted=Object.keys(freqs).sort(function(a,b){return freqs[b]-freqs[a]})
  var out="";
  var min=Infinity,max=0;
  for (var i in sorted) {
    var letter=sorted[i];
    var count=freqs[letter];
    if(count<min)min=count;
    if(count>max)max=count;
    out+="\n"+letter+":"+count;
  }
  output.textContent="min:"+min+"\nmax:"+max+"\nunique:"+sorted.length+"\nlength:"+text.length+out;
}

<textarea id="input" placeholder="code here"></textarea>
<button id="button"butt>count</button>
<pre id="output">...</pre>

视网膜0.8.2，168个 90字节

如果为false，则输出为空；如果为true，则输出为非空。

***???;;;;```!!$$$$MMMMOOOO..1111ssss222{{{{\^^^^

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

在线尝试

核心程序（39字节）

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

说明

整个核心程序处于静默循环中。第一阶段对输入进行排序。如果它由连续的不同字符对组成，则第二阶段将打印当前字符串。第三阶段删除每个字符的最后一次出现（删除字符串中每个字符的一个）。

关于顶部的垃圾：顺序很重要。除了需要在语法上有效之外，分号必须位于星号之后和反引号之前，只要*它在配置字符串中，就不能打印。

的CoffeeScript 1，96 93 90个字节

(q,a=q.split(h).length-1for h in[q][0])->a.every (w,s,pplitnggffoorsvvyy)->w>1&&a[0&10]==w

在线尝试！

从我的ES6答案开始，但回到使用Array.every。32 31 30个令牌，每个3个

Pyth，30个字节

  "&8<MQSlqr{"&q1lJ{hMrSz8<1hJ

前导空格是必需的。

在线尝试！

实际的程序是公正的&q1lJ{hMrSz8<1hJ。我只是在字符串的前面加上了前缀"&8<MQSlqr{"以使其不歧视。但是要使字符串本身不打印，我必须添加一个空格，所以我添加了2个空格。

&q1lJ{hMrSz8<1hJ

 q1l                (1 == len(
    J{                  J = deduplicate(
      hM                  map(lambda a: a[0],
        r  8                length_encode(
         Sz                   sorted(input())
                            )
                          )
                        )
                    )
&                     and
            <1hJ    (1 < J[0])

length_encode这里（r <any> 8）取一个序列，并输出相同字符的每次运行的长度，例如。"aaabbcc"成为[[3, "a"], [2, "b"], [2, "c"]]。

因此，这将接受输入，对其进行排序以进行长度编码，并在结果列表中获取每个列表的第一个元素（例如，前面的示例将变为[3, 2, 2]）。这样就可以计算出字符出现的次数。然后将其删除重复数据（前面的示例将变为[3, 2]），并将J设置为该值。

然后，它检查长度是否为1，即一个字符出现的唯一次数为1，并且是否大于1，即> = 2。

可能有内置的替代品，rSz8或者hMrSz8我找不到。

C（gcc），153字节

f(h,a,c,f){{{{{{{char*o=f=h,*r;for(a=!h;*o;o++){for(c=!h,r=h;*r;c+=!(*r++^*o)){}f*=!!(c^!!h)*(!a+!(a^c));a=c;}(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;(a=f);}}}}}}}

在线尝试！

以真值返回字符串的地址，以假值返回零。

f(
h,                              Address of string.
a,                              # instances of previous character
c,                              # instances of current character
f                               Return value
){{{{{{{                        
char*o=f=h,*r;                  Point o to string, while giving f a non-zero value.
for(a=!h;*o;o++){               Set previous char count to 0, and then traverse the string.
for(c=!h,r=h;*r;                Set current char count to 0 and r to string,
                                and start counting instances of current character.
c+=!(*r++^*o))                  Add to counter if current character matches.
{}                              Lower the amount of semi-colons
f*=                             Multiply (AND) return value with:
   !!(c^!!h)                    Is current count not 1? (Must be 2 or above.)
            *(!a+!(a^c));       AND, is previous count valid (meaning this is not the first
                                character counted), and matches current count?
a=c;}                           Previous count = current count.
(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;  Spend surplus characters to make source code valid.
(a=f);}}}}}}}                   Return value.

Perl 6的，58 57个字节

{.max==.min>()**()}o{(bag .comb){*}}###=>>abccggiinnoxx  

在线尝试！

原来，三个字符的版本比两个字符的版本稍短。