No meu desafio de código anterior , pedi que você escrevesse uma função que informa qual de suas linhas foi removida.

As instruções foram:

Escreva uma função que contenha cinco linhas.

Se você executar a função como ela é, ela deve retornar 0.

Se você remover qualquer uma das cinco linhas e executar a função, deverá informar qual das linhas foi removida (por exemplo, se você remover a linha final, ela retornará 5).

Agora, vamos tentar algo um pouco mais difícil.

Siga as mesmas regras acima, mas desta vez, a função retornará uma matriz informando que DUAS linhas foram removidas.

Assim, por exemplo, se eu remover as linhas 1 e 5, o valor de retorno deverá ser [1,5] e, se eu remover as linhas 3 e 4, o valor de retorno deverá ser [3,4].

Novamente, se nenhuma linha for removida, a função retornará 0. Pontos de bônus se você também puder lidar com o caso removido por uma linha, mas não é estritamente necessário que você faça isso.

Você pode fazer uso das funções auxiliares? Sim, mas somente se você precisar. Uma única função independente que realiza isso é o ideal.

Como no último desafio, a solução mais votada ganha. Escolherei o vencedor em uma semana ou mais cedo se nenhum novo envio foi recebido em 24 horas.

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

Na verdade, isso funciona para qualquer número de linhas removidas (desde que não sejam todas as linhas), e pode ser estendido trivialmente para mais de 5 linhas. Nenhuma função auxiliar é usada e ele usa apenas uma instrução por linha. Ele se baseia no fato de que, na ausência de uma returninstrução explícita , o valor de retorno de uma função Perl é o valor da última instrução nela.

Observe que (no contexto da lista) esse código retorna uma lista vazia em vez do número 0 se nenhuma linha foi excluída. Isso poderia ser corrigido (por exemplo, acrescentando " @a ? @a : 0;" a última linha), mas tornaria o código mais feio. Em qualquer caso, em escalar contexto, faz retornar o número de linhas removidas, o que irá ser 0 se não há linhas de ter sido removido. ;-)

Rubi

Semelhante à versão Perl, mas em Ruby. Retorno 0 se nenhuma linha for excluída conforme solicitado, mas concordo que torna o código mais feio e não faz muito sentido como um valor de retorno.

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

Se uma matriz vazia for aceitável como o valor de retorno quando nenhuma linha for excluída, o código será semelhante a este:

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

Ambos os métodos funcionam para qualquer número de linhas excluídas entre 0 e 5.

JavaScript, 152 caracteres jogados

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

Golfe:

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

Independente (mas feio):

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
}

Explora basicamente a função toStringnumerando cada linha. Observe que você realmente precisa remover a linha por causa disso (comentar não funcionará).

Isso realmente funciona para qualquer número de linhas removidas ! Ele retornará uma matriz das linhas removidas ou uma matriz vazia se nenhuma tiver sido removida. (Eu poderia facilmente mudar isso para retornar zero (substituindo return rapor return ra || 0), mas eu gosto da solução de matriz vazia, pois seria mais útil no mundo real.)

Por exemplo, remover a primeira linha retorna [1]e remover tudo, exceto a primeira linha [2,3,4,5]. (Obviamente, não funcionará se você remover todas as linhas ;-))

Rubi

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

Como isso funciona: minha ideia foi: criar uma matriz e, em cada linha, remover um valor específico. Então, na primeira linha, eu tenho o array [ 1, 2, 3, 4, 5], com o elemento 1removido. Na segunda linha, se ajá estiver definida, remova o elemento 2. Caso contrário, crie uma nova matriz com o elemento 2removido. Faça o mesmo para a linha 3. Na linha 4, você pode ter certeza de que já existe uma matriz criada; portanto, basta remover o elemento 4. Na linha 5, primeiro remova o elemento 5e, se afor uma matriz vazia, retorne 0. Caso contrário, retorne a.

Pitão

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

Retorna 0 se nenhuma linha for removida, caso contrário, retorna as linhas removidas. Você pode remover 1 a 5 linhas, exceto a 0ª e a 6ª linha ;-).

JavaScript, independente, funciona para 0, 1, 2 linhas removidas ( 607  315 186 caracteres)

→ demonstração ao vivo ←

Abuso de elevação variável de JS e vazamento global, como no outro desafio :)

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
}

para ser chamado com o array [1,2,3,4,5] como parâmetro.

315 caracteres

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
}

para ser chamado com uma matriz vazia como parâmetro.

versão sem golfe

(também funciona para 3 e 4 linhas removidas):

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

para ser chamado com uma matriz vazia como parâmetro.

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
}

violino

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)

Chame como quiser, mas acho bonito .

Permite saber quais linhas foram removidas (1 ou mais) ou 0 se nenhuma linha foi removida. Todas as 5 linhas podem ser removidas.

EDITAR:

Como soube que meu código na verdade consiste em 6 linhas e viola as regras, ajustei-o da seguinte maneira:

(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

O mesmo se aplica - ele retornará uma matriz de linhas removidas que variam de 1 - Todas ou 0, se nenhuma.

Lisp comum

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

Funciona para remoção de 1-4 linhas. Se você remover todas as linhas, ele retornará o mesmo que se você remover nenhuma.

NB: Ter parênteses finais em sua própria linha é considerado um estilo ruim, mas como outros idiomas têm ende }eu presumo que seja permitido.

Pitão

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

Funciona para todas as linhas - mas apenas se duas forem excluídas. Se apenas uma linha for excluída, ela imprimirá a linha e a linha 5. Se houver muitas linhas excluídas, não será impresso nada.

Isso usa uma função auxiliar porque a palavra-chave del não pode ser usada em uma linha com a; (tanto quanto eu sei)

Basicamente, cada linha se exclui na matriz que é declarada no construtor, se linhas suficientes foram excluídas, a matriz é impressa.

Essa função perde as especificações de duas maneiras:

1. não imprime 0 se for executado como está (assume que as duas últimas linhas foram comentadas e imprime 4, 5
2. Assume que printe returnsão intercambiáveis

Déjà Vu

Funciona para remover qualquer número de linhas (desde que você deixe pelo menos uma linha)

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

Eu tenho outra versão no R que eu acho que é melhor (mas usa uma função auxiliar):

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

Ou pode-se evitar o uso da função auxiliar definindo-a como um argumento padrão (funciona de forma idêntica, mas é menos legível - no entanto, ela não usa uma função auxiliar "definida separadamente"):

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

Ambos reportRemovedLines() e funnyVersion()funcionam com qualquer número de linhas removidas - exceto se você remover todas as linhas (nesse caso, elas retornarão NULL). Na verdade, eles retornam os números de linha, não apenas os imprimem - como em R, o valor da última expressão avaliada em uma função será retornado automaticamente.

Como funciona? O truque está notrick função que pega todos os objetos de seu "ambiente pai" (ou seja, ambiente da função que o chama), reúne seus valores em um vetor e retorna, cujos valores de 1 a 5 não são representados.

JavaScript (136/166 caracteres)

Uma versão menor com alguns valores declarados no início:

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}

Uma versão independente (você não precisa passar nada - o argumento b está lá para que eu possa verificar se b está definido com ||)

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}

Sim, ambos têm returndeclarações, mas isso é justo se eu estiver competindo com idiomas com retorno implícito.

R

Uma versão simples (não é infalível, pois você receberá um erro se remover a linha 5):

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

E uma versão infalível:

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

Ele funciona com qualquer número de linhas removidas (exceto se você remover todas as linhas) e pode ser facilmente estendido para mais de 5 linhas. Executá-lo "como está" retornará, o integer(0)que é conceitualmente semelhante a retornar apenas 0. Retornar um 0 real tornaria mais feio e mais longo, mas não seria complicado.

Finalmente, uma versão usando mágica:

Função auxiliar:

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
    }

A função real:

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

Como usar: chame a função com ie use func2 para entender o que a função está dizendo.

Se você alterar a linha int arr [] = {0,0} para int arr [] = {0,0,0,0,0}, ela também funcionará para todas as cinco linhas, também será handline uma linha remover caso de teste automaticamente, o que estou fazendo é simplesmente usar bits de uma variável como uma bandeira para cada linha ....