x%3e=y%3e=z的c语言表达式,无差别编程

无差别编程

74

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

例子

"aa!1 1 !a !1"是非歧视性的，因为每个字符，!，a和1出现三次。

"abbaabb"是不是 不歧视的，因为b往往会出现a。

"abc"也不会造成 歧视，因为字符不会出现至少两次。

任务

写一个非歧视性的程序或函数返回一个非歧视的和

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

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

测试用例

真相：

"aaaa"

"aa!1 1 !a !1"

"aabbccddeeffgg"

"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW

F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E

虚假：

"a"

"abbaabb"

"abc"

"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX"

4

@Laikoni我们可以滥用评论来使它起作用吗？

6

作为附带说明，我喜欢在挑战中可以使用其他条目来测试我的条目的有效性。

3

@MagicOctopusUrn我认为他确实在允许的沙箱中说过，因为无法观察到。

11

究竟。即使您以某种方式设法以客观的方式禁止注释，那么未使用的字符串文字又如何呢？无论如何，我认为评分是鼓励尽可能避免发表评论的动力。

4

我知道这只是一个谜，但是将“非歧视”与“存在于完全相同的部分中的所有可识别的带标签成员类型”的混和稍微令人不安。不公平地这样做意味着基于将某人视为与另一类人不同而对他们进行不公平对待或判断。当然，请继续享受乐趣！

Answers:

37

=ᵍ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

25

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

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

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

旧的168个字节(字符计数6)答案：

o->{intw[]=newint[2222],u=0,f=0;for(intr:o)u=++w[r];for(inte:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]] !!!!e(i)++,,,,-----oo000tuww::::{{{{{;;||||}}}}}>>

-6个字节，感谢@OliverGrégoire。

基本高尔夫程序的说明(98字节)：

在线尝试。

s->{// Method with character-array parameter and boolean return-typeinta[]=newint[256],// Occurrences integer-array containing 256 zeroest=0,// Temp integer, starting at 0f=0;// Flag integer, starting at 0for(intc:s)// Loop over the inputt=++a[c];// Increase the occurrence-counter of the current character// And set the temp integer to this valuefor(inti:a)// Loop over the integer-arrayif(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 2f++;// Increase the flag-integer by 1returnf<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])。

@OlivierGrégoire抱歉，我已经是174岁了：)但是，看看您的技巧是否仍然可以应用。

最近的是162个字符(161个字符)。我正在尝试删除评论，但是我仍然需要在地方放置逗号。我只是找不到任何地方。

1

15

果冻，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

13

ọ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ℕ₂ℕ₂ọᵐ

13

T-SQL，320个字节(32个字符x每个10个字符)

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

WITHBUMPFAS(SeLeCTGYP=1UNIONALLSeLeCTGYP+1FROMBUMPFWHeReGYP<=1000)SeLeCTIIF(MIN(WAXBY)

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

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

我找到+ = ,了在代码中包含10个其他符号的方法，但不幸的是找不到这种方法

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

WITHbAS(SELECTg=1UNIONALLSELECTg+1FROMbWHEREg<1000)SELECTIIF(MIN(w)

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

11

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

你可以把它降低到324个字节通过改变两个128以222这样的8能够被丢弃。

1

279个字节通过重命名i，v，S，s并L给已经出现在关键字的字符char，for并且return：网上试试吧！

@Laikoni谢谢！昨天我没有时间正确打高尔夫球。

@MagicOctopusUrn对它们进行排序是因为我懒得手工添加它们。

9

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)

{γ€gDË*P≠qq{γ€gDË*P≠是另一个20;)。

1

@MagicOctopusUrn：太好了！我也有20岁的其他人。我现在也有一个18岁的人：)

2

巫术！没有其他解释！

1

¢...好主意的人，我也很高兴看到≠它像我认为的那样有用哈哈！

9

外壳，14个字节

§

m

<

说明

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

§

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?

但是，“ u”大于“ m”，因此不符合要求。

@WGroleau m也会出现两次：在第一行和第二行。该解释不包括这两行，因为它们不会影响程序的行为。

我猜想OP应该澄清是否可以与该程序一起扫描该程序的说明。但是实际上，如果包含该说明，则您有四个'u'和两个'

没关系; 这使我困惑，就像另一个答案一样。

9

deff(s):len({2<

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

负移位错误技巧很巧妙！我喜欢它如何利用移位运算符的低优先级。

1

{{e.dil:-tu,r.dil:-tu,}} 好主那是什么？

1

@AdamBarnes在语法上有效的乱码，如果被评估，则抛出NameError。

我不明白 我试着换出来a，一切都坏了。您能再解释一下吗？

@AdamBarnes只要您在or。之后留一个空格就可以了。在计算机上时，我将添加一个说明。

9

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并ḅ高兴地作用于空列表)。

7

x=input()c=map(x.count,x)printmax(c)==min(c)>11.orour>ram>>utopia,1.,1.,

+1表示不产生错误的简短Python代码和我们的ram utopia;)

7

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 andi=>o.split(i||aeehhhlmmnnnpst)[`length`]-1// count the occurrences of each character.)).some(// Then checkg=>![g>1][-!1]// If each character appears at least twice||a[-!1]-g// and the counts are all the same number.)Moreto 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.Stillone unavoidable inefficient character left({h}).Update:1.Gotrid of one{.}by replacing{.length}by{["length"]}.2.Gotrid of one{=}by replacing{c[-!1]!=g}by{c[-!1]-g}.3.Gotrid of one{()}by replacing{!(g>1)}by{![g>1][-!1]}.4.Finally,because count per character is now4,the backslashes can be taken out.Update:1.Gotrid 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 totrue.Update:1.Gotrid of all{c}by shortcutting theundefinedvariable at{split(i)}and replacing

all{c}by{a}.Since{i}is never an empty string,it is always evaluatedtrue(except compared

directly totrue).Update:1.Gotrid 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.

6

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

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

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

6

Haskell，90 75 72字节

a[i]|d:n

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

作为参考，旧版本：

75个字节，每个字符5次

n(l)|d

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

a x|h:uacdlmmnosst">[]=h>1&&all(not.(/=h))u

6

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

5

Perl 5中，-p57个字节

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

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

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

5

R，90字节

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{yT##&[]>~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)。共有四个分配：两个带有=和，两个带有

定义这些功能会用尽所有可能的引号：两个双引号，两个单引号，并且在下一段中我将需要两个反引号，因此我不得不求助于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

令人印象深刻的是，您可以以90个字节来区分这两种情况(并且很好地滥​​用了help运算符)，但是NAa不被认为是真实值(在R中，if(NA)x else y会导致错误，所以NA既不真实也不虚假) )

1

@JDL谢谢，您是对的。最新的编辑解决了此问题。

1

@JDL的注释表明，对于真实和虚假，可以使用一致，不同的答案。

@Giuseppe实际上，我是在几秒钟前解决了这个问题(请参阅新版本，这是完全不同的，但字节数相同)；现在输出TRUE和FALSE。

4

oḅlᵐ=h≥2

oḅlᵐ=h≥2

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

绝对有可能做一些较短的不需要换行的操作(但是您可能需要更改一些内容)；)

@Fatalize暂时没有时间，是的，我确实阅读了该讨论。:)

4

红宝石，87 78字节

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

26个字符，每个重复3次

指点出来@nimi谢谢，我认为这是一些怪事与gets和;。对其进行了更改，无论如何它都更短，例如Lambda

3

R，132116字节

crudcardounenforceableuploads

它也不包含任何注释或多余的字符串，尽管这可能是我在代码高尔夫中唯一一次调用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

[1] TRUE

不知道字节数是否重要，但我们可以>通过与进行舍入比较来去除2和s f。也可以使用=代替<

您需要空间吗？您也可以尝试utf8ToInt代替strsplit，但不确定是否会有所帮助。还可能包括指向TIO的链接？

.似乎也都是多余的。

这是代码高尔夫球，因此根据您的注释，字节数很重要。

2

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

2

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

@WGroleau哪些字符出现一次？您是否足够仔细地阅读了我的答案？

—

周

“＃”比“：”出现的频率更高(仅举一个例子)。糟糕，

@WGroleau恰好有两个#和两个:，您在第二行上读了我的答案吗？您是否只是跳过了“说明”中的第一段？

—

周

抱歉，认为上面的说明是整件事。

1

点，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

1

SmileBASIC，164 152 148 140个字节

DeF M(X)DIM W[#R]WHILE""

INC w[ASC(x)]X[n]=""wEND

FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U

RETURN!H

enD

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

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

检查答案的脚本：

//javascript is a convenient language that I love using!varinput=document.getElementById("input");varbutton=document.getElementById("button");varoutput=document.getElementById("output");button.οnclick=function(){vartext=input.value;varfreqs={};for(vari=0;imax)max=count;out+="\n"+letter+":"+count;}output.textContent="min:"+min+"\nmax:"+max+"\nunique:"+sorted.length+"\nlength:"+text.length+out;}

count...

运行代码段隐藏结果

1

视网膜0.8.2，168个 90字节

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

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

s;{O`.

M!*\`^((.)\2(?!\2))*$

(.)(?!\1)

核心程序(39字节)

s;{O`.

M!*\`^((.)\2(?!\2))*$

(.)(?!\1)

说明

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

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

很好，我的答案较短，但是我不确定它是否可以缩放为固定为0/1的输出，所以我只是在这里添加它以防它对您有所

@FryAmTheEggman我一直在寻找一个纯正则表达式解决方案来连续匹配相同长度的字符组，但是我无法弄清楚。

@FryAmTheEggman有了很大的改进！我并没有真正使用您所拥有的，但是我从头开始尝试尝试一种更好的方法。

做得很好！而且我似乎还没有对我的程序进行足够的思考，但是至少您找到了一个更好的程序：)

1

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

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

1

Pyth，30个字节

"&8

前导空格是必需的。

实际的程序是公正的&q1lJ{hMrSz8<1hJ。我只是在字符串的前面加上了前缀"&8

&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 8)取一个序列，并输出相同字符的每次运行的长度，例如。"aaabbcc"成为[[3, "a"], [2, "b"], [2, "c"]]。

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

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

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

1

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,Addressof string.a,# instances of previous characterc,# instances of current characterfReturnvalue){{{{{{{char*o=f=h,*r;Pointo to string,whilegiving f a non-zero value.for(a=!h;*o;o++){Setpreviouscharcount to0,and then traverse the string.for(c=!h,r=h;*r;Setcurrentcharcount to0and r to string,and start counting instances of current character.c+=!(*r++^*o))Addto counterifcurrent character matches.{}Lowerthe amount of semi-colons

f*=Multiply(AND)returnvalue with:!!(c^!!h)Iscurrent count not1?(Mustbe2or above.)*(!a+!(a^c));AND,is previous count valid(meaningthisis not the first

character counted),and matches current count?a=c;}Previouscount=current count.(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;Spendsurplus characters to make source code valid.(a=f);}}}}}}}Returnvalue.

1

Perl 6的，58 57个字节

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

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