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):
s = list(input())
n = len(s)
#print(n)
k,g=[],[]
for i in range(n):
    if i%2==0:
        k.append(s[i])
    else:
        g.append(s[i])
#print(k)
#print(g)
for j in k:
    if j == 'L':
        print('No')
        break

else:
    for l in g:
        if l == 'R':
            print('No')
            break
    else:
        print('Yes')
        break

s = list(input())
n = len(s)
#print(n)
k,g=[],[]
for i in range(n):
    if i%2==0:
        k.append(s[i])
    else:
        g.append(s[i])
#print(k)
#print(g)
for j in k:
    if j == 'L':
        print('No')
        break

else:
    for l in g:
        if l == '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()

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

s=input()

for i in range(len(s)):
  if i%2==0 and s[i]=="L":
    print("No")
    break
  elif i%2==1 and s[i]=="R":
    print("No")
    break
  elif i==len(s)-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):
x = input()
count = 0
for i in range(len(x)):
  if i % 2 == 0:
    if x[i] == "R" || x[i] == "U" || x[i] == "D":
      count += 1
    else:
      print("No")
      break
  if i % 2 == 1:
    if x[i] == "L" || x[i] == "U" || x[i] == "D":
      count += 1
    else:
      print("No")
      break
if count == len(x):
  print("Yes")

x = input()
count = 0
for i in range(len(x)):
  if i % 2 == 0:
    if x[i] == "R" or x[i] == "U" or x[i] == "D":
      count += 1
    else:
      print("No")
      break
  if i % 2 == 1:
    if x[i] == "L" or x[i] == "U" or x[i] == "D":
      count += 1
    else:
      print("No")
      break
if count == len(x):
  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):


def main():
    s = input()
    print('Yes' if is_easy_to_step(s) else 'No')


def is_easy_to_step(strs):
    for i, s in enumerate(strs):
        if i % 2 == 0 and (s == 'L' or s == 'U' or s == 'D'):
            continue
        elif i % 2 != 0 and (s == 'R' or s == 'U' or s == 'D'):
            continue
        else:
            return False

    return True


if __name__ == '__main__':
    main()




def main():
    s = input()
    print('Yes' if is_easy_to_step(s) else 'No')


def is_easy_to_step(strs):
    for i, s in enumerate(strs):
        if i % 2 != 0 and (s == 'L' or s == 'U' or s == 'D'):
            continue
        elif i % 2 == 0 and (s == 'R' or s == 'U' or s == 'D'):
            continue
        else:
            return False

    return True


if __name__ == '__main__':
    main()


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()
str_list = list(S)
even_str = str_list[0::2]
odd_str = str_list[1::2]
if ('R' in even_str):
  print('No')
elif ('L' in odd_str):
  print('No')
else:
  print('Yes')

S = input()
str_list = list(S)
odd_str = str_list[0::2]
even_str = str_list[1::2]
if ('R' in even_str):
  print('No')
elif ('L' in odd_str):
  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()

odd = s[0::2]
even = s[1::2]
print("{} {}".format(odd, even))

if 'L' in odd or 'R' in even:
  print('No')
else:
  print('Yes')

s = input()

odd = s[0::2]
even = s[1::2]
print("{} {}".format(odd, even))

if 'L' in odd or 'R' in even:
  print('No')
else:
  print('Yes')

s = 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

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

import re

pattern1 = r"[^RUD]"
pattern2 = r"[^LUD]"

if re.search(pattern1, Dance[0::2]) and re.search(pattern2, Dance[1::2]):
  print("Yes")
else:
  print("No")
 
  

Dance = input()

import re

pattern1 = r"[^RUD]"
pattern2 = r"[^LUD]"

if re.search(pattern1, Dance[0::2]) or re.search(pattern2, Dance[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):
S = list(input())
if "R" not in S[0::2] and "L" not in S[1::2]:
    print ("Yes")
else:
    print("No")

S = list(input())
if "L" not in S[0::2] and "R" not in S[1::2]:
    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()

check = True
for i, s in enumerate(S):
  if (i+1)%2 == 0:
    if not(s == "L" or s == "U" or s == "D"):
      check = False
  else:
    if not(s == "R" or s == "U" or s ="D"):
      check = False

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

S = input()

check = True
for i, s in enumerate(S):
  if (i+1)%2 == 0:
    if not(s == "L" or s == "U" or s == "D"):
      check = False
  else:
    if not(s == "R" or s == "U" or s == "D"):
      check = False

if check:
  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(input())
for i in range(len(s)):
  if i % 2 == 0:
    if s[i] != ("R", "U", "D"):
      print("No")
      exit()
  else:
    if s[i] != ("L", "U", "D"):
      print("No")
      exit()
print("Yes")

s = list(input())
i = 0
for s_ in s:
    i += 1
    if i % 2 == 1:
        if not (s_ == "R" or s_ == "U" or s_ == "D"):
            print("No")
            exit()
    else:
        if not(s_ == "L" or s_ == "U" or s_ == "D"):
            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 = input()

flg = 0

for i in range(len(s)):
    if i % 2 == 0 and (s[i] != "R" and s[i] != "U" and s[i] != "D"):
        flg = 1
    elif i % 2 == 1 and (s[i] != "L" and s[i] != "U" and s[i] != "D"):
        flg = 1
    else:
        continue

if flg == 0:
    print("YES")
else:
    print("NO")


s = input()

flg = 0

for i in range(len(s)):
    if i % 2 == 0 and (s[i] != "R" and s[i] != "U" and s[i] != "D"):
        flg = 1
    elif i % 2 == 1 and (s[i] != "L" and s[i] != "U" and s[i] != "D"):
        flg = 1
    else:
        continue

if flg == 0:
    print("YES")
else:
    print("NO")


s = input()

flg = 0

for i in range(len(s)):
    if i % 2 == 0 and (s[i] != "L" and s[i] != "U" and s[i] != "D"):
        flg = 1
    elif i % 2 == 1 and (s[i] != "R" and s[i] != "U" and s[i] != "D"):
        flg = 1
    else:
        continue

if flg == 0:
    print("YES")
else:
    print("NO")


s = input()

for i in range(len(s)):
    if i % 2 == 0 and (s[i] != "L" and s[i] != "U" and s[i] != "D"):
        print("NO")
        break
    elif i % 2 == 1 and (s[i] != "R" and s[i] != "U" and s[i] != "D"):
        print("NO")
        break
    else:
        print("YES")
        break

s = input()

flg = 0

for i in range(len(s)):
    if i % 2 == 0 and (s[i] != "R" and s[i] != "U" and s[i] != "D"):
        flg = 1
    elif i % 2 == 1 and (s[i] != "L" and s[i] != "U" and s[i] != "D"):
        flg = 1
    else:
        continue

if flg == 0:
    print("Yes")
else:
    print("No")


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

Odd = S[0::2]
Even = S[1::2]

for i in range(len(Odd)):
    if 'L' == Odd[i]:
        l = 0
        break
    else:
        l = 1

r = 1
for j in range(len(Even)):
    if 'R' == Even[j]:
        r = 0
        break
    else:
        r = 1

S = list(input())

Odd = S[0::2]
Even = S[1::2]

for i in range(len(Odd)):
    if 'L' == Odd[i]:
        l = 0
        break
    else:
        l = 1

r = 1
for j in range(len(Even)):
    if 'R' == Even[j]:
        r = 0
        break
    else:
        r = 1

if l+r == 2:
    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()
K=[]
G[]
for i in range(0,len(S),2):
  K.append(S[i])
  try:
    G.append(S[i+1])
  except:
    pass
if ('L' in K) or ('R' in G):
  print('No')
else:
  print('Yes')

S=input()
K=[]
G=[]
for i in range(0,len(S),2):
  K.append(S[i])
  try:
    G.append(S[i+1])
  except:
    pass
if ('L' in K) or ('R' in G):
  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()
i = 0
flag = True
for c in s:
  i += 1
  if (i % 2 == 0 and c == "L") or (i % 2 == 1 and c == "R"):
    print("No")
    exit(0)
print("Yes")


s = input()
i = 1
flag = True
c in s:
  if (i % 2 == 0 and c == "L") or (i % 2 == 1 and c == "R"):
    print("No")
    exit
print("Yes")


s = input()
i = 0
flag = True
for c in s:
  i += 1
  if (i % 2 == 0 and c == "R") or (i % 2 == 1 and c == "L"):
    print("No")
    exit(0)
print("Yes")


Verdicts: Wrong Answer

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):
a=input().strip()
t=1
for i in range(len(a)):
  if i%2==0 and i not in ['R','U','D']:
    t=0
    break
  elif i%2!=0 and i not in ['L','U','D']:
    t=0
    break
if t==1:
  print('Yes')
else:
  print('No')

a=input().strip()
t=1
for i in range(len(a)):
  if i%2==0 and a[i] not in ['R','U','D']:
    t=0
    break
  elif i%2!=0 and a[i] not in ['L','U','D']:
    t=0
    break
if t==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):
bool ans = True
S = input()
i = 0
while i < len(S):
  if S[i] == "L":
    ans = False
  i += 2
j = 1
while j < len(S):
  if S[j] == "R":
    ans = False
  j += 2
if ans:
  print("Yes")
else:
  print("No")

ans = True
S = input()
i = 0
while i < len(S):
  if S[i] == "L":
    ans = False
  i += 2
j = 1
while j < len(S):
  if S[j] == "R":
    ans = False
  j += 2
if ans:
  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(int, input()))
for i in range(len(s)):
    if i%2 == 0 and s[i] == 'R' or s[i] == 'U' or s[i] == 'D':
        bool = True
    elif i%2 == 1 and s[i] == 'L' or s[i] == 'U' or s[i] == 'D':
        bool = True
    else:
        bool = False
        break
        
if bool == True:
    print('Yes')
elif bool == False:
    print('No')

s = list(map(str, input()))
bool = True
while bool == True:
    for i in range(len(s)):
        if i%2 == 0 and s[i] == 'R' or s[i] == 'U' or s[i] == 'D':
            bool = True
        elif i%2 == 1 and s[i] == 'L' or s[i] == 'U' or s[i] == 'D':
            bool = True
        else:
            bool = False
        
if bool == True:
    print('Yes')
elif bool == False:
    print('No')

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

bool = True
i = 0
while i != len(S):
    if i%2 == 0 and S[i] == 'R' or S[i] == 'U' or S[i] == 'D':
        bool = True
        i += 1
    elif i%2 == 1 and S[i] == 'L' or S[i] == 'U' or S[i] == 'D':
        bool = True
        i += 1
    else:
        bool = False
        i = len(S)
        
if bool:
    print('Yes')
else:
    print('No')

Verdicts: Runtime Error

Time Limit Exceeded

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):
{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"py.py","provenance":[]},"kernelspec":{"name":"python3","display_name":"Python 3"}},"cells":[{"cell_type":"code","metadata":{"id":"H3laJejZ8tH7","colab_type":"code","colab":{"base_uri":"https://localhost:8080/","height":35},"outputId":"13f7e97e-3eae-44b3-ce92-df84580aa0d6","executionInfo":{"status":"ok","timestamp":1569272992629,"user_tz":-540,"elapsed":1544,"user":{"displayName":"ryo t","photoUrl":"","userId":"15768515004963573815"}}},"source":["print(\"a\")"],"execution_count":1,"outputs":[{"output_type":"stream","text":["a\n"],"name":"stdout"}]}]}

# -*- coding: utf-8 -*-
"""Untitled1.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/1sPHBzfvofvfL_Ijx8PVG08rBK-9-M_-6
"""

import sys

Weather = input()

def Odd(x) :
  if x == 'L' :
    return True

def Even(x) :
  if x == 'R' :
    return True

def Step(Weather) :
  k =1
  for x in Weather :
    if k%2 ==1:
      if Odd(x) :
        break
      k+=1
    else:
      if Even(x) :
        break
      k+=1
  if k >len(Weather) :
    return True
  else :
    return False

if Step(Weather):
  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 = True
for i in range(len(s)):
    if i % 2 == 0 and s[i] != 'R' and s[i] != 'U' and s[i] != 'D':
        ans = False
        break
    if 1 % 2 == 1 and s[i] != 'L' and s[i] != 'U' and s[i] != 'D':
        ans = False
        break

if ans == True:
    print('Yes')
else:
    print('No')

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

if ans == True:
    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()
even = [v for i, v in enumerate(S) if i % 2 == 0]
odd = [v for i, v in enumerate(S) if i % 2 == 1]
count = even.count("R") + odd.count("L")
print("Yes" if count == 0 else "No")

S = input()
even = [v for i, v in enumerate(S) if i % 2 == 0]
odd = [v for i, v in enumerate(S) if i % 2 == 1]
count = even.count("L") + odd.count("R")
print("Yes" if count == 0 else "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())
n=len(s)
odd=s[0:n:2]
even=s[1:n:2]
if "L" in odd:
  print("No")
elif "R" in even:
  print("No")
else:
  print("Yes")
print(odd)  
print(even)

s=list(input())
ans="No"
odd=["R","U","D"]
even=["L","U","D"]
ODD=s[0::2]
EVEN=s[1::2]
if len(set(odd+ODD))==3 and len(set(even+EVEN))==3:
  ans="Yes"
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):
O={'R','U','D'}
E={'L','U','D'}
S=input()
if set(S[::2]) <= O | set(S[1::2]) <= E:
  print('Yes')
else:
  print('No')

O={'R','U','D'}
E={'L','U','D'}
S=input()
if set(S[::2]) <= O and set(S[1::2]) <= 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=input()
ans=0
for i in range(len(S)):
    if i%2==0:
        if S[i]=='R':
            ans+=1
    if i%2==1:
        if S[i]=='L':
            ans+=1
if ans==0:
    print('Yes')
else:
    print('No')


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


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

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

s = input()
if 'L' in s[0::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):
str = input()
ans = "Yes"
for i in len(str):
  if (i + 1) % 2 == 0 and str[i] not in ('L', 'U', 'D'):
    ans = "No"
  if (i + 1) % 2 == 1 and str[i] not in ('R', 'U', 'D'):
    ans = "No"

print(ans)

str = input()
ans = "Yes"
for i in range(len(str)):
  if (i + 1) % 2 == 0 and str[i] not in ('L', 'U', 'D'):
    ans = "No"
  if (i + 1) % 2 == 1 and str[i] not in ('R', 'U', 'D'):
    ans = "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()
k = s[::2]
g = s[1::2]

if k == "R","U","D" and g == "L","U","D":
  print("Yes")
else:
  print("No")


s=input()
rud=["R","U","D"]
lud=["L","U","D"]
if rud in s[::2] and lud in s[1::2]:
  print("Yes")
else:
  print("No")

s = input()
k = s[::2]
g = s[1::2]
 
if k in "R","U","D" and g in "L","U","D":
  print("Yes")
else:
  print("No")

s = input()
k = s[::2]
g = s[1::2]
 
if (k == "R" or "U" or "D") and (g == "L" or "U" or "D":)
  print("Yes")
else:
  print("No")

s=input()
rud=["R","U","D"]
lud=["L","U","D"]
if s[::2] in rud and s[1::2] in lud:
  print("Yes")
else:
  print("No")

s = input()
k = s[::2]
g = s[1::2]
 
if (k in "R" or "U" or "D") and (g in "L" or "U" or "D":)
  print("Yes")
else:
  print("No")


Copy
Copy
s = input()
k = s[::2]
g = s[1::2]
 
if (k in "R" or "U" or "D") and (g in "L" or "U" or "D"):
  print("Yes")
else:
  print("No")

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

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()
even = ["L","U","D"]
odd = ["R","U","D"]
f=True
for i in range(len(s)):
    if i%2==1:
        if s[i] not in even:
            f = False
    if i%2==0:
        id s[i] not in odd:
            f=False
if f:
    print("Yes")
else:
    print("No")

  


s = input()
even = ["L","U","D"]
odd = ["R","U","D"]
f=True
for i in range(len(s)):
    if i%2==1:
        if s[i] not in even:
            f = False
    if i%2==0:
        id s[i] not in odd:
            f=False
if f:
    peint("Yes")
else:
    print("No")

  

s = input()
even = ["L","U","D"]
odd = ["R","U","D"]
f=True
for i in range(len(s)):
    if i%2==1:
        if s[i] not in even:
            f = False
    if i%2==0:
        if s[i] not in odd:
            f=False
if f:
    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()

lst = []

for ( i , j ) in enumerate(S) :
  if i % 2 == 0:
    if j not in ["L","U","D"]:      
      print("No")
      exit()
  else:
    if j not in ["R","U","D"]:      
      print("No")
      exit()
print("Yes") 

for i in S[::2]:
  if i == "L":
    A = False   
for x in S[1::2]:
  if x == "R":
    A = False

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

S = input()
A = True
for i in S[::2]:
  if i == "L":
    A = False   
for x in S[1::2]:
  if x == "R":
    A = False

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


Verdicts: Wrong Answer

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

is_good = True
for i,string in enumerate(s):
  if i % 2 == 0 and string in ["R", "U", "D"]:
    continue
  elif i % 2 == 1 and string in ["L", "U", "D"]:
    continue
  else:
    is_good = False
    break
print(is_good)
    
    
  

s = input()
 
is_good = "Yes"
for i,string in enumerate(s):
  if i % 2 == 0 and string in ["R", "U", "D"]:
    continue
  elif i % 2 == 1 and string in ["L", "U", "D"]:
    continue
  else:
    is_good = "No"
    break
print(is_good)

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

odd = True
yes = True

for s in S:
    if odd:
        if s == "L":
            yes = False
            break
        odd = False
    else:
        if s == "R":
            yes = False
            break
        odd = True

print(S)

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


S = input()

odd = True
yes = True

for s in S:
    if odd:
        if s == "L":
            yes = False
            break
        odd = False
    else:
        if s == "R":
            yes = False
            break
        odd = True

# print(S)

if yes:
    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()
even = ['R', 'U', 'D']
odd = ['L', 'U', 'D']

for i, j in enumerate(s):
    if i % 2 == 0:
        if j not in odd:
            print('No')
            break
    else:
        if j not in even:
            print('No')
            break
else:
    print('Yes')

s = input()
even = ['R', 'U', 'D']
odd = ['L', 'U', 'D']

for i, j in enumerate(s):
    if i % 2 == 0:
        if j not in odd:
            print('No')
            break
    else:
        if j not in even:
            printt('No')
            break
else:
    print('Yes')

s = input()
even = ['R', 'U', 'D']
odd = ['L', 'U', 'D']

for i, j in enumerate(s):
    if i % 2 == 0:
        if j not in even:
            print('No')
            break
    else:
        if j not in odd:
            print('No')
            break
else:
    print('Yes')

Verdicts: Wrong Answer

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()
count = 0

for i in range(0, len(s)):
    if i % 1 == 0:
        if s[i] == 'L':
            count += 1
    if i % 1 == 1:
        if s[i] == 'R':
            count += 1

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

s = input()
count = 0

for i in range(0, len(s)):
    if i % 2 == 0:
        if s[i] == 'L':
            count += 1
    elif i % 2 == 1:
        if s[i] == 'R':
            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 = list(input())
a = s[::2]
b = s[1::2]
if a.count(L) == 0 and b.count(R) == 0:
  print('Yes')
else:
  print("No")

s = list(input())
a = s[::2]
b = s[1::2]
if a.count('L') == 0 and b.count('R') == 0:
  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()
flag = 0
for index, word in enumerate(S):
  if (word == 'U' or word == 'D') or (index%2 == 0 and word == 'L') or (index%2 == 0 and word == 'R'):
    pass
  else:
    flag = 1
    break;
print('Yes' if flag ==0 else 'No')

S = input()
flag = 0
for index, word in enumerate(S):
  if (word == 'U' or word == 'D') or (index%2 == 0 and word == 'L') or (index%2 == 1 and word == 'R'):
    pass
  else:
    flag = 1
    break;
print('Yes' if flag ==0 else 'No')

S = input()
odd = ['R', 'U', 'D']
even = ['L', 'U', 'D']
rslt = 'Yes'
for idx, s in enumerate(S):
    if idx%2==1 and s in even:
        continue
    elif idx%2==0 and s in odd:
        continue
    else:
        rslt = 'No'
        break
print(rslt)

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):
#coding:utf-8

S = input()

if (not 'L' in set(S[1::2])) and (not 'R' in set(S[0::2])):
    print('Yes')
else:
    print('No')


#coding:utf-8

S = input()

if (not 'L' in set(S[1::2])) and (not 'R' in set(S[0::2])):
    print('Yes')
else:
    print('No')


#coding:utf-8

S = input()

if (not 'L' in set(S[1::2])) and (not 'R' in set(S[0::2])):
    print('Yes')
else:
    print('No')


#coding:utf-8

S = input()

if ('L' in set(S[0::2]) or ('R' in set(S[1::2]):
    print('No')
else:
    print('Yes')


#coding:utf-8

S = input()

if ('L' in set(S[0::2])) or ('R' in set(S[1::2])):
    print('No')
else:
    print('Yes')


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

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())
rtu = "Yes"
ks = 1
for i in S:
    if ks == 1:
        if i == "L":
            rtu = "No"
            ks = 0
            break
    elif ks == 0:
        if i == "R":
            rtu = "No"
            ks = 1
            break
print(rtu)

S = list(input())
gs = 1
ks = 0
rtu = "Yes"
while gs <= len(S) - 1:
    if S[ks] == "L":
        rtu = "No"
        break
    elif S[gs] == "R":
        rtu = "No"
        break
    gs += 1
    ka += 1
print(rtu)

S = list(input())
rtu = "Yes"
ks = 1
for i in S:
    if ks == 1:
        if i == "L":
            rtu = "No"
            ks = 0
            break
        else:
            ks = 0
    elif ks == 0:
        if i == "R":
            rtu = "No"
            ks = 1
            break
        else:
            ks = 1
print(rtu)

Verdicts: Wrong Answer

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):
c = 0
s.append("U")

for i in range(-(-l//2)):
    d = 2*i
    if s[d] == "L":
        print("No")
        c = 1
        break
    if s[d+1] == "R":
        print("No")
        c = 1
        break
if c == 0:
    print("Yes")

S = input()
l = len(S)
s = list(S)
c = 0
s.append("U")

for i in range(-(-l//2)):
    d = 2*i
    if s[d] == "L":
        print("No")
        c = 1
        break
    if s[d+1] == "R":
        print("No")
        c = 1
        break
if c == 0:
    print("Yes")


Verdicts: Runtime Error

Accepted