รับอินพุตของสตริงที่ประกอบด้วยqs ซึ่งเป็นตัวแทนของบันทึกย่อประจำไตรมาสและes ที่เป็นตัวแทนของโน้ตที่แปดให้ส่งออกดัชนีของบันทึกประจำไตรมาสที่มีการทำข้อมูลให้ตรงกัน

การทำข้อมูลให้ตรงกันนั้นซับซ้อน แต่สำหรับวัตถุประสงค์ของการท้าทายนี้คำจำกัดความของเรา "ทำข้อมูลให้ตรงกัน" จะง่ายมาก: บันทึกไตรมาสที่เริ่มต้นที่ "ผิดจังหวะ" - นั่นคือเต้นนับเป็น "และ" ใน n / 4 เวลา.

สิ่งนี้อาจถูกกำหนดให้เป็นบันทึกประจำไตรมาสใด ๆ ที่นำหน้าด้วยเลขคี่แปดของเลขคี่ ตัวอย่างเช่นบันทึกย่อที่มีเครื่องหมาย*ด้านล่างนี้จะถูกพิจารณาว่ามีการทำข้อมูลให้ตรงกันและดัชนีของพวกเขาจะแสดงด้วย:

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

ข้อมูลที่ป้อนจะประกอบด้วยจำนวนหน่วยวัดทั้งหมดในเวลา 4/4 (บันทึกประจำไตรมาสคือหนึ่งในสี่ของการวัดและโน้ตที่แปดคือแปดของการวัด) (อินพุตจะไม่มีวันว่าง) เอาต์พุตอาจเป็นสตริงเดี่ยวที่มีองค์ประกอบคั่นด้วยตัวคั่นใด ๆ ที่ไม่มีตัวเลขหรืออาร์เรย์ / รายการ / ฯลฯ ผลลัพธ์อาจเป็นแบบอิง 1 (เช่นดัชนีแรกคือ 1 แทน 0) หากคุณต้องการและอาจอยู่ในฐานตัวเลขใด ๆ ก็ได้ (ไม่เหมือนกันเป็นทศนิยมทศนิยม ฯลฯ )

เนื่องจากนี่คือcode-golfรหัสที่สั้นที่สุดเป็นไบต์จะเป็นผู้ชนะ

กรณีทดสอบ:

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>

เจลลี่ , 12 9 ไบต์

=“e”µ<^\O

ในฐานะโปรแกรมรหัสข้างต้นจำเป็นต้องมีเครื่องหมายคำพูดรอบอินพุต เนื่องจากไม่ได้รับอนุญาตนี่เป็นการส่งฟังก์ชั่น ผลลัพธ์เป็นแบบ 1 ลองออนไลน์!

มันทำงานอย่างไร

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

ปรับปรุง

โค้ดด้านบนไม่สามารถใช้งานได้กับ Jelly เวอร์ชันล่าสุดอีกต่อไปเนื่องจากเราต้องการตัวอักษร eแต่“e”ให้ผลเป็นสตริง แก้ไขที่จะช่วยประหยัดไบต์รวมเป็น8 ไบต์

=”eµ<^\O

โปรแกรมนี้ทำงานเป็นโปรแกรมเต็ม ลองออนไลน์!

ทับทิม, 46

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

อินพุตไปยัง stdin ส่งออกไปยัง stdout, บรรทัดใหม่คั่น

แสดงความคิดเห็น

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 ไบต์

ค่อนข้างสั้นสำหรับ JS ถ้าคุณถามฉัน [for...of]ไวยากรณ์ซึ่งรวมกันโดยทั่วไปแผนที่และตัวกรองมีประโยชน์สำหรับความท้าทายนี้

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

กำหนดฟังก์ชั่นที่ไม่ระบุชื่อที่ส่งออกอาร์เรย์ 1 ดัชนี

ตัวอย่างการทดสอบ

สิ่งนี้ใช้โค้ดรุ่นที่ไม่ได้รับการปรับแต่งและไม่ได้ ES7

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

เจ 20 19 17 ไบต์

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

ขอบคุณ Randomra สำหรับการบันทึกไบต์และ Dennis สำหรับการบันทึกสองรายการ นี่คือคำกริยา monadic ที่ไม่มีชื่อใช้ดังนี้:

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

ลองที่นี่

คำอธิบาย

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

greu GNU 3 + 17 = 20 3 + 15 = 18 ไบต์

boPโปรแกรมต้องใช้ตัวเลือก รหัสคือ

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

บันทึกเป็น syncogrep -boPf syncoเรียกใช้แล้วเป็น

ตัวคั่นเอาต์พุต:qตามด้วยบรรทัดใหม่ เช่นผลลัพธ์สำหรับeqqqeคือ

1:q
2:q
3:q

ความหมายของธงคือ:

• P: ใช้ PCRE regexes
• o: นี่หมายถึงการพิมพ์เฉพาะส่วนของบรรทัดที่ตรงกับนิพจน์ทั่วไป แต่นั่นไม่ใช่เหตุผลที่สำคัญ oถูกใช้เนื่องจากมีผลในการอนุญาตการจับคู่หลายรายการต่อบรรทัด
• b: พิมพ์ออฟเซ็ตในหน่วยไบต์ของจุดเริ่มต้นของแต่ละการแข่งขันจากจุดเริ่มต้นของไฟล์

รูปแบบตรวจสอบว่าไม่มีโน้ตตัวที่แปดจำนวนเท่ากันหลังจากบันทึกไตรมาส

MATL , 12 14 16ไบต์

j101=tYs2\<f

ขอบคุณเดนนิสสำหรับการลบ 2 ไบต์ (และสำหรับการโฮสต์ MATL ในแพลตฟอร์มออนไลน์ที่ยอดเยี่ยมของเขา!)

ใช้เวอร์ชันปัจจุบัน (9.3.0)ของภาษา / คอมไพเลอร์

อินพุตและเอาต์พุตผ่าน stdin และ stdout ผลลัพธ์จะเป็นแบบ 1

ตัวอย่าง :

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

หรือลองออนไลน์!

คำอธิบาย

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 ไบต์

แก้ไข:ขอบคุณ Doorknob และ Alex A.

แก้ไข:ขอบคุณ Alex A.

แก้ไข:ตอนนี้ใช้อินพุต () ดังนั้นอินพุตจะต้องเป็นสตริงที่มีเครื่องหมายคำพูด

แก้ไข:ขอบคุณ Zgarb ที่แนะนำให้ฉันใช้แจกแจง

เพียงนับจำนวนของ e และถ้า q ตรวจสอบว่านับ e เป็นคี่แล้วพิมพ์ดัชนี

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

ลองที่นี่

Haskell, 58 51 ไบต์

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

ตัวอย่างการใช้งาน: ->f "eeeeeqeeqeeqqqqeqeqeeqe"[5,8,11,12,13,14,18,21]

ผ่านรายการและส่งออกดัชนีปัจจุบันiสำหรับถ่านทุกตัว'q'ถ้ามีจำนวนคี่'e'ก่อนหน้านี้

Minkolang 0.15 , 28 ไบต์

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

ลองที่นี่

คำอธิบาย

(                        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 (ฟังก์ชั่น), 65

ขอบคุณ @Dennis สำหรับการเล่นกอล์ฟที่พิเศษ!

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 ไบต์

นับจำนวนqs และes และเพิ่มดัชนีของกระแสqถ้าจำนวนes ก่อนหน้านี้เป็นเลขคี่

แก้ไข:ตอนนี้มันพิมพ์รายการดัชนีของ s ที่มีqและมีจำนวนคี่eก่อนหน้าพวกเขา แปดไบต์บันทึกขอบคุณที่Doorknobและสองขอบคุณมากขึ้นเพื่อ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 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อที่ส่งออกอาร์เรย์ ขอบคุณ user81655 สำหรับการบันทึกสองไบต์ นี่คือเวอร์ชันที่ไม่ดีที่ใช้ไวยากรณ์ที่ได้รับการสนับสนุนที่ดีกว่า

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 ไบต์

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

สิ่งที่น่าสนใจฉันสังเกตเห็น ทุกชิ้นส่วนลัดที่มีรูปแบบeqqq..qqeดังนั้นฉันเพิ่งตรวจสอบเหล่านั้นและให้ดัชนีของqs

Japté, 29 23 21 ไบต์

ไม่ใช่การแข่งขันอีกต่อไป!

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

ลองออนไลน์!

มันทำงานอย่างไร

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

รุ่นที่ไม่ใช่คู่แข่งขนาด 18 ไบต์

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

ลองออนไลน์!

Befunge ขนาด 43 ไบต์

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

ลองออนไลน์!

คำอธิบาย

เราเริ่มต้นด้วยสองศูนย์โดยนัยในสแต็ก: หมายเลขบันทึกและนับจังหวะ

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