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

Інструкції:

Напишіть функцію, яка містить п’ять рядків.

Якщо запустити функцію як є, вона повинна повернути 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()
}

Гольф:

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 символів)

→ live demo ←

Зловживання підйому змінної 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- Все або 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 не може використовуватися в рядку з a (наскільки я знаю)

В основному кожен рядок видаляє себе в масиві, який оголошений у конструкторі, тоді, якщо достатньо рядків було видалено, масив друкується.

Ця функція пропускає специфікацію двома способами:

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}, він також буде працювати для всіх п'яти рядків, це також ручне тестування одного рядка для вилучення рядка автоматично, що я роблю, це просто використовувати біти змінної як прапор для кожного рядка ....