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

Brevidade, novidade e elegância merecem consideração. A solução mais votada (após um período de tempo razoável) vence.

Rubi

Evitando números mágicos, pois não é um código de golfe.

def f
  r=2^3^4^5
  defined?(r) ? r^=2 : r=1^3^4^5
  r^=3
  r^=4
  r^=5
end

Cada linha retira seu próprio número 1^2^3^4^5. É Ruby, então a última linha define o valor de retorno.

JavaScript ( 134   77   69   65   60 caracteres)

→ demonstração ao vivo ←

function(n){
a=n-=1
n-=2
+3
+4;if(this.a)return 5
return n;var a
}

chame esta função com n = 10.

• Se nenhuma linha estiver faltando, a linha 5 retornará n == 0.
• Se a linha 1 estiver ausente, a linha 5 retornará n == 1.
• Se a linha 2 estiver ausente, a linha 5 retornará n == 2.
• Se a linha 3 estiver ausente, a linha 5 retornará n == 3.
• Se a linha 4 estiver ausente, a linha 5 retornará n == 4.
• Se a linha 5 estiver ausente, o var "a" se tornará global e a linha 4 detectará que retornará "5".
• Se a linha 5 estiver presente, o mecanismo JS executará "içamento variável", "a" se tornará uma var local e a linha 4 não retornará "5".

Versões prévias:

65 caracteres

function(n){
a=n-=1
n-=2
+3
+4;if(this.a)return 5
n-=5;return n;var a
}

(deve ser chamado com n = 15)

69 caracteres

function(n){
n-=1
n-=2
n-=3
a=n-=4;if(this.a)return 5
n-=5;return n;var a
}

(deve ser chamado com n = 15)

77 caracteres

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

134 caracteres

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

sem golfe

  function whichlineisremoved(){
    /* 1 */ var a = 1; e = 1; if(window.e) return 5;
    /* 2 */ var b = 1, a; if(!a) return 1;
    /* 3 */ var c = 1, b; if(!b) return 2;
    /* 4 */ var d = 1, c; if(!c) return 3;
    /* 5 */ var e = 1, d; if(!d) return 4; return 0;
  }

Python

Se parâmetros forem permitidos, isso funcionará:

def f(n=10):
    n -= 1
    n -= 2
    n -= 3
    if n == 4: return 0 if f(7) else 5
    return n - 4 or 4

R

f <- function() {
  T <- FALSE
  F <- TRUE
  month.abb <- TRUE
  (pi <- 5)
  T + (!F) * 2 + (!isTRUE(month.abb)) * 3 + (pi != 5) * 4
}

A função usa "constantes" internas e atribui outro valor a cada uma delas. Se todas essas variáveis ​​forem iguais ao novo valor, a função retornará 0. Os valores lógicos serão transformados em valores numéricos devido aos operadores matemáticos. Os parênteses em torno da quarta linha permitem retornar visivelmente o resultado (se for o último comando).

Lua 5.2+

55 caracteres no corpo da função, excluindo novas linhas. Eu não poderia pensar em nada melhor, mas isso:

function f()
return 7--[[
return 1--[=[]]-2
--[[
-2--[=[]]
-5--]=]--]]-1
end

Na esperança de obter pontos extras por abuso de comentários: P

O motivo pelo qual não funciona no 5.1 é que os aninhados [[]]foram removidos e no 5.1 ele gera um erro de compilação em vez de ignorá-lo, como o 5.2.

• Se nenhuma das linhas for removida, o corpo da função é equivalente a return 7-2-5
• Se a primeira linha for removida, return 1
• Se o segundo, return 7-5
• Se o terceiro, return 7-2-2
• Se o quarto, return 7-2-1
• Se o quinto, return 7-2

Rubi

Tentei fazê-lo com operações bit a bit e então percebi que há uma solução muito mais simples usando listas! Esse desafio é melhor atendido por uma linguagem de programação que retorna automaticamente o último valor que vê, como Ruby.

def tellMe(x=[1,2,3,4,5])
    x.delete(1)
    x.delete(2)
    x.delete(3)
    x.delete(4);x[0]
    x.delete(5);x==[]?0:x[0]
end

O Befunge não possui funções explícitas, mas aqui está o que eu chamaria de função no Befunge:

v^    <
>v
1>v
 2>v
##3>5v
$0v4 >
>>>>>>^

A primeira e a última linha são o início e o término da função. Faz a coisa mais próxima de "retornar", ou seja, coloca o valor correto na pilha.

Nova resposta

Encontrei outra solução. Isso é tão ruim, eu gostei muito da matemática. Essa solução usa variáveis ​​globais e de recursão (eca!) Para saber se todas as linhas foram executadas ou não. Eu queria fazer algo diferente das outras soluções, então isso não é muito elegante, mas funciona corretamente :)

PHP

function LOL($a) {
    if (!$a) { LOL(true); if (!$GLOBALS['b']) return 2; if (!$GLOBALS['c']) return 3; if (!$GLOBALS['d']) return 4; if (!$GLOBALS['e']) return 5; return 0; } 
    if ($a) $GLOBALS['b'] = true; else return 1;
    $GLOBALS['c'] = true;
    $GLOBALS['d'] = true;
    $GLOBALS['e'] = true;
}

Eu realmente gostei deste desafio, obrigado! :)

Resposta antiga

Eu resolvi isso usando matemática. Se cada variável é vista como desconhecida e fazemos uma declaração por linha, há cinco desconhecidas e cinco linhas de código: isso nos leva ao seguinte sistema 5x5:

b+c+d+e = 1;
a+c+d+e = 2;
a+b+d+e = 3;
a+b+c+e = 4;
a+b+c+d = 5;
//Solutions are displayed in the code below.

Depois de encontrar os valores, codifiquei-os e adicionei algumas coisas básicas.

PHP

function LOL(){
    $a = 2.75;
    $b = 1.75;
    $c = 0.75;
    $d = -0.25; if ($a+$b+$c+$d == 5) return $a+$b+$c+$d;
    $e = -1.25; return $a+$b+$c+$d+$e;
}

Nota: A resposta antiga não funcionará se for deixada como está.

cera de abelha , 86 bytes

Experimentando meu primeiro esolang inventado. Após confusão inicial, descobri que a solução é muito simples.

_1 p
_^v>~2+p
   >   >~3+p
       >   >~4+X@7~8+~@$^^{;
           >    >~5+@7~8+~@${;

Explicação:

programas de cera de abelha trabalham em uma grade hexagonal 2D. Os programas são armazenados em um formato retangular.

    a — b — c — d
   / \ / \ / \ /
  e — f — g — h
 / \ / \ / \ /
i — j — k — l

é armazenado como

abcd
efgh
ijkl

As instruções para se mover em determinadas direções são:

    b — d 
   / \ / \                                  bd
  < —IP — >    or in compact form (β=IP):   <β>
   \ / \ /                                   pq
    p — q

Breve explicação

_1 p Crie um IP, adicione 1 e redirecione o IP para a linha 2

_^v>~2+p Crie outro IP, caso a linha 1 esteja ausente, diminua a velocidade do IP para garantir que o IP da linha um esteja à frente, adicione 2 e redirecione para a linha 3

> >~3+p Adicione 3 e redirecione para a linha 4

> >~4+X@7~8+~@$^^{; Adicione 4, defina o 2º valor do lstack como 15 e, em seguida, o XOR lstack top e o 2º, reduza a velocidade do IP (para garantir que o IP na linha 5 esteja à frente, se a linha 5 existir) e emita o resultado e encerre o programa.

> >~5+@7~8+~@${; Adicione 5 e faça o mesmo que na linha 4, exceto a desaceleração.

Basicamente, o programa apenas calcula uma soma xor 15

• Programa intacto: (1 + 2 + 3 + 4 + 5) xor 15 = 0
• Linha 1 ausente: (2 + 3 + 4 + 5) xor 15 = 1
• Linha 2 ausente: (1 + 3 + 4 + 5) xor 15 = 2
• Linha 3 ausente: (1 + 2 + 4 + 5) xor 15 = 3
• Linha 4 ausente: (1 + 2 + 3 + 5) xor 15 = 4
• Linha 5 ausente: (1 + 2 + 3 + 4) xor 15 = 5

O adicional >nas linhas 3 a 5 apenas garante que, se uma das linhas 2 a 4 estiver ausente, o IP ainda será redirecionado corretamente e não sairá do programa.

Você pode clonar meu intérprete de cera de abelha, escrito em Julia, no meu repositório GitHub

O leia-me no GitHub é mais atualizado e melhor estruturado que a página esolangs.

MuPAD, 57 caracteres

subs(()->
-d(1)
-d(2)
-d(3)
-d(4)
-d(5)
,d=Dom::IntegerMod(15))

LISP comum:

(defun which-line-is-removed (&aux (x 30)) 
  (decf x 2)
  (decf x 4)
  (decf x 8)
  (decf x 16) 5
  (if (zerop x) 0 (log x 2))
)

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.

Bash, 131 caracteres

#!/bin/bash

# the function:
function f(){
  a=1;
  b=2;
  c=3;
  d=4;[ ! $1 ]&&f 1&&return 5||true
  [ $1 ]&&return 6;e=5;s=$((a+b+c+d+e));return $((15-$s))
}

# call it:
f
# report the result:
echo Removed line $?

Tudo é direto até a linha 5. Em seguida, ele precisa detectar se a linha final se foi. Isso tira proveito dos parâmetros de função permitidos, chamando a si próprio recursivamente, uma vez, para testar seu próprio valor de sucesso quando é instruído a falhar na linha 5 e, se a linha 5 for removida, a linha 4 retornará 5.

(Nota: o limite é de no mínimo 131 caracteres, se você retirar tudo, menos a função, deixar espaço em branco e alterar / bin / bash para / bin / sh)

Javascript

function(){
/*aa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(6)+"*")==-1)return 5;
/*aaa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(5)+"*")==-1)return 4;
/*aaaa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(3)+"*")==-1)return 2;
/*aaaaa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(4)+"*")==-1)return 3;
/*aaaaaa*/return +!~arguments.callee.toString().indexOf("*"+"a".repeat(2)+"*");
};