Schreiben Sie eine Funktion, die fünf Zeilen enthält.

Wenn Sie die Funktion so ausführen, wie sie ist, sollte sie 0 zurückgeben.

Wenn Sie eine der fünf Zeilen entfernen und die Funktion ausführen, sollte Ihnen mitgeteilt werden, welche der Zeilen entfernt wurden (z. B. wenn Sie die letzte Zeile entfernen, sollte sie 5 zurückgeben).

Kürze, Neuheit und Eleganz verdienen alle Beachtung. Die Lösung mit der höchsten Bewertung (nach einer angemessenen Zeitspanne) gewinnt.

Rubin

Magische Zahlen meiden, da es kein Code für Golf ist.

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

Aus jeder Zeile wird eine eigene Nummer entfernt 1^2^3^4^5. Es ist Ruby, also definiert die letzte Zeile den Rückgabewert.

JavaScript ( 134   77   69   65   60 Zeichen)

→ Live-Demo ←

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

rufen Sie diese Funktion mit n = 10 auf.

• Fehlt keine Zeile, gibt Zeile 5 n == 0 zurück.
• Fehlt Zeile 1, gibt Zeile 5 n == 1 zurück.
• Fehlt Zeile 2, gibt Zeile 5 n == 2 zurück.
• Fehlt Zeile 3, gibt Zeile 5 n == 3 zurück.
• Fehlt Zeile 4, gibt Zeile 5 n == 4 zurück.
• Wenn Zeile 5 fehlt, wird var "a" global und Zeile 4 erkennt, dass "5" zurückgegeben wird.
• Wenn Zeile 5 vorhanden ist, führt die JS-Engine ein "variables Heben" durch, "a" wird eine lokale Variable, und Zeile 4 gibt nicht "5" zurück.

Vorherige Versionen:

65 Zeichen

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

(muss mit n = 15 aufgerufen werden)

69 Zeichen

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

(muss mit n = 15 aufgerufen werden)

77 Zeichen

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 Zeichen

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
}

nicht golfen

  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

Wenn Parameter erlaubt sind, funktioniert dies:

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
}

Die Funktion verwendet eingebaute "Konstanten" und weist jedem von ihnen einen anderen Wert zu. Wenn alle diese Variablen gleich dem neuen Wert sind, gibt die Funktion 0 zurück. Logische Werte werden aufgrund der mathematischen Operatoren in numerische umgewandelt. Die Klammern um die 4. Zeile ermöglichen die sichtbare Rückgabe des Ergebnisses (wenn es sich um den letzten Befehl handelt).

Lua 5.2+

55 Zeichen im Funktionskörper ohne Zeilenumbrüche. Ich konnte mir nichts Besseres einfallen lassen als das:

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

In der Hoffnung, zusätzliche Punkte für den Missbrauch von Kommentaren zu bekommen: P

Der Grund, warum es in 5.1 nicht funktioniert, ist, dass verschachtelte Elemente [[]]entfernt wurden. In 5.1 wird ein Kompilierungsfehler angezeigt, anstatt wie in 5.2 ignoriert zu werden.

• Wenn keine der Zeilen entfernt wird, entspricht der Funktionskörper return 7-2-5
• Wenn die erste Zeile entfernt wird, return 1
• Wenn der zweite, return 7-5
• Wenn der dritte, return 7-2-2
• Wenn der vierte, return 7-2-1
• Wenn der fünfte, return 7-2

Rubin

Ich habe es mit bitweisen Operationen versucht und dann festgestellt, dass es eine viel einfachere Lösung mit Listen gibt! Diese Herausforderung wird am besten von einer Programmiersprache bewältigt, die automatisch den zuletzt angezeigten Wert zurückgibt, z. B. 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 hat keine expliziten Funktionen, aber hier ist, was ich eine Funktion in Befunge nennen würde:

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

Die erste und letzte Zeile sind Funktionsanfang und Funktionsende. Es "kehrt" am ehesten zurück, dh es legt den korrekten Wert auf den Stapel.

Neue Antwort

Ich habe eine andere Lösung gefunden. Das ist so schlimm, ich mochte die Mathematik so sehr. Diese Lösung verwendet Rekursions- und globale Variablen (yuck!), Um festzustellen, ob jede Zeile ausgeführt wurde oder nicht. Ich wollte etwas anderes als die anderen Lösungen machen, daher ist das nicht sehr elegant, aber es funktioniert einwandfrei :)

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

Ich habe diese Herausforderung wirklich genossen, danke! :)

Alte Antwort

Ich habe es mit Mathe gelöst. Wenn jede Variable als unbekannt angesehen wird und wir eine Deklaration pro Zeile durchführen, gibt es fünf Unbekannte und fünf Codezeilen: Dies führt uns zum folgenden 5x5-System:

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.

Sobald ich die Werte gefunden hatte, habe ich sie fest codiert und einige grundlegende Dinge hinzugefügt.

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

Hinweis: Die alte Antwort funktioniert nicht, wenn sie unverändert bleibt.

Bienenwachs , 86 Bytes

Probieren Sie meinen ersten erfundenen Esolang aus. Nach anfänglicher Verwirrung stellte ich fest, dass die Lösung so einfach ist.

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

Erläuterung:

Bienenwachsprogramme arbeiten auf einem 2D-Sechseckgitter. Programme werden in einem rechteckigen Format gespeichert.

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

wird gespeichert als

abcd
efgh
ijkl

Die Anweisungen zum Bewegen in bestimmte Richtungen lauten:

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

Kurze Erklärung

_1 p Erstellen Sie eine IP-Adresse, fügen Sie 1 hinzu und leiten Sie die IP-Adresse in Zeile 2 um

_^v>~2+p Erstellen Sie eine weitere IP-Adresse, falls Zeile 1 fehlt. Verlangsamen Sie die IP-Adresse, um sicherzustellen, dass die IP-Adresse von Zeile 1 voransteht. Fügen Sie dann 2 hinzu und leiten Sie sie zu Zeile 3 weiter

> >~3+p Addiere 3 und leite dann zu Zeile 4 um

> >~4+X@7~8+~@$^^{; Addiere 4, setze dann den 2. Stapelwert auf 15, dann den oberen und zweiten XOR-Stapelwert, verlangsame IP (um sicherzustellen, dass IP in Zeile 5 voraus ist, falls Zeile 5 existiert) und gebe das Ergebnis aus, beende dann das Programm.

> >~5+@7~8+~@${; Addiere 5 und mache dann dasselbe wie in Zeile 4, mit Ausnahme der Verlangsamung.

Grundsätzlich berechnet das Programm nur eine Summe xor 15

• Programm intakt: (1 + 2 + 3 + 4 + 5) xoder 15 = 0
• Zeile 1 fehlt: (2 + 3 + 4 + 5) xoder 15 = 1
• Zeile 2 fehlt: (1 + 3 + 4 + 5) xoder 15 = 2
• Zeile 3 fehlt: (1 + 2 + 4 + 5) xoder 15 = 3
• Zeile 4 fehlt: (1 + 2 + 3 + 5) xoder 15 = 4
• Zeile 5 fehlt: (1 + 2 + 3 + 4) xoder 15 = 5

Die zusätzlichen >Zeilen 3 bis 5 stellen lediglich sicher, dass bei Fehlen einer der Zeilen 2 bis 4 die IP-Adresse weiterhin ordnungsgemäß umgeleitet wird und das Programm nicht verlässt.

Sie können meinen in Julia geschriebenen Bienenwachs-Interpreter aus meinem GitHub-Repository klonen

Die Readme-Datei auf GitHub ist aktueller und besser strukturiert als die Esolangs-Seite.

MuPAD, 57 Zeichen

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

Gemeinsame LISP:

(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: Endeklammern in einer eigenen Zeile zu haben, wird als schlechter Stil angesehen, aber da es andere Sprachen gibt endund }ich davon ausgehe, dass dies zulässig ist.

Bash, 131 Zeichen

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

Bis zur 5. Zeile ist alles ganz einfach. Dann muss erkannt werden, ob die letzte Zeile weg ist. Dies nutzt die zulässigen Funktionsparameter aus, indem es sich selbst einmal rekursiv aufruft, um seinen eigenen Erfolgswert zu testen, wenn in Zeile 5 ein Fehler gemeldet wird, und wenn Zeile 5 entfernt wird, kehrt 5stattdessen Zeile 4 zurück .

(Hinweis: Es ist auf mindestens 131 Zeichen beschränkt, wenn alles außer der Funktion entfernt wird, Leerzeichen entfernt werden und / bin / bash in / bin / sh geändert wird.)

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)+"*");
};