Dans mon défi de code précédent , je vous ai demandé d'écrire une fonction qui vous indique laquelle de ses lignes a été supprimée.

Les instructions étaient les suivantes:

É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).

Maintenant, essayons quelque chose d'un peu plus difficile.

Suivez les mêmes règles que ci-dessus, mais cette fois, la fonction devrait retourner un tableau vous indiquant quelles DEUX lignes ont été supprimées.

Ainsi, par exemple, si je supprime les lignes 1 et 5, la valeur de retour doit être [1,5], et si je supprime les lignes 3 et 4, la valeur de retour doit être [3,4].

Encore une fois, si aucune ligne n'est supprimée, la fonction doit retourner 0. Des points bonus si vous pouvez également gérer le cas supprimé d'une ligne, mais il n'est pas strictement nécessaire de le faire.

Pouvez-vous utiliser des fonctions d'assistance? Oui, mais seulement si c'est nécessaire. Une seule fonction autonome qui permet de retirer cela est l'idéal.

Comme pour le dernier défi, la solution la mieux notée gagne. Je choisirai le gagnant dans une semaine, ou plus tôt si aucune nouvelle soumission n'a été reçue dans les 24 heures.

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

Cela fonctionne réellement pour n'importe quel nombre de lignes supprimées (tant que ce ne sont pas toutes les lignes, c'est-à-dire), et peut être étendu de manière triviale à plus de 5 lignes. Aucune fonction d'assistance n'est utilisée et elle n'utilise même qu'une seule instruction par ligne. Elle repose sur le fait qu'en l'absence d'une returninstruction explicite , la valeur de retour d'une fonction Perl est la valeur de la dernière instruction qu'elle contient.

Notez que (dans le contexte de la liste), ce code renvoie une liste vide plutôt que le numéro 0 si aucune ligne n'a été supprimée. Cela pourrait être corrigé (par exemple en ajoutant " @a ? @a : 0;" à la dernière ligne), mais rendrait le code plus laid. Dans tous les cas, dans scalaire contexte , il ne retourne le nombre de lignes supprimées, qui sera 0 si aucune ligne ont été supprimés. ;-)

Rubis

Similaire à la version Perl, mais en Ruby. Je retourne 0 si aucune ligne n'est supprimée comme demandé, mais je suis d'accord que cela rend le code plus laid et n'a pas vraiment de sens comme valeur de retour.

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

Si un tableau vide est acceptable comme valeur de retour lorsqu'aucune ligne n'est supprimée, le code ressemble à ceci:

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

Les deux méthodes fonctionnent pour n'importe quel nombre de lignes supprimées entre 0 et 5.

JavaScript, 152 caractères golfés

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é:

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

Autonome (mais moche):

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
}

Exploite essentiellement la fonction toStringen numérotant chaque ligne. Notez que vous devez supprimer la ligne pour cette raison (la commenter ne fonctionnera pas).

Cela fonctionne réellement pour n'importe quel nombre de lignes supprimées ! Il retournera un tableau des lignes supprimées, ou un tableau vide si aucun n'a été supprimé. (Je pourrais facilement changer cela pour retourner zéro (en le remplaçant return rapar return ra || 0), mais j'aime la solution de tableau vide car elle serait plus utile dans le monde réel.)

Par exemple, la suppression de la première ligne renvoie [1]et tout supprimer sauf la première ligne [2,3,4,5]. (Bien sûr, cela ne fonctionne pas si vous supprimez toutes les lignes ;-))

Rubis

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

Comment cela fonctionne: mon idée était: créer un tableau, et sur chaque ligne, supprimer une valeur spécifique. Donc, sur la première ligne, j'ai en fait le tableau [ 1, 2, 3, 4, 5], avec l'élément 1supprimé. À la deuxième ligne, s'il aest déjà défini, supprimez l'élément 2. Sinon, créez un nouveau tableau avec l'élément 2supprimé. Faites de même pour la ligne 3. À la ligne 4, vous pouvez être sûr qu'il y a déjà un tableau créé, donc supprimez simplement l'élément 4. À la ligne 5, supprimez d'abord l'élément 5, et si aest alors un tableau vide, retournez 0. Sinon, revenez a.

Python

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

Renvoie 0 si aucune ligne n'est supprimée, sinon renvoie les lignes supprimées. Vous pouvez supprimer 1 à 5 lignes, à l'exception des 0e et 6e lignes ;-).

JavaScript, autonome, fonctionne pour 0, 1, 2 lignes enlevées ( 607  315 186 caractères)

→ démo en direct ←

Abus de levage variable JS et fuite globale, comme dans l'autre défi :)

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
}

à appeler avec le tableau [1,2,3,4,5] comme paramètre.

315 caractères

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
}

à appeler avec un tableau vide comme paramètre.

version non golfée

(fonctionne également pour 3 et 4 lignes supprimées):

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

à appeler avec un tableau vide comme paramètre.

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
}

violon

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)

Appelez ça comme vous voulez, mais je pense que c'est joli .

Vous permet de savoir quelles lignes ont été supprimées (1 ou plus) ou 0 si aucune ligne n'est supprimée. Les 5 lignes peuvent être supprimées.

ÉDITER:

Parce qu'il a été porté à mon attention que mon code pourrait en fait être composé de 6 lignes et qu'il est en violation des règles, je l'ai ajusté comme suit:

(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

La même chose s'applique - il renverra un tableau de lignes supprimées allant de 1 à Tous ou 0 si aucun.

Lisp commun

(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))
)

Cela fonctionne pour la suppression de 1-4 lignes. Si vous supprimez toutes les lignes, le résultat sera le même que si vous n'en supprimez aucune.

NB: Avoir des parenthèses se terminant sur sa propre ligne est considéré comme un mauvais style, mais comme d'autres langues l'ont fait endet }je suppose que c'est autorisé.

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

Cela fonctionne pour toutes les lignes - mais seulement si deux sont supprimées. Si une seule ligne est supprimée, elle imprimera la ligne supprimée et la ligne 5. Si trop de lignes sont supprimées, elle n'imprimera rien.

Cela utilise une fonction d'assistance car le mot clé del ne peut pas être utilisé dans une ligne avec un; (pour autant que je sache)

Fondamentalement, chaque ligne se supprime dans le tableau qui est déclaré dans le constructeur, puis si suffisamment de lignes ont été supprimées, le tableau est imprimé.

Cette fonction manque la spécification de deux manières:

1. il n'imprime pas 0 s'il est exécuté tel quel (il suppose que les deux dernières lignes ont été commentées et imprime donc 4, 5
2. Il suppose que printet returnsont interchangeables

Déjà vu

Fonctionne pour supprimer n'importe quel nombre de lignes (tant que vous laissez au moins une ligne)

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

J'ai une autre version en R qui je pense est meilleure (mais utilise une fonction d'assistance):

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

Ou on peut éviter d'utiliser la fonction d'assistance en la définissant comme argument par défaut (fonctionne de manière identique mais est moins lisible - cependant, il n'utilise pas de fonction d'assistance "définie séparément"):

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

Les deux reportRemovedLines()et funnyVersion()fonctionnent avec n'importe quel nombre de lignes supprimées - sauf si vous supprimez toutes les lignes (dans ce cas, elles reviendront NULL). Ils renvoient en fait les numéros de ligne, pas seulement les impriment - comme dans R, la valeur de la dernière expression évaluée dans une fonction sera automatiquement retournée.

Comment ça marche? L'astuce réside dans la trickfonction qui prend tous les objets de son "environnement parent" (c'est-à-dire l'environnement de la fonction qui l'appelle), rassemble leurs valeurs dans un vecteur et renvoie, les valeurs de 1 à 5 non représentées.

JavaScript (136/166 caractères)

Une version plus petite avec quelques valeurs déclarées au début:

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}

Une version autonome (vous n'avez pas besoin de passer quoi que ce soit - l'argument b est là pour que je puisse vérifier si b est défini avec ||)

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}

Oui, les deux ont des returndéclarations, mais ce n'est juste que si je suis en concurrence avec des langues avec retour implicite.

R

Une version simple (pas infaillible car vous obtiendrez une erreur si vous supprimez la ligne 5):

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

Et une version infaillible:

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

Il fonctionne avec n'importe quel nombre de lignes supprimées (sauf si vous supprimez toutes les lignes) et peut facilement être étendu à plus de 5 lignes. L'exécuter "tel quel" reviendrainteger(0) ce qui est conceptuellement similaire au retour juste 0. Renvoyer un 0 réel le rendrait plus laid et plus long mais ne serait pas compliqué.

Enfin, une version utilisant la magie:

Fonction d'assistance:

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
    }

La fonction réelle:

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

Comment utiliser: appelez la fonction avec i et utilisez func2 pour comprendre quelle fonction est révélatrice.

Si vous changez la ligne int arr [] = {0,0} en int arr [] = {0,0,0,0,0} cela fonctionnera également pour les cinq lignes, il s'agit également d'une ligne manuelle pour supprimer le scénario de test automatiquement, ce que je fais est simplement d'utiliser des bits d'une variable comme indicateur pour chaque ligne ....