Escribe una función que contenga cinco líneas.

Si ejecuta la función tal como está, debería devolver 0.

Si elimina cualquiera de las cinco líneas y ejecuta la función, debería indicarle cuál de las líneas se ha eliminado (por ejemplo, si elimina la línea final, debería devolver 5).

La brevedad, la novedad y la elegancia merecen consideración. La solución más votada (después de un tiempo razonable) gana.

Rubí

Evitando los números mágicos ya que no es un código de golf.

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

Cada línea elimina su propio número 1^2^3^4^5. Es Ruby, por lo que la última línea define el valor de retorno.

JavaScript ( 134   77   69   65   60 caracteres)

→ demostración en vivo ←

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

llama a esta función con n = 10.

• Si no falta ninguna línea, la línea 5 devuelve n == 0.
• Si falta la línea 1, la línea 5 devuelve n == 1.
• Si falta la línea 2, la línea 5 devuelve n == 2.
• Si falta la línea 3, la línea 5 devuelve n == 3.
• Si falta la línea 4, la línea 5 devuelve n == 4.
• Si falta la línea 5, la var "a" se vuelve global y la línea 4 detecta que devuelve "5".
• Si la línea 5 está presente, el motor JS realiza "elevación variable", "a" se convierte en una var local y la línea 4 no devuelve "5".

Versión anterior:

65 caracteres

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

(debe llamarse con 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
}

(debe llamarse con 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
}

no golfizado

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

Pitón

Si se permiten parámetros, esto 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
}

La función utiliza "constantes" incorporadas y asigna otro valor a cada una de ellas. Si todas estas variables son iguales al nuevo valor, la función devuelve 0. Los valores lógicos se transforman en numéricos debido a los operadores matemáticos. Los paréntesis alrededor de la cuarta línea permiten devolver visiblemente su resultado (si es el último comando).

Lua 5.2+

55 caracteres en el cuerpo de la función excluyendo nuevas líneas. No se me ocurrió nada mejor, pero esto:

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

Con la esperanza de obtener puntos extra por abuso de comentarios: P

La razón por la que no funciona en 5.1 es que los anidados [[]]se eliminaron, y en 5.1 da un error de compilación en lugar de ignorarlo como lo hace 5.2.

• Si no se elimina ninguna de las líneas, el cuerpo de la función es equivalente a return 7-2-5
• Si se elimina la primera línea, return 1
• Si el segundo return 7-5
• Si el tercero return 7-2-2
• Si el cuarto return 7-2-1
• Si el quinto, return 7-2

Rubí

¡Intenté hacerlo con operaciones bit a bit y luego me di cuenta de que hay una solución mucho más simple usando listas! Este desafío se cumple mejor con un lenguaje de programación que devuelve automáticamente el último valor que ve, 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

Befunge no tiene funciones explícitas, pero esto es lo que llamaría una función en Befunge:

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

La primera y la última línea son inicio de función y fin de función. Hace lo más parecido a "retorno", es decir, empuja el valor correcto a la pila.

Nueva respuesta

Encontré otra solución. Eso es tan malo, me gustó mucho la matemática. Esta solución usa recursividad y variables globales (¡qué asco!) Para saber si cada línea se ejecutó o no. Quería hacer algo diferente de las otras soluciones, por lo que no es muy elegante, pero funciona correctamente :)

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

Realmente disfruté este desafío, ¡gracias! :)

Vieja respuesta

Lo resolví usando las matemáticas. Si cada variable se ve como desconocida, y hacemos una declaración por línea, hay cinco incógnitas y cinco líneas de código: esto nos lleva al siguiente 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.

Una vez que encontré los valores, los codifiqué y agregué algunas cosas 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: La respuesta anterior no funcionará si se deja como está.

cera de abejas , 86 bytes

Probar mi primer esolang inventado. Después de la confusión inicial, descubrí que la solución es muy simple.

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

Explicación:

Los programas de cera de abejas funcionan en una cuadrícula hexagonal 2D. Los programas se almacenan en formato rectangular.

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

se almacena como

abcd
efgh
ijkl

Las instrucciones para moverse en ciertas direcciones son:

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

Explicación breve

_1 p Cree una IP, agregue 1, luego redirija la IP a la línea 2

_^v>~2+p Cree otra IP, en caso de que falte la línea 1, reduzca la velocidad de la IP para asegurarse de que la IP de la línea uno esté adelante, luego agregue 2, luego redirija a la línea 3

> >~3+p Agregue 3, luego redirija a la línea 4

> >~4+X@7~8+~@$^^{; Agregue 4, luego establezca el segundo valor de lstack en 15, luego XOR lstack top y 2nd valores, reduzca la velocidad de IP (para asegurarse de que la IP en la línea 5 está adelante, si existe la línea 5) y envíe el resultado, luego finalice el programa.

> >~5+@7~8+~@${; Agregue 5, luego haga lo mismo que en la línea 4, excepto la ralentización.

Básicamente, el programa solo calcula una suma xo 15

• Programa intacto: (1 + 2 + 3 + 4 + 5) xo 15 = 0
• Falta la línea 1: (2 + 3 + 4 + 5) xo 15 = 1
• Falta la línea 2: (1 + 3 + 4 + 5) xo 15 = 2
• Falta la línea 3: (1 + 2 + 4 + 5) xo 15 = 3
• Falta la línea 4: (1 + 2 + 3 + 5) xo 15 = 4
• Falta la línea 5: (1 + 2 + 3 + 4) xo 15 = 5

El adicional >en las líneas 3 a 5 solo garantiza que si falta una de las líneas 2 a 4, la IP aún se redirige correctamente y no abandona el programa.

Puedes clonar mi intérprete de cera de abejas, escrito en Julia, desde mi repositorio de GitHub

El archivo Léame de GitHub está más actualizado y mejor estructurado que la página de esolangs.

MuPAD, 57 caracteres

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

LISP común:

(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: Tener paréntesis finales en su propia línea se considera un mal estilo, pero dado que otros idiomas tienen endy }supongo que está 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 $?

Todo es sencillo hasta la línea 5. Luego, debe detectar si la línea final se ha ido. Esto aprovecha los parámetros de función permitidos al llamarse recursivamente, una vez, para probar su propio valor de éxito cuando se le dice que falle en la línea 5, y si se elimina la línea 5, la línea 4 regresa en su 5lugar.

(Nota: se reduce a un mínimo de 131 caracteres si se elimina todo menos la función, eliminando espacios en blanco y cambiando / bin / bash a / 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)+"*");
};