在上一个代码挑战中，我要求您编写一个函数来告诉您哪些行已被删除。

说明是：

编写一个包含五行的函数。

如果按原样运行该函数，则应返回0。

如果您删除了五行中的任何一行并运行该函数，它应该告诉您哪些行已被删除（例如，如果您删除最后一行，则应返回5）。

现在，让我们尝试一些更加困难的事情。

遵循与上述相同的规则，但是这次，函数应返回一个数组，告诉您已删除了两行。

因此，例如，如果我删除第1行和第5行，则返回值应为[1,5]，如果我删除第3行和第4行，则返回值应为[3,4]。

同样，如果没有删除任何行，则该函数应返回0。如果您还可以处理删除了一行的情况，则奖励积分，但并非必须这样做。

可以使用辅助功能吗？是的，但前提是您必须这样做。理想的选择是一个独立的功能。

与上一个挑战一样，获得最高支持的解决方案将获胜。我会在一周内选出优胜者；如果24小时内未收到任何新的作品，我会尽快选出。

佩尔

sub foo {
    @a = (2..5);
    @a = grep $_ != 2, (@a ? @a : (1..5));
    @a = grep $_ != 3, (@a ? @a : (1..5));
    @a = grep $_ != 4, (@a ? @a : (1..5));
    @a = grep $_ != 5, (@a ? @a : (1..5));
}

实际上，这对于删除的任何数量的行都适用（只要不是所有的行即可），并且可以轻松扩展到多于5行。没有使用辅助函数，甚至每行只使用一个语句。它依赖于以下事实：在没有显式return语句的情况下，Perl函数的返回值就是其中的最后一条语句的值。

请注意，（在列表上下文中）如果未删除任何行，此代码将返回一个空列表，而不是数字0。这可能是固定的（例如，通过@a ? @a : 0;在最后一行后面加上“ ”），但会使代码更难看。无论如何，在标量上下文中，它确实返回已删除的行数，如果未删除任何行，则返回0。;-)

红宝石

与Perl版本类似，但在Ruby中。如果没有按要求删除任何行，我将返回0，但是我同意这会使代码更丑陋，并且作为返回值不太有意义。

def which_lines_removed(arr = [*1..5])
  arr -= [1]
  arr -= [2] 
  arr -= [3] 
  arr -= [4] 
 (arr -= [5]).empty? ? 0 : arr
end

如果在不删除任何行的情况下，可以使用空数组作为返回值，则代码如下所示：

def which_lines_removed(arr = [*1..5])
  arr -= [1]
  arr -= [2] 
  arr -= [3] 
  arr -= [4] 
  arr -= [5]
end

两种方法都适用于从0到5之间删除的任意数量的行。

JavaScript，打了152个字符

function t() {
    var fa = (f + '').match(/\d/g)
    var ra = []
    for (var i = 0; i < 5; i++) {
        if (fa.indexOf(i + '') < 0) ra.push(i + 1)
    }
    return ra
}

function f() {
    0; return t()
    1; return t()
    2; return t()
    3; return t()
    4; return t()
}

打高尔夫球：

function t(){for(a=[],i=0;++i<5;)if((f+'').indexOf(i)<0)a.push(i+1);return a}function f(){
return t(0)
return t(1)
return t(2)
return t(3)
return t(4)
}

自给自足（但丑陋）：

function f() {
    0; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    1; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    2; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    3; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    4; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
}

基本利用功能 toString通过对每行编号来。请注意，您实际上必须因此删除该行（注释掉将不起作用）。

这实际上适用于删除的任何行！它会返回一个删除行的数组，如果没有删除行，则返回一个空数组。（我可以轻松地将其更改为返回零（通过替换return ra为return ra || 0），但是我喜欢空数组解决方案，因为它在现实世界中会更加有用。）

例如，删除第一行将返回[1]，而删除除第一行以外的所有内容将返回[2,3,4,5]。（当然，如果您删除所有行，它将不起作用;-)）

红宝石

def f
    a = [ 2, 3, 4, 5 ]
    defined?(a) ? a = a.select { |num|    num != 2 } : a = [ 1, 3, 4, 5 ]
    defined?(a) ? a = a.select { |num|    num != 3 } : a = [ 1, 2, 4, 5 ]
    a = a.select { |num|    num != 4 }
    (a = a.select { |num|    num != 5 }) == [] ? a = 0 : a
end

工作原理：我的想法是：创建一个数组，然后在每一行上删除一个特定值。因此，在第一行中，我实际上具有array [ 1, 2, 3, 4, 5]，而元素1已删除。在第二行（如果a已定义）中，删除element 2。否则，创建一个2删除了元素的新数组。对第3行执行相同的操作。在第4行，可以确保已经创建了一个数组，因此只需删除element即可4。在第5行，首先删除元素5，然后如果a为空数组，则返回0。否则，返回a。

蟒蛇

f=lambda:{1,2,3,4,5}-{
1,
2,
3,
4,
5,
} or 0

如果没有删除任何行，则返回0，否则返回删除的行。您可以删除1至5行，第0行和第6行除外；-)。

JavaScript中，自包含的，适用于0，1，2条除去线（607  315 186个字符）

→ 现场演示 ←

像其他挑战一样，滥用JS变量提升和全局泄漏：)

function(r){
r.shift();
r.splice(r.indexOf(2),1)
r.splice(r.indexOf(3),1);a=b=1;if(this.a&&this.b)return r
var a;r.splice(r.indexOf(4),1);b=1;if(this.b)return r
var b;r.pop();return r[0]?r:0
}

以数组[1,2,3,4,5]作为参数调用。

315个字符

function(r){
var a;
var b;
var c;a=1;b=2;d=4;e=5;for(i in(z="abde".split("")))if(y=this[z[i]])r.push(y);return r.length?r:0
var d;a=1;b=2;c=3;e=5;for(i in(z="abce".split("")))if(y=this[z[i]])r.push(y);return r.length?r:0
var e;a=1;b=2;c=3;d=4;for(i in(z="abcd".split("")))if(y=this[z[i]])r.push(y);return r.length?r:0
}

以一个空数组作为参数调用。

非高尔夫版本

（也适用于已删除的3和4行）：

function(r){
var a;b=c=d=e=1;if(this.b)r.push(2);if(this.c)r.push(3);if(this.d)r.push(4);if(this.e)r.push(5);return r.length?r:0;
var b;a=c=d=e=1;if(this.a)r.push(1);if(this.c)r.push(3);if(this.d)r.push(4);if(this.e)r.push(5);return r.length?r:0;
var c;a=b=d=e=1;if(this.a)r.push(1);if(this.b)r.push(2);if(this.d)r.push(4);if(this.e)r.push(5);return r.length?r:0;
var d;a=b=c=e=1;if(this.a)r.push(1);if(this.b)r.push(2);if(this.c)r.push(3);if(this.e)r.push(5);return r.length?r:0;
var e;a=b=c=d=1;if(this.a)r.push(1);if(this.b)r.push(2);if(this.c)r.push(3);if(this.d)r.push(4);return r.length?r:0;
}

以一个空数组作为参数调用。

JavaScript：

var f = function(){
    1
    2
    a=[];for(i=0;i++<6;){if((f+'').indexOf(i)<0){a.push(i)}}return a.length?a:0;3
    a=[];for(i=0;i++<6;){if((f+'').indexOf(i)<0){a.push(i)}}return a.length?a:0;4
    a=[];for(i=0;i++<6;){if((f+'').indexOf(i)<0){a.push(i)}}return a.length?a:0;5
}

小提琴

Java脚本

(function (i){

i += .1;     // line 1
i += .02;    // line 2
i += .003;   // line 3
i += .0004;  // line 4
i += .00005; // line 5

return (Math.round((.12345-i)*100000)/100000+'').match(/([1-5])/g) || 0 })(0)

随便怎么说，但我认为它很漂亮。

让您知道哪些行已删除（1条或更多）；如果未删除任何行，则为0。可以删除所有5条线。

编辑：

因为引起我注意，我的代码实际上可能由6行组成，并且违反了规则，所以我将其调整为以下内容：

(Math.round((.12345 - (new (function(){

    this.i = isFinite(this.i) ? this.i + .1 : .1 ;
    this.i = isFinite(this.i) ? this.i + .02 : .02;
    this.i = isFinite(this.i) ? this.i + .003 : .003; 
    this.i = isFinite(this.i) ? this.i + .0004 : .0004;
    this.i = isFinite(this.i) ? this.i + .00005 : .00005; 

})().i || 0) )*100000)/100000+'').match(/([1-5])/g) || 0

同样适用-将返回删除的行的数组，范围从1- 全部或0（如果没有）。

普通口齿不清

(defun which-lines-are-removed (&aux (x (list 1 2 3 4 5))) 
  (setq x (remove-if #'(lambda (x) (eql x 1)) x))
  (setq x (remove-if #'(lambda (x) (eql x 2)) x))
  (setq x (remove-if #'(lambda (x) (eql x 3)) x))
  (setq x (remove-if #'(lambda (x) (eql x 4)) x))
  (setq x (remove-if #'(lambda (x) (eql x 5)) x))
)

它适用于删除1-4行。如果删除所有行，将返回与删除所有行相同的结果。

注意：在自己的行上end加上结尾括号被认为是不好的风格，但是由于其他语言也有，}我认为是允许的。

蟒蛇

def function(a = [1,2,3,4,5]):
    delete(a, len(a)-5)#1
    delete(a, len(a)-4)#2
    delete(a, len(a)-3);print a if len(a)==2 else '',#3
    delete(a, len(a)-2);print a if len(a)==2 else '',#4
    delete(a, len(a)-1);print a if len(a)==2 else '',#5

def delete(a, i):
    del a[i]
    return a

它适用于所有行-但只有删除了两个行。如果仅删除一行，则将打印已删除的行和第5行。如果删除了太多行，将不打印任何内容。

这使用了一个辅助函数，因为del关键字不能与;一起使用（据我所知）

基本上，每一行都会在构造函数中声明的数组中删除自身，然后，如果删除了足够多的行，则会打印该数组。

此函数有两种方式错过规格：

1. 如果按原样运行，它不会打印0（它假定最后两行已被注释，因此打印4、5
2. 它假定print和return是可互换的

德贾武

适用于删除任意数量的行（只要您保留至少一行）

local line n:
    try:
        dup
    catch stack-empty:
        dup set{ 1 2 3 4 5 }
    delete-from swap n

func which-gone:
    line 1
    line 2
    line 3
    line 4
    line 5

[R

我认为R中有另一个版本更好（但使用了辅助函数）：

trick <- function(sym, value) {
  assign(sym, value, envir=parent.frame())
  values <- unlist(as.list(parent.frame()))
  if(length(values)==5) 0 else which(!1:5 %in% values)
}

reportRemovedLines <- function(){
  trick("a", 1)
  trick("b", 2)
  trick("c", 3)
  trick("d", 4)
  trick("e", 5)
}

或者可以通过将辅助函数定义为默认参数来避免使用该辅助函数（工作原理相同，但可读性较低-但是，它不使用“单独定义的”辅助函数）：

funnyVersion <- function(trick = function(sym, value) {
  assign(sym, value, envir=parent.frame())
  values <- unlist(as.list(parent.frame()))
  if(length(values)==5) 0 else which(!1:5 %in% values)
}){
  trick("a", 1)
  trick("b", 2)
  trick("c", 3)
  trick("d", 4)
  trick("e", 5)
}

两者reportRemovedLines()和都funnyVersion()可以删除任何数量的行-除非您删除所有行（在这种情况下，它们将返回NULL）。他们实际上回来了行号，而不仅仅是打印它们-如R中所示，将自动返回函数中计算的最后一个表达式的值。

它是如何工作的？诀窍是在trick函数中，该函数从其“父环境”（即调用它的函数的环境）中获取所有对象，将它们的值放到一个向量中，然后返回，这些值从1到5不表示。

JavaScript（136/166个字符）

一个较小的版本，在开头声明了一些值：

function(){b=[1,2,3,4,5],i=0
    b.splice(0,1);i++
    b.splice(1-i,1);i++
    b.splice(2-i,1);i++
    b.splice(3-i,1);i++
    b.splice(4-i,1);i++
return b}

一个独立的版本（您无需传递任何内容-b参数在那里，因此我可以检查b是否用定义||）

function(b){
    b=[2,3,4,5],i=1
    b=b||[1,2,3,4,5],i=i||0,b.splice(1-i,1);i++
    b=b||[1,2,3,4,5],i=i||0,b.splice(2-i,1);i++
    b.splice(3-i,1);i++
    b.splice(4-i,1);i++
return b}

是的，两者都有return陈述，但是只有当我与具有隐式收益的语言竞争时，这才是公平的。

[R

一个简单的版本（不是万无一失的，因为删除第5行会出现错误）：

doit <- function() setdiff(1:5, c(
       1,
       2,
       3,
       4,
       5
    ))

和一个万无一失的版本：

doit<-function() setdiff(1:5, scan(text="
1
2
3
4
5
"))

它可以删除任意数量的行（除非删除所有行），并且可以轻松扩展到多于5行。按原样运行它将返回integer(0)，这在概念上类似于仅返回0。返回实际的0将使其更丑陋和更长，但并不复杂。

最后，使用魔术的版本：

辅助功能：

dysfunction <- function(E){
    FUN <- function(){}
    e <- substitute(E)
    e[[1]] <- as.name("list")
    nb <- quote(setdiff(as.list(1:5), x))
    nb[[3]] <- e
    body(FUN) <- nb
    FUN
    }

实际功能：

df <- dysfunction({
1
2
3
4
5
})

C ++

void function(int & i)
{
        i=i|1;
        i=i|2;
        i=(i|4);
        i=(i|8);
        i=(i|16);
} 


int[] func2(int i)
{
    int arr[]={0,0};
    int k=0,l=1;
    for(int j=1;j<=16;j*=2,l++)
    {
        if((i&j)==0)
        {
             arr[k++]=l;
        }
    }
    return arr;
}

使用方法：使用i调用该函数，然后使用func2来了解该函数在说什么。

如果将行int arr [] = {0,0}更改为int arr [] = {0,0,0,0,0}，则该行也将适用于所有五行，这也是手动删除一行测试用例自动地，我正在做的只是将变量的位用作每行的标志。