In meiner vorherigen Code-Abfrage habe ich Sie gebeten, eine Funktion zu schreiben, die Ihnen mitteilt, welche der Zeilen entfernt wurden.

Die Anweisungen lauteten:

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 sie Ihnen mitteilen, welche der Zeilen entfernt wurde (wenn Sie beispielsweise die letzte Zeile entfernen, sollte sie 5 zurückgeben).

Lassen Sie uns jetzt etwas versuchen, das ein bisschen schwieriger ist.

Befolgen Sie die gleichen Regeln wie oben, aber dieses Mal sollte die Funktion ein Array zurückgeben, das Ihnen mitteilt, welche ZWEI Zeilen entfernt wurden.

Wenn ich zum Beispiel die Zeilen 1 und 5 entferne, sollte der Rückgabewert [1,5] sein, und wenn ich die Zeilen 3 und 4 entferne, sollte der Rückgabewert [3,4] sein.

Wenn keine Zeilen entfernt werden, sollte die Funktion wieder 0 zurückgeben. Bonuspunkte, wenn Sie auch den Fall der Entfernung einer Zeile behandeln können, dies ist jedoch nicht unbedingt erforderlich.

Können Sie Hilfsfunktionen nutzen? Ja, aber nur wenn Sie müssen. Eine einzige eigenständige Funktion, die dies ermöglicht, ist das Ideal.

Wie bei der letzten Herausforderung gewinnt die am höchsten bewertete Lösung. Ich werde den Gewinner in einer Woche ermitteln oder früher, wenn innerhalb von 24 Stunden keine neuen Einsendungen eingegangen sind.

Perl

sub foo {
    @a = (2..5);
    @a = grep $_ != 2, (@a ? @a : (1..5));
    @a = grep $_ != 3, (@a ? @a : (1..5));
    @a = grep $_ != 4, (@a ? @a : (1..5));
    @a = grep $_ != 5, (@a ? @a : (1..5));
}

Dies funktioniert tatsächlich für eine beliebige Anzahl entfernter Zeilen (sofern dies nicht alle Zeilen sind) und kann trivial auf mehr als 5 Zeilen erweitert werden. Es werden keine Hilfsfunktionen verwendet und es wird sogar nur eine Anweisung pro Zeile verwendet. Es beruht auf der Tatsache, dass returnder Rückgabewert einer Perl-Funktion ohne explizite Anweisung der Wert der letzten Anweisung in der Perl-Funktion ist.

Beachten Sie, dass dieser Code (im Listenkontext) eine leere Liste anstelle der Nummer 0 zurückgibt, wenn keine Zeilen gelöscht wurden. Dies könnte behoben werden (zB durch Anhängen von " @a ? @a : 0;" an die letzte Zeile), würde aber den Code hässlicher machen. Auf jeden Fall in skalaren Kontext es tut die Anzahl der gelöschten Zeilen zurückgeben, die 0 sein wird , wenn keine Linien entfernt wurden. ;-)

Rubin

Ähnlich wie die Perl-Version, jedoch in Ruby. Ich gebe 0 zurück, wenn keine Zeilen wie gewünscht gelöscht wurden, aber ich bin damit einverstanden, dass der Code hässlicher wird und als Rückgabewert keinen Sinn ergibt.

def which_lines_removed(arr = [*1..5])
  arr -= [1]
  arr -= [2] 
  arr -= [3] 
  arr -= [4] 
 (arr -= [5]).empty? ? 0 : arr
end

Wenn ein leeres Array als Rückgabewert akzeptiert wird, wenn keine Zeilen gelöscht werden, sieht der Code folgendermaßen aus:

def which_lines_removed(arr = [*1..5])
  arr -= [1]
  arr -= [2] 
  arr -= [3] 
  arr -= [4] 
  arr -= [5]
end

Beide Methoden funktionieren für eine beliebige Anzahl von Zeilen, die zwischen 0 und 5 gelöscht wurden.

JavaScript, 152 Zeichen Golf

function t() {
    var fa = (f + '').match(/\d/g)
    var ra = []
    for (var i = 0; i < 5; i++) {
        if (fa.indexOf(i + '') < 0) ra.push(i + 1)
    }
    return ra
}

function f() {
    0; return t()
    1; return t()
    2; return t()
    3; return t()
    4; return t()
}

Golf gespielt:

function t(){for(a=[],i=0;++i<5;)if((f+'').indexOf(i)<0)a.push(i+1);return a}function f(){
return t(0)
return t(1)
return t(2)
return t(3)
return t(4)
}

In sich geschlossen (aber hässlich):

function f() {
    0; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    1; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    2; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    3; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
    4; var ra = []; for (var i = +![]; i < 5; i++) if ((f + '').match(/\d/g).indexOf(i + '') < +![]) ra.push(i); return ra
}

Nutzt grundsätzlich die Funktion aus, toStringindem jede Zeile nummeriert wird. Beachten Sie, dass Sie die Zeile aus diesem Grund tatsächlich entfernen müssen (das Auskommentieren funktioniert nicht).

Dies funktioniert tatsächlich für beliebig viele entfernte Zeilen ! Es wird ein Array der entfernten Zeilen oder ein leeres Array zurückgegeben, wenn keines entfernt wurde. (Ich könnte das leicht ändern, um Null zurückzugeben (durch Ersetzen return radurch return ra || 0), aber ich mag die leere Array-Lösung, da sie in der realen Welt nützlicher wäre.)

Wenn Sie beispielsweise die erste Zeile [1]entfernen, wird alles außer der ersten Zeile zurückgegeben [2,3,4,5]. (Natürlich funktioniert es nicht, wenn Sie alle Zeilen entfernen ;-))

Rubin

def f
    a = [ 2, 3, 4, 5 ]
    defined?(a) ? a = a.select { |num|    num != 2 } : a = [ 1, 3, 4, 5 ]
    defined?(a) ? a = a.select { |num|    num != 3 } : a = [ 1, 2, 4, 5 ]
    a = a.select { |num|    num != 4 }
    (a = a.select { |num|    num != 5 }) == [] ? a = 0 : a
end

So funktioniert das: Meine Idee war: Erstellen Sie ein Array und entfernen Sie in jeder Zeile einen bestimmten Wert. In der ersten Zeile habe ich also das Array [ 1, 2, 3, 4, 5], wobei das Element 1entfernt wurde. aEntfernen Sie in der zweiten Zeile, falls bereits definiert, das Element 2. Andernfalls erstellen Sie ein neues Array, wobei das Element 2entfernt wird. Gehen Sie für Zeile 3 genauso vor. In Zeile 4 können Sie sicher sein, dass bereits ein Array erstellt wurde. Entfernen Sie also einfach das Element 4. Entfernen Sie in Zeile 5 zuerst das Element5 und geben Sie zurück, wenn aes sich dann um ein leeres Array handelt 0. Andernfalls kehren Sie zurück a.

Python

f=lambda:{1,2,3,4,5}-{
1,
2,
3,
4,
5,
} or 0

Gibt 0 zurück, wenn keine Zeile entfernt wurde, andernfalls werden die entfernten Zeilen zurückgegeben. Sie können 1 bis 5 Zeilen mit Ausnahme der 0. und 6. Zeile entfernen ;-).

JavaScript, in sich geschlossen, funktioniert für 0, 1, 2 entfernte Zeilen ( 607  315 186 Zeichen)

→ Live-Demo ←

Missbrauch von JS variablem Heben und globaler Leckage, wie bei der anderen Herausforderung :)

function(r){
r.shift();
r.splice(r.indexOf(2),1)
r.splice(r.indexOf(3),1);a=b=1;if(this.a&&this.b)return r
var a;r.splice(r.indexOf(4),1);b=1;if(this.b)return r
var b;r.pop();return r[0]?r:0
}

mit dem Array [1,2,3,4,5] als Parameter aufgerufen werden.

315 Zeichen

function(r){
var a;
var b;
var c;a=1;b=2;d=4;e=5;for(i in(z="abde".split("")))if(y=this[z[i]])r.push(y);return r.length?r:0
var d;a=1;b=2;c=3;e=5;for(i in(z="abce".split("")))if(y=this[z[i]])r.push(y);return r.length?r:0
var e;a=1;b=2;c=3;d=4;for(i in(z="abcd".split("")))if(y=this[z[i]])r.push(y);return r.length?r:0
}

mit einem leeren Array als Parameter aufgerufen werden.

Nicht-Golf-Version

(funktioniert auch für 3 und 4 Zeilen entfernt):

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

mit einem leeren Array als Parameter aufgerufen werden.

JavaScript:

var f = function(){
    1
    2
    a=[];for(i=0;i++<6;){if((f+'').indexOf(i)<0){a.push(i)}}return a.length?a:0;3
    a=[];for(i=0;i++<6;){if((f+'').indexOf(i)<0){a.push(i)}}return a.length?a:0;4
    a=[];for(i=0;i++<6;){if((f+'').indexOf(i)<0){a.push(i)}}return a.length?a:0;5
}

Geige

Javascript

(function (i){

i += .1;     // line 1
i += .02;    // line 2
i += .003;   // line 3
i += .0004;  // line 4
i += .00005; // line 5

return (Math.round((.12345-i)*100000)/100000+'').match(/([1-5])/g) || 0 })(0)

Nenne es wie du willst, aber ich finde es hübsch .

Lässt Sie wissen, welche Zeilen entfernt wurden (1 oder mehr), oder 0, wenn keine Zeilen entfernt wurden. Alle 5 Zeilen können entfernt werden.

BEARBEITEN:

Da ich darauf hingewiesen wurde, dass mein Code möglicherweise aus 6 Zeilen besteht und gegen die Regeln verstößt, habe ich ihn folgendermaßen angepasst:

(Math.round((.12345 - (new (function(){

    this.i = isFinite(this.i) ? this.i + .1 : .1 ;
    this.i = isFinite(this.i) ? this.i + .02 : .02;
    this.i = isFinite(this.i) ? this.i + .003 : .003; 
    this.i = isFinite(this.i) ? this.i + .0004 : .0004;
    this.i = isFinite(this.i) ? this.i + .00005 : .00005; 

})().i || 0) )*100000)/100000+'').match(/([1-5])/g) || 0

Gleiches gilt - es wird ein Array von entfernten Zeilen zurückgegeben, das von 1 - Alle oder 0 reicht, falls keine vorhanden sind.

Common Lisp

(defun which-lines-are-removed (&aux (x (list 1 2 3 4 5))) 
  (setq x (remove-if #'(lambda (x) (eql x 1)) x))
  (setq x (remove-if #'(lambda (x) (eql x 2)) x))
  (setq x (remove-if #'(lambda (x) (eql x 3)) x))
  (setq x (remove-if #'(lambda (x) (eql x 4)) x))
  (setq x (remove-if #'(lambda (x) (eql x 5)) x))
)

Es funktioniert zum Entfernen von 1-4 Zeilen. Wenn Sie alle Zeilen entfernen, wird dasselbe zurückgegeben, als wenn Sie keine entfernen.

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.

Python

def function(a = [1,2,3,4,5]):
    delete(a, len(a)-5)#1
    delete(a, len(a)-4)#2
    delete(a, len(a)-3);print a if len(a)==2 else '',#3
    delete(a, len(a)-2);print a if len(a)==2 else '',#4
    delete(a, len(a)-1);print a if len(a)==2 else '',#5

def delete(a, i):
    del a[i]
    return a

Es funktioniert für alle Zeilen - aber nur, wenn zwei gelöscht werden. Wenn nur eine Zeile gelöscht wird, werden die gelöschte Zeile und Zeile 5 gedruckt. Wenn zu viele Zeilen gelöscht werden, wird nichts gedruckt.

Dies verwendet eine Hilfsfunktion, da das del-Schlüsselwort nicht in einer Zeile mit einem; verwendet werden kann (soweit ich weiß).

Grundsätzlich löscht sich jede Zeile in dem Array, das im Konstruktor deklariert ist. Wenn genügend Zeilen gelöscht wurden, wird das Array gedruckt.

Diese Funktion verfehlt die Spezifikation auf zwei Arten:

1. Es wird keine 0 ausgegeben, wenn es so ausgeführt wird, wie es ist (es wird davon ausgegangen, dass die letzten beiden Zeilen kommentiert wurden, und daher werden 4, 5 ausgegeben
2. Es setzt das voraus printund returnist austauschbar

Déjà Vu

Funktioniert zum Entfernen einer beliebigen Anzahl von Zeilen (solange Sie mindestens eine Zeile belassen)

local line n:
    try:
        dup
    catch stack-empty:
        dup set{ 1 2 3 4 5 }
    delete-from swap n

func which-gone:
    line 1
    line 2
    line 3
    line 4
    line 5

R

Ich habe eine andere Version in R, die ich für besser halte (aber eine Hilfsfunktion verwendet):

trick <- function(sym, value) {
  assign(sym, value, envir=parent.frame())
  values <- unlist(as.list(parent.frame()))
  if(length(values)==5) 0 else which(!1:5 %in% values)
}

reportRemovedLines <- function(){
  trick("a", 1)
  trick("b", 2)
  trick("c", 3)
  trick("d", 4)
  trick("e", 5)
}

Oder Sie können die Verwendung der Hilfsfunktion vermeiden, indem Sie sie als Standardargument definieren (funktioniert identisch, ist aber weniger lesbar - es wird jedoch keine "separat definierte" Hilfsfunktion verwendet):

funnyVersion <- function(trick = function(sym, value) {
  assign(sym, value, envir=parent.frame())
  values <- unlist(as.list(parent.frame()))
  if(length(values)==5) 0 else which(!1:5 %in% values)
}){
  trick("a", 1)
  trick("b", 2)
  trick("c", 3)
  trick("d", 4)
  trick("e", 5)
}

Beide reportRemovedLines()und funnyVersion()arbeiten mit einer beliebigen Anzahl entfernter Zeilen - es sei denn, Sie entfernen alle Zeilen (in diesem Fall werden sie zurückgegeben NULL). Sie tatsächlich zurückgeben die Zeilennummern, nicht nur sie drucken - wie in R, der Wert des letzten Ausdrucks innerhalb einer Funktion ausgewertet wird automatisch zurückgegeben werden.

Wie funktioniert es? Der Trick liegt in der trickFunktion, die alle Objekte aus ihrer "übergeordneten Umgebung" (dh der Umgebung der Funktion, die sie aufruft) entnimmt, ihre Werte in einem Vektor zusammenfügt und zurückgibt, welche Werte von 1 bis 5 nicht dargestellt sind.

JavaScript (136/166 Zeichen)

Eine kleinere Version mit einigen am Anfang deklarierten Werten:

function(){b=[1,2,3,4,5],i=0
    b.splice(0,1);i++
    b.splice(1-i,1);i++
    b.splice(2-i,1);i++
    b.splice(3-i,1);i++
    b.splice(4-i,1);i++
return b}

Eine eigenständige Version (Sie müssen nichts übergeben - das Argument b ist vorhanden, damit ich überprüfen kann, ob b mit definiert ist. ||)

function(b){
    b=[2,3,4,5],i=1
    b=b||[1,2,3,4,5],i=i||0,b.splice(1-i,1);i++
    b=b||[1,2,3,4,5],i=i||0,b.splice(2-i,1);i++
    b.splice(3-i,1);i++
    b.splice(4-i,1);i++
return b}

Ja, beide haben returnAussagen, aber das ist nur fair, wenn ich mit Sprachen mit impliziter Rendite konkurriere.

R

Eine einfache Version (nicht narrensicher, da Sie eine Fehlermeldung erhalten, wenn Sie Zeile 5 entfernen):

doit <- function() setdiff(1:5, c(
       1,
       2,
       3,
       4,
       5
    ))

Und eine narrensichere Version:

doit<-function() setdiff(1:5, scan(text="
1
2
3
4
5
"))

Es funktioniert mit beliebig vielen entfernten Zeilen (außer wenn Sie alle Zeilen entfernen) und kann problemlos auf mehr als 5 Zeilen erweitert werden. Wenn Sie es "wie es ist" ausführen, wird es zurückgegeben, integer(0)was konzeptionell dem Zurückgeben von "nur " ähnelt0 . Das Zurückgeben einer tatsächlichen 0 würde sie hässlicher und länger machen, wäre aber nicht kompliziert.

Zum Schluss eine Version mit Magie:

Hilfsfunktion:

dysfunction <- function(E){
    FUN <- function(){}
    e <- substitute(E)
    e[[1]] <- as.name("list")
    nb <- quote(setdiff(as.list(1:5), x))
    nb[[3]] <- e
    body(FUN) <- nb
    FUN
    }

Die eigentliche Funktion:

df <- dysfunction({
1
2
3
4
5
})

C ++

void function(int & i)
{
        i=i|1;
        i=i|2;
        i=(i|4);
        i=(i|8);
        i=(i|16);
} 


int[] func2(int i)
{
    int arr[]={0,0};
    int k=0,l=1;
    for(int j=1;j<=16;j*=2,l++)
    {
        if((i&j)==0)
        {
             arr[k++]=l;
        }
    }
    return arr;
}

Verwendung: Rufen Sie die Funktion mit i auf und verwenden Sie func2, um zu verstehen, welche Funktion aussagt.

Wenn Sie die Zeile int arr [] = {0,0} in int arr [] = {0,0,0,0,0} ändern, funktioniert dies auch für alle fünf Zeilen automatisch benutze ich einfach ein Bit einer Variablen als Flag für jede Zeile ...