В моей предыдущей проверке кода я попросил вас написать функцию, которая сообщит вам, какая из его строк была удалена.

Инструкции были:

Напишите функцию, которая содержит пять строк.

Если вы запустите функцию как есть, она должна вернуть 0.

Если вы удалите одну из пяти строк и запустите функцию, она должна сообщить вам, какая из строк была удалена (например, если вы удалите последнюю строку, она должна вернуть 5).

Теперь давайте попробуем что-нибудь более сложное.

Следуйте тем же правилам, что и выше, но на этот раз функция должна вернуть массив, сообщающий, какие две строки были удалены.

Так, например, если я удаляю строки 1 и 5, возвращаемое значение должно быть [1,5], а если я удаляю строки 3 и 4, возвращаемое значение должно быть [3,4].

Опять же, если ни одна строка не удалена, функция должна вернуть 0. Бонусные баллы, если вы также можете обрабатывать случай с удалением в одну строку, но это не является строго обязательным для вас.

Можете ли вы использовать вспомогательные функции? Да, но только если ты должен. Единственная автономная функция, которая выполняет это, является идеалом.

Как и в случае с последним испытанием, выигрывает решение с наибольшим количеством голосов. Я выберу победителя через неделю или раньше, если в течение 24 часов не было получено новых заявок.

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

Это на самом деле работает для любого количества удаленных строк (если это не все строки, то есть) и может быть тривиально расширено до более чем 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()
}

Golfed:

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

Как это работает: моя идея заключалась в следующем: создать массив и в каждой строке удалить определенное значение. Итак, в первой строке у меня есть массив [ 1, 2, 3, 4, 5]с 1удаленным элементом . Во второй строке, если aона уже определена, удалите элемент 2. В противном случае создайте новый массив с 2удаленным элементом . Сделайте то же самое для строки 3. В строке 4 вы можете быть уверены, что уже создан массив, поэтому просто удалите элемент 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
}

играть на скрипке

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)

Называй это как хочешь, но я думаю, что это красиво .

Позволяет узнать, какие строки были удалены (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- All или 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 строк. Если вы удалите все строки, он вернется так же, как если бы вы удалили ни одной.

NB. Заканчивать круглые скобки на отдельной строке считается плохим стилем, но поскольку другие языки имеют, 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, которая я считаю лучше (но использует вспомогательную функцию):

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утверждения, но это справедливо, если я конкурирую с языками с неявным возвратом.

р

Простая версия (не надежная, так как вы получите ошибку, если удалите строку 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}, она также будет работать для всех пяти строк, она также обрабатывает одну строку, удаляет контрольный пример автоматически я просто использую биты переменной в качестве флага для каждой строки ....