Giriş

Parsons kodu tanımlamak için sadece basit bir yoludur zift varyasyonlarını bir not daha yüksek olup olmadığı, bir müzik parçasının veya bir öncekinden daha düşük.

Zil seslerini hatırlamayı emseniz bile, bir notun aşağı veya yukarı gittiğini hala hatırlayabilirsiniz, bu nedenle Parsons kodu bir arama motorunu kullanarak bir müzik tanımlamanıza yardımcı olabilir.

Açıklama

Her varyasyon, aşağıdakilerden biri olan tek bir karakterle temsil edilir:

• Reğer not öncekiyle aynı ise ( “ R epeat” anlamına gelir )
• Ueğer not öncekinden daha yüksekse ( " U p" anlamına gelir )
• Değer not öncekinden düşükse ( " D own" anlamına gelir )

İlk not olarak yazılmıştır *.

Örnek

Parsons kodunun bir örneği ( "Ode to Joy" un başlangıcı ):

*RUURDDDDRUURDR

Aslında , bu şekilde görselleştirebilirsiniz :

      *-*                    
     /   \                   
    *     *                  
   /       \                 
*-*         *         *-*    
             \       /   \   
              *     *     *-*
               \   /         
                *-*          

Bundan sonra buna kontur diyeceğiz .

Bu tür kontürlerin çizilmesine ilişkin kurallar yukarıdaki örnekte kendi kendini açıklar .

Meydan okuma

Şimdi asıl sorun geliyor.

Girdi olarak kontur verilen ilgili Parsons kodunu çıkaran bir program yazın.

Konturu çizmeniz istenmez, bunun tam tersi de geçerlidir.
Konturdan orijinal Parsons kodunu bulun.

kurallar

• Kod golfü için genel kurallar geçerlidir
• Bayt sayısındaki en kısa program kazanır
• Giriş bir konturdur ve çıkış geçerli bir Parsons kodu olmalıdır
• Giriş için fazladan boşlukla ilgili ayrıntılar önemsizdir, sizin için en iyi olanı yapın
• Önceki kural nedeniyle fazladan boşluk kullanarak çıktının bölümlerini ve / veya programı bir şekilde veya başka bir şekilde kodlamanıza izin verilmez.

notlar

• Bu test için yararlı olabilir
• Karşılık gelen Parsons kodu *IS*
• Boş bir dize geçerli bir kontur değil
• Bir Parsons kodu her zaman ile başlar*

Pyth - 28 25 27 25 bayt

@Jakube sayesinde 2 bayt kaydedildi.

s+\*@L"RDU"-VFtBxR\*%2C.z

Burada çevrimiçi deneyin .

CJam, 21 bayt

qN/:.e>(o2%:i"DRXU"f=

Çizgileri ( :), .karakter şeklinde bir maksimum işlemi vectorized ( ) yaparak katlayın e>. Her sütunda yalnızca bir boşluk olmayan karakter bulunduğundan, bu sonuç, alanın yazdırılabilir tüm boşluksuz karakterlerden daha küçük bir ASCII koduna sahip olmasından kaynaklanır.

İlk yıldız işaretini kaldırın ve yazdırın (o, ardından 2%kalan her karakterin ( ) karakterlerini UDRmodüler indekslemeyle eşleştirin .

Eski çözüm (29 bayt)

'*qN/z2%'*f#0+2ew);::-"RDU"f=

qN/giriş satırlarını alır. zBu karakter matrisini aktarır. 2%her garip sırayı bırakır. '*f#Her satırdaki yıldız işaretini bulur. 0+2ew);art arda gelen tüm endeks çiftlerini alır. ::-aralarındaki farklılıkları hesaplar ve "RDU"f=harflerin onları eşler (modüler endeksleme yoluyla: 0 → R, 2 → U, -2 ≡ 1 → D). Lider '*yıldız hazırlar.

DÜZENLEME : Değiştim 2ewiçin 0+2ew);uğraşmak yerine CJam etrafında işe ewçok kısa listelerinde (ardışık dilim). Bu, kodun giriş dizgisi için çalışmasını sağlar *.

Burada deneyin ya da çalışırken izleyin:

Python 3, 129 108 98 86 bayt

Bunu golfla oynamanın muhtemelen birkaç yolu var, ama her şeyi tek bir satıra indirmeyi seviyorum.

Düzenleme: Şimdi''.translate()

Düzenleme: wnnmaw'a çok teşekkürler .

Düzenleme: Giriş biçimini, baytları kaydetmek için yeni satırla ayrılmış bir dize yerine bir dizge dizisi olarak değiştirdim. Ayrıca, son düzenlemede, karıştı Uve Rbunu düzelttim.

lambda a:'*'+"".join(('UR'[j<'/']+'D')[j>'/']for l in zip(*a)for j in l if j in'-/\\')

Giriş bir dizi dizisi olmalıdır. Yukarıdaki örnekte, bu şuna benziyor:

["      *-*                    ","     /   \                   ","    *     *                  ","   /       \                 ","*-*         *         *-*    ","             \       /   \   ","              *     *     *-*","               \   /         ","                *-*          "]

Ungolfed:

def f(a):
    s = ''
    for c in zip(*a):           # transpose
        for d in c:             # for each letter in column c
            if e in "-/\\":     # if that letter is either -,/,\
                if e < '/':     # if < '/' (same as if == '-')
                    s += "R"
                elif e > '/':   # if > '/' (same as if == '\')
                    s += "D"
                else:           # if == '/'
                    s += "U"
        return "*" + s          # in the code we ''.join() it all together
                                # in this ungolfing, we add to an empty string

Ruby, 87 bayt

Girişte izlenen boşlukları gerektirir, böylece tüm satırlar aynı uzunluktadır.

$><<?*+$<.readlines.map(&:chars).transpose.join.gsub(/./,{?-=>:R,?/=>:U,?\\=>:D}).strip

Japt, 38 bayt 40 41 45 46 48

@ETHproductions sayesinde 2 bayt kaydedildi

'*+U·y £Yu ?"RUD"g1+(XrS c -47 g):P} q

Bir trim komutu olsaydı bu sadece 38 bayt olurdu; -; golf bittiğinde açıklama ekleyeceğim. :PProgram aslında önemli olmayan karakterler görmezden programı, komik olmaya çalışmıyor.

Çevrimiçi deneyin

Haskell, 89 bayt

import Data.List
m '/'="U"
m '-'="R"
m '\\'="D"
m _=""
('*':).(>>=(>>=m)).transpose.lines

Kullanım örneği:

*Main> ('*':).(>>=(>>=m)).transpose.lines $ "      *-*                    \n     /   \\                   \n    *     *                  \n   /       \\                 \n*-*         *         *-*    \n             \\       /   \\   \n              *     *     *-*\n               \\   /         \n                *-*          "
"*RUURDDDDRUURDR"

*Main> ('*':).(>>=(>>=m)).transpose.lines $ "*"
"*"

Girdiyi çevirin ve // -/ karakterlerini \singleton dizeleri "U"/ "R"/ ile değiştirin "D". Diğer tüm karakterler "", daha sonra her şeyi birleştirerek kaybolan boş dizelerle değiştirilir . Sonunda yıldız işareti hazırlayın *.

Mathematica, 103 bayt

"*"<>(Differences@Position[Thread@Characters@StringSplit[#,"
"],"*"][[;;,2]]/.{-2->"U",0->"R",2->"D"})&

Oldukça kısa, bunun bir sicim işleme mücadelesi olduğunu düşünerek

JavaScript (ES6) 90

Anonim bir işlev. Girilen dizgeyi karaktere göre tarar ve mevcut satırdaki konumu dikkate alır. Bunu yaparak, o prosedürünü izlemek bir çıkış dizisini oluşturur U D Riçin / \ -doğru yerde

c=>[...c].map(c=>c>'*'?t[i++]=c>'/'?'D':c<'/'?'R':'U':c<' '?i=0:++i,t=['*'],i=0)&&t.join``

Matlab, 62 bayt

r=@(s)[85-(s<14)*3-(s>59)*17,''];@(p)r(sum(p(:,2:2:end)-32))

Bu, girişin dikdörtgen olmasını gerektirir (her satırda aynı sayıda karakter). Örneğin

    ['      *-*                    ';    '     /   \                   ';    '    *     *                  ';    '   /       \                 ';    '*-*         *         *-*    ';    '             \       /   \   ';    '              *     *     *-*';    '               \   /         ';    '                *-*          '];

açıklama

sum(p(:,2:2:end)-32)        % exctract every second column, substract 32 (spaces->zeros) 
                            % and sum column wise (results in a vector of 3 different values)
[85-(s<14)*3-(s>59)*17,'']  % map each of the values to the corresponding value of the letter and convert back to characters