TnT/Multi_CodeNet4Repair huggingface dataset:
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):
    i = r * x - D

print(i)


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

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

print(x)


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

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

print(ans)


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

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


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

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

print(x)


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

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


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

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):
  print(int(r*x-D))

r , D, x = map(int, input().split())
for i in range(10):
    print(int(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,x,d = 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, x_2000= map(int, input().split(' '))
xs = [x_2000]
for x in range(10):
	xs.append(r*xs[len(xs)-1]-D)
print('\n'.join(map(str, xs)))

r, D, x_2000= map(int, input().split(' '))
xs = [x_2000]
for x in range(10):
	xs.append(r*xs[len(xs)-1]-D)
xs.pop(0)
print('\n'.join(map(str, xs)))

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 = int(input())
D = int(input())
x = int(input())

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

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

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

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 func(a):
    return r*func(a-1) - D

for i in range(10):
  func(x)

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

def func(a):
    return r*func(a-1) - D

for i in range(10):
  print(func(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):
n,d,x=map(int,input().split())
for i in range(10):
    x= n*x-d
print(x)

a,b,c=map(int,input().split())
ans=[c]
for i in range(10):
    ans.append(ans[i]*a-b)
    print(ans[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):
r,d,x=map(int,input().split())
for i in range(1,10):
    x=r*x-d
    print(x)


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


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):
from sys import stdin
import numpt as np

def main(args):
    r = args[0]
    d = args[1]
    x = args[2]
    ar = np.zeros([10])

    ar[0] = r*x-d
    for i in range(1,len(ar)):
        ar[i] = r*ar[i-1]-d

    for i in ar:
        print(i)

if __name__ == "__main__":
    main([int(x) for x in stdin.readline().rstrip().split()])

from sys import stdin
import numpy as np

def main(args):
    r = args[0]
    d = args[1]
    x = args[2]
    ar = np.zeros([10])

    ar[0] = r*x-d
    for i in range(1,len(ar)):
        ar[i] = r*ar[i-1]-d

    for i in ar:
        print(i)

if __name__ == "__main__":
    main([int(x) for x in stdin.readline().rstrip().split()])

from sys import stdin
import numpy as np

def main(args):
    r = int(args[0])
    d = int(args[1])
    x = int(args[2])
    ar = np.zeros([10], dtype=int)

    ar[0] = r*x-d
    for i in range(1,len(ar)):
        ar[i] = r*ar[i-1]-d

    for i in ar:
        print(i)

if __name__ == "__main__":
    main(stdin.readline().rstrip().split())

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,x2000 = map(int,raw_input().split())
xi = x2000
for i in range(1,11):
    xi = r * xi - D
    print(xi)


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

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_2000 = map(int,input().split())
for i in range(1,11):
  print((r ** i) * (x_2000 + D/(1-r)) - D/(1-r))

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

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(' '))
a = [x_2000] + [0] * 10
for i in range(1, 11):
  a[i] = r * a[i - 1] - d

for x in a:
  print(x)

r, d, x_2000 = map(int, input().split(' '))
a = [x_2000] + [0] * 10
for i in range(1, 11):
  a[i] = r * a[i - 1] - d

[print(x) for x in a]

r, d, x_2000 = map(int, input().split(' '))
a = [x_2000] + [0] * 10
for i in range(1, 11):
  a[i] = r * a[i - 1] - d
  print(a[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, x = list(map(int, input()))

x_ = [0] * 10

for i in range(10):
    if i == 0:
        x_[i] = r*x - D
    else:
        x_[i] = r*x[i-1] - D
    print(x_[i])



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

x_ = [0] * 10

for i in range(10):
    if i == 0:
        x_[i] = r*x - D
    else:
        x_[i] = r*x_[i-1] - D
    print(x_[i])



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

    if i[0] < 2 or 5 < i[0]:
        return
    if i[1] < 1 or 100 < i[1]:
        return
    if i[2] <= i[1] or i[1] > 200:
        return

    for j in range(10):
        a = i[0] * i[1] - i[2]
        print(a)
        i[2] = a 

def main():
    i = list(map(int, input().split()))

    if i[0] < 2 or 5 < i[0]:
        return
    if i[1] < 1 or 100 < i[1]:
        return
    if i[2] <= i[1] or i[1] > 200:
        return

    for j in range(10):
        a = i[0] * i[1] - i[2]
        print(a)
        i[2] = a 

if __name__ == "__main__":
    main()

def main():
    i = list(map(int, input().split()))

    if i[0] < 2 or 5 < i[0]:
        return
    if i[1] < 1 or 100 < i[1]:
        return
    if i[2] <= i[1] or i[1] > 200:
        return

    for j in range(10):
        a = i[0] * i[2] - i[1]
        print(a)
        i[2] = a 

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, x2000 = map(int, input().split())
for i in range(10):
  x2000 = r*x2000+D
  print(x2000)

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

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=input().split()
m = int(x)
for i in range(1, 10):
    m = int(r) * int(m) - int(d)
    print(int(m))

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

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

tmp = r * x - D
print(tmp)

for i in range(1 to 10):
  tmp = tmp * x - D
  print(temp)

30
50
90
170
330
650
1290
2570
5130
10250


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

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_1 = input().split()
r = int(r)
D = int(D)
x = int(X_1)
for i in range(10):
  print(str(x))
  x = r * x - D


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

r, D, X_1 = input().split()
r = int(r)
D = int(D)
x = int(X_1)
for i in range(10):
  x = r * x - D
  print(str(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):
x + 1 = rx - d

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

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

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

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

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

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

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

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


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 = int(input())
d = int(input())
x = int(input())

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)

r,d,x = map(int,input().split())
for i in range(1,11):
  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):
import numpy as np
import math

# input

r, D, x = [int(_) for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D 
    
    return xans
  
for i in range(10):
    xans[i] = Linear_Recursive(x, r, D, i+1)
    
    pritnt(x[i])
    


import numpy as np
import math

# input

r, D, x = [float() for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D 
    
    return xans
  
for i in range(10):
    xans[i] = Linear_Recursive(x, r, D, 10)
    
    pritnt(x[i])
    


import numpy as np
import math

# input

r, D, x = [int(_) for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D 
    
    return xans
  
for i in range(10):
    xans[i] = round(Linear_Recursive(x, r, D, i+1))
    
    print(xans[i])
    


import numpy as np
import math

# input

r, D, x = [int(_) for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D 
    
    return xans
  
for i in range(10):
    xans[i] = int(Linear_Recursive(x, r, D, i+1))
    
    print(xans[i])
    


import numpy as np
import math

# input

r, D, x = [int(_) for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D 
    
    return xans
  
for i in range(10):
    xans[i] = Linear_Recursive(x, r, D, i+1)
    
    print(xans[i])
    


import numpy as np
import math

# input

r, D, x = [float(_) for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D 
    
    return xans
  
for i in range(10):
    xans[i] = Linear_Recursive(x, r, D, 10)
    
    pritnt(x[i])
    


import numpy as np
import math

# input

r, D, x = [int(_) for _ in input().split()]

xans = x


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


Verdicts: Runtime Error

Runtime Error

Wrong Answer

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):
r,D,x_2000 = map(int,input().split())


X=[x_2000]
for i in range(10):
    X.append(r*X[i] - D)


print(*X,sep="\n")
    

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


X=[x_2000]
for i in range(10):
    X.append(r*X[i] - 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):
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):
a,d,x = map(int,input().split())

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

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

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

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,x_ini=map(int,input().split())
x=x_ini
for i in range(9):
    x=x*r-d
    print(x*r-d)
    


r,d,x_ini=map(int,input().split())
x=x_ini
for i in range(10):
    print(x*r-d)
    x=x*r-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())

i=1
a=r*x-D
while i<=10:
	print(a)
    a=r*a-D
	i+=1

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

c=0
while c<10:
    x=r*x-D
    print(x)
    c+=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())

a = [0]*11
a[0] = x

for i in range(1,11):
  a[i] = r*a[i-1]-D

for i in a[0:11]:
    print(i)

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

a = [0]*11
a[0] = x

for i in range(1,11):
  a[i] = r*a[i-1]-D

for i in a[1:11]:
    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):
  r = r*x-d
  print(r)

r, d, x = map(int, input().split())
for i in range(10):
  r = 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, x0 = list(map(int, input().split()))
for i in range():
  x1 = r * x - D
  x = x1
  print(x1)

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

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

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):
A = list(map(int, input().split())) 
count = 0
ans = 0

for i in range(10):
    ans = (r*f) - D 
    count = count + 1
    print(ans)
    if(count == 10):
        break


A = list(map(int, input().split())) 
r = A[0]
D = A[1]
f = A[2]


count = 0
ans = 0
 
for i in range(10):
    ans = (r*f) - D 
    count = count + 1
    print(ans)
    if(count == 10):
        break

r, D, f = map(int, input().split())
count = 0
ans = 0

for i in range(10):
    ans = (r*f) - D 
    count = count + 1
    print(ans)
    if(count = 10):
        break

A = list(map(int, input().split())) 
r = A[0]
D = A[1]
f = A[2]
 
 
count = 0
ans = 0
 
for i in range(10):
    f = (r*f) - D 
    count = count + 1
    print(f)
    if(count == 10):
        break

Verdicts: Runtime Error

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,x0=map(int,input().split())
for i in range(10):
  x0=xo*r-d
  print (x0)

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

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):
ints = input().split(' ')
r, D, x_0 = int(ints[0]), int(ints[1]), int(ints[2])

def calc(i):
	if i==2000:
		return r*x_0-D
	else:
		return r*calc(i-1)-D
for i in range(2001, 2010):
	print(calc(i))

ints = input().split(' ')
r, D, x_0 = int(ints[0]), int(ints[1]), int(ints[2])

def calc(i):
	if i==2000:
		return x_0
	else:
		return r*calc(i-1)-D
for i in range(2001, 2011):
	print(calc(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 = list(map(int, input().split()))

for i in range(1,11):
    c *= a
    e = c - b
    print(e)

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

for i in range(1,11):
    c *= a
    c -= b
    print(c)


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):
read=input
r,d,x=map(int,read()).split(' ')
for i in range(10):
  x=int(r*x-d)
  print(x)

read=input
r,d,x=map(int,read().split(' '))
for i in range(10):
  x=int(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_2000=map(int,input().split())

def Algae(r,D,x):
  weight=[]
  for _ in range(10):
    x=r*x-D
    weight.append(x)
  return weight

print("{}".format(Algae(r,D,x_2000)))

r,D,x_2000=map(int,input().split())
def Algae(r,D,x):
    weight=[]
    for _ in range(10):
        x=r*x-D
        weight.append(x)
    return weight

for i in Algae(r,D,x_2000):
    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_i = 0
for i in range(10):
  x_i = x*r-d
  print(x_i)

r, d, x = map(int,input().split())
x_i = x
for _ in range(10):
  x_i = x_i*r-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):
r,d,x=map(int,input().split())
print(x for _ in range(10) x=r*x-d)

r,d,x=map(int,input().split())
for i in range(10):
      print(r*x-d)
      x=r*x-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):
r, D, a = map(int, input().split())

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

r, D, a = map(int, input().split())
 
old = a
for i in range(10):
  print(r * old - D)
  old = r * old - 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):
r, d, x = map(int, input().strip())
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):
l=list(map(int,input().split()))
r=l[0]
D=l[1]
x=l[2]
t=[x]
for i in t:
  m=i*r-D
  t.append(m)
  if(len(t)=11):
    break
for p in t[1:]:
	print(p)


l=list(map(int,input().split()))
r=l[0]
D=l[1]
x=l[2]
t=[x]
for i in t:
  m=i*r-D
  t.append(m)
  if(len(t)==11):
    break
for p in t[1:]:
	print(p)


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 calc(r, D, x):
  return (r * x) - D

for _ in range(10):
  x = calc(r, D, x)
  print(x)

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

def calc(r, D, x):
  return (r * x) - D

for _ in range(10):
  x = calc(r, D, x)
  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,x2000 = [int(i) for i in input().split()]

print(x2000)

xi = x2000

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

r,d,x2000 = [int(i) for i in input().split()]

xi = x2000

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

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())
ans = []*11
ans[0] = x_2000
for i in range(1, 11):
    ans[i] = r * ans[i-1] - d
    print(ans[i])

r, d, x_2000 = map(int, input().split())
ans = [0]*11
ans[0] = x_2000
for i in range(1, 11):
    ans[i] = r * ans[i-1] - d
    print(ans[i])


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())
def fib(n):
  if n == 0:
    return c
  else:
    return 2 * fib(n-1) -10
  
print(fib(9))

a,b,c = map(int,input().split())
def fib(n):
  if n == 0:
    return c
  else:
    return a * fib(n-1) -b
  
for i in range(10):
  print(fib(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):
r,D,x = map(int,input().split())
i = 0
while i <= 10:
    x = r * x - D
    print(x)
    i += 1
    


# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

R, D, X = lr()
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):

import numpy as np

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

def f(i):
    global x_2000
    global D
    global r
    if i == 2000:
        print (x_2000)
        return x_2000
    temp = f(i-1)*r - D
    print (temp)
    return temp
  
    

f(2010)


# -*- coding: utf-8 -*-
"""
Created on Thu Jun  6 21:15:08 2019

@author: hisaki
"""

import numpy as np

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

def f(i):
    global x_2000
    global D
    global r
    if i == 2000:
        return x_2000
    temp = f(i-1)*r - D
    print (temp)
    return temp
  
    

f(2010)



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())
ans = []
X = x
for i in range(D):
    ans.append(X + D)
    X = ans[i]
else:
    ans.reverse()
    for i in range(D):
        print(ans[i])


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

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):
  print(x)
  x = x*r-d

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

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

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):
def func(r, x, d):
    return r * x - d

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

    lst = list()
    lst.append(x0)
    for i in range(0, 10):
        lst.append(func(r, lst[i], d))
    
    for i in range(1, 10):
        print(lst[i])
    
main()

def func(r, x, d):
    return r * x - d

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

    lst = list()
    lst.append(x0)
    for i in range(0, 10):
        lst.append(func(r, lst[i], d))
    
    for it in lst:
        if (it == x0):
            continue
        print(it)
    
main()

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())
for i in range(10):
  s1=(a*c) -b
  print(s1)
  a=s1

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

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 = x * r - d
    print(x)


r, d, x = map(int, input().split())
for _ 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 range (10):
    ans = x * r - d
    print(ans)
    x = ans

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

for i in range(10):
    ans = x * r - d
    print(ans)
    x = 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):
r,d,x = map(int,input().split())
for i in range(1,11):
  w = r*x - d
  x = w
  print(W)

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

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(1,10):
  x=r*x-d
  print(x)

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

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

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())
z=0
for i in range(11):
   x=x*r-d
   print(x)

r,d,x = map(int, input().split())
for i in range(1,11):
   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,x=int(input().split())

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

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

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



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

for i in range(10):
  x= x*r-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 = [int(i) for i in input().split()]
n=2000
while n <=2010: 
  print(x) 
  X=r*x-D
  x=X
  n=n+1
        

r,D,x = [int(i) for i in input().split()]
n=2000
X=r*x-D
x=X
while n <=2009: 
  print(x) 
  X=r*x-D
  x=X
  n=n+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 = [int(i) for i in input().split()]

print(r)


def calu(r,D,x):
    X =x
    for j in range(10):
       X = r*X-D
       print(X)

calu(r,D,x)

r,D,x = [int(i) for i in input().split()]
def calu(r,D,x):
    X =x
    for j in range(10):
       X = r*X-D
       print(X)

calu(r,D,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())
for i in range(10):
  x = r*x - D
  print(x)

r, D, x2000 = map(int, input().split())
x = x2000
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 inrange(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):
x, r, D = map(int, input().split())
for _ in range(1, 11):
  x = r*x - D
  print(x)

r, d, x = [int(i) for i in 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())
for i in range(10):
  r = r * x - D
  print(r)

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

ans = []
for i in range(10):
  x = r * x - D
  ans.append(x)

print("\n".join(str(ans)))

r, D, x = list(map(lambda a: int(a), input().split(" ")))
 
ans = []
for i in range(10):
  x = r * x - D
  ans.append(str(x))
 
print("\n".join(ans))

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(11):
  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())
print(x)
for k in range(9):
  x = r*x -d
  print(x)

r,d,x = map(int,input().split())
for k 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())

L = [x]
for i in range(1,11):
  L.append(L[i-1]*r - d)
  
for i in range(len(L)):
  print(L[i])

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

L = [x]
for i in range(1,11):
  L.append(L[i-1]*r - d)
  
L.pop(0)
for i in range(len(L)):
  print(L[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())
xs = [x]
for i in range(10):
    xs.append(xs[-1] * r - d)
print("\n".join(map(str, xs)))

r, d, x = map(int, input().split())
xs = [x]
for i in range(10):
    xs.append(xs[-1] * r - d)
print("\n".join(map(str, xs[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 = map(int,input().split())
print((x = x * r - k ) for _ in range(10))

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


r, d, x = map(int,input().split())
for _ in range(10):
    x = x * r - 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,D,x=list((map(int,input().split())))
for _ in range(20):
    x=x*r-D
    print(x)

r,D,x=list((map(int,input().split())))
for _ 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, 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: Runtime Error

Accepted