Dize üzerinde belirli bir işlev grubumuz olduğunu varsayalım. Bu işlevler, boşlukları veya madlibs'leri doldurmaya benzer, tek bir girdi almaları ve tüm boşluklarını doldurmak için kullanmaları dışında. Mesela benzeyen bir fonksiyonumuz olabilir.

I went to the ____ store and bought ____ today.

Bu işlevi dizeye uygularsak cheesesonuç şöyle olur:

I went to the cheese store and bought cheese today.

Bu işlevleri, boşlukların basitçe dizeler arasındaki boşluklar olduğu boş olmayan bir dizeler listesi olarak gösterebiliriz. Örneğin yukarıdaki fonksiyonumuz:

["I went to the ", " store and bought ", " today."]

Bu gösterimde, bu türdeki her işlev için yalnızca bir temsil ve her gösterim için yalnızca bir işlev vardır.

Gerçekten temiz bir şey, bu tür fonksiyonların setinin kompozisyon altında kapalı olmasıdır. Yani fonksiyonlarımızdan ikisinin kompozisyonu her zaman bu fonksiyonlardan bir diğeri. Örneğin, yukarıdaki işlevimizi

["blue ", ""]

( bluegirişin önüne geçen işlev) İşlevi alırız :

["I went to the blue ", " store and bought blue ", " today."]

Bunlar biraz daha karmaşık olabilir. Örneğin, ilk işlevi

["big ", " and ", ""]

Sonuç

["I went to the big ", " and ", " store and bought big ", "and", " today."]

Görev

Göreviniz boş olmayan dizeler listesi olarak açıklandığı gibi iki işlev almak ve bileşimlerini boş olmayan dizeler listesi olarak çıkarmaktır.

Bu zorluğun amacı için bir liste, kopyalara izin veren herhangi bir sıralı kap olabilir ve bir dize yerel bir dize türü, bir karakter listesi veya bir tamsayı listesi olabilir.

Bu kod golf cevapları daha az bayt daha iyi ile bayt olarak puanlanır olduğunu.

Test senaryoları

["","xy"] ["ab",""] -> ["ab","xy"]
["x","y","z"] ["a","b"] -> ["xa","bya","bz"]
["xy"] ["ab"] -> ["xy"]
["","",""] ["a",""] -> ["a","a",""]
["x",""] ["","",""] -> ["x","",""]
["x","y","z"] ["a","b","c"] -> ["xa","b","cya","b","cz"]
["x","x","x"] ["a"] -> ["xaxax"]
["w","x","y","z"] ["ab","cd","e"] -> ["wab","cd","exab","cd","eyab","cd","ez"]

Jöle , 6 bayt

j0j@ṣ0

Kabul İKİLİ bağlantı ilk işlev temsil sağ ve ikinci işlev temsil sol elde edilen fonksiyonu temsil verir. Her işlev gösterimi karakter listelerinin bir listesidir (Jelly'in başka dizeleri yoktur).

Çevrimiçi deneyin! (tam program bağımsız değişkenleri Python gösteriminde verilir; dizeler listeler haline gelir. Altbilgi, Bağlantı çıktısının bir Python temsilini gösterir.)

İşte Link'in çıktılarını girdiler gibi yeniden biçimlendiren bir test takımı .

Nasıl?

Sıfırın tamsayısını yer tutucu olarak kullanarak temsillerin tüm alanına (karakter listelerinin herhangi bir listesi) izin vermek için Jelly'nin karışık tür listelerinden yararlanır:

j0j@ṣ0 - Link: b, a        e.g.    b = [['a','b'],['c','d'],['e']]
       -                   ...and  a = [['w'],['x'],['y'],['z']]
                             (i.e. test-case ["w","x","y","z"] ["ab","cd","e"])
j0     - join b with zeros         ['a','b',0,'c','d',0,'e']    
  j@   - join a with that          ['w','a','b',0,'c','d',0,'e','x','a','b',0,'c','d',0,'e','y','a','b',0,'c','d',0,'e','z']
    ṣ0 - split at zeros            [['w','a','b'],['c','d'],['e','x','a','b'],['c','d'],['e','y','a','b'],['c','d'],['e','z']
                             (i.e.: ["wab","cd","exab","cd","eyab","cd","ez"])

Jelly'in karışık listelerinden herhangi birini (herhangi bir derinlik veya şekle sahip olanlar dahil) ele almamız gerekiyorsa, bu sekiz byter'ı kullanabiliriz: j,©⁹jœṣ®eşleştirilen argümanları yer tutucu olarak kullanır.

Haskell , 78 bayt

(a:b:r)#t@(x:s)|s>[]=(a++x):init s++((last s++b):r)#t|z<-a++x++b=(z:r)#t
x#_=x

Çevrimiçi deneyin!

Python 3.8 (ön sürüm) ,  60  58 bayt

lambda a,b:(v:='&'.join(a+b)+'$').join(b).join(a).split(v)

İki dize listesini kabul eden ave bbir dize listesi döndüren adsız bir işlev .

Çevrimiçi deneyin! Veya test takımına bakın .

Nasıl?

Önce veya viçinde bulunmayan bir ayırıcı dize oluşturur . Daha sonra, dizelerini kopyalarıyla birleştirerek bir dize oluşturur . Ardından dizeleri bunun kopyalarıyla birleştirerek bir dize oluşturur. Son olarak dizeleri listelemek için bu dizeyi örneklerine böler .abbvav

Sağlanırken vdeğil aya bbiz de sağlamalıdır vbize erken bütün dizeleri durumda bölünmüş alışkanlık markasını ave beşittir. Bunu yapmak için vher iki listedeki tüm dizeleri bir dize (burada '&') örnekleri ile birleştirerek ve ekstra, farklı bir karakter (burada '$') ekleyerek oluştururuz . Girişlerdeki tüm dizeler seçilen karaktere eşit olabileceğinden, her ikisini de tek başına yapmanın yeterli olmadığını unutmayın.

05AB1E , 4 15 19 9 11 bayt

«TýR©ý¹sý®¡

Jelly cevabının aksine, 05AB1E'nin string "0", integer 0ve float 0.0hepsi (biraz) eşittir, bu yüzden bir tamsayı ile bölünemez / katılamazım. Bu yüzden +15 bayt'ı geçici çözüm olarak aldık, ancak şimdi 9 bayta kadar golf oynadım. @JonathanAllan'a 2 hata bulduğu için teşekkürler .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

«            # Merge the two (implicit) input-lists together
 Tý          # Then using a "10" delimiter join all strings together
   R         # Reverse this string
    ©        # Store this string in variable `®` (without popping)
     ý       # Use this string as delimiter to join the second (implicit) input-list
      ¹sý    # Then join the first input-list by this entire string
         ®¡  # And split it back on variable `®` so it's the expected list of strings
             # (after which this result is output implicitly)

Wolfram Dili (Mathematica) , 62 61 bayt

""<>#&/@Flatten[#~(R=Riffle)~I/.I->#2~R~I]~SequenceSplit~{I}&

Çevrimiçi deneyin!

-1 sayesinde Roman

Geçerli bir çıktı olmamasına rağmen, bu aslında işi yapan bir işlev döndürür .. (34 bytes)

(g=a""<>a~Riffle~#&)[#]@*g[#2]&

Çevrimiçi deneyin!

Japt , 8 bayt

Jonathan'ın yaklaşımını uyarlar .

qVqN²)qN

Dene

qVqN²)qN     :Implicit input of arrays U & V (N=[U,V])
q            :Join U with
 Vq          :  V joined with
   N²        :    Push 2 to N (modifying the original), which gets coerced to a string
             >     e.g., N=[["a","b"],["c","d"]] -> N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"
     )       :End join
      qN     :Split on the modified N, which, again, gets coerced to a string
             > e.g., N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"

Haskell , 62 bayt

[a]#(c:d)=(a++c):d
(a:b)#c=a:b#c
[a]%b=[a]
(a:b)%c=[a]#c#(b%c)

Çevrimiçi deneyin!

İşte Haskell cevabım. Her türlü listede çalışır.

J , ^{44 43 42} 29 bayt

_<;._1@,(;@}:@,@,.(,_&,)&.>/)

Çevrimiçi deneyin!

Mil sayesinde -13 bayt!

Bu yaklaşım tamsayılar kullanır ve milden kaynaklanır.

iplerle özgün yaklaşım

g=.[:}.@,,.
f=.(<@0<@;;._1@,];@g<"0@[)<@0<@g]

Çevrimiçi deneyin!

Not: Açıklamak için TIO'yu -3 olarak ayarladım f=.

J için uyarlanmış Jonathan Allen yöntemini kullanır.

J'nin yerleşik bir "birleştirme" yöntemi olmadığından bu golf oynamak şaşırtıcı derecede zordu ve önemli ölçüde iyileştirilip iyileştirilemeyeceğini merak ediyorum.

g bize "katıl" sağlayan yardımcı fiildir

JavaScript (Node.js) , 85 79 bayt

([a,...b],[c,...d])=>b.map(e=>r.push(r.pop(r.push(r.pop()+c,...d))+e),r=[a])&&r

Çevrimiçi deneyin!

JavaScript, 37 bayt

Jonathan'ın yaklaşımını da uyarlar .

a=>b=>a.join(b.join(a+=b+0)).split(a)

Çevrimiçi deneyin

Perl 5 (-lp ), 20 bayt

@JonathanAllan'ın yorumladığı gibi, bu, IO için, liste ayırıcı olarak bir sekme ve iki listeyi ayırmak için bir yeni satır kullanan tam bir programdır.

chop($n=<>);s/  /$n/g

TIO

sekme ve yeni satır seçildi, çünkü test senaryolarını kontrol etmek daha uygun, aksi takdirde yazdırılamayan karakterlere dönüştürülebilir \1ve\2 .

( -02l012p)

chop($n=<>);s//$n/g

TIO

Nasıl çalışır,

• -02 : giriş kayıt ayırıcısını \2
• -l : giriş bağımsız değişkenini varsayılan bağımsız değişkenten kaldırmak için $_ ve varsayılan çıktıya çıkış kayıt ayırıcısı eklemek için
• -012: çıkış kayıt ayırıcısını \012( \n) olarak ayarlamak, böylece çıkışın kontrol edilmesi daha kolaydır

• -p : varsayılan argümanı yazdırmak için

• $n=<>; : sonraki kaydı okumak ve $n

• chop$n; : ayırıcıyı $n
• s/\x1/$n/g: Tüm tekrarlarını değiştirmek \1ile$n

JavaScript (ES6),  62  59 bayt

@Shaggy sayesinde 3 bayt kaydedildi

Bu, Luis'in tüm karakterleri desteklemek için yanıtının (şimdi silindi) sabit bir sürümüdür .

a=>b=>a.map(e=escape).join(b.map(e)).split`,`.map(unescape)

Çevrimiçi deneyin!