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):
inpt = input()
print(inpt.replace(" ", ""))


inpt = input()

inpt = inpt.split(" ")
print(inpt[1]+inpt[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 k <= a:
    a1 = a - k
    b1 = b
elif a < k and k < a + b:
    a1 = 0
    b1 = b - (k-a)
else:
    a1 = 0
    b1 = 0

print(a1, b1)

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, B, K = map(int,input().split())
if(A>=k):
  print(A-k,B)
elif(B-K+A>=0):
  print(0,B-K+A)
else:
  print(0,0)

S=input()
T=input()
print(T+S)

A, B, K = map(int,input().split())
if(A>=K):
  print(A-K,B)
elif(B-K+A>=0):
  print(0,B-K+A)
else:
  print(0,0)


S=input()
T=input()
print("T"+"S")

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

Verdicts: 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):
A, B, K = list(map(int, input().split()))

diff = abs(A - B)
a_is_higher = A > B

if K <= diff:
  if a_is_higher:
  	print(A-K, B)
  else:
    print(A, B-K)
else:
  if a_is_higher:
  	A -= diff
  else:
    B -= diff
  K -= diff
  div, mod = divmod(K, 2)
  
  nA = Math.max(0, A // 2)
  nB = Math.max(0, B // 2)
  
  if mod:
    print(nA, nB + 1)
  else:
    print(nA, nB)

dfsfd

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

if A == 0:
  print(0, max(0, B - K))
elif B == 0:
  print(max(0, A - K), 0)
elif K == 0:
  print(A, B)

A_from_1 = A - 1
B_from_1 = B - 1

if (A_from_1 - K) >= 0:
  A -= K
  K = 0
else:
  A = 1
  K -= A_from_1
  
if (B_from_1 - K) > 0:
  B -= K
  K = 0
else:
  B = 1
  K -= B_from_1

if K == 0:
  print(A, B)
if K == 1:
  print(0, 1)
elif K > 1:
  print(0, 0)


a = input()
b = input()

if a[0] < b[0]:
  print(a+b)
else:
  print(b+a)

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

if A == 0:
  print(0, max(0, B - K))
elif B == 0:
  print(max(0, A - K), 0)
elif K == 0:
  print(A, B)

A_from_0 = A
B_from_0 = B

if (A_from_0 - K) >= 0:
  A -= K
  K = 0
else:
  A = 0
  K -= A_from_0
  
if (B_from_0 - K) > 0:
  B -= K
  K = 0
else:
  B = 0
  K -= B_from_0

if K == 0:
  print(A, B)
if K == 1:
  print(0, 1)
elif K > 1:
  print(0, 0)


a, b, k = map(int, input().split())

if a <= k:
  k -= a
  a = 0
else:
  a -= k
  k = 0

b = max(0, b - k)

print(a, b)

a,b,k = map(int,input().split())
num = min(a,k)
a -= num
k -= num
print(a,max(b-k,0))

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

diff = abs(A - B)
a_is_higher = A > B

if K <= diff:
  if a_is_higher:
  	print(A-K, B)
  else:
    print(A, B-K)
else:
  if a_is_higher:
  	A -= diff
  else:
    B -= diff
  K -= diff
  div, mod = divmod(K, 2)
  
  nA = A - div
  nB = B - div
  
  if mod:
    nA -= 1
  
  nA = max(0, nA)
  nB = max(0, nB)
  
  print(nA, nB)

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

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):
A, B, K  = list(map(int, input().split()))
for i in range(K):
    if A >= 1:
        A = A-1
    elif B >= 1:
        B = B-1
    elif A == 0 and B == 0:
        break
print(A,B)

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

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().strip().split()
return t + s

input s, t
return t + s

s, t = input().strip().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 =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("".join([t,s]))

s, t = input().split()

print("".join([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()

puts S + T

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

S = input().split()
 
print(S)

S = input().split()
 
print(sum(S))

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

S,T = input().split()

print(T+S)

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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(input().split())
ans=t+s
print(ans)

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

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 sys
sys.setrecursionlimit(500*500)
S = input()
T =input()
S.lower()
T.lower()
print(T + S)

import sys
sys.setrecursionlimit(500*500)
S = input()
T =input()
s = S.lower()
t = T.lower()
if len(s) or len(t) > 100 : 
    print("error")
print(T + S)

S = input()
T =input()
S.lower()
T.lower()
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,b=input(),split()
print(a+b)

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):
T,S = input().split()
print(T+S)

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

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,end="")
print(b)

a,b=map(str,input().split())
print(b,end="")
print(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=map(int,input().split())
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):
s,t=input(),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):
s = input()
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):
print(''.join(input().split().reverse()))

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):
print(input().replace(" ", ""))


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


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


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):
if __name__ == "__main__":
	S, T = input().split()
	print(S + T)

if __name__ == "__main__":
	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=input()
t=input()
print("{}{}".format(t,s))

s=str(input())
t=str(input())

print("{}{}".format(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):
a,b,c = map(int,input().split())

if c<a:
    print(a-c,b)
else:
    print(0,b+a-c)

a,b = map(str,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 = [x.strip() for x in input().split()]
print(s[0] + s[1])

a = input()
b = input()
print(a + b)

s = [x.strip() for x in input().split()]
print(s[1] + s[0])

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 = map(input().split())
print(s+t)

a,b,k = map(int,input().split())

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

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):
s,t =,map(str,input().split())

x = t+s

print(x)


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

x = str(t) + str(s)

print(x)


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):
chars = input.split(" ")
print(chars[1]+chars[0])

chars = input.split(" ")
print(chars[1]+char[0])


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

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

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

print(T + S)

S = input()
T = input()

print(T + S)

S = str(input())
T = str(input())

print(T + S)

S = input()
T = input()

print(T,S,sep="")

S ,T = input().split()

print(T,S,sep="")

Verdicts: 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):
# -*- coding: utf-8 -*-
s, t = input().split()
res = s + t
print(res)

# -*- coding: utf-8 -*-
s, t = input().split()
res = t + s
print(res)

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=int(input())
for p in range(2, 1000000):
    if n % p != 0:
        print(n)
        break
    else:
       n=n+1

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

A, B = (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):
##149
##A
S = input()
T = input()

print(T+S)

##149
##A
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):
a = int(input())
b = int(input())
if a == 1 and b == 2:
    print(3)
elif a == 2 and b ==3:
    print(1)
else:
    pritn(2)
    

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)

inputStrings = input().split()
print(inputStrings[1] + inputStrings[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 = input()
T = input()
print(T+S)


ST = input().split()
S = ST[0]
T = ST[1]
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("Enter a two value: ").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):
def stringconcant(S,T):
    x = S
    b = T
    c = x+b
    return c

S,T= input().split()
x = stringconcant(T,S)
print(a)

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

W,F= input().split()
a = stringcc(FW)
print(a)

def fun(S,T):
     print(T+S)
S="humu"
T="humu"
fun(S,T)

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

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):
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().rstrip()
t=input().rstrip()
print(s+t)


s=input().rstrip()
t=input().rstrip()
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 = 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 = input()
print(s + t)


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

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

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

Verdicts: 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):
a, b, k = map(int, input().split())

if a-k>=0:
    print(int(a-k),int(b))
elif a+b<k:
    print(0,0)
else:
    print(0,int(a+b-k))

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

print(str(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 = input()
b = input()
print(b + a)

a, b = map(str, 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(str(), input().split())
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):
s,t = map(input().split())
print(t + s)

a, b  = map(str, 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(str, input().split())
ans=S+T
print(ans)

S,T=map(str, input().split())
ans=T+S
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):
line = input()
s, t = line.split(" ")
ans = s + t
print(ans)


line = input()
s, t = line.split(" ")
ans = t + s
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):
S, T = input("Enter a two value: ").split()
print(T+S)

S, T = input("Enter a two value: ").split()
S = S.lower()
T = T.lower()
ST = T + S
print(ST)

S, T = input().split()
S = S.lower()
T = T.lower()
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):
def main():
    a, b = input().split()
    print(a + b)


if __name__ == '__main__':
    main()


def main():
    a, b = input().split()
    print(b + a)


if __name__ == '__main__':
    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):
a, b = map(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):
a,b,k = map(int,input().split())
if a>=k:
 print(a-k,b)
elif a+b<=k:
 print(0,0)
else:
 print(0,b-k+a)

S=input()
T=input()
print(T+S)

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

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(T,S)


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

print(T,S)

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, sep="")

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):
a = list(map(int,input().split()))

print(a[1],a[0])

a = list(map(str,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):
#!/usr/bin/env python3
import sys
from itertools import accumulate
from bisect import bisect_left

def solve(N: int, M: int, A: "List[int]"):
    A.sort()

    right = 2*A[-1]+1
    left = 0

    while right - left > 1:
        mid = (left+right)//2

        
        
        m = 0
        for i in range(N):
            a = A[i]
            res = mid - a
            
            index = bisect_left(A,res)
            m += N-index
        
        if m >= M:
            left = mid
        else:
            right = mid

    
    B = sorted(A,reverse=True)
    accum_B = list(accumulate(B))
    answer = 0
    handshake_count = 0
    for i in range(N):
        res = left - A[i]
        if res > A[-1]:
            continue
        index = bisect_left(A,res)
        answer += (N-index)*A[i]+accum_B[N-index-1]
        handshake_count += (N-index)

    
    if handshake_count>M:
        answer -= left*(handshake_count-M)
    print(answer)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    M = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, M, A)

if __name__ == '__main__':
    main()


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):
def stringconcant(S,T):
    a = S
    b = T
    c = a+b
    return c

S= input()
T= input()
a = stringconcant(T,S)
print(a)

String : ")
str2 = input("Please Enter the Second String : ")

concat1 = str1 + str2
print("The Final String After Python String Concatenation = ", concat1)

concat2 = str1 + ' ' + str2
print("The Final After String Concatenation with Space = ", concat2)

def chars_mix_up(a, b):
  new_a = b[:2] + a[2:]
  new_b = a[:2] + b[2:]

  return new_a + ' ' + new_b
print(chars_mix_up('abc', 'xyz'))

for mn in range(n):
    a=input()# String1 in the pair
    b=input()#String2 in the pair
    la=[]
    lb=[]

    for i in range(max(len(a),len(b))):#creating lists with all possible elements by slicing off the characters
        la.append(a[i:])
        lb.append(b[i:])

    if len(a)>len(b):
        lb=[x for x in lb if x!='']
    else:
        la=[x for x in la if x!='']

    while True:#Create empty list for sorting the 0th elements of 'la' nd 'lb'
        temp=[]
        temp.append(la[0])
        temp.append(lb[0])
        temp=sorted(temp)
        print(temp[0][0],end='')#print the 1st character

        if(temp[0] in la):#removing the element after printing the first character
            la.pop(0)
        else:
            lb.pop(0)

        if len(la)==0:#breaks the while loop if a list gets empty
            print(temp[1],end='')
            break
        elif len(lb)==0:
            print(temp[1],end='')
            break

def func(ab,bc):
     print(bc+ab)

ab="force"
cd="coding"
func(ab,cd)

def main():
    a, b = input().split()
    print(b + a)

if __name__ == "__main__":
    main()

Verdicts: Runtime Error

Runtime Error

Wrong Answer

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(s + t)


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

print(s + t)


s,t = map(str,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 = (str(x) for x in input().split())
print(S+T)


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


S,T = (str(x) for x in 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):
def main():
    s = input()
    s = s.replace(" ", "")
    print(s)


if __name__ == '__main__':
    main()


def main():
    s = input()
    items = s.split()
    S = items[0]
    T = items[1]
    print(T + S)


if __name__ == '__main__':
    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 = list(input().split())
print(s[0]+s[1])

s = list(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, t = map(str, input()split())
print(t+s)

s = input()
t = input()
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):
s,t = input().split()
print(s+t)

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


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):
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 = 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):
def solve(s, t):
    return s + t

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

def solve(s, t):
    return t + s

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

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()
print(S+T)


print(input()+input())


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


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


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):
#<ABC149>
#<A>
S, T = map(str,input().split())
print(S+T)


#<ABC149>
#<A>
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):
N , K = map(int , input().split())
R , S , P = map(int , input().split())
T = input()

dic = {"r":"p" , "s":"r" , "p":"s"}
ANS = []

for i in range(N):
    ANS.append(dic[T[i]])
    
ans = "".join(ANS)

VANISH = []
    
for i in range(N-K):
    if ans[i] == ans[i+K]:
        VANISH.append(ans[i])
        
if N - (2*K) > 0:
    for i in range(N - (2*K)):
        if ans[i] == ans[i+(2*K)]:
            VANISH.remove(ans[i])
            
vanish = "".join(VANISH)
        
point = ((ans.count("r")-vanish.count("r"))*R + (ans.count("s")-vanish.count("s"))*S + (ans.count("p")-vanish.count("p"))*P)

print(point)

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):
list= list(input().split())
print(list[0]+list[1])

list= list(input().split())
print(list[1]+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):
S,T = map(int,input().split())
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):
X = int(input())

while True:
    
    flag = 0
    
    for i in range(2, X+1): 
        if (X+1) % i == 0: 
            flag = 1
            break
    if flag == 1:
        X += 1
        continue
    break
    
print(X + 1)
 

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

print(S, end='')
print(T)

input(S)
input(T)

print(T, end='')
print(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):

S, T = input().split(" ")
S = int(S)
T = int(T)
TS = T+S

print("{}".format(TS))

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):
import argparse

def make_parser():
    parser = argparse.ArgumentParser()

    parser.add_argument('S')
    parser.add_argument('T')

    args = parser.parse_args()

    return args

def main():
    args = make_parser()
    T = args.T
    S = args.S

    print(T + S)

if __name__ == "__main__":
    main()


import argparse

def make_parser():
    parser = argparse.ArgumentParser()

    parser.add_argument('S')
    parser.add_argument('T')

    args = parser.parse_args()

    return args

def main():
    args = make_parser()
    T = args.T
    S = args.S

    print(T + S)

if __name__ == "__main__":
    main()


import argparse

def make_parser():
    parser = argparse.ArgumentParser

    parser.add_argument('S')
    parser.add_argument('T')

    args = parser.parse_args()

    return args

def main():
    args = make_parser()
	T = arg.T
    S = arg.S
    
    printf(S + T)


if __name__ == "__main__":
    main()


S,T = map(str, 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 = 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):
ST = list(map(str, inpuy().split()))

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

ST = list(map(str, input().split()))
 
print(ST[1]+ST[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(''.join(input().split()))

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

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_l = list(map(str, input().split()))
print(''.join(str_l))


str_l = list(map(str, input().split()))
print(''.join(list(reversed(str_l))))

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()
print(T+S)

S, T = input().strip().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,M=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
l=[]
for b in a:
    for c in a:
        l.append(b + c)
print(sum(sorted(l)[len(l)-M:]))

a,b=[i for i in 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):
a,b=map(int, input().split())
print(b+a)

Ar = list(map(str,input().split()))
S=Ar[0]
T=Ar[1]

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(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 sys
input = sys.stdin.readline

def main():
    n,m=map(int,input().split())
    a=sorted(list(map(int,input().split())))
    a.reverse()
    l,r=2*a[-1],2*a[0]
    x=(l+r)//2
    while l+1<r:
        cnt=0
        for A in a:
            for B in a:
                if A+B>=x:
                    cnt+=1
                else:
                    break
        if cnt>=m:
            l=x
        else:
            r=x
        x=(l+r)//2
    s,cnt=0,0
    for A in a:
        for B in a:
            if A+B>=l:
                cnt+=1
                s+=A+B
            else:
                break
    print(s+(m-cnt)*l)
    
if __name__ == '__main__':
    main()

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=input()
t=input()
print(t+s)

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

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,T = map(str,import().split())
print(S + T)

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


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


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


Verdicts: 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 = [int(i) for i in input().split()]
print(T+S)

S, T = [i for i in 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):

if __name__ == "__main__":
    A, B = input().split()
    print(A + B)


if __name__ == "__main__":
    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):
print(''.join(input().split()))

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

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):
t,s=map(input().split())
print(s+t)


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


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 -*-
S = int(input())
T = int(input())

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

ST = input("").split()
S, T = ST[0], ST[1]
print("{}".format(S + T))

# -*- coding: utf-8 -*-
S = input()
T = input()

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

ST = input("").split()
S, T = ST[0], ST[1]
print("{}".format(T + S))

Verdicts: 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):
def solve():
    A, B, K = map(int, input().split())
    if K <= A:
        print(A-K, B)
    elif A+B <= K:
        print(0, 0)
    else:
        print(0, B-(K-A))


if __name__ == '__main__':
    solve()


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


if __name__ == '__main__':
    solve()


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=list(map(int,input().split()))

if A==0 and B==0:
  pass
elif A>0:
  if A>=K:
  	A = A-K
  elif A+B>K:
    B = B-K+A
    A = 0
  else:
    A=0
    B=0
elif B>K:
  B=B-K
else:
  B=0
print('%d %d' % (A,B))

S, T = imput().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):
# -*- coding: utf-8 -*-

S, T = input().split()

U = S+T
print(U)


# -*- coding: utf-8 -*-

S, T = input().split()

U = T+S
print(U)


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())
U = ""
U = U + T + S
print(U)

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

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

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 = input()
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):
s, t = map(int,input().split())
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):
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):
n,m = input(),input
print(n+m)

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

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

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):
print(input().split()[::-1].join())

t=input().split()
print(t[1]+t[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):
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):
n = list(map(int, input.split()))

ans = str(n[0])+str(n[1])

print(ans)

n = input().split()

ans = str(n[1])+str(n[0])

print(ans)

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

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():
  [n, k] = [int(i) for i in input().split()]
  [r, s, p] = [int(i) for i in input().split()]
  T =  input()
  
  my = T.replace("r", "hoge").replace("s", "r").replace("p", "s").replace("hoge", "p") 
  for i in range(k, n):
    if my[i] == my[i-k]:
      my = my[:i] + "l" + my[i+1:]  
      
  print(my.count("r")* r + my.count("s")*s + my.count("p")* p)
  
if __name__ == "__main__":
  main()

def main():
    [s, t] = input().split()
    print(s + t)

if __name__ == "__main__":
	main()

def main():
    [s, t] = input().split()
    print(t + s)

if __name__ == "__main__":
	main()


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)

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,end="")
print(T)

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

print(T,end="")
print(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):
from collections import deque

S = str(input())
T = str(input())

print(T, S, sep='')



S, T = map(str,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 = map(input().split())
print(T+S)

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

Verdicts: Runtime Error

Accepted