In my önceki kod meydan , ben kaldırıldı kendi çizgisinden hangisinin söyler fonksiyon yazmak istedim.

Talimatlar şöyleydi:

Beş satır içeren bir işlev yazın.

İşlevi olduğu gibi çalıştırırsanız 0 döndürmelidir.

Beş satırdan herhangi birini kaldırır ve işlevi çalıştırırsanız, hangi satırların kaldırıldığını size bildirmelidir (örneğin, son satırı kaldırırsanız 5 döndürmelidir).

Şimdi, biraz daha zor bir şey deneyelim.

Yukarıdaki kurallara uyun, ancak bu sefer fonksiyonun size hangi İKİ satırın kaldırıldığını söyleyen bir dizi döndürmesi gerekir.

Yani, örneğin, 1. ve 5. satırları kaldırırsam, dönüş değeri [1,5] olmalı ve 3. ve 4. satırları kaldırırsam, dönüş değeri [3,4] olmalıdır.

Yine, hiçbir satır kaldırılmazsa, işlev 0 döndürmelidir. Tek satırlık kaldırılmış kasayı da işleyebiliyorsanız bonus puanlar, ancak bunu yapmanız kesinlikle gerekli değildir.

Yardımcı fonksiyonları kullanabilir misiniz? Evet, ama sadece mecbur kalırsan. Bunu çeken tek bir bağımsız fonksiyon idealdir.

Son mücadelede olduğu gibi, en yüksek oy alan çözüm kazanır. Bir hafta içinde kazananı seçerim veya 24 saat içinde yeni bir başvuru gelmezse daha erken kazanacağım.

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

Bu aslında kaldırılan herhangi bir sayıda satır için geçerlidir ( tüm satırlar olmadığı sürece ) ve önemsiz bir şekilde 5'ten fazla satıra genişletilebilir. Hiçbir yardımcı işlev kullanılmaz ve hatta satır başına yalnızca bir deyim kullanır. Açık bir ifadenin yokluğunda,return ifadenin bir Perl fonksiyonunun dönüş değerinin, içindeki son ifadenin değeri olduğu .

Hiçbir satır silinmediyse (liste bağlamında) bu kodun 0 yerine boş bir liste döndürdüğünü unutmayın. Bu düzeltilebilir (örn @a ? @a : 0;. Son satıra " " ekleyerek ), ancak kodu daha çirkin kılacaktır. Her durumda, içinde skaler bağlamda o does hiçbir çizgiler kaldırılmış olursa 0 olacak silinen çizgilerin sayısını döndürür. ;-)

Yakut

Perl versiyonuna benzer, ancak Ruby'de. Hiçbir satır istendiği gibi silinirse 0 döndürürüm, ancak kodu daha çirkin hale getirir ve bir dönüş değeri olarak anlamlı değildir.

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

Hiçbir satır silinmediğinde boş bir dizi dönüş değeri olarak kabul edilebilirse, kod şöyle görünür:

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

Her iki yöntem de 0 ile 5 arasında silinen herhangi bir sayıda satır için çalışır.

JavaScript, 152 karakter golf oynadı

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

golfed:

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

Bağımsız (çirkin):

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
}

Temel olarak toStringher satırı numaralandırarak işlevden yararlanır . Bu nedenle satırı gerçekten kaldırmanız gerektiğini unutmayın (yorum yapmak işe yaramaz).

Bu aslında kaldırılan herhangi bir sayıda satır için çalışır ! Kaldırılan satırların bir dizisini veya kaldırılmadıysa boş bir diziyi döndürür. (Kolay kolay değiştirerek (sıfır dönmek değiştirebilir return raile return ra || 0gerçek dünyada daha faydalı olacaktır çünkü boş dizi çözüm gibi), ama ben.)

Örneğin, ilk satırın döndürülmesi ve ilk satırın [1]dışındaki her şeyin kaldırılması [2,3,4,5]. (Tabii ki, tüm satırları kaldırırsanız çalışmaz ;-))

Yakut

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

Bu nasıl çalışır: fikrim şuydu: bir dizi oluşturmak ve her satırda belirli bir değeri kaldırmak. Yani, ilk satırda, aslında [ 1, 2, 3, 4, 5]öğe 1kaldırıldı ile dizi var . İkinci satırda, adaha önce tanımlanmışsa, elemanı kaldırın 2. Aksi takdirde, öğe 2kaldırılmış olarak yeni bir dizi oluşturun . Satır 3 için de aynısını yapın. Satır 4'te, zaten bir dizi oluşturulduğundan emin olabilirsiniz, bu yüzden öğeyi kaldırın 4. 5. satırda, önce öğeyi kaldırın 5ve asonra boş bir diziyse, geri dönün 0. Aksi takdirde geri dönün a.

piton

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

Hiçbir satır kaldırılmazsa 0, aksi takdirde kaldırılan satırları döndürür. 0 ve 6. satırlar ;-) dışında 1 ila 5 satır kaldırabilirsiniz.

JavaScript, müstakil, 0, 1, 2 kaldırılan satır için çalışıyor ( 607  315 186 karakter)

→ canlı demo ←

Diğer değişkenlerde olduğu gibi JS değişken kaldırma ve küresel sızıntıyı kötüye kullanma :)

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
}

parametre olarak [1,2,3,4,5] dizisi ile çağrılır.

315 karakter

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
}

parametre olarak boş bir dizi ile çağrılır.

golfsiz versiyon

(ayrıca kaldırılan 3 ve 4 satır için de çalışır):

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

parametre olarak boş bir dizi ile çağrılır.

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
}

Vaktini boşa harcamak

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)

Ne istersen söyle, ama bence güzel .

Hangi satırların kaldırıldığını (1 veya daha fazla) veya hiçbir satır kaldırılmazsa 0'ı bilmenizi sağlar. Tüm 5 satır olabilir çıkarılabilir.

DÜZENLE:

Kodumun aslında 6 satırdan oluşabileceği ve kurallara aykırı olduğu dikkatimi çektiğinden, aşağıdakilere ayarladım:

(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

Aynısı geçerlidir - 1- Tümü veya yoksa 0 arasında değişen kaldırılmış bir dizi döndürür .

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

1-4 çizginin çıkarılması için çalışır. Tüm çizgileri kaldırırsanız, hiçbir satırı kaldırmamanız gibi döndürür.

Not: Parantezin kendi satırında sonlandırılması kötü stil olarak kabul edilir, ancak diğer dillere sahip olduğu endve }izin verildiğini varsayıyorum.

piton

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

Tüm satırlar için çalışır - ancak yalnızca iki satır silindiğinde. Yalnızca bir satır silinirse, silinen satır ve satır 5'i yazdırır. Çok fazla satır silinirse hiçbir şey yazdırmaz.

Bu bir yardımcı işlevi kullanır, çünkü del anahtar sözcüğü bir ile (; bildiğim kadarıyla) bir satırda kullanılamaz

Temel olarak, her satır yapıcıda bildirilen dizide kendisini siler, daha sonra yeterli satır silinirse dizi yazdırılır.

Bu işlev özellikleri iki şekilde özlüyor:

1. olduğu gibi çalıştırılırsa 0 yazdırmaz (son iki satırın yorumlandığı varsayılır ve bu nedenle 4, 5 yazdırılır
2. Değiştirilebilir olduğunu printvereturn

Déjà Vu

İstediğiniz sayıda satırı kaldırmak için çalışır (en az bir satır bıraktığınız sürece)

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,

Ben daha iyi olduğunu düşünüyorum R başka bir sürümü var (ama bir yardımcı işlevi kullanır):

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

Veya yardımcı işlevi varsayılan bir bağımsız değişken olarak tanımlayarak kullanmaktan kaçınabilirsiniz (aynı şekilde çalışır ancak daha az okunabilir - ancak "ayrı olarak tanımlanmış" yardımcı işlevi kullanılmaz):

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

Her ikisi de reportRemovedLines()ve funnyVersion()kaldırılan herhangi bir sayıda satırla çalışır - tüm satırları kaldırmanız dışında (bu durumda geri dönecektir NULL). Aslında satır numaralarını döndürürler , yalnızca yazdırmazlar - R'de olduğu gibi, bir işlev içinde değerlendirilen son ifadenin değeri otomatik olarak döndürülür.

O nasıl çalışır? Hile, tricktüm nesneleri kendi "ana ortamından" (yani, onu çağıran fonksiyonun ortamından) alan, değerlerini bir vektöre koyan ve 1'den 5'e kadar olan değerlerin temsil edilmediği döndürülen işlevdedir.

JavaScript (136/166 karakter)

Başlangıçta bazı değerlerin bildirildiği daha küçük bir sürüm:

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}

Bağımsız bir sürüm (hiçbir şey iletmenize gerek yoktur - b argümanı oradadır, b ile tanımlanıp tanımlanmadığını kontrol edebilirim ||)

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}

Evet, her ikisinin de returnifadeleri var, ancak bu sadece örtük dönüşlü dillerle rekabet edersem adil olur.

R,

Basit bir sürüm (5. satırı kaldırırsanız hata almayacağınız için kusursuz değildir):

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

Ve kusursuz bir versiyon:

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

Kaldırılan herhangi bir sayıda satırla çalışır (tüm satırları kaldırmanız dışında) ve kolayca 5'ten fazla satıra genişletilebilir. "Olduğu gibi" çalıştırılması integer(0), kavramsal olarak adil döndürmeye benzer şekilde geri döner 0. Gerçek bir 0 döndürmek onu daha çirkin ve daha uzun hale getirir, ancak karmaşık olmaz.

Son olarak, sihir kullanan bir sürüm:

Yardımcı fonksiyonu:

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
    }

Gerçek fonksiyon:

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

Nasıl kullanılır: i ile işlevi çağırın ve hangi işlevin söylendiğini anlamak için func2 kullanın.

İnt arr [] = {0,0} satırını int arr [] = {0,0,0,0,0} olarak değiştirirseniz, beş satırın tümü için de çalışır, ayrıca bir satır kaldırma test durumunu da ele alır otomatik olarak, ne yapıyorum sadece her satır için bayrak olarak bir değişken bir bit kullanmaktır ....