实施惰性删除排序

26

这个挑战已经描述了dropsort。但是，我有点懒，我真的只需要对数组进行比以前更多的排序，就不必一直对它进行排序了。

在“丢弃排序”中，我们将每个元素丢弃的数量要少于之前的任何元素。在“延迟删除排序”中，我们删除的每个元素都小于严格位于其前面的元素。

这是一个例子。考虑以下数组：

8 6 9 9 7 2 3 8 1 3

让我们标记每个元素少于之前的元素。

8 6 9 9 7 2 3 8 1 3
  ^     ^ ^     ^

注意，既没有3标记，也没有标记8。它们都比它们左侧的单个元素大。

完成算法，除去标记的元素，我们得到：

8 9 9 3 8 3

这基本上看起来更加排序。金田我很懒。

您可能已经推断出，您的任务是实现此算法。

输入是1到9之间的至少1个正整数的数组，因此您也可以使用数字字符串。

这是代码高尔夫球，最少字节获胜！

其他测试用例：

1
1

1 2 3
1 2 3

5 3 1
5

1 2 3 2 1
1 2 3

1 1 1 9 9 9 1 1 1 9 9 9 1 1 1
1 1 1 9 9 9 1 1 9 9 9 1 1

9 9
9 9

5 2 4 2 3
5 4 3

code-golf array-manipulation sorting

— 帕维尔
source

它可以是一个函数还是必须是完整的程序？

— rafa11111 '18

@ rafa11111都不错

— Pavel

如果是函数，可以在主程序中对输入数组进行硬编码吗？数组的长度可以作为输入传递给函数吗？

— rafa11111 '18

@ rafa11111输入不能在函数本身中进行硬编码。函数如何在测试程序中获取此输入无关紧要。仅当使用C / C ++或其他语言（这是确定数组长度的唯一方法）时，才可以采用数组长度。

— 帕维尔

Answers:

6

外壳，4个字节

m←ġ<

在线尝试！

说明

m←ġ<
  ġ<    Group the numbers into decreasing sequences
m←      Keep the first element of each sequence

— 狮子座
source

15

JavaScript（ES6），28 25字节

@Shaggy节省了3个字节

a=>a.filter(n=>~-a<(a=n))

在线尝试！

— Arnauld
source

2

n=>p<=n看起来真棒;-)

— ETHproductions

4

@ETHproductions对于+4字节，(n=p)=>p<=(p=n)工作正常；）

— Arnauld

这个答案让我大吃一惊，为什么p第一次尝试访问时（它尚未定义）却没有爆炸？

— 布赖恩H.18年

1

@Shaggy看起来很安全。当我回到电脑前时会更新。谢谢！

— Arnauld

2

@Pavel a最初设置为输入数组，并a-1会导致NaN（除非它包含单个整数，否则将被强制为该整数）。

— Arnauld

6

R，27个字节

(l=scan())[c(T,diff(l)>=0)]

在线尝试！

— 朱塞佩
source

6

MATL，9 8字节

感谢Giuseppe，节省了一个字节。

0yd0<h~)

在线尝试！

说明：

0                 % Push a zero
 y                % Implicitly grab the input and duplicate it.
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [8 6 9 9 7 2 3 8 1 3]
  d               % The difference between each number of the last element:
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [-2, 3, 0, -2, -5, 1, 5, -7, 2]
   0<             % Which are negative?
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [1 0 0 1 1 0 0 1 0]
     h            % Concatenate. Stack: [8 6 9 9 7 2 3 8 1 3], [0 1 0 0 1 1 0 0 1 0] 
      ~           % Negate. Stack: [8 6 9 9 7 2 3 8 1 3], [1 0 1 1 0 0 1 1 0 1]
       )          % Index. Stack: [8 9 9 3 8 3]

— 斯蒂夫·格里芬
source

5

Perl 5 .10.0 + `-nl`，16字节

$f>$_||say;$f=$_

在线尝试！

— 浪费
source

1

翻译成Perl 6perl6 -ne '$/>$_||.say;$/=$_'

— 布拉德·吉尔伯特b2gills，

@Brad perl6是另一种语言（甚至不向后兼容）发布它！

— wastl

我写了一个比较惯用的Perl 6，但是更长。我在此处发布的原因之一也是炫耀语言并进行解释。发布该翻译没有任何作用，但表明它是Perl的详细版本。基本上，它不满足我在此网站上发布的任何原因。

— 布拉德·吉尔伯特b2gills，

5

Haskell，29个字节

f s=[b|(a,b)<-zip(0:s)s,a<=b]

只是一个简单的列表理解。

— 骄傲的哈斯克勒
source

4

Japt，8 7字节

@Oliver节省了1个字节

k@>(U=X

在线测试！

备择方案：

f@T§(T=X
k@ä>0 gY
i0 ò> mÅ c

— ETH生产
source

提出了完全相同的解决方案:)

— Shaggy

4

Stax，5 个字节

âÿ╠╦░

在线运行和调试

解压缩，解压缩和注释代码，我们得到了这一点。

Z   Push a zero under the input
f   Use the rest of the program as a filter on the input.  Output passing elements.
>   Current element is greater than previous?
_~  Push current element to the input stack; when the main stack is empty, pops fall back to this
!   Logical not; applies to the result of the greater-than

指令的顺序很尴尬，但这是有原因的。Stax源代码打包并不总是针对相同大小的输入产生相同大小的输出。基本上，如果源的最后一个字符具有较低的字符代码，则有机会保存一个字节。好吧，这里!是您可获得的可打印字符的最低代码之一。（特别是33个）许多6字节ASCII stax程序不能打包任何较小的程序。但是，如果它们以结尾!，则可以。因此，对指令进行这种特殊排序的原因是为了确保逻辑不会在程序结束时结束。

— 递归的
source

4

J，12字节

#~1,2&(<:/\)

说明：

#~1,2&(<:/\)    | Whole function, executed as a hook
       <:/      | Distribute <: (greater or equal) over an array
    2&(   \)    | Apply to each sub array of length 2
  1,            | Append a 1 to the front
#~              | Choose elements from the original array

例子：

    2&(<:/\) 8 6 9 9 7 2 3 8 1 3
0 1 1 0 0 1 1 0 1
    1,2&(<:/\) 8 6 9 9 7 2 3 8 1 3
1 0 1 1 0 0 1 1 0 1
    (1 0 1 1 0 0 1 1 0 1) # 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3
    f =: #~1,2&(<:/\)
    f 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

在线尝试！

— Bolce Bussiere
source

不错的解决方案！我为您的代码添加了一个TIO链接。

— Galen Ivanov

4

果冻，6个字节

>Ɲ0;¬×

I / O在字符串上。

在线尝试！

— 丹尼斯
source

我很好奇，为什么要对字符串而不是数组进行运算？有人告诉我，果冻的琴弦不好。

— 帕维尔

2

它是。×不应该用于字符重复，但是可以。

— 丹尼斯

4

Java 8，66 55 48字节

l->{for(int i=0;;)if(i>(i=l.next()))l.remove();}

@OlivierGrégoire提示后的-11个字节。@OlivierGrégoire
多了-7个字节。

说明：

在线尝试。

l->{                     // Method with Integer-ListIterator parameter and no return-type
  for(int i=0;;)         //  Loop over all items
    if(i>(i=l.next()))   //   If the current item is larger than the next
      l.remove();}       //    Remove this next item

— 凯文·克鲁伊森
source

为什么每个人~0基本上都开始使用它-1。如果字节数的长度相同，我个人会选择更直观的解决方案（while(...)vs 除外for(;...;)，在这种情况下，我更喜欢使用for。，但

— 还要

这是因为我对2补码很不好...我真的很想表达我的意思Integer.MIN_VALUE（那时候1<<31，我想...）;-)

— OlivierGrégoire18年

4

八度，21字节

@(x)x(~[0,diff(x)<0])

在线尝试！

说明：

以一个向量x为输入，并创建一个vector [0, diff(x)<0]，其中diff(x)是一个向量，所有相邻元素之间都存在差异。通过将其与零进行比较，仅保留那些负数，从而提供我们要删除的所有元素的列表。

然后，我们从输入向量中选择要保留的元素。

— 斯蒂夫·格里芬
source

4

V，25个字节

òjälá k$yl+@"òç-/d
ç /dw

在线尝试！

十六进制转储：

00000000: f26a e46c e120 6b24 796c 2b40 2218 f2e7  .j.l. k$yl+@"...
00000010: 2d2f 640a e720 2f64 77                   -/d.. /dw

最糟糕的语言。但是我敢做。

— DJMcMayhem
source

6

旁注：ojalá 希望是西班牙语。

— 丹尼斯

2

@dennis太酷了。什么是k$yl+@"òç-/d西班牙语？

— DJMcMayhem

7

k$yl+@"òç-/d可能会被翻译成Ouch，到底是谁把那个橱柜门打开了？

— Luis Mendo

3

三角形，71个字节

.....).....
....IEL....
...)rFD)...
..2+)IE)w..
.+h)2_stDO.
={M)IEm}...

在线尝试！

怎么运行的？

）IEL）rFD）2+）IE）w + h）2_stDO = {M）IEm} –完整程序。
）IE –获取第0个输入I并对其进行评估。
   L）r –并推动范围[0 ... I的长度。
      F {–过滤满足以下条件的整数：
       D）2+）IE）w + h）2_stDO = –此条件。在单独的位置上运行每个元素E
                                    堆放并丢弃不符合标准的产品。
       D）2+ –复制并在第二个副本中添加2。
           ）IE –再次检索我。
              ）–将0压入堆栈。
               w –将0包裹在列表中。[0]
                + –放在I之前。
                 h –头。在索引E + 2之后修剪元素。
                  ）2_ –文字-2。
                     st –尾巴。
                       DO = –检查结果是否在排序上是不变的。
                           M）IEm} –最后一部分：索引输入。
                           M} –对于满足条件的每个索引：
                            ）IEm –在该位置检索I的元素。

— Xcoder先生
source

2

出于好奇（因为您是Triangularity的创建者）：为什么不做类似于Hexagony / Cubically的事情，在该代码中自动用无操作点填充代码？因此，该程序将)IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}扩展到您当前的答案吗？

— 凯文·克鲁伊森

@KevinCruijssen因为我实际上打算将Triangularity设为2D esolang，但是我放弃了这个想法，因此只坚持以前的模板。我想我将在发布Triangularity v2时很快进行一些重大更改。（另外，以目前的形式打高尔夫球也很有趣，因为一个简单的1字节保存内联方法反而可以为您节省20：D ...尽管通过：C也可以追溯地适用于它）

— Xcoder先生

好吧，即使您确实计划将其作为2D esolang发行，我的评论仍然（有些）。)IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}将是您的代码，它将扩展为当前模板，然后在该扩展模板上执行2D命令。编辑：.....).....\n....IEL....\n...)rFD)...\n..2+)IE)w..\n.+h)2_stDO.\n={M)IEm}...和.....).........IEL.......)rFD).....2+)IE)w...+h)2_stDO.={M)IEm}...与)IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}将所有三个是完全一样的节目。

— 凯文·克鲁伊森

3

Python，40个字节

f=lambda h,*t:t and h+f(*t)[h>t[0]:]or h

在线尝试！

输入为字符元组。

Python 3，41个字节

p=''
for x in input():x<p or print(x);p=x

在线尝试！

字符串输入。

Python 2，41个字节

for x in input():
 if x>=id:print x
 id=x

在线尝试！

字符串输入，仅因为字符串大于id但数字较小。

— 异或
source

3

Wolfram语言（Mathematica），33个字节

Pick[#,Arg[#-{0}~Join~Most@#],0]&

在线尝试！

怎么运行的

代码# - {0}~Join~Most@#将数组{a,b,c,d,e,f}转换为{a,b-a,c-b,d-c,e-d,f-e}。应用于Arg此将负数设置为Pi，将非负数设置为0。

Pick[#, ..., 0]&在我们的例子中，挑选出#where中...具有0：的条目，恰好是减去前一个元素时产生非负数的元素。换句话说，这些正是我们在进行lazydropsorting时要保留的条目。

— 米莎·拉夫罗夫（Misha Lavrov）
source

3

不可思议，27个字节

-> ':1.!> 'sS#<=.cns2.++[0]

用法示例：

(-> ':1.!> 'sS#<=.cns2.++[0])[8 6 9 9 7 2 3 8 1 3]

说明

非高尔夫版本：

(map get 1).(fltr sS <=).(cns 2).(++ [0])

前置0，获取连续对的列表，保留列表项，其中第一个数字<=第二个数字，获取每对的第二个数字。

— 妈妈趣味卷
source

3

Wolfram语言（Mathematica），20个字节

#&@@@Split[#,##>0&]&
(* or *)
Max/@Split[#,##>0&]&

在线尝试！

说明

Input = {8, 6, 9, 9, 7, 2, 3, 8, 1, 3}

Split[#,##>0&]

对严格递减的连续元素进行分组： {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

取每个的第一个元素： {8, 9, 9, 3, 8, 3}

— 郑焕民
source

##>0是花哨的东西，但实际上并没有在#>#2这里节省任何东西；）（这将使您的程序可以使用任意整数，但这不是必需的）。

— 马丁·恩德

3

Python 2中，52个 46 45 42字节

lambda a:[v for v,w in zip(a,[1]+a)if v/w]

在线尝试！

已保存：

-3个字节，感谢Rod

— 场
source

3

SWI-Prolog，44字节

[A,B|C]-[A|E]:-B<A,[B|C]-[B|E];[B|C]-E. L-L.

用法：调用“ List -X”，其中List是一个用括号括起来的逗号分隔列表，例如[1,4,5,1,11,6,7]。

— 烟灰缸
source

1

欢迎光临本站！:)

— DJMcMayhem

2

APL + WIN，14个字节

提示屏幕输入整数向量。

(1,1>2-/v)/v←⎕

— 格雷厄姆
source

2

05AB1E，6个字节

ĆÁü›_Ï

在线尝试！

说明

Ć        # append the head of the list
 Á       # rotate right
  ü›     # apply pair-wise greater-than
    _    # logical negate each
     Ï   # keep elements of input that are true in this list

— 艾米尼亚
source

2

Kotlin，39个字节

a->a.filterIndexed{i,v->i<1||v>=a[i-1]}

在线尝试！

筛选为第一项（索引== 0，甚至是较短的索引<1）或当前值大于或等于前一项（a [i-1]）的项。

— 诚山
source

2

APL（Dyalog Unicode），11 个字节

{⍵⌿⍨1⍪2≤⌿⍵}

在线尝试！

这实际上与Graham的答案非常相似，但在Dyalog中是独立开发的。而且，更加对称。

— 暴民埃里克
source

2

K4，10个字节

解：

x_/|&<':x:

例：

q)k)x_/|&<':x:8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

说明：

查找元素小于前一个元素的索引，从输入中删除这些索引

x_/|&<':x: / the solution
        x: / store input as x
     <':   / less-than each-previous
    &      / indices where true
   |       / reverse
 _/        / drop-over
x          / the input

— 街头小贩
source

2

附件，24字节

{Mask[1'(Delta!_>=0),_]}

在线尝试！

说明

Mask从第二个参数中选择与第一个参数中的真实元素相对应的所有元素。1'(Delta!_>=0)计算与最终数组中的元素相对应的索引。

其他尝试

28个字节（无点）： ~Mask#(1&`'##Delta#`>=#C[0])

32个字节： {Mask[1'(&`<= =>Slices[_,2]),_]}

— 科纳·奥布莱恩
source

2

C＃（.NET Core），33 + 18 = 51字节

x=>x.Where((a,n)=>n<1||x[n-1]<=a)

在线尝试！

基本上，该语句是x是数组中的第一个int，或者大于或等于先前的数字，请保留该值。否则放下。

— 丹尼斯·韦尔维
source

1

您可以返回IEnumerable。没有ToArray()必要的。

— 帕维尔

@Pavel我需要添加一个额外的引用System.Collections，这将否定所有用于删除的字节ToArray()。

— Dennis.Verweij

不，因为您不会IEnumerable在答案中进行引用，只需将其用作返回类型即可。

— 帕维尔

@Pavel好的，谢谢，有时候我不确定何时计算字节数……对不起

— Dennis.Verweij

1

迅速4，56 55个字节

{var l=0;print($0.filter{($0>=l,l=$0).0})}as([Int])->()

在线尝试！

说明

{var l=0;           // Declare variable l
print($0.filter{(   // Print every element e in the input
  $0>=l,            //   where e >= l
  l=$0).0})         //   And set l to e
}as([Int])->()      // Set the input type to integer array

— 赫尔曼·L
source

1

果冻，9个字节

0;>ƝżµḢÐṂ

在线尝试！

感觉很笨重，如果有更好的方法也不会感到惊讶。

0;>ƝżµḢÐṂ
   Ɲ       For each adjacent pair in the input...
  >        ...is the first element greater than the second? (yields a list of 0/1)
0;         prepend a zero to this list (always keep the first element)
    ż      zip with the input
     µ     new monadic link
       ÐṂ  keep elements of the list with minimal value of... (Ðḟ would have worked here and been slightly more clear but I'll leave it as it is)
      Ḣ    ...their first element

— Dylnan
source

1

Brain-Flak，136，120字节

((())){{}([{}]({}))([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}(({})<>)(())(<>)}{}([][()])}{}{}<>{{}({}<>)<>}<>

在这里，它被格式化并“可读”。

((()))
{
    {}

    ([{}]({}))

    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

    {
        {}(({})<>)(())(<>)
    }

    {}

    ([][()])

}{}{}<>

{
    {}
    ({}<>)<>
}<>

在线尝试！

— DJMcMayhem
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.