TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
#ABC127 A

A, B = map(int,input(),split())
if A >= 13:
    print(B)
elif 6 <= A <= 12:
    print(B/2)
elif A <= 5:
    print(0)

A, B = map(int,input().split())
if A >= 13:
    print(B)
elif 6 <= A <= 12:
    print(B//2)
elif A <= 5:
    print(0)

Verdicts: Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

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

if a >= 13:
	print(B)
elif a >= 6:
	print(B/2)
else:
	print(0)

a, b = [int(i) for i in input().split()]

if a >= 13:
	print(b)
elif a >= 6:
	print(int(b/2))
else:
	print(0)

Verdicts: Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
def abc127d():
    N, M = (int(s) for s in input().split(" "))
    A = sorted(list(int(s) for s in input().split(" ")))
    for i in range(0, M):
        B, C = (int(s) for s in input().split(" "))
        r = len(list(filter(lambda x: x < C, A[:B])))
        A = sorted([C for n in range(0, r)] + A[r:])
    print(sum(A))
abc127d()


def abc127a():
    A, B = (int(s) for s in input().split(" "))
    answer = int(0 if A <= 5 else B / 2 if A <= 12 else B)
    print(answer)

def main():
    abc127a()

main()


Verdicts: Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
a, b = map(int, input().split())
if a <=5:
  print(0)
elif a<= 12:
  print(a//2)
else:
  print(a)

a, b = map(int, input().split())
if a <=5:
  print(0)
elif a<= 12:
  print(b//2)
else:
  print(b)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
def main():    
    n,m = map(int,input().split())

    a_list = list(map(int,input().split()))
    total = 0

    for i in range(m):
        b,c = map(int,input().split())
        a_list.extend([c]*b)

    a_list.sort(reverse=True)
    print(sum(a_list[:n]))

if __name__ == '__main__':
    main()

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


if a<=5:
    fee = 0
elif a>=13:
    fee = b
else:
    fee = b//2

print(fee)

Verdicts: Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

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

def ferris(a, b):
    price = 0
    if a <= 5:
        price = 0
    elif a <= 12:
        price = b / 2
    else:
        price = b
        
    return price

ferris(a, b)

a, b = (int(i) for i in input().split())

def ferris(a, b):
    price = 0
    if a <= 5:
        price = 0
    elif a <= 12:
        price = b // 2
    else:
        price = b
        
    return price

ferris(a, b)

a, b = (int(i) for i in input().split())

def ferris(a, b):
    price = 0
    if a <= 5:
        price = 0
    elif a <= 12:
        price = b // 2
    else:
        price = b
        
    print(price)

ferris(a, b)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

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

if A<=5:
  print(0)
elif　A>=13:
  print(B)
else:
  print(B//2)
    

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

if A<=5:
  print(0)
elif A>=13:
  print(B)
else:
  print(B//2)
    

Verdicts: Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
# -*- coding: utf-8 -*-
def main():
    A,B = map(int,input().split())
    print(A,B)
    if 6<=A<=12:
        B = B/2
    elif 5>=B:
        B = 0
    print(int(B))
if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
def main():
    A,B = map(int,input().split())

    if 6<=A<=12:
        B = B/2
    elif A<6:
        B = 0
    print(int(B))
if __name__ == '__main__':
    main()

Verdicts: Wrong Answer

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
a,b=map(int input().split())
if a>=13:
    print(b)
elif a<=5:
    print(0)
else:
    print(b/2)
    


a,b=map(int input().split())
if a>=13:
    print(b\n)
elif a<=5:
    print(0\n)
else:
    print(b/2\n)
    

a,b=map(int,input().split())
if a>=13:
    print(b)
elif a<=5:
    print(0)
else:
    print(b//2)
    


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
N,M = map(int,input().split())
ListA = list(map(int,input().split()))
dictionary = {}
for i in range(M):
    B,C = map(int,input().split())
    dictionary[C] = B
    
ListA =  sorted(ListA)
dict_keys = sorted(dictionary.keys())
for dict_key in dict_keys:
    for i in range(dictionary[dict_key]):
        if dict_key > ListA[i]:
            ListA[i] = dict_key
        else:
            ListA[i] = ListA[i]
    ListA = sorted(ListA)
print(sum(ListA))

A,B = int(input().split())
if A <= 5:
  price = B
elif A >=6 and A <= 12:
  price = B/2
else:
  price = B
print(B)

A,B = int(input().split())
if A <= 5:
  price = B
elif A >=6 and A <= 12:
  price = B/2
else:
  price = B
print(price)


A,B = map(int,input().split())
if A <= 5:
  price = 0
elif A >=6 and A <= 12:
  price = B/2
else:
  price = B
print(int(price))


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi, who is A years old, is riding a Ferris wheel.  It costs B yen (B is an even number) to ride the Ferris wheel if you are 13 years old or older, but children between 6 and 12 years old (inclusive) can ride it for half the cost, and children who are 5 years old or younger are free of charge. (Yen is the currency of Japan.)  Find the cost of the Ferris wheel for Takahashi.

Submission attempts (in order):
r, D, x = map(int, input().split())
for i in range(10):
  x = r*x-D
  print(x)


A, B = map(int, input().split())
if A >= 13:
  print(B)
elif A >= 6:
  print(B//2)
else:
  print(0)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x=map(int,input().split())
for i in range(11):
    print(str(x))
    x = x * r - d


r,d,x=map(int,input().split())
for i in range(10):
    x = x * r - d
    print(str(x))


Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
import sys

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

for i in range(1,10):	
	print(x)
	x = a*x-b

import sys

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

x = a*c -b

for i in range(0,10):	
	print(x)
	x = a*x-b

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, d, x = map(int, input().split())
for i in range (1,11):
  x = (r*x)-d
print(x)

r, d, x = map(int, input().split())
for i in range (1,11):
  x = (r*x)-d
  print(x)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,x = map(int,input().split())
for i in range(1,11):
  print(D//(r-1)+(x-D//(r-1))*r**(i-2000))

r,D,x = map(int,input().split())
for i in range(1,11):
  print(int(D/(r-1)+(x-D/(r-1))*r**i))

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):

r,d,x_2000=map(int,input().split())

def X(n):    
    if n == 1:return x_2000
    else:return r*X(n-1)-d
print([X(n) for n in range(2,12)])


r,d,x_2000=map(int,input().split())

def X(n):    
    if n == 1:return x_2000
    else:return r*X(n-1)-d
lis=[X(n) for n in range(2,12)]
[print(i) for i in lis]

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x=map(int,input().split())
for i in range(10):
  print(x)
  x=x*r-d

r,d,x=map(int,input().split())
for i in range(10):
  x=x*r-d
  print(x)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x2000 = map(int, input().split())
x = [x2000]
for i in range(11):
        x.append(r*x[i]-D)
        print(x[i])

r, D, x2000 = map(int, input().split())
x = [x2000]
for i in range(10):
        x.append(r*x[i]-D)
        print(x[i+1])

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
x,D,xx=map(int,input().split())
for i for range(10):
  xx = x*xx-D
  print(xx)

x,D,xx=map(int,input().split())
for i in range(10):
  xx = x*xx-D
  print(xx)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x=map(int,input().split())
def algae(n):
    if n==1:
        return x
    else:
        return r*algae(n-1)-d
for i in range(2,12):
    algae(i)

from functools import lru_cache

r,d,x=map(int,input().split())
@lru_cache(maxsize=100)
def algae(n):
    if n==1:
        return x
    else:
        return r*algae(n-1)-d
for i in range(2,12):
    print(algae(i))

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

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

for i in range(10):
  x += r*x - d
  printx(x)
  

r,d,x = map(int, input().split())

for i in range(10):
  x += r*x - D
  printx(x)
  

r,d,x = map(int, input().split())

count = 0
while count < 11:
  x = r*x-d
  print(x)
  count += 1
  

r,d,x = map(int, input().split())

count = 0
while count < 10:
  x = r*x-d
  print(x)
  count += 1
  

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = int(input().split())
for i in range(10):
	x = r * x - d
	print(x)

r,d,x = map(int, input().split())
for i in range(10):
	x = r * x - d
	print(x)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,X = map(int, input().split())
ope_num = 10

while ope_num > 10:
  X = r*X -D
  print(X)
  
  ope_num -= 1

r,D,X = map(int, input().split())
ope_num = 10

while ope_num > 0:
  X = (r * X) - D
  print(X)
  
  ope_num -= 1

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,x_2000=map(int, input().split())

def calc(x):
    if x==2000:
        ans=x_2000
    else:
        ans=r*calc(x-1)-D
    return ans

for i in range(2000,2011):
  ans2=calc(i)
  print(ans2)

r,D,x_2000=map(int, input().split())

def calc(x):
    if x==2000:
        ans=x_2000
    else:
        ans=r*calc(x-1)-D
    return ans

for i in range(2001,2011):
  ans2=calc(i)
  print(ans2)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r D x = map(int, input.split())
for i in range(10):
  x = r * x - D
  print(x)

r, D, x = map(int, input().split())
for i in range(10):
  x = r * x - D
  print(x)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
import sys
input = sys.stdin.readline

def main():
    r, D, x = [int(x) for x in input().split()]
    next_year = x
    for _ in range(10):
        next_year = r * next_year - D


if __name__ == '__main__':
    main()



import sys
input = sys.stdin.readline

def main():
    r, D, x = [int(x) for x in input().split()]
    next_year = x
    for _ in range(10):
        next_year = r * next_year - D


if __name__ == '__main__':
    main()



import sys
input = sys.stdin.readline

def main():
    r, D, x = [int(x) for x in input().split()]
    next_year = x
    for _ in range(10):
        next_year = r * next_year - D
        print(next_year)


if __name__ == '__main__':
    main()



Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x = map(int, ainput().split())
for i in range(1, 11):
    x = r * x - D
    print(x)


r, D, x = map(int, input().split())
for i in range(1, 11):
    x = r * x - D
    print(x)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = map(int,input().split())
for i in range(10)
    x = r * x - d
    print(x)

r,d,x = map(int,input().split())
for i in range(10):
    x = r * x - d
    print(x)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
def main():
  x=[]
  r,D,X=map(int,input().split())
  x.append(X)
  for i in range(1:11):
    x.append(r*x[i-1]-D)
    print(x[i])
main()

def main():
  r,D,X_2000=map(int,input().split())
  x=[]
  x.append(X_2000)
  for i in range(1:11):
    x.append(r*x[i-1]-D)
    print(x[i])
main()

def main():
  r,D,X_2000=map(int,input().split())
  x=[]
  x.append(X_2000)
  for i in range(1:11):
    x[i]=r*x[i-1]-D
    x.append(x[i])
    print(x[i])
main()

  

def main():
  r,D,X_2000=map(int,input().split())
  x=[]
  x.append(X_2000)
  for i in range(1,11):
    x.append(r*x[i-1]-D)
    print(x[i])
main()

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = map(int,input())

for i in range(10):
  x = r*x - d
  print(r)

r,d,x = map(int,input().split())
 
for i in range(10):
  x = r*x - d
  print(r)

r,d,x = map(int,input().split())
 
for i in range(10):
  x = r*x - d
  print(x)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,x = map(int,input().split())
for i in range(9):
  x = r * x -D
  print(x)

r,D,x = map(int,input().split())
for i in range(10):
  x = r * x -D
  print(x)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, d , x = map(int, input().split())
cnt = 0
print(x)
while cnt <= 10:
    x = r * x - d
    print(r * x - d)
    cnt += 1

r, d , x = map(int, input().split())
cnt = 0
print(x)
while cnt <= 8:
    x = r * x - d
    print(r * x - d)
    cnt += 1

r, d , x = map(int, input().split())
cnt = 0
print(r * x - d)
while cnt <= 8:
    x = r * x - d
    print(r * x - d)
    cnt += 1

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = map(int,input().split())
for i in range(10):
    x = r*x-d
print(x)


r,d,x = map(int,input().split())
for i in range(10):
    print(r*x-d)
    x = r*x-d

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x = map(int,input().split())
dp = [0]*11
dp[0]=x
for i in range(10):
  dp[i+1] = r*dp[i] - D
  
print(dp[-1])

r, D, x = map(int,input().split())
dp = [0]*11
dp[0]=x
for i in range(10):
  dp[i+1] = r*dp[i] - D
  
print(*dp[1:], sep = "\n")


Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x = map(int, input().split())
def mo(r, D, x, i):
  out = rx - D
  print(int(out))
  if i<9:
  	return mo(r, D, out, i+1)
  else:
    return 0
  
  mo(r, D, x, 0)

r, D, x = map(int, input().split())
def mo(r, D, x, i):
  out = r*x - D
  print(int(out))
  if i<9:
  	return mo(r, D, out, i+1)
  else:
    return 0
  
mo(r, D, x, 0)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):

tmp = [int(el) for el in input().split(' ')]
r = tmp[0]
d = tmp[1]
X = [0 for i in range(11)]
X[0] = tmp[2]

print(r, d, X[0])

for i in range(1, 11):
    X[i] = r*X[i-1] - d
    print(X[i])



tmp = [int(el) for el in input().split(' ')]
r = tmp[0]
d = tmp[1]
X = [0 for i in range(11)]
X[0] = tmp[2]


for i in range(1, 11):
    X[i] = r*X[i-1] - d
    print(X[i])


Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
import sys
r, D, x2000 = map(int, sys.stdin.readline().split())
x2001 = r * x2000 - D
x2002 = r * x2001 - D
x2003 = r * x2002 - D
x2004 = r * x2003 - D
x2005 = r * x2004 - D
x2006 = r * x2005 - D
x2007 = r * x2006 - D
x2008 = r * x2007 - D
x2009 = r * x2008 - D
x2010 = r * x2009 - D
print(x2001)
print(x2002)
print(x2003)
print(x2004)
print(x2005)
print(x2006)
print(x2007)
print(x2008)
print(x2009)
print(x20010)

import sys
r, D, x2000 = map(int, sys.stdin.readline().split())
x2001 = r * x2000 - D
x2002 = r * x2001 - D
x2003 = r * x2002 - D
x2004 = r * x2003 - D
x2005 = r * x2004 - D
x2006 = r * x2005 - D
x2007 = r * x2006 - D
x2008 = r * x2007 - D
x2009 = r * x2008 - D
x2010 = r * x2009 - D
print(x2001)
print(x2002)
print(x2003)
print(x2004)
print(x2005)
print(x2006)
print(x2007)
print(x2008)
print(x2009)
print(x2010)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,x=map(int,input().split())
for i in range(10):
   x=r*x-D
    print(x)

r,D,x=map(int,input().split())
for i in range(10):
  x=r*x-D
  print(x)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x=map(int,input().split())
for i range(10):
  x=rx-d
  print(x)

r,d,x=map(int,input().split())
for i range(10):
  x=r*x-d
  print(x)

r,d,x=map(int,input().split())
for i in range(10):
  x=r*x-d
  print(x)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,t,x=map(int,input().split())
print(a=r*x-t)
print(b=r*a-t)
print(c=r*b-t)
print(d=r*c-t)
print(e=r*d-t)
print(f=r*e-t)
print(g=r*f-t)
print(h=r*g-t)
print(i=r*h-t)
print(j=r*i-t)


r,t,x=map(int,input().split())
a=r*x-t
b=r*a-t
c=r*b-t
d=r*c-t
e=r*d-t
f=r*e-t
g=r*f-t
h=r*g-t
i=r*h-t
j=r*i-t
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
print(i)
print(j)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
a,b,c=map(int,input().split())
for in range(10):
  print(a*c-b)
  b=(a*c-b)

a,b,c=map(int,input().split())
for i in range(10):
  print(a*c-b)
  c=(a*c-b)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
A, B = map(int, input().split())
if A >= 13:
    print(B)
elif A >= 6:
    print(B//2)
else:
    print(0)

r, D, x = map(int, input().split())
for i in range(10):
    x = r*x - D
    print(x)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
x=input()
xx=x.split()
r=int(xx[0])
x2=int(xx[1])
D=int(xx[2])
y=[0]*10
for i in range(10):
  y[i]+=r*x2-D
  print(y[i])
  x2=y[i]

x=input()
xx=x.split()
r=int(xx[0])
x=int(xx[1])
D=int(xx[2])
y=[0]*10
for i in range(10):
  y[i]+=r*x-D
  print(y[i])
  x=y[i]

x=input()
xx=x.split()
r=int(xx[0])
D=int(xx[1])
x2=int(xx[2])
y=[0]*10
for i in range(10):
  y[i]+=r*x2-D
  print(y[i])
  x2=y[i]

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,x2000 = map(int, input().split())
next_value = algae(x2000)
for i in range(10):
    
    print(next_value)
    next_value = algae(next_value)

r,D,x2000 = map(int, input().split())
def algae(x2000):
    
        ans = r * x2000 - D
        #new_ans = algae(r, D, ans)
        
        return ans
      
next_value = algae(x2000)
for i in range(10):
    print(next_value)
    next_value = algae(next_value)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,X=map(int,input().split())
x=[X]
for i in range(10):
    x.append(r*x[i]-d)
del x[0]
print(x)
for i in range(len(x)):
    print(x[i])

r,d,X=map(int,input().split())
x=[X]
for i in range(10):
    x.append(r*x[i]-d)
del x[0]
#print(x)
for i in range(len(x)):
    print(x[i])

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
s = input.split()
r = int(s[0])
D = int(s[1])
x = int(s[2])

for i in range(10):
    x = r * x - D
    print(x)

r = int(input())
D = int(input())
x = int(input())

for i in range(10):
    x = r * x - D
    print(x)

s = input().split()
r = int(s[0])
D = int(s[1])
x = int(s[2])

for i in range(10):
    x = r * x - D
    print(int(x))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, d, x = list(map(int, input().split()))

for i in range(10):
  x = r * x - d

print(x)

r, d, x = list(map(int, input().split()))
for i in range(10):
  x = r * x - d
  print(x)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x0 = map(int,input().split())

xlist = []

xlist.append(r*x0-d)

for i in range(9):
    xlist.append(r*xlist[i]-d)
    print(xlist[i])




r,d,x0 = map(int,input().split())

xlist = []

xlist.append(r*x0-d)

for i in range(10):
    xlist.append(r*xlist[i]-d)
    map(int,xlist)
    print(xlist[i])




Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
d=c
while i<10:
d=a*d-b
print(d)
i=i+1

a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
i=0
while i<10:
  i=i+1
  c=a*c-b
  print(c)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = map(int, input().split())
for i in range(10):
  x =r*x-d
print(x)

r,d,x = map(int, input().split())
for i in range(10):
  x =r*x-d
  print(x)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):

r,D,x2000 = list(map(int, input().split()))

for i in  range(10):
    new =  r *x - D
    print(new)
    x = new



r,D,x2000 = list(map(int, input().split()))

for i in  range(10):
    new =  r *x2000 - D
    print(new)
    x = new


r,D,x = list(map(int, input().split()))

for i in  range(10):
    new =  r *x - D
    print(new)
    x = new


Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
s=list(map(int,input()))
for i in range(10):
  s[2]=s[0]*s[2]-s[1]
  print(s[2])


s=list(map(int,input().split()))
for i in range(10):
  s[2]=s[0]*s[2]-s[1]
  print(s[2])


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x = [int(i) for i in input().split()]
i = 1
whie i<=10:
  x = r*x - D
  print(X)
  i += 1	

  

r, D, x = [int(i) for i in input().split()]
i = 1
while i<=10:
  x = r*x - D
  print(x)
  i += 1	


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

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

for i in range(10):
  x = r*x-d
  print(x)


r,d,x = map(int,input().split())

for i in range(10):
  x = r*x-d
  print(x)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
arr = input.split()
r = int(arr[0])
d = int(arr[1])
x = int(arr[2])

for i in range(0,10):
  x = r*x - d
  print(x)

arr = input().split()
r = int(arr[0])
d = int(arr[1])
x = int(arr[2])

for i in range(0,10):
  x = r*x - d
  print(x)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, d, start = map(int,input().split())
X = [start]
for i in range(10):
    X.append(r*X[-1]-d)
print(*X,sep="\n")

r, d, start = map(int,input().split())
X = [start]
for i in range(10):
    X.append(r*X[-1]-d)
print(*X[1:],sep="\n")

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
a,b, c = map(int, input().split())
now = 0
for num in range(10):
    now = a*c -b
    print(now)

	a,b, c = map(int, input().split())
    now = 0
    for num in range(10):
        if num == 0:
            now = a * c -b
        else:
            now = a * now -b
        print(now)

    a,b, c = map(int, input().split())
    now = 0
    for num in range(10):
        if num == 0:
            now = a * c -b
        else:
            now = a * now -b
        print(now)

a,b, c = map(int, input().split())
now = 0
for num in range(10):
    if num == 0:
        now = a * c -b
    else:
        now = a * now -b
    print(now)

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = map(int,input().split())
ansl =[x]
for i in range(10):
  ans = r*ansl[i] - d
  print(ans)

r,d,x = map(int,input().split())
ansl =[x]
for i in range(10):
  ans = r*ansl[i] - d
  print(ans)
  ansl.append(ans)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
N, M = map(int, input().split())
lmax = 0
rmin = 10**5
for i in range(M):
    L, R = map(int, input().split())
    lmax = max(lmax, L)
    rmin = min(rmin, R)
ans = rmin - lmax
if ans >= 0:
    print(ans + 1)
else:
    print(0)

R, D, X = map(int, input().split())
for i in range(10):
    X = X*R - D
    print(X)

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

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

for i in range(10):
    x = r*x-d
    print(xi)


r, d, x = map(int, input().split())

for i in range(10):
    x = r*x-d
    print(x)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x = map(int, input().split())
ansLst = [0] * 10
print(ansLst)
ansLst[0] = int((r * x) - D)
for i in range(1, 10):
    ansLst[i] = int((ansLst[i - 1] * r) - D)
for i in ansLst:
    print(i)

r, D, x = map(int, input().split())
ansLst = [0] * 10

ansLst[0] = int((r * x) - D)
for i in range(1, 10):
    ansLst[i] = int((ansLst[i - 1] * r) - D)
for i in ansLst:
    print(i)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, D, x = map(int, input().split())
x_list = [x]

def f(x):
    x_list.append(r * x_list[i-1] - D)
    return 

for i in range(1,11):
    f(i)

for i in x_list:
    print(i) 

r, D, x = map(int, input().split())
x_list = [x]

def f(x):
    x_list.append(r * x_list[i-1] - D)
    return 

for i in range(1,11):
    f(i)

for i in x_list[1:]:
    print(i) 

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

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

for i in range(10) :
  x = r*x + D
  print(x)


r, D, x = map(int, input().split())

for i in range(10) :
  x = rx + D
  print(x)

r, D, x = map(int, input().split())

for i in range(10) :
  x = r*x - D
  print(x)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,D,x_2000=map(int,input().split())
List=[x_2000]
for i in range(10):
  List.append(List[i]*r-D)
  
for j in range(1,10):
  print(List[j])

r,D,x_2000=map(int,input().split())
List=[x_2000]
for i in range(15):
  y=List[i]*r-D
  List.append(y)
  
for j in range(1,10):
  print(List[j])



r,D,x_2000=map(int,input().split())
x=[x_2000]
for i in range(10):
  y=List[i]*r-D
  List.append(y)
  print(List[i+1])



r,D,x_2000=map(int,input().split())
x=[x_2000]
for i in range(10):
  y=x[i]*r-D
  x.append(y)
  print(x[i+1])



Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
print()
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream.



import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 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 input()

def main():
    r, D, x = LI()
    for i in range(10):
        x = r * x - D
        print(x)
    return


main()

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,x,d = map(int, input().split())
for i in range(10):
  x = x* r - d
  print(x)
  

r, d, x = map(int, input().split())
for i in range(10):
	x = r * x - d
    print(x)

r, d, x = map(int, input().split())
for i in range(10):
    x = r * x - d
    print(x)



Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

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

r = int(str[0])
D = int(str[1])
x2000 = int(str[2])

for i in range(10):
  print(x2000 = (r*x2000-D))
  

str = input().split()

r = int(str[0])
D = int(str[1])
x2000 = int(str[2])

for i in range(10):
  print(r*x2000-D)
  x2000 = r*x2000-D
  

Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
def spaceinput():
    return list(map(int,input().split(" ")))

r,D,xx=spaceinput()

for i in range(11):
    print(xx)
    xx=xx*r-D



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

r,D,xx=spaceinput()

for i in range(10):
    
    xx=xx*r-D
    print(xx)



Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r, d, x = map(int, input().split())
for _ in range(10):
  x = r * x -d
print(x)


r, d, x = map(int, input().split())
for _ in range(10):
  x = r * x -d
  print(x)

Verdicts: Wrong Answer

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x=map(int,input().split())
for i in range(10)
  x=r*x-d
  print(x)


r,d,x=map(int,input().split())
for i in range(10):
  x=r*x-d
  print(x)


Verdicts: Runtime Error

Accepted
Problem: The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000, the following formula holds:    * x_{i+1} = rx_i - D  You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print them in order.

Submission attempts (in order):
r,d,x = map(int,input().split())
p = []
for i in range(10):
    x = r * x - d
    p[i] = x

for i in range(10):
    print(p[i])

r,d,x = map(int,input().split())
p = []
for i in range(10):
    x = r * x - d
    p.append(x)

for i in range(10):
    print(p[i])

Verdicts: Runtime Error

Accepted