Tamamen qçeyrek notları etemsil eden ve sekizinci notları temsil eden bir dizgenin bir girdisi göz önüne alındığında , senkronize edilen çeyrek notların endekslerini gösterir.

Syncopation karmaşıktır, ancak bu zorluğun amaçları için, "syncopated" tanımımız çok basit olacaktır: 4 / 4'te "ve" olarak sayılan atımlar "ve" sayılma atımları "ile başlayan çeyrek not saati.

Bu, alternatif olarak, bir dizi sekizinci notadan önce gelen herhangi bir çeyrek nota olarak tanımlanabilir. Örneğin, *aşağıda işaretlenmiş notlar senkronize edilmiş sayılır ve indeksleri de gösterilir:

eqqeqqeqqe
 **    **
 12    78
Output: 1 2 7 8

Girdi her zaman 4/4 zamanında çok sayıda önlemden oluşacaktır (çeyreklik bir not dörtte bir, sekizinci not ise sekizinci ölçüdür). (Girdi asla boş kalmaz.) Çıktı, sayı içermeyen herhangi bir sınırlayıcıyla ayrılan öğelerin bulunduğu tek bir dize veya bir dizi / liste / etc olabilir. İsterseniz, çıktı 1 tabanlı olabilir (yani, ilk dizin 0 yerine 1'dir) ve ayrıca herhangi bir sayısal tabanda (unary, ondalık, vb.) Olabilir.

Bu kod-golf olduğundan, bayttaki en kısa kod kazanır.

Test durumları:

In                        Out
-----------------------------------------------
eqqqe                     1 2 3
qeqeq                     2
qqqeqqeeeeqeqeqeqqeqqeqq  4 5 10 14 19 20
eeeeeqeeqeeqqqqeqeqeeqe   5 8 11 12 13 14 18 21
qqqq                      <none>
eeeeeeee                  <none>

Jöle , 12 9 bayt

=“e”µ<^\O

Bir program olarak, yukarıdaki kod girişin çevresinde alıntı yapılmasını gerektirir. Buna izin verilmediğinden, bu bir fonksiyon gönderimidir. Çıktı 1 tabanlıdır. Çevrimiçi deneyin!

Nasıl çalışır

=“e”µ<^\O    Monadic link. Argument: s (string)

=“e”         Check each character for equality with 'e'. Yields a Boolean array.
    µ        Start a new, monadic chain.
      ^\     Compute the array of partial reductions by XOR, i. e., the parities
             of all prefixes of the Boolean array.
     <       Check if the Booleans are strictly smaller than the parities.
             A truthy outcome indicates an off-beat quarter note.
        O    Yield all indices of 1's.

Güncelleştirme

Yukarıdaki kod artık Jelly'in en son sürümünde çalışmıyor, çünkü e karakterine ihtiyacımız var , ancak bir karakter dizisi veriyor. Düzeltme, toplam 8 baytlık bir bayt kazandırır .“e”

=”eµ<^\O

Bu tam bir program olarak çalışıyor. Çevrimiçi deneyin!

Ruby, 46

i=e=0
gets.bytes{|n|e^=n
e&4|n>114&&p(i)
i+=1}

Stdin girişi. Stdout'a çıktı, yeni satır ayrıldı.

Yorumlananlar

i=e=0               #i keeps index, e keeps track of 8ths.
gets.bytes{|n|      #iterate through bytes in the input
e^=n                #xor e with input. We're interested in the 4's bit, which is only affected by ascii e, not ascii q
e&4|n>114&&p(i)     #e&4 evaluates to 4 or 0. OR with n and if the value is greater than ascii code for q, print index
i+=1}               #increment index

JavaScript ES7, 50 48 bayt

Bana sorarsan, JS için oldukça kısa. [for...of]temel olarak birleştirilmiş harita ve filtre, sözdizimi bu zorluk için kullanışlıdır.

s=>[for(c of(i=f=0,s))if(++i&&c>'e'?f%2:f++&0)i]

1 indeksli bir diziyi çıkaran isimsiz bir işlev tanımlar.

Test pasajı

Bu, kodun ESG’nin unungolfed sürümünü kullanır.

a = function(s) {   // Create a function a that takes in a parameter s and does these things:
  var r = [],       // Set variable r to an empty array,
  i = 0, f = 0;     // i to 0, and f to 0.
  for(c of s) {     // For each character c in s:
    i++;            //  Increment i by 1.
    if(             //  If
      c == 'q' ?    //   if c == 'q',
      f%2 === 1 :   //    f is even; otherwise,
      f++ && false) //    increment f and don't execute this:
      r.push(i);    //   Add i to the end of r.
  } return r;       // Return r.
}

<input type="text" value="eqqqe" id=O />
<button onclick="P.innerHTML='['+a(O.value)+']'">Try it</button>
<p id=P />

J, 20 19 17 bayt

=&'e'(I.@:<~:/\@)

Bayt kaydetme için randomra ve iki kaydetme için Dennis'e teşekkürler. Bu, aşağıdaki gibi kullanılan adsız bir monadik fiildir:

  f =: =&'e'(I.@:<~:/\@)
  f 'eqqqe'
1 2 3

Burada dene.

açıklama

=&'e'(I.@:<~:/\@)
=&'e'               Replace every 'e' with 1, other chars with 0
     (         @)   Apply the verb in parentheses to the resulting 0-1 vector
           ~:/\     Cumulative reduce with XOR (parity of 'e'-chars to the left)
          <         Element-wise less-than with original vector
      I.@:          Positions of 1s in that vector

GNU grep, 3 + 17 = 20 3 + 15 = 18 bayt

Program seçenekleri gerektirir boP. Kod

q(?!(q|eq*e)*$)

Farklı kaydet synco, sonra çalıştır grep -boPf synco.

Çıkış ayırıcısını :qyeni bir satır takip eder. İçin çıkışını örneğin eqqqeDİR

1:q
2:q
3:q

Bayrakların anlamları:

• P: PCRE regexes kullanın.
• o: Bu, satırın yalnızca normal ifadeyle eşleşen kısmını yazdırmak anlamına gelir, ancak bu yüzden önemli değildir. oSatır başına birden fazla eşleşmeye izin verme etkisine sahip olduğundan kullanılır.
• b: Ofset, dosyanın başlangıcından her bir eşleşmenin başlangıcını bayt olarak yazdırır.

Örüntü, çeyrek nottan sonra eşit sayıda sekizinci nota olmadığını kontrol eder.

MATL , 12 14 16 bayt

j101=tYs2\<f

2 byte'ı çıkardığı için Dennis'e teşekkür ederim (ve MATL'yi muhteşem çevrimiçi platformunda barındırmak için!)

Bu , dilin / derleyicinin geçerli sürümünü (9.3.0) kullanır .

Giriş ve çıkış stdin ve stdout'tan geçer. Sonuç 1 tabanlıdır.

Örnek :

>> matl j101=tYs2\<f
> eeeeeqeeqeeqqqqeqeqeeqe
6  9 12 13 14 15 19 22

Veya çevrimiçi deneyin!

açıklama

j             % input string
101=          % vector that equals 1 at 'e' characters and 0 otherwise
t             % duplicate
Ys2\          % cumulative sum modulo 2
<             % detect where first vector is 0 and second is 1
f             % find (1-based) indices of nonzero values

Python 2, 94 85 79 75 66 bayt

EDIT: Teşekkürler Kapı Tokmağı ve Alex A.

EDIT: Teşekkürler Alex A.

EDIT: Şimdi input () kullanılır, bu nedenle giriş tırnaklı bir dizge olmalıdır.

EDIT: Numaralandırmamı tavsiye ettiğim için teşekkürler Zgarb.

Sadece e sayısını sayar ve q ise, e sayının tek olup olmadığını kontrol edin, sonra indeksi yazdırın.

e=0
for j,k in enumerate(input()):
 if"q">k:e+=1
 elif e%2:print j

Burada dene

Haskell, 58 51 bayt

f x=[i|(i,'q')<-zip[0..]x,odd$sum[1|'e'<-take i x]]

Kullanım örneği: f "eeeeeqeeqeeqqqqeqeqeeqe"-> [5,8,11,12,13,14,18,21].

Listede ilerleyin ve ondan önce tek bir s sayısı varsa i, her char için geçerli dizini çıktılayın .'q''e'

Minkolang 0.15 , 28 bayt

(o"q"=7&z1+$z8!z2%,2&iN$I$).

Burada dene.

açıklama

(                        Open while loop
 o                       Read in character from input
  "q"                    Push the character "q"
     =                   1 if the top two items on stack are equal, 0 otherwise
      7&                 Pop and jump 7 spaces if truthy

        z                Push register value on stack
         1+              Add one
           $z            Pop top of stack and store in register
             8!          Jump eight spaces

        z                Push register value on stack
         2%              Modulo by 2
           ,             boolean not
            2&           Pop and jump two spaces if truthy
              i          Push loop counter
               N         Output as number

                $I       Push length of input
                  $).    Close while loop when top of stack is 0 and stop.

C (işlev), 65

Ekstra golf için @Dennis'e teşekkürler!

i,n;f(char*m){for(i=n=0;*m;i++)*m++&4?++n:n%2?printf("%d ",i):0;}

Python 3, 109 95 80 90 88 76 68 67 66 64 bayt

qS ve es sayısını sayar ve qönceki es'nin sayısı tek ise akımın indeksini ekler .

Düzenleme: Şimdi, onlardan önceki qve tek sayıda s olan indekslerinin bir listesini yazdırır e. Sekiz bayt sayesinde kaydedilen Doorknob ve iki daha teşekkür feersum .

lambda s:[x for x,m in enumerate(s)if("e"<m)*s[:x].count("e")%2]

Ungolfed:

def f(s):
    c = []
    for index, item in enumerate(s):
        if item == "q":
            if s[:index].count("e")%2 == 1:
                c.append(index)
    return c

JavaScript ES6, 63 60 58 bayt

x=>[...x].map((e,i)=>e>'e'?n%2&&a.push(i):n++,a=[],n=0)&&a

Bir dizi çıktı veren anonim işlev. İki bayt kaydetme için user81655 teşekkürler. İşte daha iyi desteklenen sözdizimini kullanan, ungolfed versiyonudur.

f=function(x) {
  a=[] // Indeces of syncopated notes
  n=0 // Number of e's encountered so far
  x.split('').map(function(e,i) { // For each letter...
    e>'e'? // If the letter is q...
      n%2&& // ...and the number of e's is odd...
        a.push(i): // ...add the current index to the array
      n++ // Otherwise, it is e so increment the counter
  })
  return a
}

run=function(){document.getElementById('output').textContent=f(document.getElementById('input').value)};document.getElementById('run').onclick=run;run()

<input type="text" id="input" value="qqqeqqeeeeqeqeqeqqeqqeqq" /><button id="run">Run</button><br />
<samp id="output"></samp>

Mathematica, 76 bayt

Flatten[Range[#+1,#2-1]&@@@StringPosition[#,"e"~~"q"..~~"e",Overlaps->1<0]]&

Fark ettim ilginç bir şey. Senkoplanan kısımların tümü formdur eqqq..qqe, bu yüzden sadece bunları tespit edip qs endekslerini veririm .

Japt, 29 23 21 bayt

Artık rekabet etmiyor!

0+U ¬®¥'e} å^ ä© m© f

Çevrimiçi deneyin!

Nasıl çalışır

         // Implicit: U = input string, e.g.    "eqqeqeq"
0+U      // Add a 0 to the beginning.           "0eqqeqeq"
¬        // Split into chars.                   ['0,'e,'q,'q,'e,'q,'e,'q]
®¥'e}    // Map each item X to (X == 'e).       [F, T, F, F, T, F, T, F]
å^       // Cumulative reduce by XOR'ing.       [0, 1, 1, 1, 0, 0, 1, 1]
ä©       // Map each consecutive pair with &&.  [0, 1, 1, 0, 0, 0, 1]
m©       // Map each item with &&. This performs (item && index):
         //                                     [0, 1, 2, 0, 0, 0, 6]
f        // Filter out the falsy items.         [   1, 2,          6]
         // Implicit output                     [1,2,6]

Rekabet etmeyen sürüm, 18 bayt

U¬m¥'e å^ ä©0 m© f

Çevrimiçi deneyin!

Befunge, 43 bayt

:~:0\`#@_5%2/:99p1++\>2%#<9#\9#.g#:*#\_\1+\

Çevrimiçi deneyin!

açıklama

Yığında iki örtülü sıfır ile başlıyoruz: nota numarası ve atım sayısı.

:               Make a duplicate of the beat count.
~               Read a character from stdin.
:0\`#@_         Exit if it's less than zero (i.e. end-of-file).
5%2/            Take the ASCII value mod 5, div 2, translating q to 1 and e to 0.
:99p            Save a copy in memory for later use.
1+              Add 1, so q maps to 2 and e to 1.
+               Then add that number to our beat count.
\               Get the original beat count that we duplicated at the start.
2%              Mod 2 to check if it's an off-beat.
99g*            Multiply with the previously saved note number (1 for q, 0 for e).
_               Essentially testing if it's a quarter note on an off-beat.
       \.:\     If true, we go turn back left, get the beat count, and output it.
         >2     Then push 2 onto the stack, and turn right again.
2%              That 2 modulo 2 is just zero.
99g*            Then multiplied by the saved note number is still zero.
_               And thus we branch right on the second pass.
\1+\            Finally we increment the note number and wrap around to the start again.