Problem:


Score : 100 points

Problem Statement

We have five variables x_1, x_2, x_3, x_4, and x_5.

The variable x_i was initially assigned a value of i.

Snuke chose one of these variables and assigned it 0.

You are given the values of the five variables after this assignment.

Find out which variable Snuke assigned 0.

Constraints

The values of x_1, x_2, x_3, x_4, and x_5 given as input are a possible outcome of the assignment by Snuke.

Input

Input is given from Standard Input in the following format:

x_1 x_2 x_3 x_4 x_5

Output

If the variable Snuke assigned 0 was x_i, print the integer i.

Sample Input 1

0 2 3 4 5

Sample Output 1

1

In this case, Snuke assigned 0 to x_1, so we should print 1.

Sample Input 2

1 2 0 4 5

Sample Output 2

3



Sample input:
0 2 3 4 5


Sample output:
1

Submission status: Accepted

Solution code:
# -*- coding:utf-8 -*-

def solve():
    Xs = list(map(int, input().split()))

    for i, x in enumerate(Xs):
        if x == 0:
            print(i+1)
            return

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
for idx, i in enumerate(a):
    if i == 0:
        print(idx+1)

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

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

A = lr()
answer = A.index(0) + 1
print(answer)

Submission status: Accepted

Solution code:
A = list(map(int,input().split()))
print(A.index(0)+1)

Submission status: Accepted

Solution code:
for i, v in enumerate([int(_) for _ in input().split()]):
    if v == 0:
        print(i + 1)
        exit()

Submission status: Accepted

Solution code:
from collections import *
from math import *

a = list(map(int,input().split()))
print(a.index(0)+1)

Submission status: Accepted

Solution code:
ar=list(map(int,input().split()))
print(ar.index(0)+1)

Submission status: Accepted

Solution code:
x=map(int,input().split())
count=0
for i in x:
    count+=1
    if i==0:
        break
print(count)

Submission status: Accepted

Solution code:
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

l=lmp()

print(l.index(0)+1)

Submission status: Accepted

Solution code:
lis = list(map(int,input().split()))
print(lis.index(0)+1)

Submission status: Accepted

Solution code:
def LI():return list(map(int,input().split()))
def MI():return map(int,open(0).read().split())
def I():return int(input())
def yes():print("Yes")
def no():print("No")

from collections import deque, Counter
from heapq import heappop, heappush
INF=float("inf")
# import math
# pi=math.pi

# import numpy as np

x=LI()
ans=x.index(0)
print(ans+1)

Submission status: Accepted

Solution code:
from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math


def get_int():
    return int(stdin.readline().strip())


def get_tuple():
    return map(int, stdin.readline().split())


def get_list():
    return list(map(int, stdin.readline().split()))

ls = get_list()
print(ls.index(0)+1)

Submission status: Accepted

Solution code:
a=list(map(int,input().split()))
for i in range(5):
    if a[i]==0:
        print(i+1)
        break

Submission status: Accepted

Solution code:
N = list(map(int, input().split()))
print(N.index(0)+1)

Submission status: Accepted

Solution code:
X = [int(n) for n in input().split()]

print(X.index(0) + 1)

Submission status: Accepted

Solution code:
from sys import stdin
import sys
import math

# A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
A = list(map(int, input().split()))

# U = input().split()
for i,v in enumerate(A):
    if v==0:
        print(i+1)

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
	return list(map(int,input().split()))
def m(): #複数文字
	return map(int,input().split())
def onem(): #Nとかの取得
	return int(input())
def s(x): #圧縮
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): #listをスペースごとに分ける
	return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
	return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""


n = l()

for i in range(5):
	if n[i] == 0:
		print(i+1)
		exit()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')
AtoZ = "abcdefghijklmnopqrstuvwxyz"

#############
# Functions #
#############

######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]

######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()

#####Shorten#####
def DD(arg): return defaultdict(arg)


#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0: 
        cnt+=1 
        temp //= i
      arr.append([i, cnt])
  if temp!=1:
    arr.append([temp, 1])
  if arr==[]:
    arr.append([n, 1])
  return arr

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

#####MakePrimes######
def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum

#####GCD#####
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#####BitCount#####
def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count

#####ChangeBase#####
def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

#####IntLog#####
def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count

#############
# Main Code #
#############

l = IL()

print(15-sum(l))

Submission status: Accepted

Solution code:
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

x = ri_()
for i, xi in enumerate(x):
    if xi == 0:
        print(i + 1)
        exit()

Submission status: Accepted

Solution code:
l=list(map(int,input().split()))
for i in range(5):
    if l[i]==0:
        print(i+1)
        exit()

Submission status: Accepted

Solution code:
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)

# UnionFind
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

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

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

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

# ダイクストラ
def dijkstra_heap(s, edge, n):
    #始点sから各頂点への最短距離
    d = [10**20] * n
    used = [True] * n #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d

# 素因数分解
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

# 2数の最小公倍数
def lcm(x, y):
    return (x * y) // gcd(x, y)

# リストの要素の最小公倍数
def lcm_list(numbers):
    return reduce(lcm, numbers, 1)

# リストの要素の最大公約数
def gcd_list(numbers):
    return reduce(gcd, numbers)

# 素数判定
def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True


# limit以下の素数を列挙
def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P

# 同じものを含む順列
def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        # set（集合）型で重複を削除、ソート
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret


# ここから書き始める
x = list(map(int, input().split()))
ans = x.index(0) + 1
print(ans)

Submission status: Accepted

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

for i in range(5):
    if X[i]==0:
        print(i+1)
        break

Submission status: Accepted

Solution code:
ls = list(map(int,input().split()))
for i in range(5):
    if ls[i] == 0:
        print(i+1)
        break

Submission status: Accepted

Solution code:
def resolve():
    A = list(map(int, input().split()))
    print(A.index(0) + 1)

resolve()

Submission status: Accepted

Solution code:
L=list(map(int,input().split()))
print(L.index(0)+1)

Submission status: Accepted

Solution code:
*l, = map(int, input().split())
for i in range(5):
  if l[i]==0:
    print(i+1)

Submission status: Accepted

Solution code:
import sys

def solve():
    input = sys.stdin.readline
    X = [int(i) for i in input().split()]
    for i, x in enumerate(X):
        if x == 0: print(i + 1)

    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
A = list(map(int,input().split()))
s = sum(A)
ans = 15-s
print(ans)

Submission status: Accepted

Solution code:

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)
# from sys import setrecursionlimit
# setrecursionlimit(1000000)
# from collections import Counter,deque,defaultdict
# import itertools
# import math
# import networkx as nx
# from bisect import bisect_left,bisect_right
# from heapq import heapify,heappush,heappop
x=n1()
ans=x.index(0)
print(ans+1)

Submission status: Accepted

Solution code:
xs = list(map(int, input().split()))

i = xs.index(0)

print(i+1)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    x = lmis()
    print(x.index(0)+1)
    

main()

Submission status: Accepted

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

X=[int(i) for i in input().split()]
for i,x in enumerate(X):
  if x==0:
    print(i+1)
    break

Submission status: Accepted

Solution code:
x1,x2,x3,x4,x5=map(int,input().split())
if x1==0:
  print(1)
elif x2==0:
  print(2)
elif x3==0:
  print(3)
elif x4==0:
  print(4)
else:
  print(5)

Submission status: Accepted

Solution code:
line = list(map(int, input().split()))

print(line.index(0) + 1)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

As = list(map(int, input().split()))
for i in range(5):
    if As[i] == 0:
        print(i + 1)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
print(list(map(int, input().split())).index(0) + 1)

Submission status: Accepted

Solution code:
A = list(map(int, input().split(' ')))

print(A.index(0) + 1)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from collections import *

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

for i in range(5):
    if x[i]==0:
        print(i+1)
        exit()

Submission status: Accepted

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

print(X.index(0)+1)

Submission status: Accepted

Solution code:
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def input():
    return sys.stdin.readline().strip()

# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
    return [ int(s) for s in input().split(" ")]

# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
    return map(int, open(0).read().split())

def rangeI(it, l, r):
    for i, e in enumerate(it):
        if l <= i < r:
            yield e
        elif l >= r:
            break

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

X = get_nums_l()

for i,x in enumerate(X):
    if x == 0:
        print(i+1)

Submission status: Accepted

Solution code:
A = list(map(int, input().split()))
for i in range(5):
    if A[i] == 0:
        print(i + 1)
        exit()

Submission status: Accepted

Solution code:
# coding:utf-8
x = list(map(int, input().split()))
print(x.index(0) + 1)

Submission status: Accepted

Solution code:
X = tuple(map(int, input().split()))
for i, x in enumerate(X, 1):
    if x == 0:
        print(i)
        exit()

Submission status: Accepted

Solution code:
l = list(map(int, input().split()))
for i in range(5):
    if l[i] == 0:
        print(i + 1)
        break

Submission status: Accepted

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

for i in range(5):
    if x[i] == 0:
        print(i+1)
        exit()

Submission status: Accepted

Solution code:
"""
~~ Author : Bhaskar
~~ Dated : 07~06~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi,log
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
ch = "abcdefghijklmnopqrstuvwxyz"
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")

def solve():
    a = list(map(int,sys.stdin.readline().split()))
    print(a.index(0)+1)

if __name__ == "__main__":
    try:
        sys.stdin = open("input.txt","r")
    except :
        pass
    solve()

Submission status: Accepted

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

for i in range(5):
    if x[i]==0:
        print(i+1)
        break

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
for num in a:
    if num == 0:
        print(a.index(num)+1)

Submission status: Accepted

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

hoge = [a,b,c,d,e]

for i in range(5):
    if hoge[i] == 0:
        print(i+1)
        break

Submission status: Accepted

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

for i in range(len(x)):
  if x[i] == 0:
    print(i + 1)

Submission status: Accepted

Solution code:
def main():
    X = list( map( int, input().split()))
    for i in range(5):
        if X[i] == 0:
            print(i+1)
            return
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
xs = [int(v) for v in input().split()]
print(xs.index(0) + 1)

Submission status: Accepted

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

import sys
sys.setrecursionlimit(300000)


def solve(x: "List[int]"):
    ret = 0
    for i, v in enumerate(x):
        if v == 0:
            ret = i + 1
    print(ret)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    x = [int(next(tokens)) for _ in range(5)]  # type: "List[int]"
    solve(x)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

print(b.index(0)+1)

Submission status: Accepted

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

for i in range(len(a)):
    if a[i] == 0:
        print(i + 1)

Submission status: Accepted

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

x = [int(x) for x in input().split()]
for i in range(len(x)):
    if x[i] == 0:
        print(i + 1)
        sys.exit()

Submission status: Accepted

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

for i in range(5):
    if x[i]==0:
        print(i+1)
        exit()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

A = li()

for i in range(len(A)):
    if A[i] == 0:
        print(i+1)
        exit()

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))
idx = x.index(0)
print(idx+1)

Submission status: Accepted

Solution code:
xs = tuple(map(int, input().split()))
for i in range(len(xs)):
    if xs[i] == 0:
        print(i + 1)

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))


def main():
    xs = na()
    for i in range(5):
        if xs[i] == 0:
            print(i+1)
            return
    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

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

A = LIST()
ans = A.index(0) + 1
print(ans)

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))
for i in range(1,6):
    if x[i-1] == 0:
        print(i)
        exit()

Submission status: Accepted

Solution code:
x = 1 + 2 + 3 + 4 + 5
a = list(map(int, input().split()))
print(x - sum(a))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率

def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    #w.sort(key=itemgetter(1),reversed=True)  #二個目の要素で降順並び替え

    #N = int(input())
    #N, K = map(int, input().split())
    A = tuple(map(int, input().split())) #1行ベクトル
    #L = tuple(int(input()) for i in range(N)) #改行ベクトル
    #S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列


    for i,a in enumerate(A):
        if a==0:
            print(i+1)
            break



if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math as mt
#import numpy as np

def ro(n):
  return mt.floor(mt.sqrt(n))
def ya():
  print("Yes")
  return
def na():
  print("No")
  return


#a,b=map(int,input().split())
lis=list(map(int,input().split()))
#n=int(input())
#s=input()
print(lis.index(0)+1)

Submission status: Accepted

Solution code:
from sys import stdin
input = stdin.readline

a = [int(x) for x in input().split()]

for x in range(5):
    if a[x] == 0:
        print(x + 1)
        break

Submission status: Accepted

Solution code:
l=list(map(int, input().split()))
for i in range(len(l)):
    if l[i]==0:
        print(i+1)
        break

Submission status: Accepted

Solution code:
nii=lambda:map(int,input().split())
lnii=lambda:list(map(int,input().split()))

l=lnii()
for i in range(5):
  if l[i]==0:
    print(i+1)
    exit()

Submission status: Accepted

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

sys.setrecursionlimit(1000000)
ACMOD = 1000000007
INF = 1 << 62



def solve(x: "List[int]"):
    print(x.index(0)+1)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    x = [int(next(tokens)) for _ in range(5)]  # type: "List[int]"
    solve(x)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

x = input().split(' ')
x = [int(a) for a in x]
print(x.index(0) + 1)

Submission status: Accepted

Solution code:
import sys
# sys.setrecursionlimit(10**10)
# N = int(sys.stdin.readline().rstrip())
# S = sys.stdin.readline().rstrip()
# N, K = map(int, sys.stdin.readline().rstrip().split())
X = list(map(int, sys.stdin.readline().rstrip().split()))
print(X.index(0) + 1)

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
for i in range(5):
    if a[i] == 0:
        print(i + 1)
        exit()

Submission status: Accepted

Solution code:
A = list(map(int,input().split()))
for i in range(5):
    if A[i]==0:
        print(i+1)

Submission status: Accepted

Solution code:
# N = int(input())
x = [int(i) for i in input().split()]
print(x.index(0) + 1)

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
print(a.index(0)+1)

Submission status: Accepted

Solution code:
li = list(map(int,input().split()))
for i in range(5):
    if i+1 != li[i]:
        print(i+1)

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))
for i in range(5):
  if x[i] == 0:
    print(i + 1)

Submission status: Accepted

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

for i, a in enumerate(A):
    if a == 0:
        print(i+1)

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))
for i, j in enumerate(x, 1):
    if j == 0:
        print(i)
        exit()

Submission status: Accepted

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

for i, x in enumerate(X):
    if x == 0:
        print(i + 1)
        break

Submission status: Accepted

Solution code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  l=LI()

  for i in range(len(l)):
    if l[i]==0:
      return i+1

# main()
print(main())

Submission status: Accepted

Solution code:
i = input().split()

print(i.index('0')+1)

Submission status: Accepted

Solution code:
al = list(map(int, input().split()))
print(al.index(0)+1)

Submission status: Accepted

Solution code:
x=list(map(int, input().split()))
print(x.index(0)+1)