I have started studying electronics recently, and I came up with a circuit made up of 2 LEDs and 3 buttons.

Here 's how it works: 2 buttons (`red` and `blue`) are connected to the LEDs (`red` and `blue` respectively). Buttons pressing pattern will be remembered and represented through the LEDs when the third button is pressed.

 - Only one LED can blink at a time.
 - The LED will only blink once even if the button is held down.
 - The button must be released to be pressed again.
 - If a button is pressed while the other button is being held down, it will be ignored.
 - If two buttons are pressed simultaneously, the red button will be preferred.
 - If a button is released while the other is being held down, the other 's LED will blink.
 - `0` is up and `1` is down.
 - The two inputs will always have the same length.
 
Here is an example:

```Python
Red:  "10011010"
Blue: "10110111"
#=> "RBRB"

Red:  "01001000"
Blue: "01011100"
#=> "RB"

Red:  "01101000"
Blue: "00111000"
#=> "RB"
```

PS:

This is my first time making a kata, so there may be some errors. 
You may report to me if the description is too confusing. 
Sorry for my poor grammar.

Difficulty: introductory

Starter code:

def button_sequences(seqR, seqB):
	

Solutions:
def button_sequences(seqR, seqB):
    pattern, state = '', ''
    toBool = lambda seq : [i == '1' for i in seq]
    for red, blue in zip(toBool(seqR), toBool(seqB)):
        if red and state == 'R' or blue and state == 'B':
            continue
        state = 'R' if red else 'B' if blue else ''
        pattern += state
    return pattern

def button_sequences(red, blue):
    s=''
    r,b=False,False
    for i in range(len(red)):
        if red[i]=='0':
            r=False
        if blue[i]=='0':
            b=False
        if red[i]=='1' and  not r and not b:
            r=True
            s+='R'
        elif blue[i]=='1' and not r and not b:
            b=True
            s+='B'
    return s

def button_sequences(seqR, seqB):
    A, B, res = 1, 1, ""
    for x, y in zip(map(int, seqR), map(int, seqB)):
        if A and B and x: y = 0
        if A and x and not y: res += 'R'
        if B and not x and y: res += 'B'
        if not (x and y): A, B = not x, not y
    return res

def button_sequences(seqR, seqB):
    state, s = '', ''
    for r, b in zip([c == '1' for c in seqR], [c == '1' for c in seqB]):
        if (state == 'R' and not r) or (state == 'B' and not b): state = ''
        if not state and r :
            s, state = s + 'R', 'R'
        elif not state and b: 
            s, state = s + 'B', 'B'
    return s


from itertools import groupby

def button_sequences(seq_r, seq_b):
    pairs = [''.join(pair) for pair in zip(seq_r, seq_b)]
    blinks = (('' if rb == '00' else 'B' if rb == '01' else 'R' if rb == '10' or prev == '00' else '-')
              for rb, prev in zip(pairs, ['00'] + pairs))
    return ''.join(key for key, _ in groupby(x for x in blinks if x != '-'))

def button_sequences(*seqRB):
    wasR, wasB, seq = 0, 0, []
    for r,b in zip(*map(lambda s: map(int,s),seqRB)):
        what             = 'BR'[r]                                            # Ensure precedence of red button
        realeaseOneofTwo = wasR+wasB == 2 and r+b == 1 and what != seq[-1]    # Only if the remaining button isn't already archived
        freshPress       = not (wasR+wasB) and r+b
        switchButtons    = b+r==1 and (wasR,wasB)==(b,r)
        
        if realeaseOneofTwo or freshPress or switchButtons:
            seq.append(what)
        wasR,wasB = r,b
        
    return ''.join(seq)

button_sequences=lambda R,B:(lambda r,f:r.sub(r'(.)\1+',r'\1',f.reduce(lambda x,y:x+('_'if y==('0','0')else'R'if y==('1','0')else'B'if y==('0','1')else'R'if x[-1:]in['','_','R']else'B'),zip(R,B),'')).replace('_',''))(__import__('re'),__import__('functools'))

def button_sequences(r, b):
    r_on, b_on = False, False
    res = ''
    for i in range(len(r)):
        ri, bi = int(r[i]), int(b[i])
        if not r_on|b_on:
            if ri:
                res += 'R'
                r_on = True
            elif bi:
                res += 'B'
                b_on = True
        elif r_on:
            if not ri:
                r_on = False
                if bi:
                    b_on = True
                    res += 'B'
        elif b_on:
            if not bi:
                b_on = False
                if ri:
                    r_on = True
                    res += 'R'
    return res

def button_sequences(seqR, seqB):

    result=""
    prec_r="0"
    prec_b="0"
    
    seqR=list(seqR)
    seqB=list(seqB)
    
    for r, b in zip (seqR, seqB):
        if r==b and r=="1" and prec_r!="1" and prec_b!="1":
            result+="R"
        
        elif r!=b and r=="1" and prec_r!="1":
            result+="R"
            
        elif r!=b and b=="1" and prec_b!="1":
            result+="B"
            
        elif prec_r==prec_b and prec_r=="1" and r=="1" and b!=r and result[len(result)-1]!="R":
            result+="R"
            
        elif prec_r==prec_b and prec_r=="1" and b=="1" and b!=r and result[len(result)-1]!="B":
            result+="B"
        
        prec_r=r
        prec_b=b
    
    return result


def button_sequences(seqR, seqB):
    # You may code here
    seq = ''
    leds = ['R','B']
    action = [None,None]
    for r,b in zip(seqR,seqB):
        r = int(r)
        b = int(b)
        for ind,button in enumerate([r,b]):
            if button and not action[ind]: action[ind] = 'press'
            elif button and action[ind]: action[ind] = 'held'
            elif action[ind] and not button: action[ind] = 'release'
        for ind in [0,1]:
            if (action[ind] == 'press') and (action[ind-1] != 'held'): 
                seq += leds[ind]
                break
            elif (action[ind] == 'held') and (action[ind-1] == 'release'):
                if seq[-1] == leds[ind]: continue
                seq += leds[ind]
                break
        
        
        if action[0] == 'release': action[0] = None
        if action[1] == 'release': action[1] = None
    return seq