TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input()
t=input()
print(t+s)

a,b,k=map(int,input().split())
if a <= k:
  print(0,end=' ')
else:
  print(a-k,end=' ')
s = a+b
if s > k:
  print(s-k)
else:
  print(0)


s,t=map(int,input())
print(t+s)

s,t=input().split()
print(t+s)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=list(map(str,input().split()))
print(T,S)

S,T=list(map(str,input().split()))
print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print('{}{}'.format(s,t))

s, t = input().split()
print('{}{}'.format(t,s))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print('',join(input().split()))

s = input().split()
print(s[1]+s[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input()
T = input()
print(T+S)

S,T = map(str,input().split())
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import math

input_from = input()
info = input_from.split(' ')
a = int(info[0])

def is_prime(n):
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for num in range(3, int(math.sqrt(n)), 2):
        if n % num == 0:
            return False
    return True

if a == 2:
    print(2)
else:
    while not is_prime(a):
        a += 1

print("{0}".format(a))


input_from = input()
strings = input_from.split(' ')
print("{0}{1}".format(strings[1], strings[0]))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input().split()
print(s[0]+s[1])

s=input().split()
print(s[1]+s[0])


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S = input()
T = input()
new = T + S
print(new)
#####################################

s=input()
t=input()
print(t+s)
#a comment for exec

def func(S,T):
     print(T+S)

S="force"
T="coding"
func(S,T)

def scc(W,F):
    a = W
    b = F
    c = a+b
    return c

W,F= input().split()
a = scc(F,W)
print(a)

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
list = []
	setup.strip','
	print(T,S)
list



list = []
	print(T,S)
	setup.strip','

list

list = [T,S]
	setup.strip','
list

input = S
input = T
a = list[S,T]:
  print(a)

A, B = input().split()
print(B, A)

A, B = input().split()
C = B + A
print(C)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
string_list = map(str, input().split(" "))
print(string_list[1] + string_list[0])

string_list = input()
string_list =  list(map(str, string_list.split(" ")))
print(string_list[1] + string_list[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = input().split()
ans = a+b
print(ans)

a,b = input().split()
ans = b+a
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a=input().split()
print(a[0]+a[1])

a=input().split()
print(a[1]+a[0])

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(s+t)

s, t = input().split()
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input.split()
print(T+S)

S,T = input().split()
print("{}{}".format(T,S))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
T,S=input().split()
print(T+S)

S,T=input().split()
print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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

S,T = input().split()
print(T,S, sep="")

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(input().split())
if s>=t:
  print(t+s)
else:
  print(s+t)

s,t=map(str,input().split())
print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = map(string, input().split())
print('{}{}'.format(T, S))

          
          

S,T = map(String, input().split())
print('{}{}'.format(T, S))

S,T = input().split()
#print('{}{}'.format(T, S))
print(T+S)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b = input().split()
print(a+b)

a,b = input().split()
print(b+a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = map(int, input().split())

if K>=A + B:
	print ("0 0")
elif K>=A:
	print (str(0) + ' ' + str(B-(K-A)))
else:
  	print (str(A-K) + ' ' +str(B))


S, T = input().split()
print (T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = list(map(int, input().split()))
print(T+S)


S,T = list(map(int, input().split()))
print(T+S)


S,T = map(str, input().split())
print(T+S)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input()+input())

print("".join(input().split())) 

print("".join(reversed(input().split()))) 

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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

print(S+T)

S, T = input().split()
print(T + S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split
print(T, S, sep='')

S, T = input().split()
print(T, S, sep='')

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b = map(input())
print(a+b)

a, b = map(str,input().split())
print(a+b)

a,b = map(str,input().split())
print(b+a)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = map(int,input().split())
  for _ in range(K):
    if A >= 1:
      A -= 1
    elif B >= 1:
      B -= 1
    else:
      break
print(A,B)

S,T=input().split()
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(str,input().split())
print(s+t)

s,t=map(int,input().split())
print(t+s)

s,t=map(int,input().split())
print(s+t)

s,t=input().split()
print(t+s)

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k=map(int,input().split())
if a>=k: print(a-k,b)
elif a+b>=k: print(0,a+b-k)
else: print(0,0)


s,t=input().split()
print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import math
n = int(input()) 

def is_prime(n):
    if n == 1: return True

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False
    return True

if(is_prime(n)):
    print(n)
else:
    while(is_prime(n) == False):
        n = n + 1
        is_prime(n)
    print(n)
        
    

s = input().split()

print(s[1]+s[0])


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
#S,T = map(int,input().split())
S,T = input().split()
#S = input()
print(S+T)

#S,T = map(int,input().split())
S,T = input().split()
#S = input()
print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().replace(' ',''))

s,t = input().split()
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input()
print(t+s)

s, t = input()
print(t+s)

s, t = input().split()
print(t+s)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b=input().split()

print(b,a)

a,b=input().split()

print(b+a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input.split()
print(t,s,sep='')

s,t = input().split()
print(t, s, sep='')

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(t+" "+s)

s, t = input().split()
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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

output = ''.join(inputValue.split())

print(output)

inputValue = input()

output = ''.join(reversed(inputValue.split()))

print(output)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = list(input())
ans = T+S
print(ans)

S,T = map(input().split())
ans = T+S
print(ans)


S,T = input().split()
ans = T+S
print(ans)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a=input.sprit()
a=''.join(a)
print(a)

List=list(map(str,input().split()))
List.reverse()
print(''.join(List))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a=input()
print(input()+a)

s = input().split()
print(s[1]+s[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print("{}{}".format(s, t))

s, t = input().split()
print("{}{}".format(t, s))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
x,y = map(int,input().split())

ans=abs(abs(x)-abs(y))

if x<0 and y<=0 or x>=0 and y>0:
  if x>y:
    ans+=2

else:
  ans+=1
  
print(ans)

s,t=input().split()
print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=input()
t=input()
print(t+s)

from math import ceil
x=int(input())
i=0
if x<=2:
  print(2)
elif x==3:
  print(3)
elif x==4:
  print(5)
else:
  while 1:
    ok=True
    n=ceil((x+i)**0.5)
    for j in range(2,n):
      if (x+i)%j==0:
        ok=False
        break
    if ok:
      print(x+i)
      exit()
    i+=1


s,t=input().split()
print(t+s)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = input().split()

C = int(K)-int(A)
B = int(B)-C

print(str(C) +" "+ str(B))

S, T = input().split()

print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import fractions
X = int(input())

def qprime(n):
    if n<2:return False
    elif n==2:return True
    elif n%2==0:return False
    for i in range(3,math.floor(math.sqrt(n))+1,2):
                   if n % i == 0:return False
    return True


for i in range(X,100000):
    if qprime(i):
        print(i)
        break


s,t = input().split()
print(t+s)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(''.join([input(),input()][::-1]))

print(''.join(input().split()[::-1]))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = [int(s) for s in input().split()]

if K <= A:
    print(A-K, B)
elif K <= A + B:
    print(0, A+B-K)
else:
    print(0, 0)

S,T = input().split()
print(T + S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
# -*- coding: utf-8 -*-
def main():
    StringS = input();
    StringT = input();

    print(StringT+StringS);

main()


# -*- coding: utf-8 -*-
def main():
    StringS,StringT = input().split();

    print(StringT+StringS);

main()


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = map(input().split())
print(s+t)

s,t = map(str,input().split())
print(s+t)

s,t = input().split()
print(t+s)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import os
nyu = input().split()
S=nyu[0].strip()
T=nyu[1].strip()
print(S+T)

import os
nyu = input().split()
S=nyu[0].strip()
T=nyu[1].strip()
print(T+S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a, b = input().split()
print(b,a)

a, b = input().split()
print(b,a, sep="")

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
n,m=list(map(input().split()))
print(m.append(n))

n,m=input().split()
print(m+n)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = map(int, input().split())
if A>=K:
    print(A-K, B)
else:
    print(0, max(0, B-(K-A)))

S, T = input().split()
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(s + t)

s, t = input().split()
print(t + s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):

a,b=map(str,input().split())


print(a+b)


a,b=map(str,input().split())


print(b+a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = [i for i in input().split()]

print(s+t)

s,t = [i for i in input().split()]
 
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split
print(s + t)

s,t = input().split
ans = t + s
print(ans)


s,t = input().split()
ans = t + s
print(ans)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().replace(' ', ''))

s, t = input().split()
print(t+s)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s=str(input())
for i in range(len(s)):
  if s[i]==" ":
    s[i]=""
print[s]

s = input().split()
print(s[1]+s[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().split().replace(" ","")


print(input().replace(" ",""))

T , S = input().split()
print(S +T)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split()
print(S + T)

S, T = input().split()
print(S + T)

In = list(map(int, input().split()))
sin = set(In)
print("Yes" if len(sin) == 2 else "No")


S, T = input().split()
print(T + S)

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(s+t)

s, t = input().split()
print(''.join([s, t]))

s, t = input().split()
print(t+s)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input().split()
print(S + T)

S,T=input().split()
print(T + S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=input()
print(t+s)

s,t=input().split()
print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().replace(" ",""))

import math
 
def main():
  N = int(input())
  
  if N==2:
    print(2)
  else:
    print(search(N))
 

def search(x):
  
  
  ints = list(range(3,x))
  
  
  for i in ints:
    
    
    if x%i==0:
      seartch(x+2)
  	elif x < i**2:
      break
    
  return x

main()

print("".join(input().replace(" ","")[::-1]))

import math
 
def main():
  N = int(input())
  
  print(search(N))
 
def search(x):
  
  ints = list(range(2,x))
  
  
  for i in ints:
    if x%i==0:
      seartch(x+1)
  	elif x < i**2:
      break
    
  return x

print("".join(input().split(" ")[::-1]))

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = map(str, input().split())
print(s+t)


s,t = map(str, input().split())
print(t+s)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()

print(s+t)

s = input()
t = input()

print(s+t)

s,t = input().split()
 
print(t+s)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a, b = input().split()
print(a+b)

#!/usr/bin/python3
# -*- coding: utf-8 -*-
a, b = input().split()
print(b+a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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

print("".join(a))

a = input().split()

print("".join(reversed(a)))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
    s, t = input().split()
    print(t+s)

s, t = map(String, input(),split())
	print(s+t)

from lib2to3.fixer_util import String
s, t = map(String, input().split())
print(s + t)

s, t = input().split()
print(s+t)

s, t = input().split()
print(s+t)

s, t = input().split()
print(t+s)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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

print(t+s)

s, t = map(str,input().split())
print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
string = int().split()
print(string[1] + string[0])

string = input().split()
print(string[1] + string[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = map(input().split())

x = t + s
print(x)

s, t = map(str, input().split())
 
x = t + s
print(x)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
ans = ''.join([str(x) for x in input().split()])
print(ans)

s,t = map(str,input().split())
print(s+t)

l = list(str(x) for x in input().split())
print(''.join(l))

l = list(x for x in input().split())
print(''.join(l))

s,t = map(str,input().split())
print(t+s)


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
def rem(string): 
	return string.replace(" ", "") 
	
string = 'asdasd asdad'
print(rem(string))

def rem(string): 
	return string.replace(" ", "") 
	
string = 'asdasd asdad asdadew'
print(rem(string))

def rem(string): 
	return string.replace(" ", "") 
	
string = 'asdasd asdad'
print(rem(string))

str = input(.split(' '))

print(str[1]+str[0])

s = str(input()).split(" ")
print(s[1] + s[0])

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
C  = input()
A , B = C.split()
print(A+B)

C  = input()
A , B = C.split()
print(B+A)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
s = s.lower()
t = t.lower()
new_string = ''.join(sorted(s + t))
print(new_string)

s,t = input().split()
s = s.lower()
t = t.lower()
new_string = (t+s)
print(new_string)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
str = inpit().split()
print(str[1]+str=[0])

string = input().split()
print(string[1]+string[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split()
print(S + T)


S, T = input().split()
print(T + S)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
def main():
    s, t = input().split()
    ans = s + t
    print(ans)


if __name__ == '__main__':
    main()


def main():
    s, t = input().split()
    ans = ''.join([s, t])
    print(ans)


if __name__ == '__main__':
    main()


def main():
    s, t = input().split()
    ans = ''.join([t, s])
    print(ans)


if __name__ == '__main__':
    main()


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input()+input())

s,t = (i for i in input().split())
print(s+t)

s,t = (i for i in input().split())
print(t+s)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
  a, b = input().split(' ')
  print(b + a)

a, b = input().split(' ')
print(b + a)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(input().split())
print(t+s)

s,t=input().split()
print(t+s)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
n = input()
(p,q) = n.split()
print(p+q)

n = input()
(p,q) = n.split()
print(q+p)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split()
return T + S

S, T = input().split()
print(T + S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
print(input().rstrip(" "))

s, t = input().split()
print(t + s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
print(s+t)

s,t = input().split()
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
x = input()
y = input()

print(y+x)

string = []

string = input().split()

print(string[1]+string[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
print(s+t)

s,t = input().split()
print(t+s)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=int(input().split())
print(t+s)

S='oder'
T='atc'
print('S+T')

S,T=map(int,input().split())
	print(S+T)

str=input().strip()
print('str')

S,T=map(int,input().split())
print(T+S)

S=input().split("区切り文字")
T=input().split("区切り文字")
print(S+T)

S,T=map(int,input().split())
	print(T+S)

str = input().strip()
S='oder'
T='atc'
print('T'+'S')

s,t=input().split()
print(t+s)

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(str, input().split())

print("{}{}",format(T, S))

S, T = map(str, input().split())

print("{}{}".format(T, S))

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = map(input().split())
print(t+s)


s,t = input().split()
print(t+s)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(t, s)

s, t = input().split()
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T = input().split()
ptint(T+S)

S,T = input().split()
print(T+S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a=list(input())
print(a[1]+a[0])

a,b=input().split()
print(a+b)

a,b=input().split()
print(b+a)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
import math

prims = list()

prims.append(2)

base = int(input())

def _is_prim(n):
  global prims
  for p in prims:
    if n == p:
      return True
    elif n % p == 0:
      return False
  
  return True


base_rt = int(math.sqrt(base))
for n in range(rt):
  if n < 2:
    continue
  elif n % 2 == 0:
    continue
  elif _is_prim(n):
    prims.append(n)


while not _is_prim(base):
  base += 1

print(base)   

stdin = input().split()
print(stdin[1] + stdin[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(str, input().split())
print(S+T)


S, T = map(str, input().split())
print(T+S)


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a = input.split()
print(''.join(a))

a = input.split()
print(a[1] + a[0])

a = input().split()
print(a[1] + a[0])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = int.split()
print(T + S)

S, T = input().split()
print(T + S)

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a=input()
b=input()
print(b + a)

line = input().split(' ')
A = int(line[0])
B = int(line[1])
K = int(line[2])
Z = 0

def p2(num1, num2, Z):
  if Z:
    return(0)
  else:
    if(num1 < num2):
      return (num2 - num1)
      Z = 1
    else:
      return(0)
  
print(str(p2(K, A, Z)) + ' ' + str(p2(K - A, B, Z)))

line=input().split(' ')
print(line[1] + line[0])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(s + t)

s,t = input()

print(s + t)

s, t = input().split()
print(t + s)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
return t + s

def conc(s, t):
  return t[:2] + t[2:] + s

s, t = input().split()
print(t + s)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input()
print(s.replace(' ', ''))

s = input()
print(s.replace(' ', '')

s, t = input().split()
print(t + s)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = input().split();print(S + T)

S, T = input().split();print(T + S)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
in_list = input().split()
A, B, K = int(in_list[0]), int(in_list[1]), int(in_list[2])

for k in range(K):
  if A > 0:
    A -= 1
  elif B > 0:
    B -= 1
  elif:
    pass

print(A, B)


a = input().split()
print(a[1]+a[0])

Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s = input().split()
print(s[1], s[0])

s = input().split()
print(s[1] + s[0])

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A,B = map(str,input().split())
out = A+B
print(out)

A,B = map(str,input().split())
out = B+A
print(out)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
st=input().split(' ')
print(st[0]+st[1])

st=input()
print(st.replace(' ',''))

st=input().split()
print(st[0]+st[1])

st=input().split()
print(st[1]+st[0])


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b,k = input().strip().split
a,b,k = [int(a), int(b), int(k)]

for i in range(c):
  if k < a:
    a = a-k
  elif k >= a+b:
    a = 0
    b = 0
  elif a+b > k > a:
    b = b-(k-a)
	a = 0

s,t = input("S T").split()
print(t + s)

a,b,k = input().strip().split
a,b,k = [int(a), int(b), int(k)]

if k < a:
	a = a-k
elif k >= a+b:
    a = 0
    b = 0
elif a+b > k > a:
    b = b-(k-a)
	a = 0


a,b,k = input().strip().split
a,b,k = [int(a), int(b), int(k)]

if k < a:
	a = a-k
elif k >= a+b:
	a = 0
	b = 0
elif a+b > k > a:
	b = b-(k-a)
	a = 0

print('{} {}'.format(a,b))

a,b,k = input().strip().split
a,b,k = [int(a), int(b), int(k)]

if k < a:
	a = a-k
elif k >= a+b:
	a = 0
	b = 0
elif a+b > k > a:
	b = b-(k-a)
    a = 0

a,b,k = input().strip().split()
a,b,k = [int(a), int(b), int(k)]

if k < a:
	a = a-k
elif k >= a+b:
	a = 0
	b = 0
elif a+b > k > a:
	b = b-(k-a)
	a = 0

print('{} {}'.format(a,b))

s,t = input().split()
print(t + s)

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=map(input().split())
print(s+t)


s,t=map(char,input().split())
print(s+t)


s,t=input(),input()
print(t+s)


s,t=input().split()
print(t+s)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A = list(map(int,input().split()))
for i in range(A[2]):
    if A[0] > 0:
        A[0] -= 1
    elif A[1] > 1:
        A[1] -=1
print(A[0],A[1])


S,T= map(str,input().split())
print(T+S)


Verdicts: Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t=input().split()
print=('{}{}'.format(t,s))

s,t=map(str,input().split())
print(str(t)+str(s))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S,T=input()
print(T+S)

S,T=input().split
print(T+S)

S,T=input().split()
print(T+S)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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

print(num[2] + num[0])

num = input()



num2 = num.split()

print(num2[1] + num2[0])

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
A, B, K = map(int, input().split())


if A + B <= K:
    print(0, 0)

elif A <= K:
    C = K - A
    print(0, B-C)

else:
    print(A - K, B)


A, B, K = map(int, input().split())


if A + B <= K:
    print(0, 0)

elif A <= K:
    C = K - A
    print(0, B-C)

else:
    print(A - K, B)


S, T = input().split()
print(T+S)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = map(str, input().split())
print(s + t)

s, t = map(str, input().split())
print(t + s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
#!/usr/bin/env python3

def main():
    N = map(int, open(0).read().split())


main()



#!/usr/bin/env python3

def main():
    S, T = open(0).read().split()
    print(T + S)
    

main()



Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
S, T = map(str, input().split())
print(''.join(S+T))


S, T = map(str, input().split())
print(''.join(T+S))


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s, t = input().split()
print(s+t)


s, t = input().split()
print(t+s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
a,b= input().split()

print(a+b)

a,b= input().split()

print(b+a)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
str_list = list(input().split(' '))
print(str_list[0]+str_list[1])


str_list = list(input().split(' '))
print(str_list[1]+str_list[0])


Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
H,W = [x for x in input().split()]
print(H+W)

H,W = [x for x in input().split()]
print(W+H)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()
print(str(s)+str(t))

s,t = input().split()
print(str(t)+str(s))

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

Submission attempts (in order):
s,t = input().split()

print(s + t)

s,t = input().split()

print(t + s)

Verdicts: Wrong Answer

Accepted
Problem: Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.

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


ans = S + T

print(ans)

S,T = input().split()


ans = T + S

print(ans)

Verdicts: Wrong Answer

Accepted