Problem:
 Score: 100 points    Problem Statement  The weather in Takahashi's town changes day by day, in the following cycle: Sunny, Cloudy, Rainy, Sunny, Cloudy, Rainy, ...  Given is a string S representing the weather in the town today. Predict the weather tomorrow.      Constraints   S is Sunny , Cloudy , or Rainy .         Input  Input is given from Standard Input in the following format:  S       Output  Print a string representing the expected weather tomorrow, in the same format in which input is given.        Sample Input 1 Sunny      Sample Output 1 Cloudy  In Takahashi's town, a sunny day is followed by a cloudy day.       Sample Input 2 Rainy      Sample Output 2 Sunny

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    s = SI()
    if s == 'Sunny':
        print('Cloudy')
    elif s == 'Cloudy':
        print('Rainy')
    else:
        print('Sunny')

solve()

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    s = input().strip()

    if s == "Sunny":
        print("Cloudy")
    elif s == "Cloudy":
        print("Rainy")
    else:
        print("Sunny")

if __name__ == "__main__":
    main()

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)


def main():
	s = input()
	t = ['Sunny', 'Cloudy', 'Rainy']
	print(t[(t.index(s)+1)%3])

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

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

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(l):
	x = l.pop()
	y = l.pop()
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	l.append(min(x,y))
	return gcd(l) if len(l) > 1 else l[0]

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

Solution (Python):
s = input()

if s == 'Sunny':
    print('Cloudy')
elif s == 'Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
import sys

stdin = sys.stdin

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

s = input()
if s == "Sunny":
    print("Cloudy")
elif s == "Cloudy":
    print("Rainy")
else:
    print("Sunny")

Solution (Python):
S = input()
if S == 'Sunny' :
    print('Cloudy')
elif S == 'Cloudy' :
    print('Rainy')
else :
    print('Sunny')

Solution (Python):

S = input()

if S =='Sunny':
    ans = 'Cloudy'
elif S == 'Cloudy':
    ans = 'Rainy'
else:
    ans = 'Sunny'
print(ans)

Solution (Python):
S = input()
if(S[0]=='S'):
    print('Cloudy')
elif(S[0]=='C'):
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
import sys
sys.setrecursionlimit(1000000)
from math import factorial, ceil, floor
from bisect import bisect_right as bsr
from operator import itemgetter as ig
from collections import defaultdict as dd
from collections import deque, Counter as cnt


args = None
INF = float("inf")
MOD = int(1e9 + 7)
def input(*ps):
    if type(ps[0]) is list:
        return [input(*ps[0][:-1]) for _ in range(ps[0][-1])]
    elif len(ps) == 1:
        return ps[0](next(args))
    else:
        return [p(next(args)) for p in ps]
def nlist(n, v):
    if not n: return [] if type(v) is list else v
    return [nlist(n[1:], v) for _ in range(n[0])]


def main():
    S = input(str)
    if S == "Sunny":
        print("Cloudy")
    elif S == "Cloudy":
        print("Rainy")
    else:
        print("Sunny")
    return

if __name__ == '__main__':
    args = iter(sys.stdin.read().split())
    main()

Solution (Python):
S = input()
if S == "Sunny":
    print("Cloudy")
elif S == "Cloudy":
    print("Rainy")
elif S == "Rainy":
    print("Sunny")

Solution (Python):
s=input()

if s=="Sunny":
  print("Cloudy")
elif s=="Cloudy":
  print("Rainy")
else:
  print("Sunny")

Solution (Python):
S = input()
if S == "Sunny":
    print("Cloudy")
elif S == "Cloudy":
    print("Rainy")
else:
    print("Sunny")

Solution (Python):
a = input()
b = {"Sunny":"Cloudy", "Cloudy":"Rainy", "Rainy":"Sunny"}
print(b[a])

Solution (Python):
s=input()
if s=='Sunny':
    print("Cloudy")
elif s=='Cloudy':
    print("Rainy")
else:
    print("Sunny")

Solution (Python):
import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
INF = float('inf')

def sol():
    S = input()
    if S[0] == 'S':
        print('Cloudy')
    elif S[0] == 'C':
        print('Rainy')
    else:
        print('Sunny')

sol()

Solution (Python):
s = input()

if(s == 'Sunny'):
    print('Cloudy')
elif(s == 'Rainy'):
    print('Sunny')
else:
    print('Rainy')

Solution (Python):
D = {
  "Sunny":"Cloudy",
  "Cloudy":"Rainy",
  "Rainy":"Sunny",
}
print(D[input()])

Solution (Python):
s=input()
if s=="Sunny":print("Cloudy")
elif s=="Cloudy":print("Rainy")
else:print("Sunny")

Solution (Python):
s = input()
if s == "Sunny":
  print("Cloudy")
elif s == "Cloudy":
  print("Rainy")
else:
  print("Sunny")

Solution (Python):
s = input()

if s == "Sunny":
  print("Cloudy")
  
elif s == "Cloudy":
  print("Rainy")
  
else:
  print("Sunny")

Solution (Python):
S = input()

if S == 'Sunny':
    print('Cloudy')
elif S == 'Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
X=["Sunny","Cloudy","Rainy"]
S=input()
for i in range(3):
    if S==X[i]:
        print(X[(i+1)%3])

Solution (Python):
S=input()
if S=="Sunny":print("Cloudy")
elif S=="Cloudy":print("Rainy")
else:print("Sunny")

Solution (Python):
S = input()
if S == "Sunny":
    print("Cloudy")
elif S == "Cloudy":
    print("Rainy")
else:
    print("Sunny")

Solution (Python):
s=input()
if s=='Sunny':
    print('Cloudy')
elif s=='Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
s = input()
if s == "Sunny":
    ans = "Cloudy"
elif s == "Cloudy":
    ans = "Rainy"
else:
    ans = "Sunny"
print(ans)

Solution (Python):
s = input()
if s == 'Sunny':
    print('Cloudy')
elif s == 'Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):



import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
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()))

s = input()
if s == 'Sunny':
    print('Cloudy')
elif s == 'Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
s=input()
if s=='Sunny':
    print('Cloudy')
elif s=='Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
S = input()

if S == "Sunny":
    print("Cloudy")
elif S == "Cloudy":
    print("Rainy")
else:
    print("Sunny")

Solution (Python):
s = input()

A = ["Sunny", "Cloudy", "Rainy"]
if s == A[0]:
    print(A[1])
elif s == A[1]:
    print(A[2])
else:
    print(A[0])

Solution (Python):
s=input()
if s[0]=="S":
	print("Cloudy")
elif s[0]=="C":
	print("Rainy")
else:
	print("Sunny")

Solution (Python):
s = input()
if s[0] == "S":
	print("Cloudy")
elif s[0] == "C":
	print("Rainy")
else:
	print("Sunny")

Solution (Python):
S = input()
if S == "Sunny":
    print("Cloudy")
elif S=="Cloudy":
    print("Rainy")
else:
    print("Sunny")

Solution (Python):
import sys
import math
from collections import defaultdict

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

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N):
    read_all = [tuple(map(int, input().split())) for _ in range(N)]
    return map(list,zip(*read_all))



S = str(input())

if S=='Sunny':
    print('Cloudy')
elif S=='Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):
a = input()
if a == 'Sunny':
    print('Cloudy')
elif a == 'Cloudy':
    print('Rainy')
else:
    print('Sunny')

Solution (Python):

import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop


def main():
    s = input()
    if s == 'Sunny':
        print('Cloudy')
    elif s == 'Cloudy':
        print('Rainy')
    else:
        print('Sunny')

if __name__ == '__main__':
    main()

Solution (Python):
s = input()

if s == "Sunny":
    print("Cloudy")
elif s == "Cloudy":
    print("Rainy")
elif s == "Rainy":
    print("Sunny")

Solution (Python):
import bisect
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7

s = ['Sunny', 'Cloudy', 'Rainy']
a = s[(s.index(input()) + 1) % 3]
print(a)

Solution (Python):
l=["Sunny", "Cloudy", "Rainy"]
s=input()
print(l[(l.index(s)+1)%3])

Solution (Python):
l = ["Sunny", "Cloudy", "Rainy", "Sunny"]
s = input()
print(l[l.index(s) + 1])