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())
print(S)
for i,j in enumerate(S):
    if i%2==0:
        
        if j=="R"or j=="U"or j=="D":
            
            continue
        else:
            print("No")
            break
    else:
        if j=="L"or j=="U"or j=="D":
            continue
        else:
            print("No")
            break
else:
    print("Yes")
        

S=list(input())

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

s = list(input())
odd = []
even = []
for i in range(len(s)):
  if i % 2 == 0:
    odd.aapend(s[i])
  else:
    even.append(s[i])
o = 0
e = 0
if "L" in odd:
  o = -1
if "R" in even:
  e = -1
if o * e == 0:
  print("Yes")
else:
  print("No")


s = list(input())
odd = []
even = []
for i in range(len(s)):
  if i % 2 == 0:
    odd.append(s[i])
  else:
    even.append(s[i])
if "L" in odd or "R" in even:
  print("No")
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()
ki=s[1::2]
gu=s[::2]
if 'L' in ki:
    print('No')
elif 'R' in gu:
    print('No')
else:
    print('Yes')


s=input()
ki=s[2::2]
gu=s[1::2]
ki=s[0]+ki
if 'L' in ki:
    print('No')
elif 'R' in gu:
    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):
n = input()

flag = True
for i in range(N):
  if i%2 == 0:
    if n[i] == 'R' or n[i] == 'U' or n[i] == 'D':
      pass
    else:
      flag = False
      
  else:
    if n[i] == 'L' or n[i] == 'U' or n[i] == 'D':
      pass
    else:
      flag = False
      
if flag:
  print('Yes')
else:
  print('No')
      

n = input()

flag = True
for i in range(len(n)):
  if i%2 == 0:
    if n[i] == 'R' or n[i] == 'U' or n[i] == 'D':
      pass
    else:
      flag = False
      
  else:
    if n[i] == 'L' or n[i] == 'U' or n[i] == 'D':
      pass
    else:
      flag = False
      
if flag:
  print('Yes')
else:
  print('No')
      

Verdicts: Runtime Error

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

Submission attempts (in order):
steps = list(list(input()))
even = True
odd = True
for i in range(0, len(steps), 2):
    if not (steps[i] == 'U' or  steps[i] == 'U' or  steps[i] == 'D'):
        odd = False

for i in range(1, len(steps), 2):
    if not (steps[i] == 'L' or  steps[i] == 'U' or  steps[i] == 'D'):
        even = False

if even and odd:
    print("Yes")
else:
    print("No")

steps = list(list(input()))
even = True
odd = True
for i in range(0, len(steps), 2):
    if not steps[i] == ('R' or "U" or "D"):
        odd = False

for i in range(1, len(steps), 2):
    if not steps[i] == ("L" or "U" or "D"):
        even = False

if even and odd:
    print("Yes")
else:
    print("No")

steps = list(list(input()))
even = True
odd = True
for i in range(0, len(steps), 2):
    if not (steps[i] == 'R' or  steps[i] == 'U' or  steps[i] == 'D'):
        odd = False

for i in range(1, len(steps), 2):
    if not (steps[i] == 'L' or  steps[i] == 'U' or  steps[i] == 'D'):
        even = False

if even and odd:
    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 = list(input())
Flag = True
for i in range(0,len(S)):
  if i % 2 == 0:
    a = S[i]
    if Flag == True and a == 'R':
       Flag = False
  else:
    b = S[i]
    if Flag == True and b == 'L':
       Flag = False
if Flag == True:
  print('Yes')
else:
  print('No')

S = list(input())
Flag = True
for i in range(0,len(S)):
  if i % 2 == 0:
    a = S[i]
    if Flag == True and a == 'R':
       Flag = False
  else:
    b = S[i]
    if Flag == True and b == 'L':
       Flag = False
if Flag == True:
  print('Yes')
else:
  print('No')

S = list(input())
Flag = True
for i in range(0,len(S)):
  if i % 2 == 1:
    a = S[i]
    if Flag == True and a == 'R':
       Flag = False
  else:
    b = S[i]
    if Flag == True and b == 'L':
       Flag = False
if Flag == True:
  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=list(input())
even=[]
odd=[]
for i in range(len(S)):
    if i%2==0:
        even.append(S[i])
    else:
        odd.append(S[i])
print(odd,even)
if not "L" in even and not "R" in odd:
    print("Yes")
else:
    print("No")

S=list(input())
even=[]
odd=[]
for i in range(len(S)):
    if i%2==0:
        even.append(S[i])
    else:
        odd.append(S[i])
if not "L" in even and not "R" in odd:
    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):
#!/usr/bin/env python3

N = int(input())
H = list(map(int, input().split()))
D = [0, abs(H[1] - H[0])]
for i in range(2, N):
    D.append(min(abs(H[i] - H[i - 1]) + D[i - 1], abs(H[i] - H[i - 2]) + D[i - 2]))
print(D[-1])

#!/usr/bin/env python3

S = input()
if S[0::2].find('L') == -1 and S[1::2].find('R') == -1:
    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 = True
for i, j in enumerate(s):
    print(i+1 ,j)
    if ( i+1) % 2 == 0:
        if not(j == "L" or j =="U" or j == "D"):
            flag = False
    else:
        if not(j == "R" or j =="U" or  j == "D"):
            flag = False
if flag:
    print("Yes")
else:
    print("No")

s = input()
flag = True
for i, j in enumerate(s):
    if ( i+1) % 2 == 0:
        if not(j == "L" or j =="U" or j == "D"):
            flag = False
    else:
        if not(j == "R" or j =="U" or  j == "D"):
            flag = False
if flag:
    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()

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

S = input()

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

s=input()
a=0
for i in range(0,len(s)):
  if i%2==0:
    if s[i]=='L':
      a=a-1
  else:
    if s[i]=='R':
      a=a-1
if a<0:
  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 = list(input())

print(s)
flag = 0

for i in range(len(s)):
    if i%2==0:
        if s[i] == 'R':
            flag = 1
    else:
        if s[i] == 'L':
            flag = 1

if flag == 1:
    print('No')
else:
    print('Yes')


s = list(input())

flag = 0

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


if flag == 1:
    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())
for i in range(len(s)):
  if i%2==0 and s[i]=="L":
    print("No")
    sys.exit()
  if i%2==1 and s[i]=="R":
    print("No")
    sys.exit()
print(Yes)

import sys
s=list(input())
odd=["R","U","D"]
even=["L","U","D"]
for i in range(len(s)):
  if i%2==0:
    if s[i] not in even:
      print("No")
  else:
    if s[i] not in odd:
      print("No")
print("Yes")
      

import sys
s=list(input())
odd=["R","U","D"]
even=["L","U","D"]
for i in range(len(s)):
  if i%2==0:
    if s[i] not in even:
      print("No")
      sys.exit()
  else:
    if s[i] not in odd:
      print("No")
      sys.exit()
print("Yes")
      

import sys
s=list(input())
for i in range(len(s)):
  if i%2==0 and s[i]=="L":
    print("No")
    sys.exit()
  if i%2==1 and s[i]=="R":
    print("No")
    sys.exit()
print("Yes")

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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

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


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

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

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


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):
h = str(input())
h = list(h)
h2 = h[0::2]
h3 = h[1::2]
print(h2)
print(h3)
if 'L' in h2 or 'R' in h3 :
    print('No')
else:
    print('Yes')

h = str(input())
h = list(h)
h2 = h[0::2]
h3 = h[1::2]
if 'L' in h2 or 'R' in h3 :
    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):
step = input()

ng = ["L", "R"]

for i in range(0, len(step)):
  if step[i] == ng[i%2]:
    return "No"
return "Yes"


#!/usr/bin/env python3
S = input()


ng = ["L", "R"]
for i in range(0, len(S)):
  if S[i] == ng[i%2]:
    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):
import sys
S = input()
def tapdance() :
    i = 0
    L = len(S)
    for i in range(L):
        if i % 2 == 0:
            if S[i] == 'L' :
                print('No')
                return 
        else :
            if S[i] == 'R' :
                print('No')
                return 
    return('Yes')

tapdance()

import sys
S = input()
def tapdance() :
    i = 0
    L = len(S)
    for i in range(L):
        if i % 2 == 0:
            if S[i] == 'L' :
                print('No')
                return 
        else :
            if S[i] == 'R' :
                print('No')
                return 
    print('Yes')
    return
 
tapdance()

Verdicts: Wrong Answer

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

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



S = input()
if S[0::2].count("L") + S[1::2].count("R") = 0: print("Yes")
  else: print("No")



S = input()
if S[0::2].count("L") + S[1::2].count("R") == 0: 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 = list(input())
Even = ["L","U","D"]
Odd = ["R", "U", "D"]
answer = "Yes"
for i in range(len(S)):
  if i % 2 == 0 and S[i] not in Even:
    answer = "No"
  elif i % 2 != 0 and S[i] not in Odd:
    answer = "No"
print(answer)
    

S = list(input())
Even = ["L","U","D"]
Odd = ["R", "U", "D"]
for i in range(len(S)):
  if (i+1) % 2 == 0 and S[i] not in Even:
    print("No")
    exit()
  elif (i+1) % 2 != 0 and S[i] not in Odd:
    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):
import re

s = input()
p = re.compile(r'^[R,U,D]([L,U,D][R,U,D])*[L,U,D]?$')

if p.match(s):
    print('YES')
else:
    print('NO')


s = input()

i = 1
badFlag = 0
for c in s:
    if i % 2 == 0:
        if not(c == 'L' or c == 'U' or c == 'D'):
            badFlag = 1
    else:
        if not(c == 'R' or c == 'U' or c == 'D'):
            badFlag = 1
    if badFlag == 1:
        break
    i += 1

if badFlag == 1:
    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):
import sys
s = input()
for idx, i in enumerate(s):
    if i == 'R' and (idx+1) % 2 == 0:
        print('NO')
        sys.exit()
    elif i == 'L' and (idx+1) % 2 == 1:
        print('NO')
        sys.exit()
print("YES")


import sys
s = input()
for idx, i in enumerate(s):
    if i not in ['L','U','R','D']:
        print('No')
    elif i == 'R' and (idx+1) % 2 == 0:
        print('No')
        sys.exit()
    elif i == 'L' and (idx+1) % 2 == 1:
        print('No')
        sys.exit()
print("Yes")



Verdicts: Wrong Answer

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

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

s = list(s)
s1=s[0::2]
s2=s[1::2]

flag = "yes"

for a in s1:
  if (a != 'R') and (a != 'U') and (a != 'D'):
    flag = "no"
for a in s2:
  if (a != 'L') and (a != 'U') and (a != 'D'):
    flag = "no"

print(flag)

s = input()

s = list(s)
s1=s[0::2]
s2=s[1::2]

flag = "yes"

for a in s1:
  if (a != 'R') and (a != 'U') and (a != 'D'):
    flag = "no"
for a in s2:
  if (a != 'L') and (a != 'U') and (a != 'D'):
    flag = "no"

print(flag)

s = input()

s = list(s)
s1=s[0::2]
s2=s[1::2]

flag = "Yes"

for a in s1:
  if (a != 'R') and (a != 'U') and (a != 'D'):
    flag = "No"
for a in s2:
  if (a != 'L') and (a != 'U') and (a != 'D'):
    flag = "No"

print(flag)

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()
for i in range(length(s)):
  if i%2 == 1:
    if not(s[i] == 'R' or s[i] == 'U' or s[i] == 'D'):
      print('No')
      exit()
  if i%2 == 0:
    if not(s[i] == 'L' or s[i] == 'U' or s[i] == 'D'):
      print('No')
      exit()
print('Yes')

s = input()
if 'L' in s[0::2] or 'R' in s[1::2]:
  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):
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
from itertools import combinations
import bisect
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
s=i()
for i in range(math.ceil(s/2)):
  if not s[i]=="R" or s[i]=="U" or s[i]=="D":
    print("No")
    sys.exit()
for j in range(s//2):
  if not s[i]=="L" or s[i]=="U" or s[i]=="D":
    print("No")
print('Yes')

import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
from itertools import combinations
import bisect
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
s=i()
for i in range(math.ceil(len(s)/2)):
  if not (s[2*i]=="R" or s[2*i]=="U" or s[2*i]=="D"):
    print("No")
    sys.exit()
for j in range(len(s)//2):
  if not (s[2*j+1]=="L" or s[2*j+1]=="U" or s[2*j+1]=="D"):
    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("")
a = 0
for i in range(len(S)):
    if i%2==1:
        print(S[i])
        if S[i] == 'L':
            a=a+1
        if S[i] == 'U': 
            a = a+1
        if S[i] == 'D':
            a = a+1
        else:
            a = 0
    elif i%2==0:
        if S[i] == 'R':
            a=a+1
        if S[i] == 'U': 
            a = a+1
        if S[i] == 'D':
            a = a+1
        else:
            a = 0
print(len(S))
print(a)
if len(S)==a:
    print("Yes")
else:
    print("No")

S = input("")
a = 0
for i in range(len(S)):
    if i%2==1:
        if S[i] == 'L':
            a=a+1
        if S[i] == 'U': 
            a = a+1
        if S[i] == 'D':
            a = a+1
        else:
            a = 0
    elif i%2==0:
        if S[i] == 'R':
            a=a+1
        if S[i] == 'U': 
            a = a+1
        if S[i] == 'D':
            a = a+1
        else:
            a = 0

if len(S)==a:
    print("Yes")
else:
    print("No")

S = input("")
a = 0
for i in range(len(S)):
    if i%2==1:
        if S[i] == 'L':
            a=a+1
        elif S[i] == 'U': 
            a = a+1
        elif S[i] == 'D':
            a = a+1
        else:
            a = 0
    elif i%2==0:
        if S[i] == 'R':
            a =a+1
        elif S[i] == 'U': 
            a = a+1
        elif S[i] == 'D':
            a = a+1
        else:
            a = 0
if len(S)==a:
    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()
isOK=True
for i in range(len(S)):
  if(i%2==1):
    if(S[i]=="L"):
      isOK=False
  else:
    if(S[i]=="R"):
      isOK=False
      
if(isOK):
  print("Yes")
else:
  print("No")

S=input()
isOK=True
for i in range(len(S)):
  if((i+1)%2==1):
    if(S[i]=="L"):
      isOK=False
  else:
    if(S[i]=="R"):
      isOK=False
      
if(isOK):
  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()
i=0
for tmp in list(s):
  i+=1
  if i%2==0:
    if tmp in ['L','U','D']:
      continue
    else:
      x='N'
      break
  else:
    if tmp in ['R','U','D']:
      continue
    else:
      x='N'
      break
  break
if x=='N':
    print('No')
else:
    print('Yes')

s=input()
i=0
for tmp in s:
  i+=1
  if i%2==0:
    if tmp in ['L','U','D']:
    else:
      print('No')
      break
  break
  else:
    if tmp in ['R','U','D']:
    else:
      print('No')
      break
  break
print('Yes')    
    

s=input()
i=0
for tmp in list(s):
  i+=1
  if i%2==0:
    if tmp in ['L','U','D']:
      x='Y'  
      continue
    else:
      x='N'
      break
  else:
    if tmp in ['R','U','D']:
      x='Y'  
      continue
    else:
      x='N'
      break
  break
if x=='N':
    print('No')
else:
    print('Yes')

Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
s = input()
odd = set(s[::1])
if "L" in odd:
  print("No")
  exit()
even = set(s[1::1])
if "R" in even:
  print("No")
  exit()
print("Yes")

s = input()
odd = set(s[::2])
if "L" in odd:
  print("No")
  exit()
even = set(s[1::2])
if "R" in even:
  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()
print("Yes" if all(s.index(i) % 2 == 1 and i in "RUD" or s.index(i) % 2 == 0 and i in "LUD" for i in s) 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):
s = list(input())
for i in range(len(s)):
  if i%2!=0 and s[i]=='L':
    print('No')
    exit()
  if i%2==0 and s[i]=='R':
    print('No')
    exit()
print('Yes')


s = list(input())
for i in range(len(s)):
  if i%2==0 and s[i]=='L':
    print('No')
    exit()
  if i%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):
def main():
  s = input()
  if is_easy(s):
    print("Yes")
  else:
    print("No")

def is_easy(str):
  for i in range(len(str)):
    c = str[i]
    mod = i % 2

    if mod == 0:
      if c == "R":
        return False
    else:
      if c == "L":
        return False

  return True

if __name__ == "__main__":
    main()

def main():
  s = input()

  if is_easy(s):
    print("Yes")
  else:
    print("No")

def is_easy(str):
  odd = ["R", "U", "D"]
  even = ["L", "U", "D"]
  rtn = True

  odds = []
  evens = []

  for i in range(len(str)):
    if i % 2 == 0:
      odds.append(str[i])
    else:
      evens.append(str[i])

  for i in range(len(odds)):
    if not odds[i] in odd:
      rtn = False
  for i in range(len(evens)):
    if not evens[i] in even:
      rtn = False
  return rtn

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()
ans="YES"
for i in range(len(s)):
	if(i%2==0 and s[i]=='L'):
		ans="NO"
		break
	elif(i%2==1 and s[i]=='R'):
		ans="NO"
		break
print(ans)

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

Verdicts: Wrong Answer

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

Submission attempts (in order):

            a=list()
b=list()
a="R", "U","D"
b="L", "U", "D"
s=input()
count=0
ans=True
for i in s:
    if count%2==0:
        if i not in a:
            ans=False
    if count%2!=0:
        if i not in b:
            ans=False
    count+=1

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

a=list()
b=list()
a="R", "U","D"
b="L", "U", "D"
s=input()
count=0
ans=True
for i in s:
    if count%2==0:
        if i not in a:
            ans=False
    if count%2!=0:
        if i not in b:
            ans=False
    count+=1

if ans==True:
    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())

ki = S[1::2]
gu = S[0::2]
ans = ''

for g in gu:
    if g == 'L' or g == 'U'  or g == 'D':
        for i in ki:
            if i == 'R' or i == 'U'  or i == 'D':
                ans = 'Yes'         
            else:
                ans = 'No'
    else:
        print('No')

print(ans)

S = list(input())

ki = S[1::2]
gu = S[0::2]
ans = ''

for g in gu:
    if g == 'L' or g == 'U'  or g == 'D':
        for i in ki:
            if i == 'R' or i == 'U'  or i == 'D':
                ans = 'Yes'         
            else:
                ans = 'No'
                break
    else:
        print('No')

print(ans)

S = list(input())

gu = S[1::2]
ki = S[0::2]
ans = ''
count = 0

if 'L' in ki or 'R' in gu:
    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):
S = input()
result = 'Yes'
for i in range(1, len(S)+1):
  print(i)
  if (i % 2 == 0 and S[i-1] == "R") or (i % 2 == 1 and S[i-1] == "L"):
      result = 'No'
      break
      
print(result)
      


S = input()
result = 'Yes'
for i in range(1, len(S)+1):
  #print(i)
  if (i % 2 == 0 and S[i-1] == "R") or (i % 2 == 1 and S[i-1] == "L"):
      result = 'No'
      break
      
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):
l = ['L', 'R', 'U', 'D']
s = list(input())
ans = 'YES'
for i in range(len(s)):
  if i % 2 == 0:
    if s[i] == 'L':
      ans = 'NO'
      break
  if i % 2 == 1:
    if s[i] == 'R':
      ans = 'NO'
      break
print(ans)

l = ['L', 'R', 'U', 'D']
s = list(input())
ans = 'YES'
for i in range(len(s)):
  if i % 2 == 0:
    if s[i] == 'L':
      ans = 'NO'
      break
  else:
    if s[i] == 'R':
      ans = 'NO'
      break
print(ans)

l = ['L', 'R', 'U', 'D']
s = list(input())
ans = 'YES'
for i in range(len(s)):
  if i % 2 == 0:
    if s[i] == 'L':
      ans = 'NO'
      break
  if i % 2 == 1:
    if s[i] == 'R':
      ans = 'NO'
      break
print(ans,end='')

l = ['L', 'R', 'U', 'D']
s = list(input())
ans = 'Yes'
for i in range(len(s)):
  if i % 2 == 0:
    if s[i] == 'L':
      ans = 'No'
      break
  if i % 2 == 1:
    if s[i] == 'R':
      ans = 'No'
      break
print(ans)

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

list = str.split()

odd=["R","U","D"]
even=["L","U","D"]

i = 1
flag = False
for l in list:
    if i % 2 == 0:
        if l in even:
            pass
        else:
            flag = True
            break
    else:
        if l in odd:
            pass
        else:
            flag = True
            break
if(flag):
    print(No)
else:
    print(Yes)

str = input()

list = str.split()

odd=["R","U","D"]
even=["L","U","D"]

i = 1
flag = False
for l in list:
    if i % 2 == 0:
        if l in even:
            pass
        else:
            flag = True
            break
    else:
        if l in odd:
            pass
        else:
            flag = True
            break
if(flag):
    print(No)
else:
    print(Yes)

str = input()

list = list(str)

i = 0
f = True
for l in list:
    i+=1
    if i%2 != 0:
        if l == "L":
            f=False
            break
    else:
        if l == "R":
            f=False
            break

if(f):
    print("Yes",end="\n")
else:
    print("No",end="\n")

Verdicts: Runtime Error

Runtime Error

Accepted