Problem:


Score : 100 points

Problem Statement

Given is an integer x that is greater than or equal to 0, and less than or equal to 1.
Output 1 if x is equal to 0, or 0 if x is equal to 1.

Constraints

0 \leq x \leq 1

x is an integer

Input

Input is given from Standard Input in the following format:

x

Output

Print 1 if x is equal to 0, or 0 if x is equal to 1.

Sample Input 1

1

Sample Output 1

0

Sample Input 2

0

Sample Output 2

1



Sample input:
1


Sample output:
0

Submission status: Accepted

Solution code:
#
# abc178 a
#
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """1"""
        output = """0"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """0"""
        output = """1"""
        self.assertIO(input, output)


def resolve():
    x = int(input())
    if x == 0:
        print(1)
    else:
        print(0)


if __name__ == "__main__":
    # unittest.main()
    resolve()

Submission status: Accepted

Solution code:
import math

x=int(input())
#H,W=map(int,input().split())

if x==0:
    print("1")
else:
    print("0")

Submission status: Accepted

Solution code:
x = int(input())

print((x+1) % 2)

Submission status: Accepted

Solution code:
#a
x = int(input())
if x == 1:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
a = int(input())
if a ==1:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
n=int(input())
print(1 if n==0 else 0)

Submission status: Accepted

Solution code:
i=int(input())
if i==1:
  print(0)
else:
  print(1)

Submission status: Accepted

Solution code:
x=int(input())
if x==0:
    print('1')
else:
    print('0')

Submission status: Accepted

Solution code:
n=int(input())

if n == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
i = int(input())

if i == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
import sys
import math
import collections
import bisect
import itertools
import decimal
import copy
import heapq

# import numpy as np

# sys.setrecursionlimit(10 ** 6)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353

ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: map(int, sys.stdin.readline().rstrip().split())
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))
flush = lambda: sys.stdout.flush()


# ===CODE===
def main():
    x=ni()
    print(1 if x==0 else 0)





if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def resolve():
    #n=int(input())
    #a,b=map(int,input().split())
    #x=list(map(int,input().split()))
    #a=[list(map(lambda x:int(x)%2,input().split())) for _ in range(h)]
    x=int(input())
    if x==0:
      print(1)
    else:
      print(0
      )

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
def resolve():
    x = int(input())
    if x == 1:
        print(0)
    else:
        print(1)
resolve()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
import math
import decimal
import itertools
from itertools import product
from functools import reduce
def input():
    return sys.stdin.readline()[:-1]
def gcd(*numbers):
    return reduce(math.gcd, numbers)
def lcm_base(x, y):
    return (x * y) // math.gcd(x, y)
def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)
def sort_zip(a:list, b:list):
    z = zip(a, b)
    z = sorted(z)
    a, b = zip(*z)
    a = list(a)
    b = list(b)
    return a, b
def ceil(x):
    return math.ceil(x)
def floor(x):
    return math.floor(x)

def main():
    x = int(input())

    if x == 0:
        print(1)
    else:
        print(0)




if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x=int(input())
if x == 0:
  print(1)
else:
  print(0)

Submission status: Accepted

Solution code:
n = int(input())
print(1 if n is 0 else 0)

Submission status: Accepted

Solution code:
A=int(input())
if A==1:
  print(0)
else:
  print(1)

Submission status: Accepted

Solution code:
x = int(input())
print(int(1-x))

Submission status: Accepted

Solution code:
X=int(input())
if X==0:
  print(1)
else:
  print(0)

Submission status: Accepted

Solution code:
N = int(input())
if N==1:
  print(0)
else:
  print(1)

Submission status: Accepted

Solution code:
a = input()
print(int(not int(a)))

Submission status: Accepted

Solution code:
x = input()
d = {"1": "0", "0": "1"}
print(d[x])

Submission status: Accepted

Solution code:
x = int(input())
a = [1,0]
print(a[x])

Submission status: Accepted

Solution code:
x=input()

if(x=="0"):
  print(1)
else:
  print(0)

Submission status: Accepted

Solution code:

def main():
    x = int(input())
    if x == 0:
        print(1)
    else:
        print(0)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

if n == 0:
    print(1)
elif n == 1:
    print(0)

Submission status: Accepted

Solution code:
s = int(input())
if s == 0:
    print('1')
elif s == 1:
    print('0')

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
x = int(input())
if x==0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
num = int(input())
if num == 1:
    print(0)
elif num == 0:
    print(1)

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    x = input()
    print('0' if x == '1' else '1')

Submission status: Accepted

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key
from bisect import bisect_left


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

def mulinputs():
    return map(int,input().split())

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

def bindex(a,x):
    i = bisect_left(a,x)
    if i != len(a) and a[i] == x:
        return i
    return None

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    N = intinput()

    # 出力
    print((not N)+0)

Submission status: Accepted

Solution code:
def main():
    x = int(input())
    if x == 1:
        print(0)
    else:
        print(1)
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
if __name__ == '__main__':

	n = int(input())
	if n == 0:
		print(1)
	else:
		print(0)

Submission status: Accepted

Solution code:
x = int(input())
if x: print(0)
else: print(1)

Submission status: Accepted

Solution code:
s = int(input())
if s == 1:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
X=int(input())
print([1,0][X])

Submission status: Accepted

Solution code:
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
#R = 998244353

def ddprint(x):
  if DBG:
    print(x)

x = inn()
print(1-x)

Submission status: Accepted

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

def solve():
    return str(1-int(input()))

if __name__ == '__main__':
    print(solve())

Submission status: Accepted

Solution code:
x = int(input())

if x == 0:
    print(1)
else :
    print(0)

Submission status: Accepted

Solution code:
a = int(input())
print("1" if(a == 0) else "0")

Submission status: Accepted

Solution code:
n = int(input())
if n:
  print(0)
else:
  print(1)

Submission status: Accepted

Solution code:
a=int(input())
if a==1 :
  print('0')
else :
  print('1')

Submission status: Accepted

Solution code:
a=int(input())
if a:
  print(0)
else:
  print(1)

Submission status: Accepted

Solution code:
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
def celi(a,b):
    return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

x=int(input())
print(1-x)

Submission status: Accepted

Solution code:
def main():
    x = int(input())

    if x == 0:
        print(1)
    elif x == 1:
        print(0)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N = int(input())
print(1 if not N else 0)

Submission status: Accepted

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


def read():
    x = int(input().strip())
    return x,


def solve(x):
    return 1 - x


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Submission status: Accepted

Solution code:
from sys import stdin

def main():

    input = stdin.readline

    x= int(input())

    if x == 1:
        print("0")
    else:
        print("1")


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a=int(input())

if a==0:
  print("1")
elif a==1:
  print("0")

Submission status: Accepted

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

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()
    DD = ((1,0),(0,1),(-1,0),(0,-1))

    x = NI()
    print(1-x)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

N = int(input())
res = (N+1) % 2
print(res)

Submission status: Accepted

Solution code:
x=int(input())

if x==0:
    print(1)
if x==1:
    print(0)

Submission status: Accepted

Solution code:
x = int(input())

if x == 0:
  print('1')

else:
  print('0')

Submission status: Accepted

Solution code:
x = int(input())

if x == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
x = int(input())

if x==1:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
a=input()
if a == "1":
  print("0")
else:
  print("1")

Submission status: Accepted

Solution code:
import sys
import math

x = int(input())

if x == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

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


def solve(x: int):
    return 1 if x == 0 else 0


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    x = int(next(tokens))  # type: int
    print(solve(x))

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    #test()
    main()

Submission status: Accepted

Solution code:
def main():
    x = int(input())
    if x == 0:
        return 1
    else:
        return 0

print(main())

Submission status: Accepted

Solution code:
print([1,0][input()=='1'])

Submission status: Accepted

Solution code:
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    x = int(input())
    print(x ^ 1)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = int(input())
if a == 0:
    print(1)
elif a == 1:
    print(0)

Submission status: Accepted

Solution code:
#: Author - Soumya Saurav
import sys,io,os,time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

input = sys.stdin.readline

########################################

x = int(input())
if x == 1:
	print(0)
else:
	print(1)








'''
# Wrap solution for more recursion depth
#submit as python3
import collections,sys,threading
sys.setrecursionlimit(10**9)
threading.stack_size(10**8)



threading.Thread(target=solve).start()
'''

Submission status: Accepted

Solution code:
A = int(input())
print(0 if A == 1 else 1)

Submission status: Accepted

Solution code:
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy

def main():
    x = int(input())

    if (x == 1):
        print(0)
    else:
        print(1)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def resolve():
    x = int(input())
    if x == 0:
        print(1)
    else:
        print(0)
resolve()

Submission status: Accepted

Solution code:
x = input()
print(1 - int(x))

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
x = int(input())
print(1 - x)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

n = int(input())
if n==1:
    print(0)
elif n==0:
    print(1)

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    if a==0:
        print(1)
    else:
        print(0)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# a,b = map(int, input().split())
x = int(input())

if x == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate

sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7


def main():
    N = int(input())
    print(int(N == 0))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
s=int(input())
if s==1:
	print(0)
else:
	print(1)

Submission status: Accepted

Solution code:
# abc178_a.py
N = int(input())
if N==0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
#======================================================#
def main():
    x = II()
    if x == 0:
        print(1)
    else:
        print(0)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
    return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
    return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
  ns = []
  while len(ns) < rantime:
    n = random.randint(ran1, ran2)
    if not n in ns:
      ns.append(n)
  return sorted(ns)

def rand_query(ran1, ran2, rantime):
  r_query = []
  while len(r_query) < rantime:
    n_q = rand_ints_nodup(ran1, ran2, 2)
    if not n_q in r_query:
      r_query.append(n_q)
  return sorted(r_query)

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7

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

X = getN()
if X == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

x = int(input())
ans = 0 if x==1 else 1
print(ans)

Submission status: Accepted

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

x = int(input())
outs = [0, 1]
outs.remove(x)
print(outs[0])

Submission status: Accepted

Solution code:
from sys  import stdin,stdout

st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")

mod=1000000007

def solve():
    n=inp()
    print((n+1)%2)
    


for _ in range(1):
    solve()

Submission status: Accepted

Solution code:
N = int(input())

if N == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
x = int(input())

if x == 0:
    print(1)

else :
    print(0)

Submission status: Accepted

Solution code:
import sys
import math

#https://atcoder.jp/contests/agc008/submissions/15248942
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

x = ini()

if x == 0:
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    if n == 1:
        return 0
    else:
        return 1

if __name__ == '__main__':
    print(main())

Submission status: Accepted

Solution code:
n = int(input())
print(1 - n)

Submission status: Accepted

Solution code:
x = input()

if (x == "0"):
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
x = int(input())
if x==0:
  print('1')
else:
  print('0')

Submission status: Accepted

Solution code:
n=int(input())
if (n==1):
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
n=int(input())
if n==0:
    print('1')
else:
    print('0')

Submission status: Accepted

Solution code:
x = int(input())

print('0' if x == 1 else '1')

Submission status: Accepted

Solution code:
s=input()

if s=='0':
  print(1)
else:
  print(0)

Submission status: Accepted

Solution code:
x=int(input())
if x == 0:
  print(1)
else:
  print(0)

Submission status: Accepted

Solution code:
a = int(input())
if a:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
def main():
    x = int(input())
    print(abs(1-x))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
from math import gcd,pi,sqrt
INF = float("inf")

import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]


def main():
    x = i_input()
    if x == 1:
        print(0)
    else:
        print(1)


if __name__=="__main__":
    main()

Submission status: Accepted

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


# 入力を整数に変換して受け取る
def input_int():
    return int(input())


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return map(int, input().split())


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    x = int(input())

    if x >= 1:
        return 0
    return 1


if __name__ == "__main__":
    print(main())

Submission status: Accepted

Solution code:
# Date [ 2020-09-13 21:00:11 ]
# Problem [ a.py ]
# Author Koki_tkg

import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict

# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846

def read_str():      return sys.stdin.readline().strip()
def read_int():      return int(sys.stdin.readline().strip())
def read_ints():     return map(int, sys.stdin.readline().strip().split())
def read_ints2(x):   return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)

def Main():
    x = read_int()
    if x == 0:
        print(1)
    else:
        print(0)

if __name__ == '__main__':
    Main()

Submission status: Accepted

Solution code:
x = int(input())
if(x == 0):
    print(1)
else:
    print(0)

Submission status: Accepted

Solution code:
N = int(input())
print((N+1)%2)

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math
from collections import deque
import itertools
import heapq
#import bisect
from fractions import Fraction
import copy
from functools import lru_cache
from collections import defaultdict
import pprint

#oo=list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
# ko=list("abcdefghijklmnopqrstuvwxyz")

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]

def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)

def soinsubunkai(n):
    a = []
    i = 1
    while i*i <= n:
        if n % i == 0 and i!=1:
            a.append(i)
            n=n//i

        if n% i !=0 or i==1:
            i += 1
    nokori=[n]
    return a + nokori

def soinsubunkai_e(n,m): #高速素因数分解 m[n]=nを割ることの出来る最小の素数
    a = set()
    i = 1
    while n>1:
        a.add(m[n])
        n=n//m[n]
    nokori=n
    a.add(nokori)
    return a

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]


def era(n): #b[n]=nを割ることの出来る最小の素数　の配列を生成　エラトステネスの篩
    b=[i for i in range(n+1)]
    for i in range(2,int(math.sqrt(n)+10)):
        j=1
        temp=i*j
        while temp<=n:
            b[temp]=min(i,b[temp])
            temp+=i
    return b


def main():
    #l,r,d=map(int,input().split())
    n=int(input())
    print(-(n-1))









if __name__ == "__main__":

    main()

Submission status: Accepted

Solution code:
a = int(input())
if a == 1 :
  print(0)
else :
  print(1)

Submission status: Accepted

Solution code:
n=int(input())
if(n==0):
	print(1)
else:
	print(0)

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())


def main():
    x = in_n()

    if x == 0:
        print(1)
    else:
        print(0)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x = int(input())
if x == 1:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify

import itertools
import math, fractions
import sys, copy

def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]

def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))

def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]

dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")

sys.setrecursionlimit(1000000)

def main():
    N = I()
    print(int(not bool(N)))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math

i = int(input())

if i:
    print(0)
else:
    print(1)

Submission status: Accepted

Solution code:
def main():
    X = int(input())
    print(1-X)


main()

Submission status: Accepted

Solution code:
x = int(input())

if x==1:
    print(0)
elif x==0:
    print(1)

Submission status: Accepted

Solution code:
if int(input()) >= 1:
    print(0)
else:
    print(1)