Genelleştirilmiş Dizi Tüfek

22

Haftaya başlamak için basit bir golf! Üç dizi verilir: temel dizi B , değer dizisi V ve dizin dizisi I . Tarafından belirtilen değerlere Vgirilen değerlerin eklendiği başka bir dizi üretmelisiniz . İşte bir örnek:BI

Base:    [5, 1, 4, 1, 3]
Values:  [0, 0, 7]
Indices: [5, 0, 3]

Endeksler, baz dizisinde aşağıdaki pozisyonları gösterir:

[ 5, 1, 4, 1, 3 ]
 ^        ^    ^
 0        3    5

Dolayısıyla, değer elemanından ilgili elemanların eklenmesiyle sonuç şöyle olmalıdır:

[0, 5, 1, 4, 7, 1, 3, 0]

kurallar

STDIN (veya en yakın alternatif), komut satırı argümanları veya fonksiyon argümanları üzerinden giriş alarak bir program veya fonksiyon yazabilir ve sonucu STDOUT (veya en yakın alternatif), fonksiyon dönüş değeri veya Bparametre olarak verilen diziyi değiştirerek yazdırabilirsiniz. .

Gönderiminiz bir işlevse Ive çıktı olarak kullanılmadığı Vgibi herhangi bir şekilde değiştirilebilir B.

Girdi hakkında aşağıdaki varsayımları yapabilirsiniz:

  • Temel ve değer dizisinin tüm öğeleri negatif olmayan tam sayılar olacaktır.
  • Değer dizisi, temel diziden en fazla bir öğeye sahip olacaktır.
  • Değer dizisi ve dizin dizisi aynı sayıda öğeye sahip olacaktır.
  • İndeks dizisi tekrarlanan indeksler içermeyecek ve tüm indeksler aralık içinde olacaktır.
  • Taban ve değer dizileri olabilir tekrarlanan elemanları içerir.
  • Dizilerin herhangi biri veya tümü boş olabilir.
  • Endekslerin belirli bir sırada verildiğini varsaymamalısınız.
  • Herhangi bir uygun, açık dize veya liste biçiminde girdi alabilir ve çıktı alabilirsiniz. Üç diziyi farklı bir sırayla almayı da seçebilirsiniz.
  • 0 tabanlı ve 1 tabanlı indeksleme arasından seçim yapabilirsiniz.

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

Test Kılıfları

B V I => Result0 tabanlı indeksleme için verilen format . 1 tabanlı endeksleme kullanıyorsanız, üçüncü dizinin öğelerini 1 arttırın.

[] [] [] => []
[] [1] [0] => [1]
[1,2] [] [] => [1,2]
[1,2] [3] [0] => [3,1,2]
[1,2] [3] [1] => [1,3,2]
[1,2] [3] [2] => [1,2,3]
[0,0,0] [1,1,1,1] [0,1,2,3] => [1,0,1,0,1,0,1]
[5,1,4,1,3] [0,0,7] [5,0,3] => [0,5,1,4,7,1,3,0]
[1,2,3,4] [4,3,2,1] [4,0,3,1] => [3,1,1,2,3,2,4,4]

Başka ilginç kenar davalarıyla karşılaşırsan bana haber ver, ben de ekleyeceğim.

Liderler Sıralaması

Burada hem düzenli bir lider tablosu hem de kazananların dile göre bir genel bakışını oluşturmak için bir Stack Snippet'i var.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Kod pasajını göster

code-golf  array-manipulation 
— Martin Ender
kaynak
4
NULLBoş bir dizinin olduğu diller için boş bir diziyi nasıl hissedersiniz NULL?
— Alex A.
@AlexA. Ortak bir / buysa söz konusu dil (ler) de boş dizinin gösterimi, bununla cezası değilim.
— Martin Ender
3
Bir basit bir golf ? Bütün hafta CJam'da yaptığım en zor şey bu. : P
— Dennis,

Yanıtlar:

13

Pyth, 14 bayt

s.icFPQmedSCtQ

Gösteri.

Bu program, girişleri Temel, Endeksler, Değerler sırasına göre 3'lü liste halinde alır.

Örnek hakkında açıklama [5, 1, 4, 1, 3], [5, 0, 3], [0, 0, 7]:

  1. Girdiyi alın: örtülü, Q giriştir.

  2. Dizini yapın, değer çiftleri: CtQ=[(5, 0), (0, 0), (3, 7)]

  3. Çiftleri artan dizin sırasına göre sıralayın: SCtQ=[(0, 0), (3, 7), (5, 0)]

  4. Her çiftin değerini al: medSCtQ=[0, 7, 0]

  5. Temel listeyi göstergelerin bulunduğu yerde ayırın: cFPQ=[[], [5, 1, 4], [1, 3], []]

  6. Serpiştirme 3 ve 4: .icFPQmedSCtQ=[[], 0, [5, 1, 4], 7, [1, 3], 0, []]

  7. Tek bir listede birleştirin: s.icFPQmedSCtQ=[0, 5, 1, 4, 7, 1, 3, 0]

— isaacg
kaynak
Lanet olsun. Ne zamandan beri interleave yöntemimiz var? Sadece postalamak istedim ssC,cFPQamedSCtQ].
— Jakube
5
@Jakube isaac sinsice 6 gün önce işledi.
— orlp
— isaacg
3
@Jakube Pyth herhangi bir sorunu çözmek için büyüyebilir beri. Golf dillerinde sorun bu. Ezoterik diller ezoterik diller uğruna vardır; tasarlandıkları gibi * sonradan.
— sentiao
@sentiao Adil olmak gerekirse, ev sahibi dil (Python) bir süredir farklı bir adla araya giriyordu .
— Mego
16

Python 2, 54

lambda B,*X:map(B.insert,*zip(*sorted(zip(*X))[::-1]))

Girişi olarak alır B,I,V. Çağrıldığında girişi değiştirir B(bunun mümkün olduğunu hatırlattığı için Martin Büttner'e teşekkürler).

Kullanımları mapçağırmak için B.inserther endeksi / eleman çifti. Liste endeksleri, elemanlar eklenirken kayma riskinden kaçınmak için çifte bir zip / sort / unzip ile azalan indeks sırasına göre çiftleri sıralar. Değişen konu için olmasa da yapabiliriz map(B.insert,*X).

Eski yöntem (65):

B,V,I=input()
for i,v in sorted(zip(I,V))[::-1]:B[i:i]=v,
print B
— XNOR
kaynak
5

Haskell, 62 bayt

import Data.List
f b v i=map snd$sort$zip[0.5,1.5..]b++zip i v

Kullanım örneği: f [5,1,4,1,3] [0,0,7] [5,0,3]-> [0,5,1,4,7,1,3,0].

Nasıl çalışır: temel listeyi 0.5(örn. [(0.5,5),(1.5,1),(2.5,4),(3.5,1),(4.5,3)]) Başlayan "ve bir buçuk" endeksleri ile güçlendirin ve endeks değeri çiftleri ile birleştirin. Dizini sıralayın ve atın.

Not : Burada hile yapıyorum mu bilmiyorum. Görünümünde bir matematiksel açıdan sorun değil ama bir programcı endeksleri listesi iddia edebilir [5,0,3]bir liste değildir Integersistendiği gibi, ama bir liste Fractionals(tam olarak yazın polimorfik olmakla ait olmalıdır Fractional, örneğin sınıfta, Floatya Double).

— niml'i
kaynak
5

Ruby, 60 59 53 bayt

->a,b,c{c.zip(b).sort.reverse.map{|i,v|a.insert i,v}}

Ve asılsız versiyon

def riffle(array, values, indices)
    indices.zip(values).sort.reverse.each do |index, value|
        array.insert(index, value)
    end
end
— Dylan Frese
kaynak
2
Bunun yerine bunu bir isimsiz işlev yaparak bu kısaltabilirsiniz: ->a,b,c{...}. Ayrıca şanslar insertparantez gerektirmez.
— Martin Ender
@ MartinBüttner lambda ile isimlendirilmemiş işlev hakkında bir şey biliyordum, ancak bunun zorluğun ruhunda olduğunu (genellikle adlandırılmış bir işlev için sorar) hissetmedim. Yine de parenleri gördüğünüz için teşekkürler.
— Dylan Frese
Görev, özellikle adlandırılmış bir işlev istemiyorsa , adlandırılmamış işlevler her zaman kabul edilebilir . Ve adlandırılmış bir işlev istemedim (Asla yapmam;).
— Martin Ender
5

CJam, 34 23 18 bayt

{.\2/\ee+{0=}$1f=}

İlk CJam gönderim. Tavsiyeler açıktır, golf için çok fazla olduğundan eminim.

@ MartinBüttner ve @Dennis yardımı ile 16 bayt kaydedildi.

Yığın üzerinde sıra bekleyen işlev B V I(en üstteki I).

Örnek kullanım:

[5 1 4 1 3] [0 0 7] [5 0 3] {.\2/\ee+{0=}$1f=}~

Yöntem:

  • Dizinin ith elemanını eşleştirmeki+0.5
  • ekleme değerlerini ekleme konumlarıyla eşleştirin
  • elde edilen iki diziyi birleştirmek
  • pozisyon elemanlarına göre sıralama dizisi
  • değer unsurlarını koru
— randomra
kaynak
Bu kayan nokta yaklaşımı benimkinden çok zeki ve (ne yazık ki) daha iyi. q~.5fm.\2/\ee+$1f=pAnonim bir işlev kullanarak 19 bayta ve 18 bayta kadar alabilirsiniz:{.5fm.\2/\ee+$1f=}
— Dennis
Kayan nokta numarası olmadan aynı fikir: {.\2/\ee+{0=}$1f=}(hala 18 bayt)
— Dennis,
@Dennis Teşekkürler, get array elementoperatörü bulamadım 1f=. Yine de tam bir program olarak bırakacağım.
— randomra
Senin çağrı. Neden bir işlev göndermeye karşı olduğunuzu sormamın sakıncası var mı?
— Dennis
@Dennis CJam'ı yeni başlattım ve işlevleri nasıl kullanacağımdan emin değildim. Şimdi anladım ki cevabı değiştirdim.
— randomra
5

K, 22 21 bayt

{,//+(y@<z;(z@<z)_ x)}

Biz 3 argüman fonksiyonunu tanımlayan {…}kapalı değişkenlerle x, yve zsırası ile, başlangıç listesi, değer listesi ve dizin listesi temsil eder. "Cut" operatörü ( _), başlangıç ​​listesini verilen indekslerin ( (z@<z)) sıralanan listesinden ayırmak için kullanılır . Değerlerini (bunları uygun şekilde sıraladıktan sonra) orijinal dizinin parçalara (a;b)ayırıp, bir liste ( ) oluşturarak , transpoze (+ ) 'yi ve sonucu ( ,//) düzleştirerek sıraladıktan sonra ) birleştiririz.

Kullanım örneği:

  f:{,//+(y@<z;(z@<z)_ x)}
{,//+(y@<z;(z@<z)_ x)}

  f[1 2 3 4;4 3 2 1;4 0 3 1]
3 1 1 2 3 2 4 4

  f[5 1 4 1 3;0 0 7;5 0 3]
0 5 1 4 7 1 3 0

Alt çizgi etrafındaki boşluklar gereklidir, çünkü K tanımlayıcılarda alt çizgi çizilmesine izin verir. K5 bu potansiyel belirsizliği ortadan kaldırıyor. Artan sırada gelen endekslere güvenebilirsek ve alt çizgiler geçerli tanımlayıcılar değilse, daha güzel olan 13 baytlık programı kullanabiliriz:

{,//+(y;z_x)}

(iç çekmek.)

Düzenle:

{,//+(y@<z;(z@<z)_ x)} / before
{,//+(y@<z;z[<z]_ x)}  / after

Simetriyi keser, ancak […]infix @indeksleme operatörü yerine braket indeksleme ( ) kullanarak bir bayttan tasarruf edebiliriz . Bu genellikle programları daha uzun yapar, ancak bu durumda zkesimi yapmadan önce sıralamak için parens'e ihtiyacımız vardı .

— Johne
kaynak
4

Pyth, 17 bayt

ssC,cFPQamedSCtQ]

@isaacg zaten çözümümü yendi. Ama belgelerimi tamamladığımdan beri, yine de göndereceğim.

Bu girdi biçiminde alır B, I, V. Burada deneyebilirsiniz: Gösteri veya Test Takımı

Açıklama:

B = [5,1,4,1,3], I = [5,0,3], V = [0,0,7]OP’deki örneği kullanıyorum .

                    implicit: Q = input()
      PQ            all elements but last of Q   => [[5,1,4,1,3], [5,0,3]]
    cF              split B it the indices in I  => [[], [5,1,4], [1,3], []]

              tQ    all elements but first of Q  => [[5,0,3], [0,0,7]]
             C      zip                          => [(5,0), (0,0), (3,7)]
            S       sort                         => [(0,0), (3,7), (5,0)]
         med        extract the end of each pair => [0,7,0]
        a       ]   append an empty list         => [0,7,0,[]]

   ,                create a pair => ([[], [5,1,4], [1,3], []], [0,7,0,[]])
  C                 zip           => [([],0), ([5,1,4],7), ([1,3],0), ([],[])]
 s                  sum           => ([],0,[5,1,4],7,[1,3],0,[],[])
s                   sum           => [0,5,1,4,7,1,3,0]
— Jakube
kaynak
4

JavaScript (ES6), 75

Bir dizi döndüren, 3 dizi parametresine sahip bir işlev. Tuhaf bir şekilde, bu işlev iparametresini değiştirir (nazikçe izin verdiği şekilde)

Parçacığı ve Firefox’u yalnızca normal şekilde çalıştırarak test edin. 

f=(b,v,i,j=0)=>b.concat(v).map(p=>(p=i.indexOf(j))<0?b[j++]:(i[p]=-1,v[p]))

// TEST
out=x=>O.innerHTML+=x+'\n'

test=[
{ b:[], v:[], i:[], k:[] },
{ b:[], v:[1], i:[0], k:[1] },
{ b:[1,2], v:[], i:[], k:[1,2] },
{ b:[1,2], v:[3], i:[0], k:[3,1,2] },
{ b:[1,2], v:[3], i:[1], k:[1,3,2] },
{ b:[1,2], v:[3], i:[2], k:[1,2,3] },
{ b:[0,0,0], v:[1,1,1,1], i:[0,1,2,3], k:[1,0,1,0,1,0,1] },
{ b:[5,1,4,1,3], v:[0,0,7], i:[5,0,3], k:[0,5,1,4,7,1,3,0] },
{ b:[1,2,3,4], v:[4,3,2,1], i:[4,0,3,1], k:[3,1,1,2,3,2,4,4] }
];

test.forEach(x=>{
  r = f(x.b,x.v,x.i.slice(0)) // pass a copy of i, as the function will alter it
  ok = ''+r==''+x.k
  s='Test ' + (ok?'OK':'FAIL')
  +'\n B ['+x.b
  +']\n V ['+x.v
  +']\n I ['+x.i
  +']\n Result ['+r
  +']\n Check  ['+x.k
  +']\n'
  out(s)
  
})
<pre id=O></pre>
Parçacığı genişlet

— edc65
kaynak
Meraktan, kodu Firefox’a özgü kılan şey nedir? ES6 olduğu için mi?
— Alex A.
@ AlexA.it çünkü ES6, evet. Özellikle fat arrow functionChrome'un geliştirici sürümünde bile uygulanmadı (AFAIK)
— edc65
Nitekim, Chrome'un Kanarya yapısı bile desteklememektedir.
— DocMax
4

Mathematica, 52 51 bayt

Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&

Örnek:

In[1]:= f = Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&;

In[2]:= f[{5, 1, 4, 1, 3}, {0, 0, 7}, {5, 0, 3}]

Out[2]= {0, 5, 1, 4, 7, 1, 3, 0}

Açıklama:

Yukarıdaki örneği kullanarak.

  • Tr@#2->#&~MapIndexed~# => {1 -> 5, 2 -> 1, 3 -> 4, 4 -> 1, 5 -> 3}
  • Thread[#3+.5->#2] => {5.5 -> 0, 0.5 -> 0, 3.5 -> 7}
  • Sonra bu iki listenin (sıralanmış) birleşimini alın. (=> {0.5 -> 0, 1 -> 5, 2 -> 1, 3 -> 4, 3.5 -> 7, 4 -> 1, 5 -> 3, 5.5 -> 0})
  • Ve sonra her çiftin son elemanını alın. (=> {0, 5, 1, 4, 7, 1, 3, 0})
— alephalpha
kaynak
3

R, 75 bayt

function(b,v,i){n=b;j=0;for(g in v)n=append(n,g,i[j<-j+1]+sum(i<i[j])-1);n}

Bu adsız bir işlev oluşturur. Aramak için bir isim verin, örneğin f=function.... Dizilerin 1 indeksli olması gerektiğine dikkat edin, çünkü bu sadece R'nin yuvarlanmasıdır.

Ungolfed + açıklama:

f <- function(b, v, i) {
    # Initialize the output vector to b
    n <- b

    # Initialize an index over the indices
    j <- 0

    # Loop over the values to insert
    for(g in v) {
        # Get the index of the next given insertion index
        j <- j + 1

        # Insert g into n.
        # The position at which to insert the value is determined by
        # adding the number of indices less than the current one and
        # subtracting 1. The subtraction is because we're using the
        # `after` argument in the `append` function.

        n <- append(n, g, i[j] + sum(i < i[j]) - 1)
    }

    # Return n
    n
}

Örnekler:

> f(c(), c(), c())
[1] NULL

> f(c(0, 0, 0), c(1, 1, 1, 1), c(1, 2, 3, 4))
[1] 1 0 1 0 1 0 1

> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(6, 1, 4))
[1] 0 5 1 4 7 1 3 0

Öneriler her zaman olduğu gibi açığız!

— Alex A.
kaynak
2

CJam, 19 bayt

l~_,)N*q~.{t}~.\N-p

Bu, STDIN'den B , I ve V dizilerini (her sıra için bir tane) okuyan tam bir programdır .

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

l~    e# Evaluate the first line of input.
_,)   e# Compute the array length and add 1.
N*    e# Push a string of that many linefeeds.
q~    e# Evaluate the remaining input.
.{t}~ e# Vectorized array set: for each index in the array from line 2, replace the
      e# LF at that index by the corresponding element of the array from line 3.
.\    e# Interleave the two arrays on the stack.
N-    e# Remove the linefeeds.
p     e# Print.

CJam, 20 bayt

{Qa+@@.{a2$2$=+t}e_}

Bu, B , V ve I (yukarıdan aşağıya) yığından çıkan ve karşılığında yığında tek bir dizi bırakan anonim bir işlevdir .

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

Qa+      e# Append [[]] to B.
@@       e# Rotate V and I on top of B.
.{       e# For each v in V and the corresponding i in I:
   a     e#     Push [v].
   2$2$= e#     Retrieve b := B[i].
   +     e#     Append to push [v b].
         e#     The stack now consists of: B i [v b]
   t     e#     Set B[i] := [v b].
}        e#
e_       e# Flatten B.
— Dennis
kaynak
1

Ruby, 48 bayt

Bunun kurallara uygun olduğunu düşünüyorum ama lütfen kontrol edin.

->b,v,i{l=-1;i.map{|j|b[j]=[v[l+=1],b[j]]};b*?:}

Üç diziyi giriş olarak alan adsız işlev. Yakut biçimde ayrıştırılabilen bir dizeyi, yakut ifadesiyle bir sayılar dizisine çıkarır x.split(/:+/).map(&:to_i).

İdeone üzerinde test vakaları .

3 bayt daha kurtarabilirdim, ancak çıktı biçimi [1,2,[nil,5]], kuralları açık olmasına rağmen, kuralları biraz fazla uzatıyor.

— blutorange
kaynak
Bence şu anki format uygun. Birleştirici nildeğerleri olan iç içe geçmiş diziler biraz gerilir. Ancak her iki durumda da bu yarışmayı kazanmıyor, bu yüzden bu konuda gerçekten endişelenmiyorum.
— Martin Ender
1

R, 60

B, v ve i alan adsız bir işlev olarak

function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}

B 'yi NA'larla genişletir v ile gereken boşlukları doldurur v' yi vektörsüz döndürür

> f=function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}
> f(c(), c(), c())
logical(0)
> f(c(0, 0, 0), c(1, 1, 1, 1), c(0, 1, 2, 3))
[1] 1 0 1 0 1 0 1
> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(5, 0, 3))
[1] 0 5 1 4 7 1 3 0
— MickyT
kaynak
1

Java, 253, 226, 219, 209

tam olarak kazanan değil, ama peki.

Varsayalım ki B, V ve ben boş değiliz. v (küçük harf v), Değerler / Göstergeler dizisinin uzunluğudur. R, döndürülen dizidir. r, döndürülen dizinin uzunluğu. x, y ve ben hepsi geçici girdiler.

int[]f(int[]B,int[]V,int[]I){int v=V.length,r=B.length+v,x,y,i;int[]R=java.utils.Arrays.copyOf(B,r);for(x=0;x<v;x++){i=I[x];for(y=0;y<x;y++)if(I[x]>I[y])i++;for(y=r-2;y>=i;y--)R[y+1]=R[y];R[i]=V[x];}return R;}

genişletilmiş:

int[]f( int[] B, int[] V, int[] I ) {
    int v = V.length, //length of Values
        r = B.length + v, //length of the result
        x, y, i; //temps
        int[] R = java.utils.Arrays.copyOf( B, r );       
        for( x = 0; x < v; x++ ) {
        i = I[x];
        for( y = 0; y < x; y++ )
            if( I[x] > I[y] )
                i++;
        for( y = r - 2; y >= i; y-- )
            R[y+1] = R[y];
        R[i] = V[x];
    }
    return R;
}
— Jack Cephane
kaynak
1

APL, 22 bayt

{(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}

←IO ← 0'da test durumlarına uygun.

Bu standart bir algoritma: İlk argümanın indeks vektörü verilen endekslere eklenir (3. argüman). ⍋Endeksleri artan düzende sıralayacak permütasyonu hesaplar. APL'nin sıralama algoritması tanım gereği sabit olduğundan, hesaplanan permütasyon ikinci ve ilk argümanın katılaştırıcı unsurunu doğru yere koyar.

Örneğin :

    {(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}(5 1 4 1 3)(0 0 7)(5 0 3)
0 5 1 4 7 1 3 0
— lstefano
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.