TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
words = list(input())

for index, word in enumerate(words):
    isEven = index % 2 == 0
    if (isEven and word == "L") or (not isEven and word == "R") :
        continue
    else:
        print("NO")

print("YES")

import re

s = input()
pattern = re.compile(r'^([^L][^R])*[L]?$')
is_easy_to_dance = pattern.match(s)

print("Yes") if is_easy_to_dance else print("No")

words = list(input())

for index, word in enumerate(words):
    isEven = index % 2 == 0
    if (isEven and word == "L") or ((not isEven) and word == "R") :
        continue
    else:
        print("NO")
        exit(-1)

print("YES")

words = list(input())

is_easy_to_dance = True

for index, word in enumerate(words):
    is_even = index % 2 == 0
    if (is_even and word == "L") or ((not is_even) and word == "R") :
        continue
    else:
        is_easy_to_dance = False
        break

if is_easy_to_dance:
    print("Yes")
else:
    print("No")

words = list(input())

for index, word in enumerate(words):
    isEven = index % 2 == 0
    if (isEven and word == "L") or ((not isEven) and word == "R") :
        continue
    else:
        print("NO")

print("YES")

import re

s = input()

pattern = re.compile(r'^([^L][^R])*[^L]?$')
is_easy_to_dance = pattern.match(s)

print("Yes") if is_easy_to_dance else print("No")

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = list(input())
for i in range(len(s)):
  if i % 2 == 0:
    if not s[i] in "RUD":
      print ("No") 
      exit() 
  else: 
    if nit s[i] in "LUD":
      print("No")
      exit()
print("Yes"

s = list(input())
for i in range(len(s)):
  if i % 2 == 0:
    if not s[i] in "RUD":
      print ("No") 
      exit() 
  else: 
    if not s[i] in "LUD":
      print("No")
      exit()
print("Yes"


s = list(input())
for i in range(len(s)):
  if i % 2 == 0:
    if not s[i] in "RUD":
      print ("No") 
      exit() 
  else: 
    if nit s[i] in "LUD":
      print("No")
      exit()
print("Yes")


s = list(input())
for i in range(len(s)):
  if i % 2 == 0:
    if not s[i] in "RUD":
      print ("No") 
      exit() 
  else: 
    if not s[i] in "LUD":
      print("No")
      exit()
print("Yes")


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
x = list(input())
i = 0
edetector = True
odetector = True
while i < len(x):
    if  i % 2 == 0:
        if x[i] not in ["L", "U", "D"]:
            edetector = False
    else:
        if x[i] not in ["R", "U", "D"]:
            odetector = False
    i += 1

if edetector and odetector:
    print("Yes")
else:
    print("No")


x = list(input())
i = 0
while i < len(x) - 2:
    if  i % 2 == 0:
        if x[i] in ["L", "U", "D"]:
            edetector = True
        else:
            edetector = False
    else:
        if x[i] in ["R", "U", "D"]:
            odetector = True
        else:
            odetector = False
    i += 1

if edetector and odetector:
    print("Yes")
else:
    print("No")


x = list(input())
i = 0
edetector = True
odetector = True
while i < len(x):
    if  i % 2 == 0:
        if x[i] not in ["L", "U", "D"]:
            edetector = False
    else:
        if x[i] not in ["R", "U", "D"]:
            odetector = False
    i += 1

if edetector and odetector:
    print("Yes")
else:
    print("No")


x = list(input())
i = 0
edetector = True
odetector = True
while i < len(x):
    if  i % 2 == 0:
        if not x[i] in ["R", "U", "D"]:
            edetector = False
    else:
        if not x[i] in ["L", "U", "D"]:
            odetector = False
    i += 1

if edetector and odetector:
    print("Yes")
else:
    print("No")


Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()

odd  = [ (c in 'RUD') for i, c in enumerate(s) if i % 2 == 1 ]
even = [ (c in 'LUD') for i, c in enumerate(s) if i % 2 == 0 ]

if all(odd) and all(even):
  print('Yes')
else:
  print('No')

s = input()

odd  = [ (c in 'RUD') for i, c in enumerate(s) if i % 2 == 0 ]
even = [ (c in 'LUD') for i, c in enumerate(s) if i % 2 == 1 ]

if all(odd) and all(even):
  print('Yes')
else:
  print('No')


Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
n = len(s)
a = 0
if n % 2 == 0:
  for i in range(0,n+1,2):
    if s[i] == "R":
      a = 1
      break
  for i in range(1,n,2):
    if s[i] == "L":
      a = 1
      break
if n % 2 == 1:
  for i in range(0,n,2):
    if s[i] == "R":
      a = 1
      break
  for i in range(1,n+1,2):
    if s[i] == "L":
      a = 1
      break
if a == 0:
  print("Yes")
if a == 1:
  print("No")

s = input()
n = len(s)
a = 0
if n % 2 == 0:
  for i in range(0,n+1,2):
    if s[i] == "R":
      a = 1
      break
  for i in range(1,n,2):
    if s[i] == "L":
      a = 1
      break
if n % 2 == 1:
  for i in range(0,n,2):
    if s[i] == "R":
      a = 1
      break
  for i in range(1,n+1,2):
    if s[i] == "L":
      a = 1
      break
if a == 0:
  print("Yes")
if a == 1:
  print("No")

s = input()
n = len(s)
a = 0
if n % 2 == 0:
  for i in range(0,n,2):
    if s[i] == "L":
      a = 1
      break
  for i in range(1,n,2):
    if s[i] == "R":
      a = 1
      break
else:
  for i in range(0,n,2):
    if s[i] == "L":
      a = 1
      break
  for i in range(1,n,2):
    if s[i] == "R":
      a = 1
      break
if a == 0:
  print("Yes")
if a == 1:
  print("No")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
S_o = S[::2]
S_e = S[1::2]
if 'L' in S_o or 'R' in _e:
    print('No')
else:
    print('Yes')

S = input()
S_o = S[::2]
S_e = S[1::2]
if 'L' in S_o or 'R' in S_e:
    print('No')
else:
    print('Yes')


Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
for i,s in enumerate(S):
  if (i%2 == 0)&(s=='L'):
    print('No')
    break
  elif (i%2 == 1)&(s=='R'):
    print('No')
    break
  else:
    print('Yes')

S = input()
flag = 'Yes'
for i,s in enumerate(S):
  if (i%2 == 0)&(s=='L'):
    flag = 'No'
    break
  elif (i%2 == 1)&(s=='R'):
    flag = 'No'
    break
  else:
    flag = 'Yes'
    continue

print(flag)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
for i in range(len(S)+1):
  if i == len(S):
    print('Yes')
    break
  if S[i] =='U' or S[i] =='D':
    pass
  else:
    if S[i] % 2 ==0:
      if S[i] == 'R':
        pass
      else:
        print('No')
        break
    else:
      if S[i]== 'L':
        pass
      else:
        print('No')
        break
        
      
    


S = input()
for i in range(len(S)+1):
  if i == len(S):
    print('Yes')
    break
  if S[i] =='U' or S[i] =='D':
    pass
  else:
    if S[i] % 2 ==0:
      if S[i] == 'R':
        pass
      else:
        print('No')
        break
    else:
      if S[i]== 'L':
        pass
      else:
        print('No')
        break
        
      
    

S = input()
for i in range(len(S)+1):
  if i == len(S):
    print('Yes')
    break
  if S[i] =='U' or S[i] =='D':
    pass
  else:
    if i % 2 ==0:
      if S[i] == 'R':
        pass
      else:
        print('No')
        break
    else:
      if S[i]== 'L':
        pass
      else:
        print('No')
        break
        
      
    


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()


for i,tap in enumerate(s):
        
        if i % 2 == 1:
                if tap == 'R':
                        print ('NO')
                        exit()
        else:
                if tap == 'L':
                        print ('NO')
                        exit()
else:
        print('YES')

s = input()


for i,tap in enumerate(s):
        
        if i % 2 == 1:
                if tap == 'R':
                        print ('NO')
                        exit()
        else:
                if tap == 'L':
                        print ('NO')
                        exit()
else:
        print('YES')

s = input()


for i,tap in enumerate(s):
        
        if i % 2 == 1:
                if tap == 'R':
                        print ('No')
                        exit()
        else:
                if tap == 'L':
                        print ('No')
                        exit()
else:
        print('Yes')

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s=input()
a=0
for i in range (0,len(s)):
  if s[i]=="R"or"L":
    if i%2==0:
      if s[i]=="R":
        a=a+1
    else:
      if s[i]=="L":
        a=a+1
if a==0:
  print("Yes")
else:
  print("No")
print(len(s))

s=input()
a=0
for i in range (0,len(s)):
  if s[i]=="R"or"L":
    if i%2==0:
      if s[i]=="L":
        a=a+1
    else:
      if s[i]=="R":
        a=a+1
if a==0:
  print("Yes")
else:
  print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
ans = "Yes"
for i in range(len(s)):
    if i & 2 == 0 and s[i] == "L":
        ans = "No"
        break
    elif i & 2 != 0 and s[i] == "R":
        ans = "No"
        break
print(ans)


s = input()
ans = "Yes"
for i in range(len(s)):
    if i % 2 == 0 and s[i] == "L":
        ans = "No"
        break
    elif i % 2 != 0 and s[i] == "R":
        ans = "No"
        break
print(ans)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = str(input())
ans = 'Yes'
print(list(s))
for i in list(s)[0::2]:
    if i == 'L':
        ans = 'No'
for i in list(s)[1::2]:
    if i == 'R':
        ans = 'No'
print(ans)
    

s = str(input())
ans = 'Yes'
for i in list(s)[0::2]:
    if i == 'L':
        ans = 'No'
for i in list(s)[1::2]:
    if i == 'R':
        ans = 'No'
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
if set(s[0:len(s):2]) == {'L','U','D'} or set(s[1:len(s):2]) == {'R','U','D'}:
    print("Yes")
else:
    print("No")

s = input()
if 'L' in s[0:len(s):2] or 'R' in s[1:len(s):2]:
    print('No')
else:
    print('Yes')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
def lcs(s1, s2):
    dp = []
    for s2_k in s2:
        bgn_idx = 0
        for i, cur_idx in enumerate(dp):
            chr_idx = s1.find(s2_k, bgn_idx) + 1
            if not chr_idx:
                break
            dp[i] = min(cur_idx, chr_idx)
            bgn_idx = cur_idx
        else:
            chr_idx = s1.find(s2_k, bgn_idx) + 1
            if chr_idx:
                dp.append(chr_idx)
    return len(dp)

def solve():
    N = int(input())
    S = input()
    ans = 0
    for i in range(1,N):
      S1 = S[:i]
      S2 = S[i:]
      ans = max(ans,lcs(S1, S2))
    print(ans)

if __name__ == '__main__':
    solve()

S = input()
N = len(S)
for i in range(0,N,2):
  if S[i] == "L":
    print("No")
    exit()
for i in range(1,N,2):
  if S[i] == "R":
    print("No")
    exit()
print("Yes")

Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = list(input())

for c in range(1,len(S)+1):
    if c%2==1: 
        if S[c] == 'L':
            print('No')
            break
    else:
        if S[c] == 'R':
            print('No')
            break
else:
    print('Yes')


S = list(input())

for c in range(1,len(S)+1):
    if c%2==1: 
        if S[c-1] == 'L':
            print('No')
            break
    else:
        if S[c-1] == 'R':
            print('No')
            break
else:
    print('Yes')


Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
ans = 'No'
for i in s:
	if i == 'R':
		if s.index(i) % 2 == 0:
			print('No')
			exit()
		else:
			ans = 'Yes'
	if i == 'L':
		if s.index(i) % 2 == 0:
			ans = 'Yes'
		else:
			print('No')
			exit()
print(ans)


s = input()
ans = 'Yes'
for i in range(len(s)):
	if i %2 == 0:
		if s[i] == 'L':
			ans = 'No'
	else:
		if s[i] == 'R':
			ans = 'No'
print(ans)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
N = len(S)
ans = 'Yes'

for i in range(N):
    if S[2*i] == 'R':
        ans = 'No'
        break
    elif S[2*i+1] == 'L':
        ans ='No'
        break

print(ans)



S = input()
N = len(S)

for i in range(N):
    if S[2*i] == 'R':
        print('No')
        break
    else S[2*i+1] == 'L':
        print('No')
        break

print('Yes')

S = input()
N = len(S)
ans = 'Yes'

for i in range(N):   
    if S[i] == 'R' and (i+1)%2 == 0:
        ans = 'No'
        break
    elif S[i] == 'L' and (i+1)%2 == 1:
        ans ='No'
        break

print(ans)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
# coding: utf-8
def is_easy(steps):
  for i, step in enumerate(steps):
    if i % 2 == 0 and step == 'L':
      return 'No'
  	elif i % 2 == 1 and step == 'R':
      return 'No'
	return 'Yes'
  
steps = input()
print(is_easy(steps))

# coding: utf-8

def is_easy(S):
    for i, s in enumerate(S):
        if i % 2 == 0 and s == 'L':
            return 'No'
        elif i % 2 == 1 and s == 'R':
            return 'No'
    return 'Yes'

def main():
    S = input()
    print(is_easy(S))   

main()

Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = list(map(str, input()))
for i in range(len(S)):
  if i % 2 == 0:
    if S[i] == "L":
      unreadble += 1
  else:
    if S[i] == "R":
  	  unreadble += 1
if unreadble >= 1:
  print("No")
else:
  print("Yes")

S = list(map(str, input()))
for i in range(len(S)):
  if i % 2 == 0:
    if S[i] == "L":
      print("No")
  else:
    if S[i] == "R":
      print("No")
print("Yes)


S = list(map(str, input()))
unreadble = 0
for i in range(len(S)):
  if i % 2 == 0:
    if S[i] == "L":
      unreadble += 1
  else:
    if S[i] == "R":
  	  unreadble += 1
if unreadble >= 1:
  print("No")
else:
  print("Yes")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s=input()

s_1 = set(list(s[1::2]))
s_2 = set(list(s[0::2]))

if {"R","U","D"} >= s_1 and {"L","U","D"} >= s_2:
  print("Yes")
else:
  print("No")

s=input()

s_1 = set(list(s[1::2]))
s_2 = set(list(s[0::2]))

if {"R","U","D"} >= s_1:
  if {"L","U","D"} >= s_2:
  	print("Yes")
  else:
    print("No")
else:
  print("No")

s=input()
a = "No"

if {"R","U","D"} >= set(list(s[0::2])):
  if {"L","U","D"} >= set(list(s[1::2])):
  	a = "Yes"

print(a)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input().split()

if S[1::2] == "R" or S[1::2] == "U" or S[1::2] == "D" :
  print("Yes")
  
else :
  print("No")

s = list(input())
for i in range(len(s)):
    if i%2==0:
        if s[i] == 'R' or s[i] == 'U' or s[i] == 'D':
            s[i] = '*'
    else:
        if s[i] == 'L' or s[i] == 'U' or s[i] == 'D':
            s[i] = '*'
print(['No','Yes'][set(s)=={'*'}])

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()

N = len(S)


for i in range(N):
  if (i % 2 == 0 and S[i] == 'L') or (i % 2 == 1 and S[i] == 'R'):
    ans = 'No'
    break
    
print(ans)

S = input()
 


N = len(S)
ans = 'Yes'
for i in range(N):
  if (i % 2 == 0 and S[i] == 'L') or (i % 2 == 1 and S[i] == 'R'):
    ans = 'No'
    break
    
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()

even = set({})
odd = set({})
for i in range(len(S)):
    if i % 2 == 0:
        even.add(S[i])
    else:
        odd.add(S[i])
print(even, odd)

if (not "R" in odd) and (not "L" in even):
    print("Yes")
else:
    print("No"

S = input()

even = set({})
odd = set({})
for i in range(len(S)):
    if i % 2 == 0:
        even.add(S[i])
    else:
        odd.add(S[i])


if (not "R" in odd) and (not "L" in even):
    print("Yes")
else:
    print("No")

Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
id = 0
res = 'Yes'
for i in s:
    if id & 1 == 0 and i == 'L' or id & 1 == 1 and i == 'R':
        res = 'No'
        break
print(res)

s = input()
id = 0
res = 'Yes'
for i in s:
    if id & 1 == 0 and i == 'L' or id & 1 == 1 and i == 'R':
        res = 'No'
        break
    id += 1
print(res)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
print("L" not in S[::2] and "R" not in S[1::2])

S = input()
print("No" if "L" in S[::2] or "R" in S[1::2] else "Yes")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
n = len(S)
flag = 0
for i in range(0,n):
  if i%2==0 and (not (S[i]=='L' or S[i]=='U' or S[i]=='D')):
      flag = 1
  elif (i+1)%2!=0 and (not (S[i]=='R' or S[i]=='U' or S[i]=='D')):
      flag = 1
      
if flag==1:
  print("No")
else:
  print("Yes")

S = input()
n = len(S)
flag = 0
for i in range(0,n):
  if i%2==0:
  	if !(S[1]=='L' || S[1]=='U' || S[1]=='D')
    	flag = 1
  else:
    if !(S[1]=='R' || S[1]=='U' || S[1]=='D')
    	flag = 1
      
if flag==1:
  print("No")
else:
  print("Yes")

S=input()
flag = 0
for i in range(0,len(S)):
  if (i+1)%2==0 and not (S[i]=='L'):
    flag = 1
  elif (i+1)%2!=0 and not (S[i]=='R'):
    flag = 1
    
if flag==1:
  print("No")
else:
  print("Yes")

S=input()
flag = 0
for i in range(0,len(S)):
  if (i+1)%2==0 and not (S[i]=='L' or S[i]=='U' or S[i]=='D'):
    flag = 1
  elif (i+1)%2!=0 and not (S[i]=='R' or S[i]=='U' or S[i]=='D'):
    flag = 1
    
if flag==1:
  print("No")
else:
  print("Yes")

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
count = 1
for i in s:
    if (count % 2 == 1) and ( i == 'L'):
        flag = False
        count += 1
    elif (count % 2 == 0) and (i == 'R'):
        flag = False
        count += 1
    else:
        count += 1
if flag:
    print('Yes')
else:
    print('No')

s = input()
flag = True
count = 1
for i in s:
    if (count % 2 == 1) and ( i == 'L'):
        flag = False
        count += 1
    elif (count % 2 == 0) and (i == 'R'):
        flag = False
        count += 1
    else:
        count += 1
if flag:
    print('Yes')
else:
    print('No')

Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S = input()
if "L" in S[::2] and "R" in S[1::2]:
    print("Yes")
else:
    print("No")

s=list(input())
if 'L' in s[::2] or 'R' in s[1::2]:
    print('No')
else:
    print('Yes')


Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
for i in range(0, n, 2):
  if s[i] == 'L':
    f = False

s = input()
n = len(s)

f = True

for i in range(0, n, 2):
  if s[i] == 'L':
    f = False

for i in range(1, n, 2):
  if s[i] == 'R':
    f = False
    
print("Yes" if f else "No")

Verdicts: Runtime Error

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
for i in range(len(s)):
  if i%2==0:
    if s[i]!='R' or s[i]!='U' or s[i]!='D':
      print('No')
      exit()
  else:
    if s[i]!='L' or s[i]!='U' or s[i]!='D':
      print('No')
      exit()
print('Yes')
 

s = input()
for i in range(len(s)):
  if i%2==0:
    if i!='R' or i!='U' or i!='D':
      print('No')
      exit()
  else:
    if i!='L' or i!='U' or i!='D':
      print('No')
      exit()
print('Yes')
 

s = input()
if s=='L':
  print('No')
  exit()
for i in range(0,len(s),2):
  for j in range(1,len(s),2):
    if s[i] not in 'RUD' or s[j] not in 'LUD':
      print('No')
      exit()
print('Yes')

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S  = list(input())
print(len(S))
index_even = ['R','U','D']
index_odd = ['L','U','D']
cnt_odd = 0
cnt_even = 0
for i in range(len(S)):
    if i % 2 == 0:
        if S[i] in index_even:
            cnt_even += 1
    else:
        if S[i] in index_odd:
            cnt_odd += 1
if (cnt_even + cnt_odd) == len(S):
    print('Yes')
else:
    print('No')

S  = list(input())
index_even = ['R','U','D']
index_odd = ['L','U','D']
cnt_odd = 0
cnt_even = 0
for i in range(len(S)):
    if i % 2 == 0:
        if S[i] in index_even:
            cnt_even += 1
    else:
        if S[i] in index_odd:
            cnt_odd += 1
if (cnt_even + cnt_odd) == len(S):
    print('Yes')
else:
    print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
import sys
odd = 'RUD'
even = 'LUD'
step = input()
odd_step = step[0::2]
even_step = step[1::2]
for o in odd_step:
    if not o in odd:
        print('NO')
        sys.exit(0)
for e in even_step:
    if not e in even:
        print('NO')
        sys.exit(0)
print('YES')

odd = 'RUD'
even = 'LUD'
step = input()
odd_step = step[0:: 2]
print(odd_step)
even_step = step[1:: 2]
print(even_step)
success_odd = len(list(filter(lambda c: c in odd, odd_step))) == len(odd_step)
success_even = len(
    list(filter(lambda c: c in even, even_step))) == len(even_step)
print('YES' if success_odd and success_even else 'NO')


odd = 'RUD'
even = 'LUD'
step = input()
odd_step = step[0::2]
print(odd_step)
even_step = step[1::2]
print(even_step)
success_odd = len(list(filter(lambda c: c in odd, odd_step))) == len(odd_step)
success_even = len(list(filter(lambda c: c in even, even_step))) == len(even_step)
print('YES' if success_odd and success_even else 'NO')


odd = 'RUD'
even = 'LUD'
step = input()
odd_step = step[0::2]
even_step = step[1::2]
success_odd = len(list(filter(lambda c: c in odd, odd_step))) == len(odd_step)
success_even = len(list(filter(lambda c: c in even, even_step))) == len(even_step)
print('YES' if success_odd and success_even else 'NO')


import sys
odd = 'RUD'
even = 'LUD'
step = input()
odd_step = step[0::2]
even_step = step[1::2]
for o in odd_step:
    if not o in odd:
        print('No')
        sys.exit(0)
for e in even_step:
    if not e in even:
        print('No')
        sys.exit(0)
print('Yes')

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s=input()
flag=1
for i in range(len(s)):
    if((i+1)%2!=0):
        if(s[i]=='L'):
            print("NO")
            flag=0
            break
    if((i+1)%2==0):
        if(s[i]=='R'):
            print("NO")
            flag=0
            break
if(flag==1):
    print("YES")
        

s=input()
flag=1
for i in range(len(s)):
    if((i+1)%2!=0):
        if(s[i]=='L'):
            print("No")
            flag=0
            break
    if((i+1)%2==0):
        if(s[i]=='R'):
            print("No")
            flag=0
            break
if(flag==1):
    print("Yes")
        

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
S=list(input())

flag=0

for i in range(len(S)):
    if i%2==0:
        if S[i]=='R':
            flag+=1
    elif i%2==1:
        if S[i]=='L':
            flag+=1
if flag==0:
    print('Yes')
else :
    print('No')


S=list(input())

flag=0

for i in range(len(S)):
    if (i+1)%2==0:
        if S[i]=='R':
            flag+=1
    elif (i+1)%2==1:
        if S[i]=='L':
            flag+=1
if flag==0:
    print('Yes')
else :
    print('No')


Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
import sys

i = str(input())
if i =="Sunny":
	print("Cloudy")
elif i =="Cloudy":
	print("Rainy")
elif i =="Rainy":
	print("Sunny")

import sys

alf = list(str(input()))
for index1 in range(0,len(alf),2):
	if alf[index1]=="L":
		print("No")
		sys.exit()
for index1 in range(1,len(alf),2):
	if alf[index1]=="R":
		print("No")
		sys.exit()
print("Yes")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.  S is said to be _easily playable_ if and only if it satisfies both of the following conditions:    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.   * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.  Your task is to print `Yes` if S is easily playable, and `No` otherwise.

Submission attempts (in order):
s = input()
#print(len(s))
ans = 0
for i in range(len(s)):
    #print(i)
    if i+1 %2==0:
        if s[i] == 'R':
            #print('g')
            ans = 1
    if i %2==1:
        if s[i]== 'L':
            #print('k')
            ans=1

if ans ==1:
    print('No')
if ans == 0:
    print('Yes')

s = input()
ans = 0
for i in range(len(s)):
    #print(i)
    if i %2==0:
        if s[i] == 'L':
            #print('g')
            ans = 1
    if i %2==1:
        if s[i]== 'R':
            #print('k')
            ans=1

if ans ==1:
    print('No')
if ans == 0:
    print('Yes')

Verdicts: Wrong Answer

Accepted