Scrivi una funzione che contiene cinque righe.

Se si esegue la funzione così com'è, dovrebbe restituire 0.

Se rimuovi una delle cinque righe ed esegui la funzione, dovrebbe dirti quale delle righe è stata rimossa (ad esempio, se rimuovi l'ultima riga dovrebbe restituire 5).

Brevità, novità ed eleganza meritano tutte considerazione. Vince la soluzione con il punteggio più alto (dopo un ragionevole lasso di tempo).

Rubino

Evitando i numeri magici poiché non è un codice golf.

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

Ogni riga rimuove il proprio numero da 1^2^3^4^5. È Ruby, quindi l'ultima riga definisce il valore di ritorno.

JavaScript ( 134   77   69   65   60 caratteri)

→ demo live ←

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

chiama questa funzione con n = 10.

• Se non manca alcuna riga, la riga 5 restituisce n == 0.
• Se manca la riga 1, la riga 5 restituisce n == 1.
• Se manca la riga 2, la riga 5 restituisce n == 2.
• Se manca la riga 3, la riga 5 restituisce n == 3.
• Se manca la riga 4, la riga 5 restituisce n == 4.
• Se manca la riga 5, la var "a" diventa globale e la riga 4 rileva che per restituire "5".
• Se è presente la riga 5, il motore JS esegue il "sollevamento variabile", "a" diventa una var locale e la riga 4 non restituisce "5".

Versione precedente:

65 caratteri

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

(deve essere chiamato con n = 15)

69 caratteri

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

(deve essere chiamato con n = 15)

77 caratteri

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 caratteri

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 golfed

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

Pitone

Se i parametri sono consentiti, funzionerà:

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 funzione utilizza "costanti" incorporate e assegna un altro valore a ciascuna di esse. Se tutte queste variabili sono uguali al nuovo valore, la funzione restituisce 0. I valori logici vengono trasformati in valori numerici a causa degli operatori matematici. Le parentesi attorno alla 4a riga consentono di restituire visibilmente il suo risultato (se è l'ultimo comando).

Lua 5.2+

55 caratteri nel corpo della funzione escluse le nuove righe. Non potrei trovare niente di meglio, ma questo:

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

Sperando di ottenere punti extra per l'abuso di commenti: P

Il motivo per cui non funziona in 5.1 è che i nidificati [[]]sono stati rimossi e in 5.1 dà un errore di compilazione invece di ignorarlo come fa 5.2.

• Se nessuna riga viene rimossa, il corpo della funzione è equivalente a return 7-2-5
• Se la prima riga viene rimossa, return 1
• Se il secondo, return 7-5
• Se il terzo, return 7-2-2
• Se il quarto, return 7-2-1
• Se il quinto, return 7-2

Rubino

Ho provato a farlo con operazioni bit per bit e poi mi sono reso conto che esiste una soluzione molto più semplice usando le liste! Questa sfida è meglio servita da un linguaggio di programmazione che restituisce automaticamente l'ultimo valore che vede, come 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 non ha funzioni esplicite, ma ecco come definirei una funzione in Befunge:

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

La prima e l'ultima riga sono l'inizio e la fine della funzione. Fa la cosa più vicina a "restituire", cioè spinge il valore corretto nello stack.

Nuova risposta

Ho trovato un'altra soluzione. È così brutto, mi è piaciuta così tanto la matematica. Questa soluzione utilizza la ricorsione e le variabili globali (schifo!) Per dire se ogni riga è stata eseguita o meno. Volevo fare qualcosa di diverso dalle altre soluzioni, quindi non è molto elegante, ma funziona correttamente :)

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

Mi è davvero piaciuta questa sfida, grazie! :)

Vecchia risposta

L'ho risolto usando la matematica. Se ogni variabile è vista come sconosciuta e facciamo una dichiarazione per riga, ci sono cinque incognite e cinque righe di codice: questo ci porta al seguente 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 volta trovati i valori, li ho codificati e aggiunti alcuni elementi di 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;
}

Nota: la vecchia risposta non funzionerà se lasciata così com'è.

cera d'api , 86 byte

Provando il mio primo esolang inventato. Dopo la prima confusione ho scoperto che la soluzione è così semplice.

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

Spiegazione:

i programmi di cera d'api funzionano su una griglia esagonale 2D. I programmi sono memorizzati in un formato rettangolare.

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

è memorizzato come

abcd
efgh
ijkl

Le istruzioni per spostarsi in determinate direzioni sono:

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

Breve spiegazione

_1 p Crea un IP, aggiungi 1, quindi reindirizza IP alla riga 2

_^v>~2+p Crea un altro IP, nel caso in cui manchi la linea 1, rallenta l'IP per assicurarti che l'IP dalla linea uno sia avanti, quindi aggiungi 2, quindi reindirizza alla linea 3

> >~3+p Aggiungi 3, quindi reindirizza alla riga 4

> >~4+X@7~8+~@$^^{; Aggiungi 4, quindi imposta il 2o valore dello stack su 15, quindi XOR i migliori valori dello stack e 2o, rallenta l'IP (per assicurarti che l'IP nella riga 5 sia avanti, se esiste la riga 5) e produci il risultato, quindi termina il programma.

> >~5+@7~8+~@${; Aggiungi 5, quindi fai come nella riga 4, tranne il rallentamento.

Fondamentalmente il programma calcola solo una somma xo 15

• Programma intatto: (1 + 2 + 3 + 4 + 5) xo 15 = 0
• Riga 1 mancante: (2 + 3 + 4 + 5) xo 15 = 1
• Riga 2 mancante: (1 + 3 + 4 + 5) xo 15 = 2
• Riga 3 mancante: (1 + 2 + 4 + 5) xo 15 = 3
• Riga 4 mancante: (1 + 2 + 3 + 5) xo 15 = 4
• Riga 5 mancante: (1 + 2 + 3 + 4) xo 15 = 5

L'aggiunta >nelle righe da 3 a 5 garantisce solo che se manca una delle righe da 2 a 4, l'IP viene comunque reindirizzato correttamente e non lascia il programma.

Puoi clonare il mio interprete di cera d'api, scritto in Julia, dal mio repository GitHub

Il file Leggimi su GitHub è più aggiornato e strutturato meglio della pagina di esolangs.

MuPAD, 57 caratteri

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

LISP comune:

(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: Avere la parentesi finale sulla propria riga è considerato un cattivo stile, ma dal momento che altre lingue hanno ende }presumo che sia permesso.

Bash, 131 caratteri

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

È tutto semplice fino alla linea 5. Quindi deve rilevare se l'ultima linea è andata. Questo sfrutta i parametri di funzione consentiti chiamando se stesso in modo ricorsivo, una volta, per testare il proprio valore di successo quando gli viene detto di fallire sulla linea 5, e se la linea 5 viene rimossa, la riga 4 restituisce 5invece.

(Nota: si tratta di un minimo di 131 caratteri se si elimina tutto tranne la funzione, si annulla lo spazio bianco e si cambia / bin / bash in / 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)+"*");
};