Negatif olmayan bir tamsayı dizisi verildiğinde, göreviniz aşağıda açıklandığı gibi yalnızca belirli öğelerini tutmaktır.

• Diyelim ki dizi [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Önce dizinin ilk elemanını al n,. İlk nelemanları saklayın ve sonrakini atın ( n+1th atın ). Yeni dizi [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Ardından, kaldırılan öğeyi takip ederek öğeyi alırsınız ve aynı şeyi yaparsınız. Süreci yeniden uygulayarak,[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Dizinin sınırları dışına gelene kadar işlemi tekrarlarsınız / dizide hiç öğe kalmaz. Duruyoruz çünkü 11dizi uzunluğundan daha yüksek.

• Şimdi sonucu çıkarmalısınız.

Giriş / çıkış herhangi bir standart biçimde alınabilir / sağlanabilir. Dizi asla boş olmayacak ve yalnızca negatif olmayan tamsayılar içerecektir. Tüm standart boşluklar yasaktır.

Bu kod golf yani bayt kısa kod kazanır!

Test Durumları

Giriş -> Çıkış

[1, 2, 3, 4, 5] -> [1, 3, 4]

[6, 1, 0, 5, 6] -> [6, 1, 0, 5, 6]

[1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1] -> [1, 2, 11, 5, 2, 0, 13, 10, 1]

[2, 2, 2, 2, 2, 2] -> [2, 2]

[1, 2, 3, 1, 2, 3, 1, 2, 3] -> [1, 2]

[3, 1, 2, 4, 0] -> [] *

* Son test durumu içerir 0, bu yüzden süreci daha net olacak şekilde yayınlamaya karar verdim:

[3, 1, 2, 4, 0] --> [3, 1, 2, 0] --> [1, 2, 0] --> [1, 0] --> [0] --> [] )

^{( Bu meydan esinlenerek tarafından Erik Outgolfer )}

Pyth, 18 bayt

#IgZlQB .(Q=Z@QZ)Q

Burada deneyin.

JavaScript (ES6), 45 bayt

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

Test senaryoları

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

console.log(JSON.stringify(f([1, 2, 3, 4, 5]))) // --> [1, 3, 4]
console.log(JSON.stringify(f([6, 1, 0, 5, 6]))) // --> [6, 1, 0, 5, 6]
console.log(JSON.stringify(f([1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]))) // --> [1, 2, 11, 5, 2, 0, 13, 10, 1]
console.log(JSON.stringify(f([2, 2, 2, 2, 2, 2]))) // --> [2, 2]
console.log(JSON.stringify(f([1, 2, 3, 1, 2, 3, 1, 2, 3]))) // -> [1, 2]
console.log(JSON.stringify(f([3, 1, 2, 4, 0]))) // --> []

Haskell , 50 bayt

g.pure.(0:)anonim bir işlev alır ve Ints listesini döndürerek , olarak kullanın (g.pure.(0:))[1,2,3,4,5].

g.pure.(0:)
g(a,_:b:c)=g$splitAt b$a++b:c
g(a,_)=a

Çevrimiçi deneyin!

Nasıl çalışır

• İşlev g, bölünmüş listeyi temsil eden bir tuple argümanı alır. aönceki adımda tutulan başlangıç ​​öğelerinin listesidir, _atılacak böğedir, uzunluk olarak kullanılacak bir sonraki öğedir cve kalan öğelerdir.
  • Grubun ikinci bölümünde a seçmek için yeterli eleman varsa b, yeni bir bölünme yapılır ve gtekrarlanır. Aksi takdirde asonuç olarak durur .
• Anonim işlev g.pure.(0:)tüm arayarak başlatır gtuple ile ([],0:l), lgiriş ve 0hemen ıskartaya alır g.
  • pureburada Applicative(ikili) tuples örneğini kullanır ve sonuç türü ([Int],[Int])ile argümanını []ilk eleman olarak bir tupledaki ikinci eleman olarak rahatça koyar .

Python 3 , 59 bayt

f=lambda a,i=0:f(a[:a[i]]+a[a[i]+1:],a[i])if i<len(a)else a

Çevrimiçi deneyin!

Haskell , 51 bayt

f s=s%s
s%(n:_)|(x,_:z)<-splitAt n s=(x++z)%z
s%_=s

Çevrimiçi deneyin! Örnek kullanımı: f [1,2,3,4,5].

Java 8, 68 bayt

Bu lambda bir değişkeni kabul eder List<Integer>( remove(int)örneğin destekler ArrayList). Çıktı mutasyona uğramış girdidir. Atayın Consumer<List<Integer>>.

l->{for(int i=0,f=0;i<l.size();f^=1)i=f>0?l.remove(i)*0+i:l.get(i);}

Çevrimiçi Deneyin

Bu sorun için kontrol akışı çok can sıkıcı. Her yinelemede bir öğeyi kaldırmamız ve öğeyi bir sonraki konuma almamız gerekir ve bu işlemlerin her ikisi de bir aralık denetimi gerektirir (ve her ikisi de programın tamamlanmasını tetikleyebilir). Bir strateji, her iki işlemi tek bir döngü yinelemesinde gerçekleştirmektir; dizin güncellemesi kendi aralık denetimi tarafından korunur. Daha kısa olduğu ortaya çıkan bir başka strateji ise, her döngü yinelemesi arasındaki işlemler arasında geçiş yapmaktır, bu da bu çözümün yaptığı şeydir.

APL (Dyalog Klasik) , 32 bayt

1∘{n∇⍣(n≤≢w)⊢w←⍵/⍨(n←1+⍺⊃⍵)≠⍳≢⍵}

açıklama

1∘{                             } bind 1 as starting left argument (⍺)
                             ⍳≢⍵  generate indexes for right argument (⍵)
                   (n←1+⍺⊃⍵)      n is 1+item at position ⍺ 
              w←⍵/⍨         ≠     w is ⍵ with item at n removed
   n∇⍣(n≤≢w)⊢                     recurse with n as left and w as right arg if n <= length of w

Çevrimiçi deneyin!

Perl 5,38 + 1 (-a) = 39 bayt

splice@F,$p=$F[$p],1while$p<@F;say"@F"

Çevrimiçi deneyin!

Haskell, 99 bayt (girinti olmadan 88)

f x y
 |y>=l=f x$l-1
 |e>=l=x
 |True=f (take e x ++ drop (1+e) x) e
 where e=x!!y
       l=length x

VI, 31 25 bayt

O@0kdd<C-v><C-a>Y<C-v><C-x>gg@a<Esc>"add<C-a>Y<C-x>@a

<C-?>karşılık gelir Control + ?ve <Esc>karşı Escapebelli. Bunların her biri 1 bayt için sayılır ( meta'ya bakın ).

Giriş

Giriş dosyası satır başına 1 tamsayı + sonunda 1 boş satır içermelidir, örnek:

1
2
3
4
5
⁣

Giriş dosyasının her satırını, örneğin 1 :: 2 :: 3 :: 4 :: 5 :: []bazı dillerde olduğu gibi bir dizi öğesi olarak görebiliriz.

Başlatmak

Vi komutunu aşağıdaki komutla başlatabilir ve çözüm konturunu kontur ile yazabilirsiniz:

vi -u NONE input

Bu tek astarı da kullanabilirsiniz:

vi -u NONE -c ':exec "norm O@0kdd\<C-v>\<C-a>Y\<C-v>\<C-x>gg@a\<Esc>\"add\<C-a>Y\<C-x>@a"' -c ":w output" -c ':q' input

Bu output, bir giriş dosyasından doğru sonucu veren bir dosya üretmelidir input.

açıklamalar

Çözümü tanıtmak için, ilk önce yalnızca 0 içermeyen diziler için çalışan 19 baytlık bir çözüm sunacağım. Bu çözüm, son çözümde çok az değişiklikle kullanılan özyinelemeli bir makro kullanır:

Yqa@0ddYgg@aquggY@a

Kısmi bir çözümün açıklaması

Y                       # yank first line (first integer + line break) to "0 register
 qa                     # start recording a macro ("a register)
   @0                   # jump n lines, where n is the content of the "0 register
     dd                 # delete the current line (n+1th line)
       Y                # yank current line (integer after the previously deleted line)
        gg              # go back to the first line
          @a            # recurse on macro "a"
            q           # finish recording the macro
             u          # cancel modifications done by the execution of the macro
              gg        # go back to the first line
                Y@a     # apply the recorded macro with first parameter equal to the first integer

Buradaki hile "0, geçerli tamsayıyı (ve satır sonunu, çok önemli) depolamak için kaydı kullanmaktır . Bu nedenle, komut satırları @0atlamaya izin verir n( ndeğerini çağır "0). Atlama dosyadaki satır sayısını aşarsa, makro başarısız olur, böylece program durur (gerektiği gibi dizi sınırlarının dışında).

Ancak giriş içeriyorsa bu çözüm çalışmaz 0. Gerçekten de, "0kayıt değeri eşitse 0, sevdiğimiz gibi @0değil, bir satır (satır sonu nedeniyle) atlar 0. Böylece sonraki komut ( dd) 0'ın tamsayısını silmez, ancak 1'inci (doğru değil) siler.

Geçerli bir çözüm 0, tamsayı sormadan önce her zaman arttırmak ve hemen sonra azaltmaktır. Böylece, @0komut n+1satırları atlar ( nartırılmış geçerli tamsayıdır). Daha ksonra hatta n(önceki satır) gitmek için bir komut gereklidir . Bu hileyi kullanarak, dizinin dışına atlamaktan (böylece programı sonlandırmaktan) kaçınmak için giriş dosyasının sonunda boş bir satıra ihtiyaç vardır, çünkü şimdi her zaman bir n+1önceki satıra atlamadan önce satırları atlıyoruz.

Nihai çözümün açıklaması

O                                                       # insert a new line at the beginning of the file, enter insert mode to write the macro content
 @0                                                     # jump n lines                                                       
   k                                                    # go to the previous line
    dd                                                  # delete this line
      <C-v><C-a>                                        # type Control+A (C-v is needed because we are in insert mode) to increment the current integer
                Y                                       # yank the incremented integer
                 <C-v><C-x>                             # decrement the current integer
                           gg                           # go to the first line
                             @a                         # recurse on macro "a"
                               <Esc>                    # exit insert mode : at this step, the first line of the file contains the macro content @0kdd^AY^Xgg@a
                                    "add                # copy @0kdd^AY^Xgg@a line to the register "a and delete the line
                                        <C-a>           # increment the first integer
                                             Y          # yank it (into "0)
                                              <C-x>     # decrement the first integer
                                                   @a   # apply macro in a" (initial @0 will jump n+1 lines, since we incremented the first integer before calling the macro)

Makro içeriğini kaydetmeden önce dosyanın içine yazmak birkaç bayt kaydetmenizi sağlar:

• qa...qkayıt olduktan sonra tüm değişiklikleri yazmaktan ve geri almaktan kaçınır
• önler :let @a="...")

Düzenlemeler

1.

• makro içeriğini ilk satıra yazın (son satır yerine)
• girişi değiştir (sonunda 1 boş satır)
• komut satırında test etmek için bir satır ekleyin

Pyth, 32 bayt

VlQIgNlQBK@QNI!K=QYBIgKlQB.(QK;Q

Çevrimiçi deneyin

C # (.NET Core) , 74 bayt

n=>{for(int i=n[0];i<n.Count;){n.RemoveAt(i);i=i<n.Count?n[i]:n.Count+1;}}

Çevrimiçi deneyin!

Bu, bir listeyi alır ve değiştirir. Lambda argümanı tanımında tam olarak nitelenmiş adı kullanarak, ithalatın etrafında bazı Java cevapları gördüm. Buna izin verilmiyorsa, bu yanıtı kaldırabilirim.

R , 64 53 bayt

f=function(a,i=1,d=a[i]+1)"if"(is.na(d),a,f(a[-d],d))

Özyinelemeli işlev. Bir zorunlu girişi vardır, aatlamak için liste. i(varsayılan için üzerinden atlamak şeyler sayısının endeksidir 1) ve daynı zamanda kaldırılacak keza indeks kaldırıldı gerekli değerden sonra sonraki öğenin endeksidir. numeric(0)Boş çıktı için boş bir vektör döndürür .

Çevrimiçi deneyin!

Ungolfed:

f <- function(a, i = 1, d = a[i] + 1) {
  if(is.na(d)) {   # d is NA if and only if a[i] is out of bounds
    a
  } else {
    f( a[-d], d, a[d] + 1 )   # a[-d] is a with the item at index d removed
  }
}