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):
tap = input()

tap_list = list(tap)

for val in range(len(tap)):
	if ('R' in tap_list[val]) and (val%2 == 0) :
		print('No')
	elif ('L' not in tap_list[val])and (val%2 ==1) :
		print('Yes')
	else:
		print('No')
		
		
	

tap = input()

tap_list = list(tap)
result_list = []

for val in range(len(tap)):
	if ('R' in tap_list[val]) and (val%2 == 1) :
		result_list.insert(0,1)
	elif ('L' in tap_list[val])and (val%2 == 0) :
		result_list.insert(0,1)
	else:
		result_list.insert(0,0)

if 1 in result_list :
	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):

S = input()

N = len(S)

Ans = 1

for i in range(N):
  nTmp = (i+1) % 2
  
  if nTmp == 1 and S[i]=='L':
    Ans = 0
  if nTmp == 0 and S[i]=='R':
    Ans = 0

if Ans == 0:
  print('Yes')
else:
  print('No')


S = input()
 
N = len(S)
 
Ans = 1
 
for i in range(N):
  nTmp = (i+1) % 2
  
  if nTmp == 1 and S[i]=='L':
    Ans = 0
  if nTmp == 0 and S[i]=='R':
    Ans = 0
 
if Ans == 1:
  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):
li = list(input())
od = li[0::2]
ev = li[1::2]

for i in range(len(od)):
    if od[i] == "L" or od[i] == "U" or od[i] == "D":
        pass
    else:
        print("No")
        exit()
for j in range(len(ev)):
    if ev[j] == "R" or ev[j] == "U" or ev[j] == "D":
        pass
    else:
        print("No")
        exit()
        
print("Yes")

li = list(input())
od = li[0::2]
ev = li[1::2]
for i in range(len(od)):
    if od[i] == "R" or od[i] == "U" or od[i] == "D":
        pass
    else:
        print("No")
        exit()
for j in range(len(ev)):
    if ev[j] == "L" or ev[j] == "U" or ev[j] == "D":
        pass
    else:
        print("No")
        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=str(input())
L = list(s)
count = 0
n = 0
for i in L:
  n += 1
  if n % 2 == 1:
    if i == "R":
      count += 1
  else:
    if i == "L":
      count += 1
if count == 0:
  print("Yes")
else:
  print("No")
    

s=str(input())
L = list(s)
count = 0
n = 0
for i in L:
  n += 1
  if n % 2 == 0:
    if i == "R":
      count += 1
  else:
    if i == "L":
      count += 1
if count == 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()



e=0
for x in s:
  if s.index(x)%2==0 and x == 'R':
    e = 1

o=0
for y in s:
  if s.index(y)%2!=0 and y == 'L':
    o = 1
    
if e==1 or o==1:
  print('No')

else:
  print('Yes')


s = input()

e=0
for x in range(0, len(s)):
  if x%2==0 and s[x] == 'R':
    e = 1

o=0
for y in range(0, len(s)):
  if y%2!=0 and s[y] == 'L':
    o = 1
    
if e==1 or o==1:
  print('No')

else:
  print('Yes')


s = input()



e=0
for x in s:
  if s.index(x)%2==0 and x == 'R':
    e = 1

o=0
for y in s:
  if s.index(y)%2!=0 and x == 'L':
    o = 1
    
if e==1 or o==1:
  print('No')

else:
  print('Yes')


s = input()

e=0
for x in range(0, len(s)):
  if x%2==0 and s[x] == 'L':
    e = 1

o=0
for y in range(0, len(s)):
  if y%2!=0 and s[y] == 'R':
    o = 1
    
if e==1 or o==1:
  print('No')

else:
  print('Yes')


Verdicts: 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()

flg = 0
for i, c in enumrate(range(s)):
  if i%2!=0:
    if c in ["R", "U", "D"]:
      continue
    else:
      flg = 1
      break
  else:
    if c in ["R", "U", "D"]:
      continue
    else:
      flg = 1
      break
    
ans = "Yes" if flg else "No"
print(ans)

s = input()

flg = 0
for i, c in enumerate(s):
  if i%2!=0:
    if c in ["L", "U", "D"]:
      continue
    else:
      flg = 1
      break
  else:
    if c in ["R", "U", "D"]:
      continue
    else:
      flg = 1
      break

ans = "Yes" if not flg else "No"
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()
if 'L' in S[1::2] or 'R' in S[0::2]:
    print('No')
else:
    print('Yes')

S = input()
if 'R' in S[1::2] or 'L' in S[0::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):
s=input()
print("No" if "L" in S[::2] or "R" in S[1::2] else "Yes")

import sys
s=input()
a=["R","U","D"]
b=["L","U","D"]
for i in range(len(s)):
    if i%2==0:
        if s[i] not in a:
            print("No")
            sys.exit()
    else:
        if s[i] not in b:
            print("No")
            sys.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 = input()
for i in range(len(S)):
  if i%2==1:
    if S[i] in ['R', 'U', 'D']:
      continue
    else:
      print('No')
      break
  else:
    if S[i] in ['L', 'U', 'D']:
      continue
    else:
      print('No')
      break
else:
  print('Yes')

S = input()
for i in range(len(S)):
  if i%2==0:
    if S[i] in ['R', 'U', 'D']:
      continue
    else:
      print('No')
      break
  else:
    if S[i] in ['L', 'U', 'D']:
      continue
    else:
      print('No')
      break
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):
s =input()

even = ["L", "U", "D"]
odd  = ["R", "U", "D"]
cnt = 1
result = "Yes"

for i in s:

    if cnt % 2 == 0:
        
        if not(i in even):
            result = "No"
            break
    else:
        if not(i in odd):
            result = "No"
            break
        
print(result)

s =input()

even = ["L", "U", "D"]
odd  = ["R", "U", "D"]
cnt = 1
result = "Yes"

for i in s:

    if cnt % 2 == 0:
        
        if not(i in even):
            result = "No"
            break
    else:
        if not(i in odd):
            result = "No"
            break
    cnt += 1
print(result)

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(s):
  if s[i] % 2 == 0 and s[i] == 'R':
    s = False
    break
  elif s[i] % 2 == 1 and s[i] == 'L':
    s = False
    break

if s:
  print('Yes')
else:
  print('No')
    

s = input()

for i in range(len(s)):
  if i % 2 == 0 and s[i] == 'R':
    s = False
    break
  elif i % 2 == 1 and s[i] == 'L':
    s = False
    break

if s:
  print('Yes')
else:
  print('No')
    


s = input()

for i in range(len(s)):
  if i % 2 == 1 and s[i] == 'R':
    s = False
    break
  elif i % 2 == 0 and s[i] == 'L':
    s = False
    break

if s:
  print('Yes')
else:
  print('No')


Verdicts: 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()

for i in range(s.len()):
  if (i % 2 == 0 and s[i] == 'L') or (i % 2 == 1 and s[i] == 'R'):
    print("No")
    exit()

print("Yes")

s = input()
 
for i in range(len(s)):
  if (i % 2 == 0 and s[i] == 'L') or (i % 2 == 1 and 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):
from sys import exit


S = input()

for i in range(len(S)):
    if i // 2 == 1 and S[i] == 'L':
        print('No')
        exit()
    if i // 2 == 0 and S[i] == 'R':
        print('No')
        exit()

print('Yes')


from sys import exit


S = input()

for i in range(len(S)):
    num = i+1
    if num % 2 == 1 and S[i] == 'L':
        print('No')
        exit()
    if num % 2 == 0 and S[i] == 'R':
        print('No')
        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 = list(input())
n = len(s)
k = ['R','U','D']
g = ['L','U','D']

for i in range(n):
    if i % 2 ==0:
        if s[i] in k:
            count +=1
    else:
        if s[i] in g:
            count += 1
       
if count == n:
    print("Yes")
else:
    print("No")

s = list(input())
n = len(s)
k = ['R','U','D']
g = ['L','U','D']
count =0

for i in range(n):
    if i % 2 ==0:
        if s[i] in k:
            count +=1
    else:
        if s[i] in g:
            count += 1
       
if count == n:
    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):
import sys
 
t = input()
 
t2 = t[0::2]
t1 = t[1::2]
 
if "L" in t1:
  print("No")
else:
  if "R" in t2:
    print("No")
  else:
    print("Yes")

import sys
 
t = input()
 
t1 = t[0::2]
t2 = t[1::2]
if "L" in t1:
  print("No")
else:
  if "R" in t2:
    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):
S = list(input())

can = True

for i in range(len(S)):
    if (i % 2 == 0):
        if (S[i] != 'R'):
            can = False
            break
    else:
        if (S[i] == 'L'):
            can = False
            break
if (can):
    print("Yes")
else:
    print("No")


S = list(input())

can = True

for i in range(len(S)):
    if (i % 2 != 0):
        if (S[i] == 'R'):
            can = False
            break
    else:
        if (S[i] == 'L'):
            can = False
            break
if (can):
    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):
text = list(input())

text_1, text_2 = list(text), list(text)
for i in range(int(len(text)/2)):
    text_1.pop(i)
    text_2.pop(i+1)
str_1, str_2 = "", ""
for i in range(len(text_1)):
    str_1 += text_1[i]
for i in range(len(text_2)):
    str_2 += text_2[i]

if str_1.find('L') == -1 and str_2.find('R') == -1:
    print('Yes')
else:
    print('No')

text = list(input())

text_1, text_2 = list(text), list(text)
for i in range(int(len(text)/2)):
    text_1.pop(i)
    text_2.pop(i+1)
if len(text) % 2 == 1:
    text_1.pop(len(text_1)-1)

str_1, str_2 = "", ""
for i in range(len(text_1)):
    str_1 += str(text_1[i])
for i in range(len(text_2)):
    str_2 += str(text_2[i])

if str_2.find('L') == -1 and str_1.find('R') == -1:
    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 = list(input())
odd = S[0::2]
even = S[1::2]
if 'L' in odd or 'R' in even:
    print('NO')
else:
    print('YES')


S = list(input())
odd = S[0::2]
even = S[1::2]
if 'L' in odd:
    print('NO')
elif 'R' in even:
    print('NO')
else:
    print('YES')

S = list(input())
odd = S[1::2]
even = S[0::2]
if 'L' in odd or 'R' in even:
    print('NO')
else:
    print('YES')

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

Verdicts: 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()
print("Yes" if s[::2] in "RUD" and s[1::2] in "LUD" else "No")

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):
if __name__ == "__main__":
  inputstr = input()
  size = len(inputstr)

  isEasy = True

  for i in range(size):
    if i % 2 == 0:
      if inputstr[i] in ["R", "U", "D"]:
      else:
        isEasy = False
        break
    else:
      if inputstr[i] in ["L", "U", "D"]:
      else:
        isEasy = False
        break

  if isEasy = True:
    print("Yes")
  else:
    print("No")


if __name__ == "__main__":
  inputstr = input()
  size = len(inputstr)

  isEasy = True

  for i in range(size):
    if i % 2 == 0:
      if inputstr[i] in ["L", "U", "D"]:
        pass
      else:
        isEasy = False
        break
    else:
      if inputstr[i] in ["R", "U", "D"]:
        pass
      else:
        isEasy = False
        break

  if isEasy == True:
    print("Yes")
  else:
    print("No")


if __name__ == "__main__":
  inputstr = input()
  size = len(inputstr)
  isEasy = True

  for i in range(size):
    point = i + 1
    if point % 2 == 0:
      if inputstr[i] in ["L", "U", "D"]:
        pass
      else:
        isEasy = False
        break
    else:
      if inputstr[i] in ["R", "U", "D"]:
        pass
      else:
        isEasy = False
        break

  if isEasy == True:
    print("Yes")
  else:
    print("No")


Verdicts: 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):
import sys
S = input()
L = len(S)
i = 0
while i < L:
  if L[i] not in ['R','U','D']:
    print('No')
    sys.exit(0)
  i+=2
i = 1
while i < L:
  if L[i] not in ['L','U','D']:
    print('No')
    sys.exit(0)
  i += 2
print('Yes')


import sys
S = input()
L = len(S)
i = 0
while i < L:
  if S[i] not in ['R','U','D']:
    print('No')
    sys.exit(0)
  i+=2
i = 1
while i < L:
  if S[i] not in ['L','U','D']:
    print('No')
    sys.exit(0)
  i += 2
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()
print("NYoe s"[len(re.sub("[RUD]",'',S[0::2]))==0==len(re.sub("[LUD]",'',S[1::2]))::2])

S=input()
print("YNeos"["L" in S[0::2] or "R" in S[1::2]::2])

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):
import sys
S = list(input())
S.insert(0,"X")

for i in range(1,len(S)-1,2):
  if S[i] == "L":
    print("No")
    sys.exit()
for j in range(2,len(S)-1,2):
  if S[i] == "R":
    print("No")
    sys.exit()
print"Yes")
    

import sys
S = list(input())
S.insert(0,"X")


for i in range(1,len(S),2):
  if S[i] == "L":
    print("No")
    sys.exit()

for j in range(2,len(S),2):
  if S[j] == "R":
    print("No")
    sys.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())
def easy_step(s) :
    s_odd = s[::2]
    s_even = [1::2]
    if ("L" in s_odd) or ("R" in s_even) :
        print("No")
    else :
        print("Yes")
easy_step(s)

s = list(input())
def easy_step(s) :
    s_even = s[::2]
    s_odd = [1::2]
    if ("L" in s_odd) or ("R" in s_even) :
        print("No")
    else :
        print("Yes")
easy_step(s)

def easy_step(s) :
    s_odd = s[::2]
    s_even = s[1::2]
    if ("L" in s_odd) or ("R" in s_even) :
        print("No")
    else :
        print("Yes")
s = list(input())
easy_step(s)

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=list(input())
a=0
for j in range(0,len(S),2):
    if S[i]=="R" or S[i]=="U" or S[i]=="D":
        a+=1
for i in range(1,len(S),2):
    if S[i]=="L" or S[i]=="U" or S[i]=="D":
        a+=1
if a==len(S):
    print("Yes")
else:
    print("No")

S=list(input())
a=0
for i in range(1,len(S),2):
    if S[i]=="R" or S[i]=="U" or S[i]=="D":
        a+=1
for j in range(0,len(S),2):
    if S[i]=="L" or S[i]=="U" or S[i]=="D":
        a+=1
if a==len(S):
    print("Yes")
else:
    print("No")

S=list(input())
a=0
for j in range(0,len(S),2):
    if S[j]=="R" or S[j]=="U" or S[j]=="D":
        a+=1
for i in range(1,len(S),2):
    if S[i]=="L" or S[i]=="U" or S[i]=="D":
        a+=1
if a==len(S):
    print("Yes")
else:
    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):
function Main(input) {
  const step = input.trim().split('');
  const even = ['L', 'U', 'D'];
  const odd = ['R', 'U', 'D'];
  var easy = true;

  for (var i in step) {
    var cnt = i + 1
    if (cnt % 2 == 0) {
      if ( even.indexOf(step[i]) !== -1 ) easy = false;
    } else {
      if ( odd.indexOf(step[i]) !== -1 ) easy = false;
    }
  }

  console.log(easy ? 'Yes':'No')
}
Main(require('fs').readFileSync('/dev/stdin', 'utf8'));


import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    S = list(iss())
    odd = 'RUD'
    even = 'LUD'
    ret = 'Yes'
    for n in range(len(S)):
        if (n + 1) % 2 == 0 and S[n] not in even or (n + 1) % 2 != 0 and S[n] not in odd:
            ret = 'No'
    else:
        print(ret)


if __name__ == '__main__':
    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):
def resolve():
    S = input()
    odd_flag = True

    for s in S:
        if odd_flag:
            if s == 'R' or s == 'U' or s == 'D':
                break
            else:
                print('No')
                return
        else:
            if s == 'L' or s == 'U' or s == 'D':
                break
            else:
                print('No')
                return


if __name__ == "__main__":
    resolve()

def resolve():
    S = input()
    odd_flag = True

    for s in S:
        if odd_flag:
            if not (s == 'R' or s == 'U' or s == 'D'):
                print('No')
                return
        else:
            if not (s == 'L' or s == 'U' or s == 'D'):
                print('No')
                return
        odd_flag = not(odd_flag)

    print('Yes')

if __name__ == "__main__":
    resolve()

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())
tf = True
for i,letter in enumerate(s):
  if (i+1) % 2 == 1:
    if letter not in ['R','U','D']:
      tf = False
  if (i+1) % 2 == 0:
    if letter not in ['L','U','D']:
      tf = False
print(tf)

s = str(input())
tf = True
for i,letter in enumerate(s):
  if (i) % 2 == 0:
    if letter not in ['R','U','D']:
      tf = False
  if (i) % 2 == 1:
    if letter not in ['L','U','D']:
      tf = False
if tf:
  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()
a = []
b = []
n = 0

if len(s) % 2 == 1:
    for i in range((len(s) // 2) + 1):
        a.append(s[2 * i])
else:
    for i in range(len(s) // 2):
        a.append(s[2 * i])
    
for i in range(len(s) // 2):
    b.append(s[2 * i + 1])
    
for i in range(len(a)):
    if a[i] == "L":
        n += 1
        
for i in range(len(b)):
    if b[i] == "R":
        n += 1
        
if n > 0:
    print("NO")
else:
    print("YES")

s = input()
a = []
b = []
n = 0

if len(s) % 2 == 1:
    for i in range((len(s) // 2) + 1):
        a.append(s[2 * i])
else:
    for i in range(len(s) // 2):
        a.append(s[2 * i])
    
for i in range(len(s) // 2):
    b.append(s[2 * i + 1])
    
for i in range(len(a)):
    if a[i] == "L":
        n += 1
        
for i in range(len(b)):
    if b[i] == "R":
        n += 1
        
if n > 0:
    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):
S = input()
even = S[::2]
odd = S[1::2]
if 'L' in odd or 'R' on even:
  print('No')
else:
  print('Yes')

s = input()
 
for i in range(len(s)):
  if i % 2 == 0 and s[i] == 'L':
    print('No')
    break
  if i % 2 == 1 and s[i] =='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):
import re

S = input()
P = re.compile()

if P.match(S):
    print("Yes")
else:
    print("No")

import re

S = input()
A = re.compile(r'^([^L][^R])*[^L]?$')

if A.match(S):
    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=list(map(str,input()))
N=len(S)

count=0
for i in range(N):
  if i %2==0:
    if S[i]=="R":
      count+=1
    else:
      count+=0
  if i %2==1:
    if S[i]=="L":
      count+=1
    else:
      count+=0
if count==0:
  print("Yes")
else:
  print("No")

S=list(map(str,input()))
N=len(S)

count=0
for i in range(N):
  if i %2==0:
    if S[i]=="L":
      count+=1
    else:
      count+=0
  if i %2==1:
    if S[i]=="R":
      count+=1
    else:
      count+=0
if count==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 re
s = input()
odd = s[::2]
eve = s[1::2]
odd_re = re.compile{^[RUD]*$}
eve_re = re.compile{^[LUD]*$}
if odd_re.findall(odd) != [] and eve_re.findall(eve) != []:
    print("Yes")
else:
    print("No")

import re
s = input()
odd = s[::2]
eve = s[1::2]
odd_re = re.compile(^[RUD]*$)
eve_re = re.compile(^[LUD]*$)
if odd_re.findall(odd) != [] and eve_re.findall(eve) != []:
    print("Yes")
else:
    print("No")

    

import re
s = input()
odd = s[::2]
eve = s[1::2]
odd_re = re.compile(r"^[RUD]*$")
eve_re = re.compile(r"^[LUD]*$")
if odd_re.findall(odd) != [] and eve_re.findall(eve) != []:
    print("Yes")
else:
    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()

isEasy = True
for i, v in enumerate(S):
  if (i % 2 == 1 and v == 'L' or v == 'U' or v == 'D'):
    pass
  else:
    isEasy = False
  if (i % 2 == 0 and v == 'R' or v == 'U' or v == 'D'):
    pass
  else:
    isEasy = False

if isEasy:
  print('Yes')
else:
  print('No')

S = input()

isEasy = True
for i, v in enumerate(S):
  if ((i + 1) % 2 == 0 and (v == 'L' or v == 'U' or v == 'D')):
    continue
  elif ((i + 1) % 2 == 1 and (v == 'R' or v == 'U' or v == 'D')):
    continue
  else:
    isEasy = False
    break
  
if isEasy:
  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 = list(input())
S_o = []
S_e = []
for i in range(len(S)):
    if i%2 == 0:
        S_e.append(S[i])
    elif i%2 == 1:
        S_o.append(S[i])
if ('L' not in set(S_o)) and ('R' not in set(S_e)):
    print('Yes')
else:
    print('No')

S = list(input())
S_o = []
S_e = []
for i in range(len(S)):
    if i%2 == 0:
        S_e.append(S[i])
    elif i%2 == 1:
        S_o.append(S[i])
if ('R' not in set(S_o)) and ('L' not in set(S_e)):
    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 = list(input())
T = []
for i in range(len(S)):
    if i%2 == 0 :
        S[i] = "R"
        T.append("A")
    if i%2 == 1 :
        S[i] = "L"
        T.append("B")
if "A" in T or "B" in T:
    print("No")
else :
    print("Yes")

S = list(input())
T = []
for i in range(len(S)):
    if i%2 == 0 :
        if S[i] == "L":
            T.append("A")
        
    if i%2 == 1 :
        if S[i] == "R":
            T.append("B")
if "A" in T or "B" in T:
    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):
li = list(input())

for i in range(len(li)):
    if i % 2 == 0:
        if len[i] == "R":
            print("No")
            quit()
    else:
        if len[i] == "L":
            print("No")
            quit()
print("Yes")


li = list(input())

for i in range(len(li)):
    if i % 2 == 0:
        if len[i] = "R":
            print("No")
            quit()
    else:
        if len[i] = "L":
            print("No")
            quit()
print("Yes")


li = list(input())

for i in range(len(li)):
    if i % 2 == 1:
        if li[i] == "R":
            print("No")
            quit()
        else:
            continue
    else:
        if li[i] == "L":
            print("No")
            quit()
        else:
            continue
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=str(input())
even = ["L". "U", "D"]
odd = ["R", "U", "D"]
a = []
b = []
for i in range(len(str)):
     if i%2 == 0:
            if s[i] in even:
                a.apend(True) 
            else:
                a.apend(False)
     elif i%2 i= 0:
            if s[i] in odd:
                b.apend(True) 
            else:
                b.apend(False)
if all(a) and all(b):
    print('Yes')
else:
    print('No')

s=str(input())
even = ["L","U", "D"]
odd = ["R", "U", "D"]
a = []
b = []
for i in range(len(s)):
     if (i+1)%2 == 0:
            if s[i] in even:
                a.append(True) 
            else:
                a.append(False)
     elif (i+1)%2 != 0:
            if s[i] in odd:
                b.append(True) 
            else:
                b.append(False)
if all(a) and all(b):
    print('Yes')
else:
    print('No')

Verdicts: Runtime Error

Accepted