基本排序，带有令人讨厌的错误

28

您的输入是一个包含5-255个正整数的列表/序列/向量/数组，不一定是唯一的。您可以假设最适合的输入格式是什么，并且每个整数（以及整数的数量）都是从5-255范围内随机选择的。

目标是以相同（或等效）格式输出相同列表，但按升序（不降序）排序。学习语言的常见早期练习。提交的内容包括：

  1. 正确起作用并达到目标的答案；和

  2. 第二个答案包含一个令人讨厌的错误。在1％到10％的时间之间，输出需要是一个格式正确且包含正确元素的列表，但是顺序错误（除了正确排序以外的任何顺序）。其余时间，程序必须正确运行并达到目标。

这两个答案必须具有Levenshtein距离 1；也就是说，我们可以通过删除一个字节，添加一个字节或更改一个字节来获得另一个。

在代码高尔夫球中照常计分（基于两个答案中的较短者），并禁止通常的漏洞。

如果烦人的错误是与输入无关的，则10％的奖金（降低得分），即再次使用相同的输入不会重现该错误（除了1％到10％的时间）。

code-golf  array-manipulation  random  integer 
— 瓦迪姆·波诺马连科（Vadim Ponomarenko）
source
9
欢迎来到PPCG！我建议删除奖金，这不是很好的做法。
— Xcoder先生17年
2
目前尚不清楚每种可能的输入长度的概率是多少。
— user202729
12
对于每个输入，是否应该满足1％到10％的时间要求，或者对于一组可能的输入，只能满足全部要求？对于某些输入，例如不可能产生错误的命令[5,5,5]
— Luis Mendo
4
关于我们的默认IO格式有一个微妙之处。如果我们的代码定义了一个函数，相对于定义一个有可能成为bug的函数，它是否有机会定义该函数始终存在bug？
— xnor
1
@VadimPonomarenko在此站点上，人们可以提供功能以及完整程序。xnor询问是否允许在创建时有1％到10％的时间是一个有bug的函数，该函数始终会出现bug。坚持回答您的问题的信的答案可能不是，但是如果回答是肯定的，那将会更加有趣。
— wizzwizz4

Answers:

9

Python 3，36个字节

无错误的版本，37字节

lambda l:sorted(l,reverse=l[-9:]==[])

在线尝试！

烦人的版本，36个字节

lambda l:sorted(l,reverse=l[9:]==[])

在线尝试！

这取决于输入，因此没有资格获得奖金。
失败的可能性约为2％。输入长度小于10时失败。

结合LyricLy的答案得到34个字节：

lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]
— ovs
source
我认为您不需要无错误版本的空间。
— wizzwizz4
不带空格的@ wizzwizz4 or1将被解释为变量名并引发语法错误。
— ovs
9

05AB1E，5 * 0.9 = 4.5字节

工作方案

{TLΩi

在线尝试！

说明

{      # sort input
 TL    # push the range [1 ... 10]
   Ω   # pick a random number in the range
    i  # if true (equal to 1), do nothing

包含错误的解决方案

10％的时间给出错误的解决方案（取决于输入）。

{TLΩiR

在线尝试！

说明

与工作解决方案相同，不同之处在于，如果选择的数字为true，它将反转列表。

— 艾米尼亚
source
认真的嘿。输出甚至不是正确的基数。
— 约书亚
@约书亚是什么意思？
— 暴民埃里克（Erik the Outgolfer）
在线尝试显示它输出列表列表。
— 约书亚
4
@Joshua TiO链接包括一个页眉100F和一个页脚},，可帮助我们可视化多次调用输入的函数的结果。这向我们表明，有效的解决方案总是返回正确的结果，而错误的解决方案的输出有缺陷。
— Xcoder先生17年
请有人解释算法。很快我将接受排名最高的提交（或排名最高的提交之一）。我无法接受任何我无法理解的解决方案。
— Vadim Ponomarenko
7

果冻，7 *（100％-10％）= 6.3字节

Ṣ¹⁵X:¤¡

在线尝试！

越野车版本：

ṢẊ⁵X:¤¡

在线尝试！

在这两个链接中，都有一个测试工具，它将运行代码100次，每次以您给出的列表作为参数，然后返回结果。

每个输入长度的概率为：

0.1 - 0.1/(length!)

因此，对于长度1，概率为0％，对于长度2，为5％，对于长度3，为8.83̅％，对于长度4，为9.583̅％，依此类推，直到长度∞的概率为10％。

— 暴民埃里克
source
应该是0.1 - 0.1/(length!)。
— user202729
@ user202729肯定
— Erik the Outgolfer '17
Ṣ⁵X’¤¡并且也Ṣ⁵X¤¡应该起作用：越野车版本会在不到10％的时间内返回未排序的列表，并且考虑到输入是均匀随机选择的，因此应该可以工作，节省2个字节。
— user202729
如果您不喜欢该解决方案，则可以删除¹节省1个字节（规则计数的字节数=较短的字节数）；在第二次比赛之后也有多余的合并6上线6.6̅%。
— user202729
@ user202729不幸的是，它将不再是与输入无关的，并且我不能“仅删除¹”，因为那样的话，它在10％的时间内都无法排序。
— Erik the Outgolfer
6

Python 3，得分58 57-10％= 51.3

多亏了ovs，节省了一个字节。

无错误的版本，57字节

lambda m:sorted(m)[::random()>.1or 1]
from random import*

在线尝试！

错误版本，57字节

lambda m:sorted(m)[::random()>.1or-1]
from random import*

在线尝试！

我决定尝试使用奖金的解决方案。它没有击败其他Python答案，但是我很开心地想到了它。

— 歌词
source
5

C，71 * 0.9 = 63.9字节

无错误：

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%1<9)qsort(a,n,4,c);}

在线尝试！

越野车：

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%10<9)qsort(a,n,4,c);}

在线尝试！

— 稳定箱
source
为％1 +1（哦，再来6个，走了，你一定是在跟我开玩笑）
— 约书亚
4

Groovy，31个字节

错误的解决方案：

{a->a.sort()[a[9]?0..-1:-1..0]}

工作解决方案：

{a->a.sort()[a[0]?0..-1:-1..0]}

getAt如果索引大于大小，则Groovy下标运算符（该方法）为列表返回null。因此，如果有第九个元素，它将与排序后的列表保持不变，但是如果没有（1.99203187％的机会），它将被反转。但是，总会有第一个元素，因为列表的大小总是大于或等于5。因此，a[0]可以将0 in 替换为1、2、3或4。

— Hlaaftana
source
1
欢迎来到该网站，并发表第一篇好文章！
— caird coinheringaahing
3

PHP，70个字节

无错误的版本，70字节

<?unset($argv[0]);((rand(1,9)?"":r).sort)($argv);echo join(" ",$argv);

在线尝试！

错误版本，70字节

<?unset($argv[0]);((rand(0,9)?"":r).sort)($argv);echo join(" ",$argv);

在线尝试！

错误版本的错误排序时间为10％（基于随机数生成器）。

— 乔
source
不需要带有-r（-2字节）的标签。下划线加入；应该相等（-2个字节）。使用asort代替sort（-1字节）。
— 泰特斯
...或使用整个单词而不是前缀（或不使用前缀）：（unset($argv[0]);(rand(1,9)?sort:rsort)($argv);echo join(_,$argv);也是65个字节）
— Titus
3

Python 2，26个字节

越野车：

lambda l:l[9:]and l.sort()

在线尝试！

通过修改输入列表进行输出。仅当列表的长度至少为10时才对列表进行排序。非越野车版本将替换为9，0以始终进行排序。

工作方式：

lambda l:l[0:]and l.sort()

在线尝试！

我们可以修改该函数以4字节的代价返回列表，总共30字节：

lambda l:l[9:]and l.sort()or l

在线尝试！

25个字节，包含一些规则：

[list,sorted][id(0)%17>0]

在线尝试！

使用id(0)随机来源输出排序或为标识的函数文字。更改>到>=要修复，或0到~0。

— 异或
source
3

外壳，6个字节

越野车版本：

?OIV¦9

在线尝试！

正确版本：

?OIVK9

在线尝试！

说明

这些程序是完全确定性的。实际上，Husk目前完全不支持随机数。

?  V    If any element
    ¦9  is divisible by 9 (in buggy version),
    K9  is truthy when replaced by 9 (in correct version),
 O      sort the list,
  I     otherwise return it unchanged.

我声称越野车程序的输出未按1％到2％之间的概率排序。用N = 251表示元素的可能值的数量。长度为L的随机列表不包含9的倍数的概率为（（NK）/ N）^ L，其中K为可被9整除的值的数量（在我们的情况下为K = 28）。的总概率是平均的这对5≤大号≤255，这是约1.98％。这些列表中有一些是误报，因为它们已经排序。长度为L的随机列表要排序的概率最大为（（N + N *（N-1）/ 2）/ N ^ 2）^⌊L/2⌋：如果将列表分成长度为几块2，每个“ L / 2”块必须排序。列表的总概率被分类是由平均的上述用于有界5≤大号≤255，这是约0.30％。因此，该函数返回未排序列表的概率在1.67％至1.98％之间。

— 兹加布
source
被9整除的失败几率约为11％。并且不排序并不能保证列表没有排序。
— 泰特斯
1
@Titus我在分析中解决了这个问题。只有在列表中包含未发生排序没有元素是由9整除的这种情况的概率约为1.98％。的确，如果列表已经排序，则不执行任何操作也会给出已排序的列表。但是，列表已被排序的概率最多为0.30％，这足够低，以至于输出未排序列表的总概率大于1％。
— Zgarb
true ...并且排序的输入不会更改错误。
— 泰特斯
您可以使用↓9代替V¦9，并将其缩短为仅9适用于正确的版本吗？这将使它在输入短时总是失败，而在输入长时总是正确地工作，但是由于输入长度遵循随机分布，因此它仍然是有效的答案
— Leo
3

Bash，26个字节

正确版本

s=n
sort -${s:RANDOM%20<0}

在线尝试！或检查概率。

错误版本

s=n
sort -${s:RANDOM%20<1}

在线尝试！或检查概率。

将输入作为以换行符分隔的数字。使用内置变量RANDOM，该变量始终返回0到32767范围内的（伪）随机数。使用%20结果的失败率约为5％（感谢@Titus澄清了问题%10）。

这种随机性意味着故障率与输入无关，但这确实要求输入数组至少包含一个数字和一个以上的数字，因为故障输出是按字典顺序排序的。

替代版本，27字节

((RANDOM+20))||cat&&sort -n

错误版本将替换+为%。在线尝试或尝试错误解决。

— 贾斯汀·马里纳（Justin Mariner）
source
便士采摘：%10具有返回的机会较高0，以7大于8或9），所以对于失败的几率是10％以上
— 泰特斯
@Titus谢谢，我忘记了这个事实。已更新，可以%20像您的答案一样使用。
— 贾斯汀·马里纳
3

Pyth得分8 * 0.9 = 7.2

第一个代码段（正确的一个）：

h.uSNT.S

在这里尝试！

第二个片段（错误的一个）：

O.uSNT.S

在这里尝试！

感谢isaacg，节省了两个字节（和1.8分）！

— Xcoder先生
source
我认为9份而不是10份的新副本就可以了。.S返回输入不变的可能性意味着在那些（罕见）情况下，我们得到错误答案的机会从10％下降到0％-因此，平均而言，它仍然在正确的范围内。当然，十份也可以。
— 米沙·拉夫罗夫
@MishaLavrov我的解释出错了，现在解决。我说过.S也可能会返回输入本身（这不是问题），但我的意思是.S可能还会返回已排序的列表。
— Xcoder先生17年
是的，这也是我的意思。
— 米莎·拉夫罗夫
相同的想法，但更短：O.uSNT.S
— isaacg
2

JavaScript（ES6），24个字节

无错误的版本（至少对于0-2147483647范围内的整数，因此在给定范围内的任何值）：

a=>a.sort((a,b)=>a-b>>0)

越野车版本：

a=>a.sort((a,b)=>a-b>>1)

取决于a）引擎的排序算法和b）包含两个错误顺序的值相差1的输入列表。（如果结果的概率太低，则1可以增加，但是等到得到对8了，它只是不排序范围内的任何东西5-255。）

— 尼尔
source
2

PHP，62字节

受Jo´s解决方案的启发（我刚刚注意到：这是Justin Mariner´s的港口）：

工作（升序排列）：

unset($argv[0]);(r[rand()+20].sort)($argv);echo join(_,$argv);

越野车（降序排序的可能性约为5％）：

unset($argv[0]);(r[rand()%20].sort)($argv);echo join(_,$argv);

与运行 -nr

— 泰特斯
source
2

Pushy，9个字节-10％= 8.1

错误的解决方案：

g0TUn?};_

在线尝试！

工作解决方案：

g1TUn?};_

在线尝试！

错误的代码执行以下操作：

g0TUn?};_

g          \ Sort the stack correctly
 0TU       \ Generate random(0, 10)
    n? ;   \ If this is zero:
      }    \    Cyclically shift the stack right once
        _  \ Print the result

固定代码只需更改0为即可1。就像random(1, 10)永远不会那样0，if语句将永远不会执行。

— FlipTack
source
2

MATL，7 * 0.9 = 6.3 6 * 0.9 = 5.4字节

越野车版本：

Gr.9<?S

在线尝试！

说明：

G        % Grab input
 r       % Push a random number between 0 and 1
  .9     % Push 0.9
    <    % Check if the random number is smaller than 0.9
     ?   % If true
      S  % Sort input
         % Implicit output

无错误的版本：

Gr9<?S

在线尝试！

说明：

G       % Grab input
 r      % Push a random number between 0 and 1
  9     % Push 9
   <    % Check if the random number is smaller than 9 (always true)
    ?   % If true
     S  % Sort the input
        % Implicit output
— 斯蒂夫·格里芬
source
1

Jq 1.5，42字节

越野车

sort|if length%13<=0then reverse else. end

工作（删除=）

sort|if length%13<0then reverse else. end

假设行长在[5,255]范围内是一致的，则大约7％将触发该错误

在线尝试！

— jq170727
source
1

J，22.5字节（25字节-10％）

有错误：

[:]`(1&A.)@.(0.1>?@0:)/:~

没有错误：

[:]`(0&A.)@.(0.1>?@0:)/:~

在线尝试！

— 约拿
source
1

R，30 * .9 = 27字节

（越野车）

function(l)sort(l,runif(1)<.1)

在线尝试！

（不是越野车）

function(l)sort(l,runif(1)<.0)

越野车版本会在decreasing=T10％的时间内进行排序，并从统一（0,1）分布中采样。非越野车版本始终decreasing=F

— 朱塞佩
source
1

Röda，42个字节-10％= 37.8

无错误：

{sort key={|i|currentTime|[_%20//19*0+i]}}

越野车：

{sort key={|i|currentTime|[_%20//19*i+i]}}

在线尝试！

这使用该currentTime函数创建随机数。看来它们的分布在机器之间略有不同。20//19可以调整比率以得到不同的结果，而不会产生字节损失（除非它小于99//98）。

— Fergusq
source
1

爪哇8，45 34.2（50 38 - 10％）的字节

普通版：

a->{if(Math.random()>0.)a.sort(null);}

说明：

在这里尝试。

a->{                    // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.)  //  If the random 0-1 double is larger than 0:
    a.sort(null);       //   Sort the input-List
}                       // End of method

错误版本（51 39字节）：

a->{if(Math.random()>0.1)a.sort(null);}

LD为1：已1添加。

说明：

在这里尝试。

a->{                     // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.1)  //  If the random 0-1 double is larger than 0.1:
    a.sort(null);        //   Sort the input-List
}                        // End of method
— 凯文·克鲁伊森
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.