Problem:


Score : 100 points

Problem Statement

We have three boxes A, B, and C, each of which contains an integer.

Currently, the boxes A, B, and C contain the integers X, Y, and Z, respectively.

We will now do the operations below in order. Find the content of each box afterward.  

Swap the contents of the boxes A and B

Swap the contents of the boxes A and C

Constraints

1 \leq X,Y,Z \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

X Y Z

Output

Print the integers contained in the boxes A, B, and C, in this order, with space in between.

Sample Input 1

1 2 3

Sample Output 1

3 1 2

After the contents of the boxes A and B are swapped, A, B, and C contain 2, 1, and 3, respectively.

Then, after the contents of A and C are swapped, A, B, and C contain 3, 1, and 2, respectively.  

Sample Input 2

100 100 100

Sample Output 2

100 100 100

Sample Input 3

41 59 31

Sample Output 3

31 41 59



Sample input:
1 2 3


Sample output:
3 1 2

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def main():
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
    return [ int(s) for s in input().split(" ")]

# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

x,y,z = get_nums_l()

print( z, x, y )

Submission status: Accepted

Solution code:
x,y,z=[int(x) for x in input().split()]
print(z,x,y)

Submission status: Accepted

Solution code:
data=input().split()
output=data[2]+" "+data[0]+" "+data[1]
print(output)

Submission status: Accepted

Solution code:
from collections import defaultdict, deque
import sys
import heapq
import bisect
import math
import itertools
import string
import queue
import copy
import time
# import numpy as np
from fractions import gcd

sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())
 
def inp_list(): return list(map(int, sys.stdin.readline().split()))

def lcm(x, y): return (x * y) // gcd(x, y)


X, Y, Z = inp_list()
print(Z, X, Y)

Submission status: Accepted

Solution code:
n = list(map(int,input().split()))
print(str(n[2])+' ' +str(n[0])+' '+str(n[1]))

Submission status: Accepted

Solution code:
*s,c=input().split();print(c,*s)

Submission status: Accepted

Solution code:
# A - ABC Swap
def main():
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False
# show_flg = True


def main():
    X, Y, Z = MI()
    X, Y = Y, X
    X, Z = Z, X

    print(X, Y, Z)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x,y,z = input().split()
x,y = int(y),int(x)
x,z = int(z),int(x)
print(x,y,z)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split(' '))
print('{} {} {}'.format(z, x, y))

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())
a = z
b = x
c = y
print(a,b,c)

Submission status: Accepted

Solution code:
X, Y, Z = list(map(int, input().split()))
Y, X = X, Y
Z, X = X, Z

print(X, Y, Z)

Submission status: Accepted

Solution code:
import copy

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

print(C,A,B)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
 
x, y, z = y, z, x
print(y, z, x)

Submission status: Accepted

Solution code:
X,Y,Z = (int(i) for i in input().split())

A = Z
B = X
C = Y

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
print (C,A,B)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print("{} {} {}".format(z, x, y))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print (z,x,y)

Submission status: Accepted

Solution code:
#A
XYZ = input().split(' ')
X = int(XYZ[0]) ; Y = int(XYZ[1]) ; Z = int(XYZ[2])
print(Z,X,Y)

Submission status: Accepted

Solution code:
import sys

a = list(map(int, input().split()))

b = [a[2], a[0], a[1]]

print(b[0], b[1], b[2])

Submission status: Accepted

Solution code:
a, b, c = input().split()

a1 = b
b1 = a
a2 = c
c1 = a1

print(a2, b1, c1)

Submission status: Accepted

Solution code:
x, y, z = [int(w) for w in input().strip().split()]
t = x
x = y
y = t
t = x
x = z
z = t
print(x, y, z)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

x, y = y, x
x, z = z, x

print(x, y, z)

Submission status: Accepted

Solution code:
A,B,C = list(map(int,input().split()))
print(C,A,B)

Submission status: Accepted

Solution code:
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False
# show_flg = True


def main():
    X, Y, Z = MI()

    tmp = Y
    Y = X
    X = tmp
    tmp = Z
    Z = X
    X = tmp

    print(X, Y, Z)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from collections import Counter, deque

INF = float('inf')


def main():
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c = map(int,raw_input().split())
print c,a,b

Submission status: Accepted

Solution code:
def main():
    x,y,z = map(int,input().split())
    tmp = x
    x = y
    y = tmp
    tmp = x
    x = z
    z = tmp
    print(*[x,y,z])

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
x,y=y,x
x,z=z,x
print(x,y,z)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())

x,y = y,x
x,z = z,x

print(x , y, z)

Submission status: Accepted

Solution code:
l = list(input().split())
l[0] = int(l[0])
l[1] = int(l[1])
l[2] = int(l[2])
l[0], l[1]=l[1], l[0]
l[0], l[2]=l[2], l[0]
print(l[0], l[1], l[2])

Submission status: Accepted

Solution code:
base = input().split()
print(int(base[2]),int(base[0]),int(base[1]))

Submission status: Accepted

Solution code:
l = [int(x) for x in input().split()]
print('{} {} {}'.format(l[2],l[0],l[1]))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    x,y,z = map(int,input().split())
    print(z,x,y)
resolve()

Submission status: Accepted

Solution code:
X,Y,Z = map(int, input().split())
print('{} {} {}'.format(Z,X,Y),end=" ")

Submission status: Accepted

Solution code:
arr = list(map(int, input().rstrip().split()))
a = arr[0]
b = arr[1]
c = arr[2]
a = a + b
b = a - b
a -= b
a = a + c
c = a - c
a -= c
print(a, end = " ")
print(b, end = " ")
print(c)

Submission status: Accepted

Solution code:
data = input().split()
# data = "1 2 3".split()
order = [2, 0, 1]
shuffle = []

for i in order :
    shuffle.append(data[i]+' ')

output = " ".join(shuffle)
print(output)

Submission status: Accepted

Solution code:
# coding: utf-8
x,y,z = list(map(int, input().split()))

print('{} {} {}'.format(z,x,y))

Submission status: Accepted

Solution code:
hello,y,z=input().split()
hello=int(hello)
y=int(y)
z=int(z)
print(z,hello,y)

Submission status: Accepted

Solution code:
X,Y,Z= map(int,input().split())
print(Z,X,Y)

Submission status: Accepted

Solution code:
x,y,z=input().split()
x=int(x)
y=int(y)
z=int(z)
print(z,x,y)

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

a, b, c = na()
print(c, a, b)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
print(str(z),str(x),str(y))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


X, Y, Z = MI()
print(Z, X, Y)

Submission status: Accepted

Solution code:
def main():
    X, Y, Z = map(int, input().split())

    w = X
    X = Y
    Y = w
    w = X
    X = Z
    Z = w

    print('{} {} {}'.format(X, Y, Z))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import itertools
import queue
import numpy as np
input = sys.stdin.readline
sys.setrecursionlimit(100000)
# mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


def main():
    X, Y ,Z = read_values()
    print(Z, X, Y)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys
import itertools
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
# mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


def main():
    X, Y ,Z = read_values()
    print(Z, X, Y)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A, B, C = input().split()
temp = A
A = C
C = B
B = temp
print(A+" "+B+" "+C)

Submission status: Accepted

Solution code:
a = input()
b = a.split()
print(b[2]+' '+b[0]+' '+b[1])

Submission status: Accepted

Solution code:
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

Submission status: Accepted

Solution code:
a ,b ,c = map(int,input().split())

d = a
a = b
b = d

d = a
a = c
c = d

print(a, b, c)

Submission status: Accepted

Solution code:
X=input().split()

A=' '.join([X[2], X[0], X[1]])

print(A)

Submission status: Accepted

Solution code:
x, y,z = map(int,input().split(' '))
print(z,x,y)

Submission status: Accepted

Solution code:
def RA():
    l = input().split()
    return [int(i) for i in l]
arr = RA()
print(arr[2], arr[0], arr[1])

Submission status: Accepted

Solution code:
def swap(a,b):
  return b,a
x,y,z = map(int,input().split())
x,y = swap(x,y)
x,z = swap(x,z)
print(x,y,z)

Submission status: Accepted

Solution code:
X,Y,Z = input().split()
print(Z+" "+X+" "+Y)

Submission status: Accepted

Solution code:
x, y, z = map(str, input().split())
a = [x, y, z]
a[0], a[1] = a[1], a[0]
a[0], a[2] = a[2], a[0]
b = '  '.join(a)
print(b)

Submission status: Accepted

Solution code:
A, B, C = input().split()
print(C,A,B)

Submission status: Accepted

Solution code:
old = list(map(int, input().split()))
new = []
new.append(old[2])
new.append(old[0])
new.append(old[1])
print(new[0] ,new[1], new[2])

Submission status: Accepted

Solution code:
a=list(map(int,input().split()))
print(a[2],a[0],a[1])

Submission status: Accepted

Solution code:
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

x,y,z = na()
print(z,x,y)

Submission status: Accepted

Solution code:
s = input().split()
A = s[0]
B = s[1]
C = s[2]

print(str(s[2]) + " " + str(s[0]) + " " + str(s[1]))

Submission status: Accepted

Solution code:
def inputs(): return [int(x) for x in input().split()]
x,y,z = inputs()
print(z,x,y)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
x, y, z = z, x, y
print("{0} {1} {2}".format(x, y, z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int, input().split())
a=Y
b=X
c=a
a=Z
print(a,b,c)

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
print(str(Z)+" "+str(X)+" " + str(Y))

Submission status: Accepted

Solution code:
a,b,c = map(int, input().split());
d = a;
e = b;
a = c;
b = d;
c = e;
print(a,b,c)

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())
temp = y
y = x
x = z
z = temp
print(x,y,z)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())

print("%d %d %d" % (Z, X, Y))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x,y,z = LI()
print(z,x,y)

Submission status: Accepted

Solution code:
X,Y,Z = map(int, raw_input().split())
print Z,X,Y

Submission status: Accepted

Solution code:
str = input().split()
new = []
new.append(str[2])
new.append(str[0])
new.append(str[1])
print(new[0] + " " + new[1] + " " + new[2])

Submission status: Accepted

Solution code:
A,B,C= map(int,input().split())
print(C,A,B)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split(' '))
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp
print(x,y,z)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
tmp = X
X = Y
Y = tmp

tmp_ = X
X = Z
Z = tmp_

print(X, Y, Z, sep=' ')

Submission status: Accepted

Solution code:
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    temp = a
    a = b
    b = temp
    return (a,b)
 
x,y = swap(x,y)
x,z = swap(x,z)
print(x,y,z)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())

print(str(z) + ' ' + str(x) + ' ' + str(y))

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
x = A
A = B
B = x
x = A
A = C
C = x

print(' '.join(map(str, [A,B,C])))

Submission status: Accepted

Solution code:
a=input().split()
print(a[2]+' '+a[0]+' '+a[1])

Submission status: Accepted

Solution code:
X, Y, Z = [i for i in input().split()]

ans =  " ".join([Z, X , Y])
print(ans)

Submission status: Accepted

Solution code:
a, b, c = input().split()
print(c+" "+a+" "+b)

Submission status: Accepted

Solution code:
#!/usr/bin/python3

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

(a, b) = (b, a)
(a, c) = (c, a)

print(a, b, c)

Submission status: Accepted

Solution code:
X, Y, Z = [int(i) for i in input().split()]
print("{} {} {}".format(Z, X, Y))

Submission status: Accepted

Solution code:
a = input().split()
b = ""
n = a[0]
a[0] = a[1]
a[1] = n
n = a[0]
a[0] = a[2]
a[2] = n
for i in a:
    b = b + i + " "
print(b)

Submission status: Accepted

Solution code:
X, Y, Z =map(int, input().split())
X, Y = Y, X
X, Z = Z, X


print(X, Y, Z)

Submission status: Accepted

Solution code:
a, b, c = map(int, input().strip().split(" "))
# a b
tmp = a
a = b
b = tmp
# print(" ".join(map(str, [a, b, c])))
# a c
tmp = a
a = c
c = tmp
print(" ".join(map(str, [a, b, c])))

Submission status: Accepted

Solution code:
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))

#################

X,Y,Z = LI()

print(Z,X,Y)

Submission status: Accepted

Solution code:

if True:
    a,b,c=input().split()
    a,b=b,a
    a,c=c,a
    print(a,b,c)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# from typing import *

# def solve(X: int, Y: int, Z: int) -> Any:
def solve(x, y, z):
    x, y = y, x
    x, z = z, x
    return x, y, z

# generated by online-judge-template-generator (https://github.com/kmyk/online-judge-template-generator)
def main():
    X, Y, Z = map(int, input().split())
    ans = solve(X, Y, Z)
    print(*ans)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!usr/bin/env python3
X, Y, Z = map(int, input().split())
print(Z, X, Y)

Submission status: Accepted

Solution code:
x, y, z = [int(i) for i in input().split()]
x, y = y, x
x, z = z, x
print(x, y, z)

Submission status: Accepted

Solution code:
i = list(map(int, input().split())) 
L = [i[2], i[0], i[1]]
print(' '.join(map(str, L)))

Submission status: Accepted

Solution code:
arr = list(map(int, input().split()))
print(arr[2], arr[0], arr[1])

Submission status: Accepted

Solution code:
l_input = [int(e) for e in input().split()]
l_output = [l_input[2], l_input[0], l_input[1]]
print(*l_output)

Submission status: Accepted

Solution code:
def q1():
    X,Y,Z = (int(i) for i in input().split())
    print('{} {} {}'.format(Z,X,Y))


if __name__ == '__main__':
    q1()

Submission status: Accepted

Solution code:
def main(x,y,z):
    return " ".join(map(str, [z,x,y]))

x,y,z = map(int, input().split())
print(main(x,y,z))

Submission status: Accepted

Solution code:
#!/usr/bin/python

import sys

def main():
    x, y, z = map(int, sys.stdin.readline().strip().split(' '))
    print(z, x, y)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
li= list(map(int, input().split()))
li.insert(1, li.pop(0))
li.insert(2, li.pop(0))
li.insert(0, li.pop(1))
print(li[0], li[1], li[2])

Submission status: Accepted

Solution code:
X, Y, Z = input().split()
A = X
B = Y
C = Z
# swap the contents of the boxes A and B
temp = B
B = A
A = temp
# swap the contents of the boxes A and C
swapAC = C
C = A
A = swapAC
print(A, B, C)

Submission status: Accepted

Solution code:
X,Y,Z=input().split()
X=int(X)
Y=int(Y)
Z=int(Z)
if (1<=X<=100)and(1<=Y<=100)and(1<=Z<=100):
    print(Z,X,Y)

Submission status: Accepted

Solution code:
a, b, c = map(int,input().split())
print(c,a,b)

Submission status: Accepted

Solution code:
X, Y, Z = input().split()
A = X
B = Y
C = Z
temp = A
A = B
B = temp
temp = A
A = C
C = temp

print(A, B, C);

Submission status: Accepted

Solution code:
X, Y ,Z = (map(int, input().split()))

print(Z,X,Y)

Submission status: Accepted

Solution code:
a, b,c = map(int, input().split())
print(c,a,b)

Submission status: Accepted

Solution code:
m,n,o = input().split()
m = int(m)
n = int(n)
o = int(o)
m,n = n,m
m,o = o,m
print(m,n,o)

Submission status: Accepted

Solution code:
inp=list(map(int,input().strip().split()))[:3]
a,b,c=inp[0],inp[1],inp[2]
a,b=b,a
a,c=c,a
print(a,b,c)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
a,b,c = map(int,input().split())
a,b = b,a
a,c = c,a

print(a,b,c)

Submission status: Accepted

Solution code:
a, b, c = map(int, input().rstrip().split())
print(c,a,b)

Submission status: Accepted

Solution code:
def main():
    X, Y, Z = [int(x) for x in input().split()]
    print(" ".join(map(str, [Z,X,Y])))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

X, Y, Z = map(int, input().split())

print(Z, X, Y)

Submission status: Accepted

Solution code:
x, y, z = [int(x) for x in input().split()]

a, b, c = x, y, z
a, b = b, a
a, c = c, a

print(a, b, c)

Submission status: Accepted

Solution code:
x, y, z = list(map(int,(input().split())))

x, y = y, x 
x,z = z,x
print(x,y,z)

Submission status: Accepted

Solution code:
A,B,C = map(int, input().split())
print(C,A,B)

Submission status: Accepted

Solution code:
s1, s2, s3 = input().split()
print("{} {} {}".format(s3, s1, s2))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp

print(x, y, z)

Submission status: Accepted

Solution code:
#coding: utf-8
XYZ = input().split()
XYZ[0],XYZ[1],XYZ[2] = XYZ[2],XYZ[0],XYZ[1]
print(' '.join(map(str, XYZ)))

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))


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

Submission status: Accepted

Solution code:
a,b,c=(int(x) for x in input().split())

a,b = b,a
a,c = c,a

print(a, b, c)

Submission status: Accepted

Solution code:
x,y,z = input().split()
print(z+" "+x+" "+y)

Submission status: Accepted

Solution code:
box = []
box = list(map(int,input().split()))

temp = 0
temp = box[0]
box[0] = box[1]
box[1] = temp

temp = box[0]
box[0] = box[2]
box[2] = temp

print(box[0],box[1],box[2])

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())

A, B = B, A
A, C = C, A
print(A, B, C)

Submission status: Accepted

Solution code:
A = list(map(int, input().split()))
B =[A[2],A[0],A[1]]

for i in B:
    print(i)

Submission status: Accepted

Solution code:
a,b,c = list(map(int,input().split()))
 
def myFun(x,y):
    val = x
    x = y
    y = val
    return (x,y)
 
a,b = myFun(a,b)
a,c = myFun(a,c)
print(a,b,c)

Submission status: Accepted

Solution code:
A = list(input().split())


A[0],A[1],A[2] = A[2],A[0],A[1]

print(' '.join(A))

Submission status: Accepted

Solution code:
x, y, z = input().split(" ")
print("{} {} {}".format(z,x,y))

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
a[0], a[1] = a[1], a[0]
a[0], a[2] = a[2], a[0]
print(a[0], a[1], a[2])

Submission status: Accepted

Solution code:
array = list(map(int, input().split()))

tmp = array[0]
array[0] = array[1]
array[1] = tmp

tmp = array[0]
array[0] = array[2]
array[2] = tmp


print("%d %d %d" %(array[0], array[1], array[2]))

Submission status: Accepted

Solution code:
X,Y,Z=input().split()

print(Z+" "+X+" "+Y)

Submission status: Accepted

Solution code:
X,Y,Z=list(map(int,input().split()))
print(Z,' ',X,' ',Y)

Submission status: Accepted

Solution code:
X,Y,Z = list(map(int, input().split()))
X, Y = Y, X
X, Z = Z, X
print(X,Y,Z)

Submission status: Accepted

Solution code:
from sys import stdin
a,b,c = map(int,input().split())
print("{} {} {}".format(c,a,b))

Submission status: Accepted

Solution code:
# your code goes here
X,Y,Z = map(int,input().split())
print(Z,X,Y)

Submission status: Accepted

Solution code:
quiz = input()
quiz = quiz.split()

quiz[0], quiz[1] = quiz[1], quiz[0]
quiz[0], quiz[2] = quiz[2], quiz[0]
print(quiz[0], quiz[1], quiz[2])

Submission status: Accepted

Solution code:
X,Y,Z=map(int, input().split())
print(str(Z) + " " +str(X)+" "+ str(Y))

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
X,Y = Y,X
X,Z = Z,X
print(str(X)+" "+str(Y)+" "+str(Z))

Submission status: Accepted

Solution code:
x, y, z = map(int,input().split())

a = x
b = y
c = z

z = str(b)
y = str(a)
x = str(c)

print(x +" " + y + " " + z)

Submission status: Accepted

Solution code:
import sys
# sys.stdin = open('input.txt')

x, y, z = input().split()
x, y = y, x
x, z = z, x
print(x + ' ' + y + ' ' + z)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10

#solve
def solve():
    xyz = LI()
    xyz[0], xyz[1] = xyz[1], xyz[0]
    xyz[0], xyz[2] = xyz[2], xyz[0]
    print(*xyz)
    return


#main
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
line = input()

x, y, z = line.lstrip().rstrip().split(' ')
a = int(x)
b = int(y)
c = int(z)

t = a
a = b
b = t

t = a
a = c
c = t

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

Submission status: Accepted

Solution code:

def main():
    X, Y, Z = [_ for _ in input().split()]
    output = str(Z) + " " + str(X) + " " +str(Y)
    print(output)

main()

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())

A,B = B,A
A,C = C,A
print(A,B,C)

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
A,B=B,A
A,C=C,A
print(A,B,C)

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))
print(x[2], x[0], x[1])

Submission status: Accepted

Solution code:
X,Y,Z = input().split()

print(Z +" "+  X + " "+Y)

Submission status: Accepted

Solution code:
a, b, c = [int(x) for x in input().split()]
a, b, c = c, a, b
print(a, b, c)

Submission status: Accepted

Solution code:
aa=list(map(int,input().split()))
a=aa[0]
b=aa[1]
c=aa[2]
print(c,a,b)

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())
x,y = y,x
z,x = x,z
print(x, y, z)

Submission status: Accepted

Solution code:
url = "https://atcoder.jp/contests/abc161/tasks/abc161_a"

def main():

    a,b,c = list(map(int, input().split()))
    t = a
    a = b
    b = t
    t = c
    c = a
    a = t
    print(a,b,c)



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
X,Y,Z=input().split()
print(int(Z),int(X),int(Y))

Submission status: Accepted

Solution code:
line = input().split(" ")

A = line[0]
B = line[1]
C = line[2]

X = int(B)
Y = int(A)

ZO = X
X = int(C)


print(str(X) + " " + str(Y) + " " + str(ZO))

Submission status: Accepted

Solution code:
A, B, C = map(int, raw_input().split())
print C, A, B

Submission status: Accepted

Solution code:
X,Y,Z = list(map(int, input().split()))

print(Z, X, Y)

Submission status: Accepted

Solution code:
a = list(input().split())

b = [a[2], a[0], a[1]]
print(" ".join(b))

Submission status: Accepted

Solution code:
X,Y,Z = map(int, input().split())

print(Z,X,Y, sep=" ")

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())
x, y = y, x
x, z = z, x
print(str(x)+" "+str(y)+" "+str(z))

Submission status: Accepted

Solution code:
def calc():
    x, y, z = c, a, b

    print(x, y, z)

a, b, c = map(int, input().split())
calc()

Submission status: Accepted

Solution code:
a = input()
b = a.split()
c = [0]*len(b)
for i in range(len(b)):
    c[i]= int(b[i])
d = c[0]
e = c[1]
c[0] = c[2]
c[1] = d
c[2] = e

print(' '.join(map(str, c)))

Submission status: Accepted

Solution code:
li = list(map(int,input().split()))	
print(li[2],li[0],li[1])

Submission status: Accepted

Solution code:
a,b,c= map(str, input("").split())
tem=a
a=c
c=b
b=tem
print(a+' '+b+' '+c)

Submission status: Accepted

Solution code:
a,b,c = map(int,input().split())

tmp = a

a = b
b = tmp

tmp = a
a = c
c = tmp

print(a,b,c)

Submission status: Accepted

Solution code:
def solve():
    a, b, c = map(int, input().split())
    print(c, a, b)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
a,b,c = map(int, input().strip().split())
print(c,a,b)

Submission status: Accepted

Solution code:
X, Y, Z  = map(int, input().split())

print(Z, X, Y)

Submission status: Accepted

Solution code:
A,B,C=[int(i) for i in input().split(" ")]
A,B=B,A
A,C=C,A
print(A,B,C)

Submission status: Accepted

Solution code:
A,B,C = map(int, input().split())
A,B = B,A
A,C = C,A
print(A, B, C)

Submission status: Accepted

Solution code:
data = input().split()
x = int(data[0])
y = int(data[1])
z = int(data[2])

print(z,x,y)

Submission status: Accepted

Solution code:
a,b,c = map(str, input().split())
print(c + ' ' + a + ' ' + b)

Submission status: Accepted

Solution code:
a, b, c = input().strip().split(" ")
print(c, a, b)

Submission status: Accepted

Solution code:
li = input().split()
print(li[2]+" "+li[0]+" "+li[1])

Submission status: Accepted

Solution code:
a, b, c = map(int,input().split())
a, b = b, a
a, c = c, a
print(a, b, c)

Submission status: Accepted

Solution code:
x, y, z  = map(int, input().split())
print(str(z) + " " + str(x) + " " +str(y))