TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
import sys
inputs = sys.stdin.readline
N, M = map(int,inputs().split())
K = [None]*M
for t in range(M):
	x, y, z = map(int,inputs().split())
	K[t] = (x, y)
c = 0

U = [0]*(N+1)

for k in K:
	if U[k[0]] and U[k[1]]:
		a = U[k[0]]
		while(U[a] != a ):
			a = U[a]
		U[k[1]] = a
	elif U[k[1]]:
		U[k[0]] = U[k[1]]
	elif U[k[0]]:
		U[k[1]] = U[k[0]]
	else:
		U[k[0]] = k[0]
		U[k[1]] = k[0]

ans = 0
c = 0
group = set()
for n in range(1,N+1):
	print(n,U[n])
	if U[n] == 0:
		ans += 1
		continue
	elif n == U[n]:
		ans += 1
		group.add(U[n])
	elif U[n] in group:
		continue
	else:
		while(n != U[n] and U[n] not in group):
			group.add(U[n])
			n = U[n]
		group.add(U[n])
print(ans)

import sys
inputs = sys.stdin.readline
N, M = map(int,inputs().split())
K = [None]*M
for t in range(M):
	x, y, z = map(int,inputs().split())
	K[t] = (x, y)
c = 0

U = [0]*(N+1)

for k in K:
	if U[k[0]] and U[k[1]]:
		a = U[k[0]]
		while(U[a] != a ):
			a = U[a]
		U[k[1]] = a
	elif U[k[1]]:
		U[k[0]] = U[k[1]]
	elif U[k[0]]:
		U[k[1]] = U[k[0]]
	else:
		U[k[0]] = k[0]
		U[k[1]] = k[0]

ans = 0
group = set()
for u in U[1:]:
	if u == 0:
		ans += 1
		continue
	elif u == U[u]:
		ans += 1
		group.add(u)
	elif u in group:
		group.add(u)
		continue
	else:
		while(u != U[u] and u not in group):
			group.add(u)
		group.add(u)
print(ans)

import sys
inputs = sys.stdin.readline
N, M = map(int,inputs().split())
K = [None]*M
for t in range(M):
	x, y, z = map(int,inputs().split())
	K[t] = (x, y)
c = 0

U = [0]*(N+1)

for k in K:
	if U[k[0]] and U[k[1]]:
		a = U[k[0]]
		b = U[k[1]]
		while(U[a] != a ):
			a = U[a]
		while(U[b] != b ):
			c = b
			b = U[b]
			U[c] = a
		U[b] = a
	elif U[k[1]]:
		U[k[0]] = U[k[1]]
	elif U[k[0]]:
		U[k[1]] = U[k[0]]
	else:
		U[k[0]] = k[0]
		U[k[1]] = k[0]

ans = 0
c = 0
group = set()
for n in range(1,N+1):
	if U[n] == 0:
		ans += 1
		continue
	elif n == U[n]:
		ans += 1
		group.add(U[n])
	elif U[n] in group:
		continue
	else:
		while(n != U[n] and U[n] not in group):
			group.add(U[n])
			n = U[n]
		group.add(U[n])
print(ans)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
class UnionFind:
	def __init__(self, n):
		self.par = [i for i in range(n)]  
		self.rank = [1] * n  
		self.size = [1] * n  

	def find(self, x):
		if self.par[x] == x:
			return x
		else:
			return self.find(self.par[x])

	def unite(self, x, y):
		x = self.find(x)
		y = self.find(y)
		if x != y:
			if self.rank[x] < self.rank[y]:
				self.par[x] = y
				self.size[y] += self.size[x]
			else:
				self.par[y] = x
				self.size[x] += self.size[y]
				if self.rank[x] == self.rank[y]:
					self.rank[x] += 1

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def group_size(self, x):
		return self.size[self.find(x)]

N, M = map(int, input().split())
X, Y, Z = [0] * M, [0] * M, [0] * M
for i in range(M):
	X[i], Y[i], Z[i] = map(int, input().split())

uf = UnionFind(N)

for j in range(M):
	uf.unite(X[j] - 1, Y[j] - 1)

ans = 0
root = []
for k in range(M):
	tmp = uf.find(X[k])
	if tmp not in root:
		ans += 1
		root.append(tmp)
print(ans)


class UnionFind:
	def __init__(self, n):
		self.par = [i for i in range(n)]  
		self.rank = [1] * n  
		self.size = [1] * n  

	def find(self, x):  
		if self.par[x] == x:
			return x
		else:
			return self.find(self.par[x])

	def unite(self, x, y):  
		x = self.find(x)
		y = self.find(y)
		if x != y:
			if self.rank[x] < self.rank[y]:
				self.par[x] = y
				self.size[y] += self.size[x]
			else:
				self.par[y] = x
				self.size[x] += self.size[y]
				if self.rank[x] == self.rank[y]:
					self.rank[x] += 1

N, M = map(int, input().split())
X, Y, Z = [0] * M, [0] * M, [0] * M
for i in range(M):
	X[i], Y[i], Z[i] = map(int, input().split())

uf = UnionFind(N)

for j in range(M):
	uf.unite(X[j] - 1, Y[j] - 1)

roots = set([])
for k in range(N):
	roots.add(uf.find(k))
print(len(roots))


Verdicts: Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):

class UnionFind(object):
 
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0 for i in range(n)]
        self.size=[1 for i in range(n)]
 
    def find(self, x):
  
        if self.par[x] == x:
            return x
        else:
            self.par[x]=self.find(self.par[x])
            return self.par[x]
        
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x]+=self.size[y]
            
    def same(self, x, y):
        return self.find(x) == self.find(y)
    
    def tree_size(self,x):
        return self.size[self.find(x)]
    
def main():
    n,m = map(int, input().split())
    uf = UnionFind(n)
    for i in range(m):
        x,y,z = map(int, input().split())
        uf.union(x,y)
    res = n
    for i in range(n):
        if uf.par[i] == i:
            res -= 1
    print(res)

if __name__ == '__main__':
    main()


class UnionFind(object):
 
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0 for i in range(n)]
        self.size=[1 for i in range(n)]
 
    def find(self, x):
  
        if self.par[x] == x:
            return x
        else:
            self.par[x]=self.find(self.par[x])
            return self.par[x]
        
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x]+=self.size[y]
            
    def same(self, x, y):
        return self.find(x) == self.find(y)
    
    def tree_size(self,x):
        return self.size[self.find(x)]
    
def main():
    n,m = map(int, input().split())
    uf = UnionFind(n)
    for i in range(m):
        x, y, z = map(int, input().split())
        x -= 1
        y -= 1
        if not uf.same(x,y):
            uf.union(x,y)
    res = 0
    for i in range(n):
        if uf.par[i] == i:
            res += 1
    print(res)

if __name__ == '__main__':
    main()

Verdicts: Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
def union_find():
    
    def get_parent(node):
        if par[node] == -1:
            return node
        else:
            par[node] = get_parent(par[node])
            return par[node]

    def merge(i, j):
        i = get_parent(i)
        j = get_parent(j)
        if i != j:
            par[j] = i
        return

    n, m = map(int, input().split())
    xy = [list(map(int, input().split())) for _ in range(m)]
    par = [-1] * n
    for x, y in xy:
        merge(x-1, y-1)
    print(par.count(-1))


union_find()

N,M = map(int,input().split())
xy = [list(map(int,input().split())) for _ in range(M)]
par = [-1] * N

def get_parent(n):
  if par[n] == -1:
    return n
  else:
    par[n] = get_parent(par[n])
    return par[n]

  def merge(i,j):
    i = get_parent(i)
    j = get_parent(j)
    if i != j:
      par[j] = i
      return

    for x, y in xy:
      merge(x-1, y-1)

      print(par.count(-1))

def union_find():
    
    def get_parent(node):
        if par[node] == -1:
            return node
        else:
            par[node] = get_parent(par[node])
            return par[node]

    def merge(i, j):
        i = get_parent(i)
        j = get_parent(j)
        if i != j:
            par[j] = i
        return

    n, m = map(int, input().split())
    xyz = [list(map(int, input().split())) for _ in range(m)]
    par = [-1] * n
    for x, y, z in xyz:
        merge(x-1, y-1)
    print(par.count(-1))

union_find()

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
class UnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0] * (n)

    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

n,m=map(int,input().split())
U=UnionFind(n)

for i in range(m):
  x,y,z=map(int,input().split())
  U.union(x-1,y-1)
ans=0
for i,j in enamurate(U.par):
  if i==j:
    ans+=1
print(ans)


class UnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0] * (n)

    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

n,m=map(int,input().split())
U=UnionFind(n)

for i in range(m):
  x,y,z=map(int,input().split())
  U.union(x-1,y-1)
ans=0
for i,j in ensmurate(U.par):
  if i==j:
    ans+=1
print(ans)


class UnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0] * (n)

    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

n,m=map(int,input().split())
U=UnionFind(n)

for i in range(m):
  x,y,z=map(int,input().split())
  U.union(x-1,y-1)
ans=0
for i,j in enumerate(U.par):
  if i==j:
    ans+=1
print(ans)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
def find(x):
    if x == par[x]:
        return x
    par[x] = find(par[x])
    return par[x]

def union(x,y):
    x,y = find(x),find(y)
    if x == y:
        return
    par[y] = x

n,m = map(int,input().split())
par = {i:i for i in range(1,n+1)}
for _ in range(m):
    a,b,c = map(int,input().split())
    union(a,b)
print(len(set(par.values()))

def find(x):
    if x == par[x]:
        return x
    par[x] = find(par[x])
    return par[x]
 
def union(x,y):
    x,y = find(x),find(y)
    if x == y:
        return
    par[y] = x
 
n,m = map(int,input().split())
par = {i:i for i in range(1,n+1)}
for _ in range(m):
    a,b,c = map(int,input().split())
    union(a,b)
print(sum([1 for i in range(1,n+1) if par[i] == i]))

Verdicts: Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
class UnionFind:
    def __init__(self, num):
        self.rank = [0] * num
        self.par = [i for i in range(num)]
        self.n = num
 
    def find_root(self, node):
        if self.par[node] == node:
            return node
        else:
            self.par[node] = self.find_root(self.par[node])
            return self.par[node]
 
    def same_root(self, x, y):
        return self.find_root(x) == self.find_root(y)
 
    def union(self, x, y):
        x = self.find_root(x)
        y = self.find_root(y)
        if x == y:
            return
        if self.rank[x] > self.rank[y]:
            self.par[y] = x
        else:
            self.par[x] = y
            if self.rank[x] == self.rank[y]:
                self.rank[y] += 1


N,M = map(int,input().split())

UF = UnionFind(N)
for i in range(M) :
    x,y,z = map(int,input().split())
    x -= 1
    y -= 1
    UF.union(x, y)

ans = 0
for i in range(N) :
    if i == UF.par[i] :
        continue
    else :
        ans += 1
print(ans)


class UnionFind:
    def __init__(self, num):
        self.rank = [0] * num
        self.par = [i for i in range(num)]
        self.n = num
 
    def find_root(self, node):
        if self.par[node] == node:
            return node
        else:
            self.par[node] = self.find_root(self.par[node])
            return self.par[node]
 
    def same_root(self, x, y):
        return self.find_root(x) == self.find_root(y)
 
    def union(self, x, y):
        x = self.find_root(x)
        y = self.find_root(y)
        if x == y:
            return
        if self.rank[x] > self.rank[y]:
            self.par[y] = x
        else:
            self.par[x] = y
            if self.rank[x] == self.rank[y]:
                self.rank[y] += 1


N,M = map(int,input().split())

UF = UnionFind(N)
for i in range(M) :
    x,y,z = map(int,input().split())
    x -= 1
    y -= 1
    UF.union(x, y)

ans = sum([1 if i == UF.par[i] else 0 for i in range(N)])
print(ans)


Verdicts: Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
import numpy as np
import sys
from collections import deque

input = sys.stdin.readline
def dfs(start, G):
    stack = deque()
    stack.append(start)
    visited = [0]*len(G)
    while stack:
        label = stack.pop()
        visited[label-1]= 1
        for i in G[label-1]:
          if not visited[i-1]:
            #visited[label-1]= 1
            stack.append(i)
    return visited    
 
N, M =map(int, input().split())
G  = [[] for _ in range(N)]
for i in range(M):
    a,b ,_= map(int, input().split())
    G[a-1].append(b)
    G[b-1].append(a)
 
count = 0

 
print(count)

import sys
sys.setrecursionlimit(10**5+10)
input = sys.stdin.readline
def dfs(v,G,visit):
    visit[v-1]=1    
    for next in G[v-1]:        
        if visit[next-1]:
            continue
        _ = dfs(next,G,visit) 
 
N, M =map(int, input().split())
G  = [[] for _ in range(N)]
for i in range(M):
    a,b ,_= map(int, input().split())
    G[a-1].append(b)
    G[b-1].append(a)
    
count = 0

visit = [0]*N
for i in range(1,N+1):
  if visit[i-1]:
    continue
  if G[i-1]:  
    _ = dfs(i,G,visit)
  else:
    visit[i-1] = 1
  count += 1

print(count)

Verdicts: Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
class UnionFind:
    def __init__(self,n):
        self.parent=[i for i in range(n)]
        self.rank=[0 for _ in range(n)]

    def find(self,x):
        if self.parent[x]==x:
            return x
        else:
            rootx=self.find(self.parent[x])
            self.parent[x]=rootx
            return rootx

    def union(self,x,y):
        rootx=self.find(x)
        rooty=self.find(y)
        if self.rank[rootx]<self.rank[rooty]:
            self.parent[rootx]=rooty
        else:
            self.parent[rooty]=rootx
            if self.rank[rootx]==self.rank[rooty]:
                self.rank[rootx]+=1

n,m=map(int,input().split())
xyz=[list(map(int,input().split())) for _ in range(m)]
uf=UnionFind(n)
for x,y,z in xyz:
    x,y=x-1,y-1
    uf.union(x,y)


for i in range(n):
    uf.find(n)
print(len(set(uf.parent)))

class UnionFind:
    def __init__(self,n):
        self.parent=[i for i in range(n)]
        self.rank=[0 for _ in range(n)]

    def find(self,x):
        if self.parent[x]==x:
            return x
        else:
            rootx=self.find(self.parent[x])
            self.parent[x]=rootx
            return rootx

    def union(self,x,y):
        rootx=self.find(x)
        rooty=self.find(y)
        if self.rank[rootx]<self.rank[rooty]:
            self.parent[rootx]=rooty
        else:
            self.parent[rooty]=rootx
            if self.rank[rootx]==self.rank[rooty]:
                self.rank[rootx]+=1

n,m=map(int,input().split())
xyz=[list(map(int,input().split())) for _ in range(m)]
uf=UnionFind(n)
for x,y,z in xyz:
    x,y=x-1,y-1
    uf.union(x,y)


for i in range(n):
    uf.find(i)
print(len(set(uf.parent)))

Verdicts: Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
class UnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n+1)]
        self.rank = [0] * (n+1)

    
    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

    
    def same_check(self, x, y):
        return self.find(x) == self.find(y)
      
      
uf = UnionFind()
n, m = map(int,input().split())
for i in range(m):
  x, y, z = map(int,input().split())
  uf.union(x,y)
  
  
a = [0]*n
for i in range(n):
  a[uf.find[i]] += 1
  
print(n-a.count('0'))
  

n, m = map(int,input().split())

par = [i for i in range(n+1)]
rank = [0] * (n+1)

def find(x):
  if par[x] == x:
    return x
  return find(par[x])

def unite(x,y):
  root_x = find(x)
  root_y = find(y)
  if rank[root_x] != rank[root_y]:
    par[min(root_x,root_y)] = max(root_x,root_y)
  else:
    par[root_y] = root_x
    rank[root_x] += 1


for i in range(m):
  x, y, z = map(int,input().split())
  unite(x,y)
  
roo = [-1]

for i in range(n):
  roo.append(find(i+1))

print(len(set(roo))-1)

Verdicts: Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
# 2019/10/10

class unionfind():
    def __init__(self,n):
        self.par=list(range(n+1))
        self.rank=[0]*(n+1)
    
    def find(self,x):
        if self.par[x]==x:
            return x
        else:
            self.par[x]=self.find(self.par[x])
            return self.par[x]
    
    def is_same(self,x,y):
        return self.find(x)==self.find(y)
    
    def unite(self,x,y):
        x=self.find(x)
        y=self.find(y)
        if self.rank[x]<self.rank[y]:
            self.par[x]=y
        else:
            self.par[y]=x
            if self.rank[x]==self.rank[y]:
                self.rank[x]+=1

n,m=map(int,input().split())

uf=unionfind(n)

for i in range(m):
    x,y=map(int,input().split())
    uf.unite(x,y)
    uf.unite(y,x)

ans=set(uf.par[1:])
print(len(ans))

# 2019/10/10

class unionfind():
    def __init__(self,n):
        self.par=list(range(n+1))
        self.rank=[0]*(n+1)
        self.groups=n
    
    def find(self,x):
        if self.par[x]==x:
            return x
        else:
            self.par[x]=self.find(self.par[x])
            return self.par[x]
    
    def is_same(self,x,y):
        return self.find(x)==self.find(y)
    
    def unite(self,x,y):
        x=self.find(x)
        y=self.find(y)
        if self.rank[x]<self.rank[y]:
            self.par[x]=y
        else:
            self.par[y]=x
            if self.rank[x]==self.rank[y]:
                self.rank[x]+=1
        if x!=y:self.groups-=1

n,m=map(int,input().split())

uf=unionfind(n)

for i in range(m):
    x,y,z=map(int,input().split())
    uf.unite(x,y)
print(uf.groups)

Verdicts: Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
import sys
sys.setrecursionlimit(1000000)
N, M = map(int, input().split())
X = [0] * M
Y = [0] * M
Z = [0] * M 
for i in range(M):
  X[i], Y[i], Z[i] = map(int, input().split())

reach = [[] for _ in range(N)]

for i in range(M) :
    reach[Y[i]-1].append(X[i])
    reach[X[i]-1].append(Y[i])

approach = [False for _ in range(N)]

def change(reach, s):       
    approach[s-1] = True
    for i in reach[s-1]:
        if not approach[i-1] :
            change(reach, i)

ans = 0
for i in range(N) :
    if not approach[i]:
        change(reach, i+1)
        ans += 1

print(approach)
print(reach)
print(ans)

import sys
sys.setrecursionlimit(1000000)
N, M = map(int, input().split())
X = [0] * M
Y = [0] * M
Z = [0] * M 
for i in range(M):
  X[i], Y[i], Z[i] = map(int, input().split())

reach = [[] for _ in range(N)]

for i in range(M) :
    reach[Y[i]-1].append(X[i])
    reach[X[i]-1].append(Y[i])

approach = [False for _ in range(N)]

def change(reach, s):       
    approach[s-1] = True
    for i in reach[s-1]:
        if not approach[i-1] :
            change(reach, i)

ans = 0
for i in range(N) :
    if not approach[i]:
        change(reach, i+1)
        ans += 1

print(ans)

Verdicts: Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
N,M=map(int,input().split())

parent=[i for i in range(N)]
depth=[0 for i in range(N)]

def root(x):
  if parent[x]==x:
    return x
  else:
    return root(parent[x])

def same(x,y):
  return root(x)==root(y)

def unite(x,y):
  rx=root(x)
  ry=root(y)
  if rx==ry:
    return
  if depth[x]<depth[y]:
    parent[rx]=ry
  else:
    parent[ry]=rx
    if depth[x]==depth[y]:
      depth[x]+=1
      
for i in range(M):
  a,b=map(int,input().split())
  a,b=a-1,b-1
  unite(a,b)
  
roots=set()
for i in range(N):
  roots.add(root(i))

print(len(roots)-1)

import sys
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines

# 0-indexed
class UnionFind:
  N=0
  parent=None
  size=None
  def __init__(self,N):
    self.N=N
    self.parent=[i for i in range(self.N)]
    self.size=[1]*self.N
    
  def root(self,x):
    while x!=self.parent[x]:
      self.parent[x]=self.parent[self.parent[x]]
      x=self.parent[x]
    return x
  
  def same(self,x,y):
    return self.root(x)==self.root(y)
  
  def unite(self,x,y):
    x=self.root(x)
    y=self.root(y)
    if x==y:
      return
    if self.size[x]>self.size[y]:
      
      self.parent[y]=x
      self.size[x]+=self.size[y]
    else:
      self.parent[x]=y
      self.size[y]+=self.size[x]
      
  def get_group_size(self,x):
    return self.size[self.root(x)]
  
  def get_roots(self):
    r=set()
    for i in range(self.N):
      r.add(self.root(i))
    return r
  
  def show_parent(self):
    print(self.parent)
    
  def show_size(self):
    print(self.size)
    
N,M=map(int,readline().split())
UF=UnionFind(N)
for i in range(M):
  x,y,z=map(int,readline().split())
  UF.unite(x-1,y-1)
  
print(len(UF.get_roots()))


Verdicts: Runtime Error

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
N, M = map(int,input().split())
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]

def unite(x,y):
    x = find(x)
    y = find(y)
    if x == y:
        continue
    par[x] = y
    size[y] += size[x]
    size[x] = 0

for i in range(M):
    x, y, z= map(int,input().split())
    unite(x,y)

Ans =0
for j in size[1:]:
    if j != 0:
        Ans +=1
print(Ans)


import collections

N, M = map(int, input().split())
par = [i for i in range(N+1)]

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x]) 
        return par[x]

def unite(x, y):
    x = find(x)
    y = find(y)
    if x == y:
        return 0
    par[x] = y

for i in range(M):
    X, Y, Z = map(int, input().split())
    unite(X, Y)
    print(par)

res = par[1:]
c = collections.Counter(res)
print(len(c))

N, M = map(int,input().split())
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]

def unite(x,y):
    x = find(x)
    y = find(y)
    if x == y:
        pass
    par[x] = y
    size[y] += size[x]
    size[x] = 0

for i in range(M):
    x, y, z= map(int,input().split())
    unite(x,y)

print(len(set(size[1:])))

N, M = map(int,input().split())
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]

def unite(x,y):
    x = find(x)
    y = find(y)
    if x == y:
        return 0
    par[x] = y
    size[y] += size[x]
    size[x] = 0

for i in range(M):
    x, y, z= map(int,input().split())
    unite(x,y)

Ans = 0
for j in size[1:]:
    if j != 0:
        Ans += 1
print(Ans)


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.  Let A_i be the integer written on the i-th card.  Your objective is to guess A_1, A_2, ..., A_N correctly.  You know the following facts:    * For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.  You are a magician and can use the following magic any number of times:  **Magic** : Choose one card and know the integer A_i written on it. The cost of using this magic is 1.  What is the minimum cost required to determine all of A_1, A_2, ..., A_N?  It is guaranteed that there is no contradiction in given input.

Submission attempts (in order):
# coding: utf-8
# Your code here!
N,M = map(int,input().split())
lst = [i for i in range(N)]

def root(n):
    if n == lst[n]:
        return n
    lst[n] = func(lst[n])
    return lst[n]

def union(x,y):
    rootX, rootY = root(x), root(y)
    if rootX != rootY:
        lst[max(x,y)] = min(x,y)

for i in range(M):
    X,Y,Z = map(int,input().split())
    X -= 1
    Y -= 1
    union(X, Y)

for i in range(N):
    func(i)

ans = len([i for i in range(N) if lst[i] == i])
print(ans)



# coding: utf-8
# Your code here!
N,M = map(int,input().split())
lst = [i for i in range(N)]

def root(n):
    if n == lst[n]:
        return n
    lst[n] = func(lst[n])
    return lst[n]

def union(x,y)
    rootX, rootY = root(x), root(y)
    if rootX != rootY:
        lst[max(x,y)] = min(x,y)

for i in range(M):
    X,Y,Z = map(int,input().split())
    X -= 1
    Y -= 1
    union(X, Y)

for i in range(N):
    func(i)

ans = len([i for i in range(N) if lst[i] == i])
print(ans)



# coding: utf-8
# Your code here!
N,M = map(int,input().split())
lst = [i for i in range(N)]

def root(n):
    if n == lst[n]:
        return n
    lst[n] = root(lst[n])
    return lst[n]

def union(x,y):
    rootX, rootY = root(x), root(y)
    if rootX != rootY:
        if rootX > rootY:
            lst[rootX] = rootY
        if rootY > rootX:
            lst[rootY] = rootX

for i in range(M):
    X,Y,Z = map(int,input().split())
    X -= 1
    Y -= 1
    union(X, Y)

ans = len([i for i in range(N) if root(i) == i])
print(ans)



Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = map(int, input().split())
print((T + 0.5)//A * B)

A, B, T = map(int, input().split())
print(int((T + 0.5)//A * B))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
int(ans)=(t+0.5)/a*b
print(ans)

a,b,t=map(int,input().split())
ans=int((t+0.5)/a)
print(ans*b)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import math

N = int(input())
inp_ints = list(map(int, input().split()))
# ints = list(set(inp_ints))

uniq_ints = list(set(inp_ints))
ints = uniq_ints
for m in uniq_ints:
    if inp_ints.count(m) >= 2:
        ints.append(m)

gcd = 0
result = 1
for i in range(len(ints)):
    gcd = 0
    for m in ints[:i]:
        gcd = math.gcd(gcd, m)
    for m in ints[i+1:]:
        gcd = math.gcd(gcd, m)
    if gcd > result:
        result = gcd

print(result)

import fractions

N = int(input())
inp_ints = list(map(int, input().split()))
ints = list(set(inp_ints))
""" uniq_ints = list(set(inp_ints))

ints = uniq_ints
for m in uniq_ints:
    if inp_ints.count(m) >= 2:
        ints.append(m) """

gcd = 0
result = 1
holed_ints = []
for i in range(len(ints)):
    holed_ints = ints[:i] + ints[i+1:]
    gcd = 0
    for j in range(len(ints)-1):
        gcd = fractions.gcd(gcd, holed_ints[j])
    if gcd > result:
        result = gcd

print(result)

import fractions

N = int(input())
inp_ints = list(map(int, input().split()))
ints = list(set(inp_ints))
""" uniq_ints = list(set(inp_ints))

ints = uniq_ints
for m in uniq_ints:
    if inp_ints.count(m) >= 2:
        ints.append(m) """

gcd = 0
result = 1
for i in range(len(ints)):
    gcd = 0
    for m in ints[:i]:
        gcd = fractions.gcd(gcd, m)
    for m in ints[i+1:]:
        gcd = fractions.gcd(gcd, m)
    if gcd > result:
        result = gcd

print(result)

A, B, T = map(int, input().split())
result = T // A * B

print(result)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,c=input().split()
time=int(int(c)/int(a))
print(int(time*b))

a,b,c=input().split()
time = (c+0.5)/a
print (time*b)

a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
time=int(c/a)

p=time*b
print(p)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
#include <bits/stdc++.h>
using namespace std;

int main(){
  int a, b, t;
  cin >> a >> b >> t;
  cout << (t / a) * b << endl;
}

a, b, t=map(int,input().split())
print((t//a)*b)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int,input().split())
print((t+0.5)//a*b)


a,b,t = map(int,input().split())
print(int((t+0.5)//a*b))


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
print(sum)


a, b, t = map(int, input().split())
cnt = 0
for i in range(1,100):
    if a*i <= t+0.5:
        cnt = cnt + 1
    else:
        break
sum = b * cnt
print(sum)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A,B,T = map(int,input().split())
print((T+0.5)//A*B)

A,B,T = map(int,input().split())
print(int((T+0.5)//A*B))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int,input().split())
print((t+0.5)//a*b)

a,b,t = map(int,input().split())
print(int((t+0.5)//a*b))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(float,input().split())
c=0
n=2
while True:
    if a<=t+0.5:
        c+=b
        k=a*n
        a=k
        n+=1
    else:
        break
print(c)

a,b,t=map(float,input().split())
c=0
n=2.0
while True:
    if a<=t+0.5:
        c+=b
        k=a*n
        a=k
        n+=1.0
    else:
        break
print(c)

a,b,t=map(int,input().split())
a=float(a)
t=float(t)
j=a
c=0
n=2.0
while True:
    if j<=t+0.5:
        c+=b
        j=a*n
        n+=1.0
    else:
        break
print(c)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,c=map(int,input().split())
print((c//a)/b)

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

a,b,t,=map(int,input().split())
T=t//a

print(int(T*b))

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
N = int(input())
V = list(map(int,input().split()))
C = list(map(int,input().split()))
sa = 0

for i in range(N):
    if v[i] - c[i]>0:
        sa += v[i]-c[i]

print(sa)        
    

A,B,T = map(int,input().split())
print(T//A*B)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,c=map(int,input(),split());print(c//a*b)

a,b,c=map(int,input().split());print(c//a*b)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, t = map(int, input().split())
n = a/t*b


a, b, t = map(int, input().split())
t=t+0.5
print(int(t//a*b))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A,B,T = map(int, input().split())
for i in range(T/A):
	i += B
print(i)


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

print(B*(T/A))


A,B,T = map(int, input().split())
for i in range(T/A)
	i += B
print(i)

A,B,T = map(int, input().split())
i = int(T/A)
print(B*i)


Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int, input().split())
sum = a//t
print(b*sum)

a,b,t = map(int, input().split())
sum = a//t
print(b*ans)


a,b,t = map(int, input().split())
sum = t//a
print(b*sum)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
print((t+0.5//a)*b)

a,b,t=map(int,input().split())
print(((t+0.5)//a)*b)

a,b,t=map(int,input().split())
print(int(((t+0.5)//a)*b))

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
N=int(input())
A=list(map(int,input().split()))
ans=0
c=0
tmp=10**9
for a in A:
    if a<0:
        c+=1
    ans+=abs(a)
    tmp=min(tmp,abs(a))
if c%2==0:
    print(ans)
else:
    print(ans-tmp*2)

A,B,T=map(int,input().split())
print(int((T+0.5)//A*B))


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, c = map(int ,input().split())
	print((a+0.5)//c * a)

a, b, c = map(int ,input().split())
print((a+0.5)//c * 5)

a, b, c = map(int ,input().split())
print((c+0.5)//a * b)

a, b, c = map(int ,input().split())
print(int((c+0.5)//a * b))

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
t=t/a
print(b*t)

a,b,t=map(int,input().split())
print(t/a*b)

a,b,t=map(int,input().split())
print(b*(t//a))

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A,B,T = map(int,input().split)
count = int((T+0.5)/A)
ans = B*count
print(ans)

A,B,T = map(int,input().split())
count = int((T+0.5)/A)
ans = B*count
print(ans)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
n = input()
print(n)

a, b, t = input().split() 
print(t / a * b)

a, b, t = input().split() 
print(int(t) // int(a) * int(b))

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A,B,T=map(input(),split())
a=int(T/A+0.5)
print(a*B)

A,B,T=map(int,input().split())
count=0
while T>=A:
	T=T-A
	count+=1
print(count*B)

Verdicts: Runtime Error

Accepted