Trong thử thách mã trước đây của tôi , tôi đã yêu cầu bạn viết một hàm cho bạn biết dòng nào đã bị xóa.

Các hướng dẫn là:

Viết hàm chứa năm dòng.

Nếu bạn chạy chức năng như hiện tại, nó sẽ trả về 0.

Nếu bạn xóa bất kỳ một trong năm dòng và chạy chức năng, nó sẽ cho bạn biết dòng nào đã bị xóa (ví dụ: nếu bạn xóa dòng cuối cùng, nó sẽ trả về 5).

Bây giờ, chúng ta hãy thử một cái gì đó khó khăn hơn một chút.

Thực hiện theo các quy tắc tương tự như trên, nhưng lần này, hàm sẽ trả về một mảng cho bạn biết dòng TWO nào đã bị xóa.

Vì vậy, ví dụ, nếu tôi xóa các dòng 1 và 5, giá trị trả về phải là [1,5] và nếu tôi xóa các dòng 3 và 4, giá trị trả về sẽ là [3,4].

Một lần nữa, nếu không có dòng nào bị xóa, hàm sẽ trả về 0. Điểm thưởng nếu bạn cũng có thể xử lý trường hợp loại bỏ một dòng, nhưng bạn không cần phải làm như vậy.

Bạn có thể sử dụng các chức năng của người trợ giúp? Có, nhưng chỉ khi bạn phải. Một chức năng độc lập duy nhất kéo ra điều này là lý tưởng.

Như với thử thách cuối cùng, giải pháp nâng cao nhất sẽ thắng. Tôi sẽ chọn người chiến thắng trong một tuần hoặc sớm hơn nếu không nhận được bài nộp mới nào trong 24 giờ.

Perl

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));
}

Điều này thực sự hoạt động đối với bất kỳ số dòng nào bị loại bỏ (miễn là nó không phải là tất cả các dòng), và có thể được mở rộng tầm thường đến hơn 5 dòng. Không có chức năng trợ giúp nào được sử dụng và thậm chí nó chỉ sử dụng một câu lệnh trên mỗi dòng. Nó dựa vào thực tế là, trong trường hợp không có returncâu lệnh rõ ràng , giá trị trả về của hàm Perl là giá trị của câu lệnh cuối cùng trong nó.

Lưu ý rằng (trong ngữ cảnh danh sách) mã này trả về một danh sách trống thay vì số 0 nếu không có dòng nào bị xóa. Điều này có thể được sửa chữa (ví dụ bằng cách thêm " @a ? @a : 0;" vào dòng cuối cùng), nhưng sẽ làm cho mã xấu hơn. Trong mọi trường hợp, trong ngữ cảnh vô hướng, nó sẽ trả về số lượng dòng bị xóa, sẽ là 0 nếu không có dòng nào bị xóa. ;-)

Hồng ngọc

Tương tự như phiên bản Perl, nhưng trong Ruby. Tôi trả về 0 nếu không có dòng nào bị xóa theo yêu cầu, nhưng tôi đồng ý rằng nó làm cho mã xấu hơn và không hoàn toàn có ý nghĩa như một giá trị trả về.

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

Nếu một mảng trống được chấp nhận là giá trị trả về khi không có dòng nào bị xóa, mã sẽ trông như thế này:

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

Cả hai phương pháp đều hoạt động đối với bất kỳ số dòng nào bị xóa trong khoảng từ 0 đến 5.

JavaScript, 152 ký tự được đánh gôn

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()
}

Chơi gôn

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)
}

Tự khép kín (nhưng xấu xí):

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
}

Về cơ bản khai thác chức năng toStringbằng cách đánh số từng dòng. Lưu ý rằng bạn thực sự phải xóa dòng vì điều này (nhận xét nó sẽ không hoạt động).

Điều này thực sự hoạt động cho bất kỳ số lượng dòng bị loại bỏ ! Nó sẽ trả về một mảng của các dòng bị loại bỏ, hoặc một mảng trống nếu không có dòng nào bị xóa. (Tôi có thể dễ dàng thay đổi điều đó để trả về số 0 (bằng cách thay thế return rabằng return ra || 0), nhưng tôi thích giải pháp mảng trống vì nó sẽ hữu ích hơn trong thế giới thực.)

Ví dụ: xóa dòng đầu tiên trả về [1]và xóa mọi thứ trừ dòng đầu tiên trả về [2,3,4,5]. (Tất nhiên, nó không hoạt động nếu bạn xóa tất cả các dòng ;-))

Hồng ngọc

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

Cách thức hoạt động: ý tưởng của tôi là: tạo một mảng và trên mỗi dòng, loại bỏ một giá trị cụ thể. Vì vậy, trên dòng đầu tiên, tôi thực sự có mảng [ 1, 2, 3, 4, 5], với phần tử 1bị loại bỏ. Ở dòng thứ hai, nếu ađã được xác định, loại bỏ phần tử 2. Nếu không, tạo một mảng mới với phần tử 2bị loại bỏ. Thực hiện tương tự cho dòng 3. Ở dòng 4, bạn có thể chắc chắn rằng đã có một mảng được tạo, vì vậy chỉ cần loại bỏ phần tử 4. Ở dòng 5, đầu tiên loại bỏ phần tử 5và nếu asau đó là một mảng trống, trả về 0. Nếu không, trở lại a.

Con trăn

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

Trả về 0 nếu không có dòng nào bị xóa, nếu không thì trả về các dòng bị xóa. Bạn có thể xóa 1 đến 5 dòng, ngoại trừ dòng 0 và 6 ;-).

JavaScript, khép kín, hoạt động cho 0, 1, 2 dòng bị xóa ( 607  315 186 ký tự)

→ bản demo trực tiếp ←

Lạm dụng biến JS cẩu và rò rỉ toàn cầu, như trong thử thách khác :)

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
}

được gọi với mảng [1,2,3,4,5] làm tham số.

315 ký tự

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
}

được gọi với một mảng trống làm tham số.

phiên bản không chơi gôn

(cũng hoạt động cho 3 và 4 dòng bị xóa):

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;
}

được gọi với một mảng trống làm tham số.

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
}

vĩ cầm

Javascript

(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)

Gọi nó là những gì bạn thích, nhưng tôi nghĩ nó đẹp .

Cho phép bạn biết những dòng nào đã bị xóa (1 hoặc nhiều hơn) hoặc 0 nếu không có dòng nào bị xóa. Tất cả 5 dòng có thể được gỡ bỏ.

CHỈNH SỬA:

Bởi vì tôi đã nhận thấy rằng mã của tôi thực sự có thể bao gồm 6 dòng và vi phạm các quy tắc, tôi đã điều chỉnh nó thành như sau:

(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

Áp dụng tương tự - nó sẽ trả về một loạt các dòng bị loại bỏ từ 1- Tất cả hoặc 0 nếu không có.

Lisp thường gặp

(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))
)

Nó hoạt động để loại bỏ 1-4 dòng. Nếu bạn xóa tất cả các dòng, nó sẽ trả về giống như khi bạn xóa không có dòng nào.

Lưu ý: Việc kết thúc dấu ngoặc đơn trên dòng riêng của nó được coi là kiểu xấu, nhưng vì các ngôn ngữ khác có endvà }tôi cho rằng nó được cho phép.

Con trăn

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

Nó hoạt động cho tất cả các dòng - nhưng chỉ khi hai bị xóa. Nếu chỉ có một dòng bị xóa thì nó sẽ in dòng bị xóa và dòng 5. Nếu quá nhiều dòng bị xóa, nó sẽ không in bất cứ thứ gì.

Điều này sử dụng chức năng trợ giúp vì từ khóa del không thể được sử dụng trong một dòng với a; (theo như tôi biết)

Về cơ bản, mỗi dòng sẽ tự xóa trong mảng được khai báo trong hàm tạo, sau đó nếu đủ các dòng đã bị xóa thì mảng được in.

Hàm này bỏ lỡ thông số theo hai cách:

1. nó không in 0 nếu nó chạy như hiện tại (nó giả sử hai dòng cuối cùng đã được nhận xét và do đó in 4, 5
2. Nó giả định rằng printvà returncó thể hoán đổi cho nhau

Đức Bà Vũ

Hoạt động để loại bỏ bất kỳ số lượng dòng (miễn là bạn để lại ít nhất một dòng)

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

Tôi có một phiên bản khác trong R mà tôi nghĩ là tốt hơn (nhưng sử dụng chức năng trợ giúp):

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)
}

Hoặc người ta có thể tránh sử dụng hàm trợ giúp bằng cách xác định nó làm đối số mặc định (hoạt động giống hệt nhưng ít đọc hơn - tuy nhiên, nó không sử dụng hàm trợ giúp "được xác định riêng"):

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)
}

Cả hai reportRemovedLines()và funnyVersion()hoạt động với bất kỳ số dòng nào bị xóa - ngoại trừ nếu bạn xóa tất cả các dòng (trong trường hợp đó, chúng sẽ trả về NULL). Chúng thực sự trả về số dòng, không chỉ in chúng - như trong R, giá trị của biểu thức cuối cùng được đánh giá trong một hàm sẽ tự động được trả về.

Làm thế nào nó hoạt động? Thủ thuật nằm ở trickhàm lấy tất cả các đối tượng từ "môi trường cha" của nó (nghĩa là môi trường của hàm gọi nó), đặt các giá trị của chúng lại với nhau trong một vectơ và trả về, các giá trị từ 1 đến 5 không được biểu diễn.

JavaScript (136/166 ký tự)

Một phiên bản nhỏ hơn với một số giá trị được khai báo ở đầu:

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}

Một phiên bản độc lập (bạn không cần phải vượt qua bất cứ điều gì - đối số b ở đó để tôi có thể kiểm tra xem b có được xác định không ||)

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}

Vâng, cả hai đều có returntuyên bố, nhưng điều đó chỉ công bằng nếu tôi cạnh tranh với các ngôn ngữ với lợi nhuận ngầm.

R

Một phiên bản đơn giản (không thể đánh lừa vì bạn sẽ gặp lỗi nếu xóa dòng 5):

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

Và một phiên bản hoàn hảo:

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

Nó hoạt động với bất kỳ số dòng nào bị loại bỏ (trừ khi bạn loại bỏ tất cả các dòng) và có thể dễ dàng được mở rộng đến hơn 5 dòng. Chạy nó "như là" sẽ trở lại integer(0), về mặt khái niệm tương tự như chỉ trở lại 0. Trả về 0 thực tế sẽ làm cho nó xấu hơn và dài hơn nhưng sẽ không phức tạp.

Cuối cùng, một phiên bản sử dụng phép thuật:

Chức năng trợ giúp:

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
    }

Các chức năng thực tế:

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;
}

Cách sử dụng: gọi hàm với i và sử dụng func2 để hiểu rằng hàm đang nói gì.

Nếu bạn thay đổi dòng int Array [] = {0,0} thành int Array [] = {0,0,0,0,0} thì nó cũng sẽ hoạt động cho tất cả năm dòng, nó cũng là dòng xử lý loại bỏ một dòng tự động, những gì tôi đang làm chỉ đơn giản là sử dụng một bit của biến làm cờ cho mỗi dòng ....