Đưa ra một đầu vào của một chuỗi bao gồm hoàn toàn qs đại diện cho các ghi chú quý và es đại diện cho các ghi chú thứ tám, xuất ra các chỉ số của các ghi chú quý được kết hợp.

Syncopation rất phức tạp, nhưng với mục đích của thử thách này, định nghĩa của chúng tôi về "syncopated" sẽ rất đơn giản: một lưu ý bắt đầu từ "beat-beat", nhịp đập được tính là "và" trong n / 4 thời gian.

Điều này có thể được định nghĩa thay thế là bất kỳ ghi chú quý nào trước một số lẻ của ghi chú thứ tám. Ví dụ: các ghi chú được đánh dấu *bên dưới được coi là được cách ly và các chỉ số của chúng cũng được hiển thị:

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

Đầu vào sẽ luôn bao gồm toàn bộ số lượng các biện pháp trong 4/4 thời gian (một lưu ý quý là một phần tư của một biện pháp và một lưu ý thứ tám là một phần tám của một biện pháp). (Đầu vào cũng sẽ không bao giờ trống.) Đầu ra có thể là một chuỗi đơn với các thành phần được phân tách bằng bất kỳ dấu phân cách nào không chứa số hoặc mảng / danh sách / v.v. Đầu ra có thể dựa trên 1 (tức là chỉ số đầu tiên là 1 thay vì 0) nếu bạn muốn và nó cũng có thể nằm trong bất kỳ cơ sở số nào (đơn nhất, thập phân, v.v.).

Vì đây là môn đánh gôn , mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm:

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>

Thạch , 12 9 byte

=“e”µ<^\O

Là một chương trình, đoạn mã trên yêu cầu báo giá xung quanh đầu vào. Vì điều đó không được phép, đây là một chức năng đệ trình. Đầu ra là 1 dựa trên. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

=“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.

Cập nhật

Đoạn mã trên không hoạt động nữa trong phiên bản mới nhất của Jelly, vì chúng ta cần một ký tự e , nhưng “e”mang lại một chuỗi. Sửa lỗi tiết kiệm một byte, tổng cộng 8 byte .

=”eµ<^\O

Điều này hoạt động như một chương trình đầy đủ. Hãy thử trực tuyến!

Ruby, 46

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

Đầu vào cho stdin. Đầu ra cho thiết bị xuất chuẩn, dòng mới tách ra.

Đã bình luận

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 byte

Khá ngắn gọn cho JS, nếu bạn hỏi tôi. [for...of]cú pháp, về cơ bản kết hợp bản đồ và bộ lọc, có ích cho thử thách này.

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

Xác định hàm ẩn danh tạo ra mảng 1 chỉ mục.

Kiểm tra đoạn

Điều này sử dụng một phiên bản mã không mã hóa, không ES7'd.

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 byte

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

Cảm ơn Randomra vì đã lưu một byte và Dennis để lưu hai byte. Đây là một động từ đơn âm không tên, được sử dụng như sau:

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

Hãy thử nó ở đây.

Giải trình

=&'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 byte

Chương trình yêu cầu các tùy chọn boP. Mã là

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

Lưu nó như synco, sau đó chạy như grep -boPf synco.

Dấu phân tách đầu ra được :qtheo sau bởi một dòng mới. Ví dụ: đầu ra cho eqqqelà

1:q
2:q
3:q

Ý nghĩa của các cờ là:

• P: Sử dụng biểu thức PCRE.
• o: Điều này có nghĩa là chỉ in một phần của dòng phù hợp với biểu thức thông thường, nhưng đó không phải là lý do tại sao nó quan trọng. ođược sử dụng vì nó có tác dụng cho phép nhiều trận đấu trên mỗi dòng.
• b: In phần bù theo byte của đầu mỗi trận đấu từ đầu tệp.

Mẫu kiểm tra rằng không có số chẵn của ghi chú thứ tám sau một ghi chú quý.

MATL , 12 14 16 byte

j101=tYs2\<f

Cảm ơn Dennis vì đã xóa 2 byte (và để lưu trữ MATL trong nền tảng trực tuyến tuyệt vời của anh ấy!)

Điều này sử dụng phiên bản hiện tại (9.3.0) của ngôn ngữ / trình biên dịch.

Đầu vào và đầu ra là thông qua stdin và stdout. Kết quả là dựa trên 1.

Ví dụ :

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

Hoặc thử trực tuyến!

Giải trình

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 byte

EDIT: Cảm ơn Doorknob và Alex A.

EDIT: Cảm ơn Alex A.

EDIT: Bây giờ sử dụng input () để đầu vào phải là một chuỗi có dấu ngoặc kép.

EDIT: Cảm ơn Zgarb đã giới thiệu cho tôi sử dụng liệt kê.

Đơn giản chỉ cần đếm số e và nếu q, kiểm tra xem số e có phải là số lẻ không, sau đó in chỉ mục.

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

Hãy thử nó ở đây

Haskell, 58 51 byte

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

Ví dụ sử dụng: f "eeeeeqeeqeeqqqqeqeqeeqe"-> [5,8,11,12,13,14,18,21].

Đi qua danh sách và xuất chỉ mục hiện tại icho mỗi char 'q'nếu có số 'e's lẻ trước nó.

Chồn 0,15 , 28 byte

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

Hãy thử nó ở đây.

Giải trình

(                        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 (chức năng), 65

Cảm ơn @Dennis vì đã chơi golf thêm!

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

Trăn 3, 109 95 80 90 88 76 68 67 66 64 byte

Đếm số qs và es và thêm chỉ số của dòng điện qnếu số es trước đó là số lẻ.

Chỉnh sửa: Bây giờ nó in một danh sách các chỉ số của s qvà có một số lẻ es trước chúng. Tám byte được lưu nhờ Doorknob và hai byte nữa nhờ frageum .

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

Ung dung:

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 byte

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

Hàm ẩn danh xuất ra một mảng. Cảm ơn user81655 vì đã lưu hai byte. Đây là một phiên bản không sử dụng cú pháp được hỗ trợ tốt hơn.

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>

Toán học, 76 byte

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

Một cái gì đó thú vị tôi nhận thấy. Tất cả các bộ phận được cách ly đều có dạng eqqq..qqe, vì vậy tôi chỉ cần phát hiện những bộ phận đó và đưa ra các chỉ số của qs.

Japt, 29 23 21 byte

Không thi đấu nữa!

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

         // 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]

Phiên bản không cạnh tranh, 18 byte

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

Hãy thử trực tuyến!

Befunge, 43 byte

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

Hãy thử trực tuyến!

Giải trình

Chúng tôi bắt đầu với hai số không ẩn trên ngăn xếp: số ghi chú và số đếm nhịp.

:               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.