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:
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') #無限大
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(sys.stdin.readline()) #整数読み込み
def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み
def isn(): return sys.stdin.readline().split() #文字列読み込み
def imn(): return map(int, sys.stdin.readline().split()) #整数map取得
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得
def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得
def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
def print_list(l): print(*l, sep='\n')
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def No(): print('No')

def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime

X,Y,Z = imn()

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

Submission status: Accepted

Solution code:
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    X, Y, Z = lr()
    A = [0]*3
    A[0] = Z
    A[1] = X
    A[2] = Y
    print(*A, sep=' ')
resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

#step1
a = y
b = x
c = z

#step2

a = z
c = y

print(a, b, c)

Submission status: Accepted

Solution code:


############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
    return(int(input().rstrip()))
def inlt():
    return(list(map(int,input().rstrip().split())))
def insr():
    s = input().rstrip()
    return(s[:len(s) - 1])
def invr():
    return(map(int,input().rstrip().split()))
################################################################
a,b,c = invr()
tempa = a
tempc = c
tempb = b
a = tempc
b = tempa
c = tempb
print(a,b,c)
#print()

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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(Z,X,Y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
 
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
 
# for i in range(int(ri())):
x,y,z = RI()
print(z,x,y)

Submission status: Accepted

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

# print('-----output-----')
print(Z, X, Y)

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip()

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

print(C, A, B)

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:
x,y,z=map(int,input().split())
lst=[z,x,y]
print(*lst)

Submission status: Accepted

Solution code:
XYZ = input().split()
X = int(XYZ[0])
Y = int(XYZ[1])
Z = int(XYZ[2])

print(Z,X,Y)

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:
import sys,math,copy,queue,itertools,bisect
from fractions import gcd
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
INF = 10**18
MOD = 10**9 + 7
DD = ((1,0),(0,1),(-1,0),(0,-1))
x,y,z = LI()
x,y = y,x
x,z = z,x
print (x,y,z)

Submission status: Accepted

Solution code:
a,b,c = map(int, input().split())  #3個の数字の入力を受け取る
print(c, a, b)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    x, y, z = map(int, input().split(" "))
    ans = "{0} {1} {2}".format(z, x, y)
    print(ans)
if __name__ == '__main__':
    main()

Submission status: Accepted

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

print(z, x, y)

Submission status: Accepted

Solution code:
# import sys
# import math #sqrt
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# import itertools
# import collections # deque
# from operator import itemgetter
# from fractions import Fraction

mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

if __name__=='__main__':
    main()

Submission status: Accepted

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

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

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

print(a,end=" ")
print(b,end=" ")
print(c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

def many_int():
    return list(map(int, input().split()))

X,Y,Z = input_int()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def main():
    x,y,z = map(int, readline().split())

    print(z, x, y)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def count_section_by_zero(data):
  count = 0
  flg = False
  start = 0
  for i, d in enumerate(data):
    if flg is False and d != 0:
      count += 1
      flg = True
      
    if d == 0:
      flg = False
  return count

def input_list():
  return list(map(int, input().split()))

def input_list_str():
  return list(map(str, input().split()))

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

# 2で割り切れる回数
def divide_two(arg):
  c = 0
  while True:
    if c >= 2:
      break
    if arg % 2 != 0:
      break
    arg //= 2
    c += 1
  return c

# 素因数分解
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

def main():
  a,b,c = input_list()
  a, b = b, a
  a, c = c, a
  print(a, b, c)
  
import math
import fractions
import collections
import itertools
from functools import reduce
main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    s = input().rstrip().split(' ')
    X = int(s[0])
    Y = int(s[1])
    Z = int(s[2])
    print("{} {} {}".format(Z,X,Y))

Submission status: Accepted

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

Submission status: Accepted

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

MOD = 10**9
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

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())
ans=[Z,X,Y]
print(*ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
# A,B = [int(x) for x in stdin.readline().rstrip().split()]
# U = input().split()
# A, B = [str(x) for x in stdin.readline().rstrip().split()]
temp = A
A = B
B = temp
temp = C
C = A
A = temp
print(A, B, C)

Submission status: Accepted

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

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("{} {} {}".format(z,x,y))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a, b ,c = map(int,input().split())

print(c, a, b)

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

X, Y, Z = i_l()

X, Y = Y, X
X, Z = Z, X

print(X, Y, Z)

Submission status: Accepted

Solution code:
from sys import stdin

def main():

    input = stdin.readline

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

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

    
if __name__ == "__main__":
    main()

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

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:
x, y, z = map(int, input().split())
print(z,x,y)

Submission status: Accepted

Solution code:
import sys

x,y,z = [int(j) for j in sys.stdin.readline().split()]
a = x
x = y
y = a
a = z
z = x
x = a
print(x, y, z)

Submission status: Accepted

Solution code:
X,Y,Z= map(int,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:
# a = int(input())
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:
x, y, z = [int(x) for x in input().split()]

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

Submission status: Accepted

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

#print(ans)
print(*ans,sep=' ')

Submission status: Accepted

Solution code:

a,b,c=map(int,input().strip().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(z,x,y,sep=' ')

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
x,y,z = list(map(int,input().split()))
print(" ".join(map(str,[z,x,y])))

Submission status: Accepted

Solution code:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    x, y, z = [int(s) for s in input().strip().split()]
    print(z, x, y)


# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


def main():
    a, b, c = map(int, input().split())
    print(c, a, b)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import bisect,collections,copy,itertools,math,numpy,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())
##################################################
A,B,C = LI()
B,A = A,B
C,A = A,C
print(A,B,C)

Submission status: Accepted

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

Submission status: Accepted

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

X, Y = Y, X
X, Z = Z, X

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

Submission status: Accepted

Solution code:


from sys import stdin
import sys
sys.setrecursionlimit(10**8)

def nextLine(): return next(stdin)
def nextStrList(): return nextLine().split()
def nextIntList(): return [int(_) for _ in nextStrList()]


def main():
	x,y,z=nextIntList()
	x,y=y,x
	x,z=z,x
	print(x,y,z)


if __name__=="__main__":
	main()

Submission status: Accepted

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

import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


def main():
    x, y, z = read_list(str)
    x, y = y, x
    x, z = z, x
    print("%s %s %s" % (x, y, z))


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
x, y, z = map(int, input().split())
print(z, x, y)

Submission status: Accepted

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

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:


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

print(z, x, y)

Submission status: Accepted

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

Submission status: Accepted

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


def solve(X: int, Y: int, Z: int):
    print(Z, X, Y)


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    Z = int(next(tokens))  # type: int
    solve(X, Y, Z)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    x,y,z = mi()
    y,x = x,y
    z,x = x,z
    print(x,y,z)


main()

Submission status: Accepted

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

print(c + " " + a + " " + b)

Submission status: Accepted

Solution code:
A,B,C = [int(n) for n in 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:
import sys
from copy import deepcopy
from collections import deque
sys.setrecursionlimit(10**6)

X, Y, Z = [int(n) for n in input().split(' ')]

print(Z, X, Y)

Submission status: Accepted

Solution code:

import heapq
from collections import defaultdict, deque
from math import ceil, factorial
from fractions import gcd
import sys
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9+7

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
smii = lambda: sorted(map(int, input().split()))


x, y, z = mii()

print(z, x, y)

Submission status: Accepted

Solution code:
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.readline().strip()
def mdata(): return map(int, data().split())
#def print(x): return sys.stdout.write(str(x)+'\n')
#sys.setrecursionlimit(100000)
mod=int(1e9+7)

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq

#sys.setrecursionlimit(10**7)
#N, Q = map(int, input().split())
#G = [list(input()) for i in range(H)]
#INF = V * 10001
#A = [int(i) for i in input().split()]
#AB = [list(map(int, input().split())) for _ in range(K)]

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

temp = A
A = B
B = temp
temp = A
A = C
C =temp


print(A, B, C)

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

print(Z,X,Y)

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
#N = int(input())
#S = input()[:-1]
x,y,z = map(int,input().split())
#S,T = map(str,input().split())
#A = list(map(int,input().split()))
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
#print()
print(z,x,y)

Submission status: Accepted

Solution code:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))

# print("Yes")
# print("No")

# print("YES")
# print("NO")


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

print(X,Y,Z)

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

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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# coding:utf-8

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

tmp = X
X = Y
Y = tmp

tmp = X
X = Z
Z = tmp

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

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

x, y, z = nm()
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:
a,b,c= map(int, input().split())

print(c,a,b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
# int(input()) # 入力が1つ
x, y, z = map(int, input().split()) # 入力が複数

print(z, x, y)

Submission status: Accepted

Solution code:
#
import sys
import math
import numpy as np
import itertools


# いくつか入力
a, b, c = (int(i) for i in input().split())  

print(c,a,b)

Submission status: Accepted

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

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

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 = input().split()
print(C + ' ' + A + ' ' + B)

Submission status: Accepted

Solution code:
import sys

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

    tmp = y
    y = x
    x = tmp

    tmp = z
    z = x
    x = tmp
    print("{} {} {}".format(x, y, z))

    return 0

if __name__ == '__main__':
    sys.exit(main())

Submission status: Accepted

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

print(z, x, y)

Submission status: Accepted

Solution code:
import sys
import numpy as np

#n=int(sys.stdin.readline())
x,y,z=map(int,sys.stdin.readline().split())
#a=np.array(sys.stdin.readline().split(),dtype='int64')
#a=np.array([sys.stdin.readline().split() for i in range(n)],dtype='int64')

print(z,x,y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import collections
import itertools as it
import math
import numpy as np

#  = input()
#  = int(input())
X, Y, Z = map(int, input().split())
print(Z, X, Y)
#  = list(map(int, input().split()))
#  = [int(input()) for i in range(N)]
#
# c = collections.Counter()

Submission status: Accepted

Solution code:
#A - ABC Swap
A,B,C= map(int, input().split())

print(C,A,B)

Submission status: Accepted

Solution code:
import numpy as np
import collections

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



print(Z,X,Y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main() -> None:
    X, Y, Z = map(int, input().split())
    X, Y = Y, X
    X, Z = Z, X
    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 = list(map(int, input().split(' ')))
print(z, x, y)

Submission status: Accepted

Solution code:
#A
x = [int(x) for x in input().split()]

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

x,y,z = inm()
print("{} {} {}".format(z,x,y))

Submission status: Accepted

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

print(C, A, B)

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n, m, h = map(int, input().split())

print(h, n, m)

Submission status: Accepted

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

INF = float('inf')

""" Input
S = input()
N = int(input())
A = list(map(int, input().split()))
D = [int(input()) for _ in range(N)]
"""

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Code for A - ABC Swap
# Use input() to fetch data from STDIN
[x, y, z] = [int(x) for x in input().split()]
print(z, x, y)

Submission status: Accepted

Solution code:


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



if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
# 2020/04/04
# AtCoder Beginner Contest 161 - A

# Input
x, y, z = map(int,input().split())

# Calc

# Output
print(z, x, y)

Submission status: Accepted

Solution code:
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, input().split())

print(C,A, B)

Submission status: Accepted

Solution code:
#def main(S, b):
if __name__ == '__main__':
    x, y, z = map(int, 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 = 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, Z = Y, X, Z
X, Y, Z = Z, Y, X
print(X, Y, Z)

Submission status: Accepted

Solution code:
A, B, C = [int(e) for e in input().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:
x, y, z = map(int, input().split(" "))

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

print(x, y, z)

Submission status: Accepted

Solution code:
# coding: utf-8
X,Y,Z=map(int,input().split())

print(Z,X,Y)

Submission status: Accepted

Solution code:
# coding: utf-8
n, m ,l = map(int, open(0).read().split())
print('{} {} {}'.format(l, n, m))