跳过像兔子!

Erik the Outgolfer 08/26/2017. 30 answers, 2.887 views
code-golf array-manipulation

给出一个以任何合理格式表示的非负整数列表,重复遍历它,跳过与每一个整数相同的元素。


这是一个工作的例子:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | []
 ^ First element, always include it
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0]
    ^ Skip 0 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1]
          ^ Skip 1 element
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2]
                   ^ Skip 2 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2, 3]
Skip 3 elements; you're done 

另一个工作的例子,不是所有的平等增量:

[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | []
 ^ First element, always include it
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4]
                ^ Skip 4 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3]
                            ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3]
                                        ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3, 4]
Skip 4 elements; you're done 

一个超越界限的例子:

[0, 2, 0, 2, 4, 1, 2] | []
^ First element, always include it
[0, 2, 0, 2, 4, 1, 2] | [0]
    ^ Skip 0 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2]
             ^ Skip 2 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2, 4]
Skip 4 elements; you're done (out of bounds) 

规则

  • 你可能不会在这些人中间使用任何无聊的欺骗手段,他们会让挑战变得无聊和无趣。
  • 你只应该返回/打印最终结果。 STDERR输出被忽略。
  • 您可能无法将输入作为任何基数中的一串数字输入(例如,第一种情况为“0102513162”)。
  • 您必须使用从左到右的顺序输入。
  • 正如在工作的例子中,如果你超出界限,执行终止,否则。
  • 您应该使用0来跳过0个元素。
  • 给定空列表( [] )作为输入,你应该返回[]

测试用例

[]                                                     => []
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                     => [0, 1, 3, 7]
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]                   => [5, 2, 1, 0]
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2]                         => [0, 1, 2, 3]
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] => [4, 3, 3, 4]
[0, 2, 0, 2, 4, 1, 2]                                  => [0, 2, 4] 

这是 ,所以最短的答案获胜!

5 Comments
Erik the Outgolfer 07/28/2017
沙盒 (仅限2k +用户)
3 Shaggy 07/28/2017
是的,刚刚发现它。 /把眼镜放在上面
2 Rod 07/28/2017
可能是妖精¯\ _(ツ)_ /¯
1 Roman Gräf 07/28/2017
在我的数组中有尾随零可以吗? 会节省我〜18个字节
1 Erik the Outgolfer 07/28/2017
@RomanGräf抱歉但不是,这会太模棱两可,因为有些情况下你应该在输出中跟踪0秒。

30 Answers


Rod 07/28/2017.

Python 2,36字节

 f=lambda x:x and x[:1]+f(x[x[0]+1:]) 

在线试用!

4 comments
Mr. Xcoder 07/28/2017
我曾经期待过高,但不是那么糟糕:)
Erik the Outgolfer 07/28/2017
你不能做x[0]而不是x[:1]
Rod 07/28/2017
@EriktheOutgolfer是的,但它需要是一个列表,所以它会是[x[0]]
Erik the Outgolfer 07/28/2017
@Rod你并没有用x[:1]保存任何字节,反正... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

Python 2,49 46 * 41字节

越过4仍然是正常的4 :(

* -3 thanks to @ASCII-only

 l=input()
while l:print l[0];l=l[l[0]+1:] 

在线试用!

由于OP允许在聊天中打印由换行符分隔的结果。 我不认为它可以缩短non-recursive full program


这个怎么用?

  • l=input() - 从标准输入中读取列表。

  • while l: - 滥用空列表在Python中是虚假的,循环直到列表为空。

  • print l[0]; - 打印列表的第一个元素。

  • l=l[l[0]+1:] - “像兔子一样跳过” - 修剪列表中的第一个l[0]+1

我们举个例子吧

给定列表[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]作为输入,代码执行以下操作(根据上面的解释) - 打印第一项数组: 5 ,修剪第一个6: [2, 1, 2, 1, 0, 0] 。 然后我们打印2并修剪第一个3: [1,0,0] 。 同样,我们输出1 ,裁剪前2,我们得到[0] 。 当然,打印0并且程序终止。

1 comments

w0lf 07/28/2017.

哈斯克尔, 29 27 26字节

 j(x:y)=x:j(drop x y)
j x=x 

感谢Zgarb保存了1个字节。

在线试用。

2 comments
Zgarb 07/28/2017
第二行的f x=x保存一个字节。
w0lf 07/28/2017
@Zgarb酷,谢谢!

Adnan 07/28/2017.

05AB1E10 9个字节

[¬Dg>#=ƒ¦ 

使用05AB1E编码。 在线试用!

1 comments
Magic Octopus Urn 07/28/2017
是的,那比我想象的要好得多。

Martin Ender 07/28/2017.

Mathematica, 46 44字节

SequenceCases[#,NO 

备择方案:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
哇,太好了!

Johan Karlsson 07/28/2017.

JavaScript(ES6), 42 39 35字节

a=>a.map((n,i)=>a.splice(i+1,n))&&a 

 let f = 
a=>a.map((n,i)=>a.splice(i+1,n))&&a

console.log(f([]))                                                     // => []
console.log(f([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))                     // => [0, 1, 3, 7]
console.log(f([5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]))                   // => [5, 2, 1, 0]
console.log(f([0, 1, 0, 2, 5, 1, 3, 1, 6, 2]))                         // => [0, 1, 2, 3]
console.log(f([4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2])) // => [4, 3, 3, 4]
console.log(f([0, 2, 0, 2, 4, 1, 2]))                                  // => [0, 2, 4] 

旧的解决方案39字节

a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r 

-3 bytes thanks to @ThePirateBay

1 comments
ThePirateBay 07/28/2017
39个字节a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

TheLethalCoder 07/28/2017.

C#,68个字节

 a=>{for(int i=0;i 

在线试用!

完整/格式化版本:

 namespace System
{
    class P
    {
        static void Main()
        {
            Action> f = a =>            {
                for (int i = 0; i < a.Count; i += a[i] + 1)
                    System.Console.Write(a[i] + " ");
            };

            f(new Collections.Generic.List() { });Console.WriteLine();
            f(new Collections.Generic.List() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });Console.WriteLine();
            f(new Collections.Generic.List() { 5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0 });Console.WriteLine();
            f(new Collections.Generic.List() { 0, 1, 0, 2, 5, 1, 3, 1, 6, 2 });Console.WriteLine();
            f(new Collections.Generic.List() { 4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2 });Console.WriteLine();
            f(new Collections.Generic.List() { 0, 2, 0, 2, 4, 1, 2 });Console.WriteLine();

            Console.ReadLine();
        }
    }
} 

返回列表的时间长度为107个字节。

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
为什么有人低估了这一点?
Thomas Ayoub 07/31/2017
把你的分数凑成一个完美的5K?
TheLethalCoder 07/31/2017
@ThomasAyoub我们只能假设它是有OCD的人。

Zgarb 07/28/2017.

稻壳8个 6字节

←TU¡Γ↓ 

在线试用!

-2字节(以及一个全新的解决方案概念),感谢Leo!

说明

我使用列表模式匹配函数Γ 。 它采用函数f和头部x和尾部xs的列表,并将f应用于xxs 。 如果列表为空,则Γ返回与其类型一致的默认值,在这种情况下为空列表。 我们认为f ,它会从xs删除x元素。 然后迭代此函数,并将结果元素收集到列表中。

←TU¡Γ↓  Implicit input, e.g. [0,2,0,2,4,1,2]
    Γ↓  Pattern match using drop
   ¡    iterated infinitely: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[],[],[],...
  U     Cut at first repeated value: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[]]
 T      Transpose: [[0,2,4],[2,0,1],[0,2,2],[2,4],[4,1],[1,2],[2]]
←       First element: [0,2,4] 
5 comments
Leo 07/28/2017
你可以放弃ø的默认值,所有东西都会神奇地工作:)
Leo 07/28/2017
Zgarb 07/28/2017
@Leo哦,哇,这很聪明!
Erik the Outgolfer 07/28/2017
你为什么这么做?
Zgarb 07/28/2017
@ErikTheOutgolfer这是一个错误(我在我的手机上,显然推了一些意外)。 我试图撤消它...

Ruud 07/28/2017.

Python 2,59 55字节

 l=input()
i=0
while l[i:]:i+=1;l[i:i+l[i-1]]=[]
print l 

在线试用!

2 comments
1 Rod 07/28/2017
你可以用l[i:i+l[i-1]]=[]代替del l[i:i+l[i-1]]来保存一个字节

Dave 07/28/2017.

Pyth,22字节

VQ aY.(Q0VeY .x.(Q0 ;Y 

删除了无用的字节

4 comments
Erik the Outgolfer 07/28/2017
我在那里看到23个字节。
Dave 07/28/2017
错字:)抱歉...
3 Wheat Wizard 07/28/2017
我不确定你为什么有投票。 有一种可能性,当你编辑修复你的答案时,这触发了一个“自动倒票”。 这种自动downvote的原因是令人困惑和可怕的,但如果系统认为你的答案是基于启发式的“低质量”,就会发生这种情况。 也有可能有人不喜欢你的答案,但我目前没有看到任何问题,所以我不确定为什么会这样。
isaacg 07/31/2017
我很高兴你使用Pyth!

Rod 07/28/2017.

Python 2,60 42字节

-18字节感谢Luis Mendo

 x=input()
i=0
while 1:print x[i];i+=1+x[i] 

在线试用!


Martin Ender 07/28/2017.

视网膜 ,36字节

字节数假定ISO 8859-1编码。

.+
$*
((1)*¶)(?<-2>1*¶)*
$1
%M`.
0$ 

输入和输出用换行符进行换行分隔。

在线试用! (使用逗号代替换行符以允许方便的测试套件。)


Riley 07/28/2017.

Brain-Flak ,64字节

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

在线试用!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
哇靠! 我写了一个解决方案,然后向下滚动以发布它,但事实证明我们写了exact解决方案byte-for-byte! 即使像({}[()]<{}>) vs ({}<{}>[()])这样的小细节也是一样的! 真是巧合!
2EZ 4RTZ 07/28/2017
@DJMcMayhem窃取了所有名气的XD

user202729 07/28/2017.

Mathematica, 64 50字节

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={} 
1 comments
Mr.Wizard 07/28/2017
我忍不住进一步打高尔夫球这个整洁的代码; 我的回答如下。

jkelm 07/28/2017.

C#(.NET Core) ,68字节

 n=>{var t="";for(int i=0;i 

在线试用!

将输入作为整数数组输入,返回包含未跳过的值的字符串。

3 comments
TheLethalCoder 07/28/2017
很好的方式来做到这一点,并与打印相同。
jkelm 07/28/2017
我喜欢简单的解决方案。 尽管如此,仍然需要学习LINQ,正如我所看到的那样缩短了很多c#lambda。
TheLethalCoder 07/28/2017
缩短它,因为你可以隐式返回大部分时间。 虽然它是隐式返回与using System.Linq;之间的折腾using System.Linq; 和一个正常的循环。

Jarko Dubbeldam 07/28/2017.

R,58个字节

f=function(x,p=1)NO 

递归函数。 将一个向量x作为参数并引入一个指针p 。 这将打印x的相应条目,检查p+x[p]是否超出界限,如果不超过,则调用新指针的函数。

f=function(x,p=1,s=x[1])`if`((z<-x[p]+p+1)>sum(x|1),s,f(x,z,c(s,x[z]))) 

这是一个可比较的解决方案,它返回一个适当的矢量,而不是打印数字。

3 comments
Giuseppe 07/28/2017
numeric(0)的输入怎么样? 又名空阵列。
Jarko Dubbeldam 07/28/2017
@Giuseppe我会在我的电脑后面看看它
Giuseppe 08/24/2017
57字节! 它也处理空的情况。

Roman Gräf 07/28/2017.

Java(OpenJDK 8) ,53字节

感谢@ PunPun1000和@TheLethalCoder

 a->{for(int n=0;;n+=1+a[n])System.out.println(a[n]);} 

在线试用!

5 comments
TheLethalCoder 07/28/2017
打印结果,就像在我的C#答案中,为你节省了什么?
Roman Gräf 07/28/2017
@ TheLethalCoder我试试
TheLethalCoder 07/28/2017
你可以通过将n移入循环来保存一个字节吗?
TheLethalCoder 07/28/2017
此外,目前这似乎不起作用。
PunPun1000 07/28/2017
你在(a[n+=1+a[n]]之后遗漏了一个paren,函数在输出正确的值之后也会抛出一个错误,我不知道是否允许这个意见一致(问题的确存在如果这是意图,那么你可以在for循环中删除n ,最后TIO代码不会按原样运行,即使是paren也是如此。一个Consumer并使用func.accept(test)

Martin Ender 07/28/2017.

爱丽丝 ,15个字节

/$.. \h&
\I@nO/ 

在线试用!

输入并输出换行分隔的十进制整数列表。

说明

/   Switch to Ordinal mode.
I   Read a line.
.   Duplicate it.
n   Logical NOT (gives truthy if we're at EOF).
/   Switch to Cardinal.
    The IP wraps around to the left.
\   Switch to Ordinal.
$@  Terminate the program if we're at EOF.
.   Duplicate the input line again.
O   Print it.
\   Switch to Cardinal.
h   Increment the value.
&   Store the result in the iterator queue.
    The program wraps around to the beginning. 

在迭代器队列中存储整数n会导致下一个命令被执行n次。 镜像/不是命令,所以下一个命令将是I 因此,如果我们只读取并打印一个值x ,我们将在下一次迭代中读取x+1值,最后一个值在堆栈顶部。 这将跳过所需的号码列表元素。


Mr.Wizard 07/28/2017.

Mathematica ,37(30?)

进一步打高尔夫user202729的好方法。

±NO 

规则似乎没有明确指定输出格式,因此可能:

±NO 

第二个函数的输出如下所示: 0.2.4.{} - 值得注意的是{}仍然返回空集,符合最终规则。

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO可以是±NO因为±的优先级低于Infix
Mr.Wizard 07/28/2017
@JungHwanMin我错过了; 谢谢!

Jenny_mathy 07/28/2017.

Mathematica,65字节

(s=#;t=1;w={};While[t<=Length@s,AppendTo[w,k=s[[t]]];t=t+k+1];w)& 

在线试用!


w0lf 07/28/2017.

Ruby, 36 33 31

f=->l{a,*l=l;a&&f[l.drop(p a)]} 

在线试用。

4 comments
sethrin 07/30/2017
您可以将f=减去作为标题元素。
w0lf 07/30/2017
@sethrin即使我需要递归调用它?
sethrin 07/30/2017
嗯,很好的问题。 我想不是。 顺便说一下,我非常喜欢你的解决方案。
w0lf 07/30/2017
@sethrin谢谢! :)

AnonymousReality 07/28/2017.

Swift,63字节

func a(d:[Int]){var i=0;while i 

这是我的第一次入场,所以我对规则不是100%肯定的,但希望这个回答足够了。 我对如何将输入输入系统的规则有点不确定。 如果允许某个可以返回输入的函数,我有一个较短的答案。

2 comments
Stephen 07/28/2017
欢迎来到PPCG! 默认的规则是你可以让代码充当完整的程序,所以在STDIN中输入(通常)并输出(通常)到STDOUT or函数,所以通常从函数参数和输出(通常)输入函数返回。
AnonymousReality 07/28/2017
@StepHen - 谢谢! 我想这会让我的其他版本无效。 期待更多贡献!

Perl 6,31字节

 {(@_,{.[1+.[0]..*]}...^0)[*;0]} 

测试它

扩展:

 {  # bare block lambda with implicit parameter 「@_」
  (
    # generate a sequence

    @_,

    {
      .[ # index into previous value in the sequence
        1 + .[0]  # start by skipping one plus the first element
                  # of the previous value in the sequence
        ..  *     # use that to create a Range with no end
      ]
    }

    ...^  # keep doing that until: (and throw away last value)
    0     # it generates an empty list

  )[ *; 0 ]  # from every value in the sequence, get the first element
} 

为了帮助理解代码如何工作,没有[*;0]这会产生如下的序列:

 [0, 1, 0, 2, 5, 1, 3, 1, 6, 2],
   (1, 0, 2, 5, 1, 3, 1, 6, 2),
         (2, 5, 1, 3, 1, 6, 2),
                  (3, 1, 6, 2) 

Renzo 07/29/2017.

Common Lisp,51字节

(do((x(read)(nthcdr(1+(print(car x)))x)))((not x))) 

在线试用!


C ++(gcc),172字节

#includeint main(){std::istream& i=std::cin;char c;int a,b;while(i>>c&&i>>a){std::cout<>c&&i>>b);}std::cout< 

在线试用

可怕的(c/91?"":" ")是用于输出中正确的间距。 如果没有它(-15字节),输出形式为: [0,2,4] ,当我将其更改为简单的" " (-9字节)时,输出类似于[ 0, 2, 4] [0,2,4] [ 0, 2, 4] (开头为附加空间) 。

<<(c/93?"":"]")最后只是处理[]空输入转角的情况

打印没有尾随线。

1 comments
Erik the Outgolfer 07/30/2017
您还可以打印由无数字分隔符分隔的数字,不需要[]并且您可以为该边缘情况输出空白,并且不需要(c/91?"":" ") 。 您不必与挑战中的示例格式相匹配。

Jonathan Allan 07/29/2017.

果冻 ,8 个字节

ḢṄ‘ṫ@µL¿ 

一个完整的程序打印每个结果后跟一个换行符(空列表不产生输出)。

Try it online!

怎么样?

ḢṄ‘ṫ@µL¿ - Main link: list of non-negative integers  e.g. [2,5,4,0,1,2,0]
       ¿ - while:           Iteration:  1                  2             3          4        5
      L  -   length (0 is falsey)       7                  4             3          1        0
     µ   - ...do:                                                                            stop
Ḣ        -   head (pop & modify)        2 ([5,4,0,1,2,0])  0 ([1,2,0])   1 ([2,0])  0 ([0])
 Ṅ       -   print it (and yield it)   "2\n"              "0\n"         "1\n"      "0\n"
  ‘      -   increment                  3                  1             2          1
   ṫ@    -   tail from index            [0,1,2,0]          [1,2,0]      [0]         []
         -
         -                       i.e. a resulting in the printing of: '''2
                                                                         0
                                                                         1
                                                                         0
                                                                         ''' 
2 comments
Erik the Outgolfer 07/30/2017
最后一个果冻答案! 顺便说一句,我可以做到7字节。
Erik the Outgolfer 07/30/2017
我还有一个18字节的列表返回函数。

Evpok 07/30/2017.

Python 3,35字节

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

在线试用!

f(*l)运行它,其中l是您的输入。 可以延伸的输入规则,但我只是喜欢高级拆包。


cliffroot 07/28/2017.

Clojure,67字节

#(nth(reduce(fn[[z k]b](if(= z 0)[b(conj k b)][(- z 1)k]))[0[]]%)1) 

从初始参数[0 []] ,其中0是计数器, []是结果。 如果此列表中的第一个元素为0 ,则将参数n添加到结果中,并进一步传递该列表[n [... n]]否则递减第一个元素。 (这个解释对我来说很可怕)

在线查看


Dead Possum 07/28/2017.

Python 2.4,85字节

没有机会用python获胜,但我喜欢线上人物,这可能会让其他人感兴趣。
原来,有一种幻想技巧可以用于理解内部的建筑物列表,但它只能在2.4版本中使用,并且在<= 2.3中进行了一些编辑
locals()['_[1]']是。 Python为列表创建秘密名称_[1] ,同时创建它并将其存储在locals 。 名称_[2]_[3] ...也用于嵌套列表。

lambda n:[j for i,j in enumerate(n)if i==len(locals()['_[1]'])+sum(locals()['_[1]'])] 

因此,它计算已添加元素的数量加上它们的总和。 结果是下一个所需元素的索引。
我认为,应该有一种方法来避免枚举。 就像直接通过索引访问输入数组一样: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ] 。 但我无法想出一个紧凑的方法来保护它免受索引超出范围(同时保留它的内容)

在这里输入图像描述


Neil 07/28/2017.

批量,69字节

:l
@if not "%1"=="" echo %1&(for /l %%i in (0,1,%1)do @shift)&goto l 

(我需要() s for否则goto会在循环中发生。)

Related questions

Hot questions

Language

Popular Tags