Écrivez une fonction qui contient cinq lignes.

Si vous exécutez la fonction telle quelle, elle doit retourner 0.

Si vous supprimez l'une des cinq lignes et exécutez la fonction, elle devrait vous indiquer laquelle des lignes a été supprimée (par exemple, si vous supprimez la dernière ligne, elle devrait renvoyer 5).

La concision, la nouveauté et l'élégance méritent toutes d'être prises en considération. La solution la mieux notée (après un laps de temps raisonnable) l'emporte.

Rubis

Éviter les nombres magiques car ce n'est pas du golf de code.

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

Chaque ligne retire son propre numéro 1^2^3^4^5. C'est Ruby, donc la dernière ligne définit la valeur de retour.

JavaScript ( 134   77   69   65   60 caractères)

→ démo en direct ←

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

appeler cette fonction avec n = 10.

• Si aucune ligne n'est manquante, la ligne 5 renvoie n == 0.
• Si la ligne 1 est manquante, la ligne 5 renvoie n == 1.
• Si la ligne 2 est manquante, la ligne 5 renvoie n == 2.
• Si la ligne 3 est manquante, la ligne 5 renvoie n == 3.
• Si la ligne 4 est manquante, la ligne 5 renvoie n == 4.
• Si la ligne 5 est manquante, le var "a" devient global et la ligne 4 le détecte pour retourner "5".
• Si la ligne 5 est présente, le moteur JS effectue un "levage variable", "a" devient une variable locale et la ligne 4 ne renvoie pas "5".

Versions précédentes:

65 caractères

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

(doit être appelé avec n = 15)

69 caractères

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

(doit être appelé avec n = 15)

77 caractères

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 caractères

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
}

non-golfé

  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

Si les paramètres sont autorisés, cela fonctionnera:

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 fonction utilise des "constantes" intégrées et attribue une autre valeur à chacune d'entre elles. Si toutes ces variables sont égales à la nouvelle valeur, la fonction renvoie 0. Les valeurs logiques sont transformées en valeurs numériques en raison des opérateurs mathématiques. Les parenthèses autour de la 4ème ligne permettent de retourner visiblement son résultat (s'il s'agit de la dernière commande).

Lua 5.2+

55 caractères dans le corps de la fonction, sauf les sauts de ligne. Je ne pouvais rien trouver de mieux mais ceci:

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

En espérant obtenir des points supplémentaires pour les commentaires abusifs: P

La raison pour laquelle cela ne fonctionne pas en 5.1 est que les imbriqués [[]]ont été supprimés et en 5.1, il donne une erreur de compilation au lieu de l'ignorer comme le fait la 5.2.

• Si aucune des lignes n'est supprimée, le corps de la fonction est équivalent à return 7-2-5
• Si la première ligne est supprimée, return 1
• Si le second, return 7-5
• Si le troisième, return 7-2-2
• Si le quatrième, return 7-2-1
• Si le cinquième, return 7-2

Rubis

J'ai essayé de le faire avec des opérations au niveau du bit, puis j'ai réalisé qu'il y avait une solution beaucoup plus simple en utilisant des listes! Ce défi est mieux servi par un langage de programmation qui renvoie automatiquement la dernière valeur qu'il voit, comme 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 n'a pas de fonctions explicites, mais voici ce que j'appellerais une fonction dans Befunge:

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

Les première et dernière lignes sont le début et la fin de la fonction. Il fait la chose la plus proche de "retourner", c'est-à-dire qu'il pousse la valeur correcte sur la pile.

Nouvelle réponse

J'ai trouvé une autre solution. C'est tellement mauvais, j'aimais tellement les mathématiques. Cette solution utilise la récursivité et des variables globales (beurk!) Pour savoir si chaque ligne a été exécutée ou non. Je voulais faire quelque chose de différent des autres solutions, donc ce n'est pas très élégant, mais cela fonctionne correctement :)

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

J'ai vraiment apprécié ce défi, merci! :)

Ancienne réponse

Je l'ai résolu en utilisant les mathématiques. Si chaque variable est vue comme une inconnue, et que nous faisons une déclaration par ligne, il y a cinq inconnues et cinq lignes de code: cela nous conduit au système 5x5 suivant:

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.

Une fois que j'ai trouvé les valeurs, je les ai codées en dur et ajouté quelques trucs de base.

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

Remarque: l'ancienne réponse ne fonctionnera pas si elle reste telle quelle.

cire d'abeille , 86 octets

Essayer mon premier esolang inventé. Après une confusion initiale, j'ai trouvé que la solution était si simple.

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

Explication:

les programmes de cire d'abeille fonctionnent sur une grille hexagonale 2D. Les programmes sont stockés dans un format rectangulaire.

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

est stocké sous

abcd
efgh
ijkl

Les instructions pour se déplacer dans certaines directions sont les suivantes:

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

Brève explication

_1 p Créez une IP, ajoutez 1, puis redirigez l'IP vers la ligne 2

_^v>~2+p Créez une autre IP, juste au cas où la ligne 1 est manquante, ralentissez IP pour vous assurer que l'IP de la ligne 1 est en avance, puis ajoutez 2, puis redirigez vers la ligne 3

> >~3+p Ajoutez 3, puis redirigez vers la ligne 4

> >~4+X@7~8+~@$^^{; Ajoutez 4, puis définissez la 2e valeur lstack sur 15, puis XOR lstack top et 2nd values, ralentissez IP (pour vous assurer que IP dans la ligne 5 est en avance, si la ligne 5 existe) et sortez le résultat, puis terminez le programme.

> >~5+@7~8+~@${; Ajoutez 5, puis faites la même chose qu'à la ligne 4, sauf le ralentissement.

Fondamentalement, le programme calcule simplement une somme xor 15

• Programme intact: (1 + 2 + 3 + 4 + 5) xor 15 = 0
• Ligne 1 manquante: (2 + 3 + 4 + 5) xor 15 = 1
• Ligne 2 manquante: (1 + 3 + 4 + 5) xor 15 = 2
• Ligne 3 manquante: (1 + 2 + 4 + 5) xor 15 = 3
• Ligne 4 manquante: (1 + 2 + 3 + 5) xor 15 = 4
• Ligne 5 manquante: (1 + 2 + 3 + 4) xor 15 = 5

Les >lignes supplémentaires 3 à 5 garantissent simplement que si l'une des lignes 2 à 4 est manquante, l'adresse IP est toujours redirigée correctement et ne quitte pas le programme.

Vous pouvez cloner mon interprète de cire d'abeille, écrit en Julia, à partir de mon référentiel GitHub

Le readme sur GitHub est plus à jour et mieux structuré que la page esolangs.

MuPAD, 57 caractères

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

LISP commun:

(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: La fin des parenthèses sur sa propre ligne est considérée comme un mauvais style, mais comme d'autres langues l'ont fait endet }je suppose que c'est autorisé.

Bash, 131 caractères

#!/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 $?

Tout est simple jusqu'à la ligne 5. Ensuite, il doit détecter si la dernière ligne a disparu. Cela tire parti des paramètres de fonction autorisés en s'appelant récursivement, une fois, pour tester sa propre valeur de succès lorsqu'il lui est dit d'échouer sur la ligne 5, et si la ligne 5 est supprimée, la ligne 4 revient à la 5place.

(Remarque: il s'agit d'un minimum de 131 caractères si vous supprimez tout sauf la fonction, en supprimant les espaces blancs et en remplaçant / bin / bash par / 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)+"*");
};