Problem:


Score : 100 points

Problem Statement

Takahashi is going to set a 3-character password.

How many possible passwords are there if each of its characters must be a digit between 1 and N (inclusive)?

Constraints

1 \leq N \leq 9

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

Print the number of possible passwords.

Sample Input 1

2

Sample Output 1

8

There are eight possible passwords: 111, 112, 121, 122, 211, 212, 221, and 222.

Sample Input 2

1

Sample Output 2

1

There is only one possible password if you can only use one kind of character.



Sample input:
2


Sample output:
8

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# abc140/abc140_a
import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    N = i2n()
    print(N**3)
    return

main()

Submission status: Accepted

Solution code:
n = int(input())
count = 0
for i in range(1,n+1):
    for k in range(1,n+1):
        for j in range(1,n+1):
            count += 1
print(count)

Submission status: Accepted

Solution code:
N = int(input().rstrip())

print(N**3)

Submission status: Accepted

Solution code:
N=int(input())
print (N**3)

Submission status: Accepted

Solution code:
def solve():
    data = read()
    result = think(data)
    write(result)


def read():
    return read_int(1)[0]


def read_int(n):
    return list(map(lambda x: int(x), read_line().split(' ')))[:n]


def read_float(n):
    return list(map(lambda x: float(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(data):
    return data ** 3


def write(result):
    print(result)


if __name__ == '__main__':
    # import doctest
    # doctest.testmod()
    # import sys
    # sys.setrecursionlimit(10000)
    solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
'use strict'

N = int(input())
print( N * N * N)

Submission status: Accepted

Solution code:
# coding: utf-8

a = int(input())
print(pow(a,3))

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    a = int(input())
    if a == 1:
        print(1)
    else:
        print(pow(a, 3))

Submission status: Accepted

Solution code:
import sys
import math
from copy import deepcopy
from collections import deque, defaultdict
from operator import mul
from functools import reduce
sys.setrecursionlimit(20000000)

# input = sys.stdin.readline


def main():
    n = int(input())
    print(n**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

def main():
    S = int(input())
    Ans = S ** 3
    print(Ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
n = int(input())

print (n**3)

Submission status: Accepted

Solution code:
a=int(input())

a=a*a*a

print(a)

Submission status: Accepted

Solution code:
n = int(input())
cnt = 0
for d3 in range(1, n + 1):
    for d2 in range(1, n + 1):
        for d1 in range(1, n + 1):
            cnt += 1
print(cnt)

Submission status: Accepted

Solution code:
N = int(input()) 
print(N ** 3)

Submission status: Accepted

Solution code:
import sys

def main():
    N = int(sys.stdin.readline())
    print(N**3)

if __name__=='__main__':
    main()

Submission status: Accepted

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


def solve(N: int):
    print(N * N * N)
    return


# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())
Ans = N**3
print(Ans)

Submission status: Accepted

Solution code:
import sys

n=int(sys.stdin.readline())
print( n**3 )

Submission status: Accepted

Solution code:
while True:
    try:
        N = int(input())
        print(N**3)
    except EOFError:
        break

Submission status: Accepted

Solution code:
n = int(input())

if n == 1:
    print(1)
else :
    print(n**3)

Submission status: Accepted

Solution code:
n = int(input());

print(n**3);

Submission status: Accepted

Solution code:
a=int(input())

print(a*a*a)

Submission status: Accepted

Solution code:
import itertools
N = int(input().split()[0])

p_gen = itertools.product(list(range(0, N)), repeat=3)
ans = len(list(p_gen))
print(ans)

Submission status: Accepted

Solution code:
N = int(input())

ans = N
for _ in range(2):
    ans *= N

print(ans)

Submission status: Accepted

Solution code:
m = int(input())
print(m ** 3)

Submission status: Accepted

Solution code:
n = int(input());print(n**3)

Submission status: Accepted

Solution code:
n = int(input())

answer = n*n*n

print(answer)

Submission status: Accepted

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

def main():
    N = int(input())
    print(N**3)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/Library/Frameworks/Python.framework/Versions/3.5/bin/python3

n = int(input())

print(n ** 3)

Submission status: Accepted

Solution code:
inputs = int(input())
print(inputs*inputs*inputs)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

N = int(input().strip())

ans = N**3

print(ans)

Submission status: Accepted

Solution code:
variation = int(input())
print("{}".format(variation ** 3))

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

#A
def A():
    n = I()
    print(n**3)
    return

#B
def B():
    n = I()
    a = LI()
    b = LI()
    c = LI()
    ans = sum(b)
    for i in range(n-1):
        x = a[i]
        y = a[i+1]
        if y == x+1:
            ans += c[x-1]
    print(ans)
    return

#C
def C():

    return

#D
def D():

    return

#E
def E():

    return

#F
def F():

    return

#Solve
if __name__ == "__main__":
    A()

Submission status: Accepted

Solution code:
N=int(input()) 
print(N**3)

Submission status: Accepted

Solution code:
from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True # and False
BIG = 999999999
R = 10**9 + 7

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

n = inn()
print(n**3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
n = int(input())
print(n*n*n)

Submission status: Accepted

Solution code:
# coding: UTF-8
import sys
#sys.setrecursionlimit(n)
import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

n = readi()

count = 0
for i in range(n):
    for j in range(n):
        for k in range(n):
            count += 1
print(count)

Submission status: Accepted

Solution code:
n =int(input())

print(n**3)

Submission status: Accepted

Solution code:
import sys
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

n=int(input())
print(pow(n,3))

Submission status: Accepted

Solution code:
N = int(input())
print(int(N ** 3))

Submission status: Accepted

Solution code:
N = int(input())
a = N * N * N
print("{}".format(a))

Submission status: Accepted

Solution code:
n=int(input())

print(n*n*n)

Submission status: Accepted

Solution code:
N = int(input())

ans = N**3

print(ans)

Submission status: Accepted

Solution code:
s=int(input())
print(s**3)

Submission status: Accepted

Solution code:
n = int(input())

print(n*n*n)

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

n = int(raw_input())
#a, b = map(int, raw_input().split())
#s = raw_input()
#a,b,c,x = map(int, [input() for i in range(4)])

if n == 1:
    print 1
else:
    print n*n*n

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

N = I()

print(N ** 3)

Submission status: Accepted

Solution code:
s = input()
S = int(s[0])

max = S ** 3
print(max)

Submission status: Accepted

Solution code:
n=int(input())
print(int(n**3))

Submission status: Accepted

Solution code:
n = int(input())

print(pow(n,3))

Submission status: Accepted

Solution code:

n = int(input())

print(n*n*n)

Submission status: Accepted

Solution code:
n1 = int(input())

r1 = n1 * n1 * n1

print(r1)

Submission status: Accepted

Solution code:
#!/usr/bin/python

import sys
from pprint import pprint

def solve(n):
   print(n**3)

if __name__ == '__main__':
  n = int(sys.stdin.readline().strip())
  solve(n)

Submission status: Accepted

Solution code:
inp = int(input())
print(inp*inp*inp)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
n = int(input())
print(n**3)

Submission status: Accepted

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

n = int(input())

print(n**3)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    n = int(input())
    print(n ** 3)


# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
I=int(input())

print(I*I*I)

Submission status: Accepted

Solution code:
def A():
    print(int(input())**3)

A()

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    N = int(input())
    print(N ** 3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N = int(input())

print(N*N*N)

Submission status: Accepted

Solution code:
print( int(input())**3 )

Submission status: Accepted

Solution code:
N = int(input().strip())
print(N*N*N)

Submission status: Accepted

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

N = int(input())

print(N*N*N)

Submission status: Accepted

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


def solve(N: int):
    print(N**3)
    return


# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Sep  7 20:54:13 2019

@author: doppe
"""

n = int(input())

print(pow(n, 3))

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy

# If you use recursive call, uncomment this code
#sys.setrecursionlimit(10**6)

def main():
    N = int(input())
    print(N**3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

answer = n * n * n

print(answer)

Submission status: Accepted

Solution code:
a=int(input())
b = a**3
print(b)

Submission status: Accepted

Solution code:
A = int(input())

print(pow(A,3))

Submission status: Accepted

Solution code:

n = int(input())
a = n * n * n
print(a)

Submission status: Accepted

Solution code:
from collections import defaultdict
from heapq import heappush, heappop, heapify
from bisect import bisect_left

class Solution:
    def main(self):
        N = int(input())
        print(N**3)


if __name__ == '__main__':
    Solution().main()

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
print(int(input())**3)

Submission status: Accepted

Solution code:
N = int(input())
ans = N**3

print(ans)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    print(n ** 3)

if __name__ == '__main__':
    main()

Submission status: Accepted

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


def solve(N: int):
    print(N ** 3)


# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())

print(N * N * N)

Submission status: Accepted

Solution code:
n = int(input())
s = n**3
print(s)

Submission status: Accepted

Solution code:
a=int(input());print(a**3)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
def LILI(n): return [LI() for _ in range(n)]
INF = 10 ** 18
MOD = 10 ** 9 + 7

def main(): 
    N = II()
    ans = 1
    for i in range(3):
        ans *= N

    print(ans)

main()

Submission status: Accepted

Solution code:
N = int(input())
ans=N**3
print(ans)

Submission status: Accepted

Solution code:
a = int(input())

a = a* a* a

print(a)

Submission status: Accepted

Solution code:
def resolve():
    n = int(input())
    print(n ** 3)



resolve()

Submission status: Accepted

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

    print(N*N*N)
main()

Submission status: Accepted

Solution code:
while True:
    try:
        N = int(input())
        print(N**3)
    except:
        break

Submission status: Accepted

Solution code:
def p_a():
    i = int(input())
    print(i ** 3)


if __name__ == '__main__':
    p_a()

Submission status: Accepted

Solution code:
import collections as c
ip = lambda : map(int, input().split())
# ##############
N = int(input())
print(N**3)

Submission status: Accepted

Solution code:
N = int(raw_input())

print N**3

Submission status: Accepted

Solution code:
N = int(raw_input().strip())

print(N**3)

Submission status: Accepted

Solution code:
n = int(input())

ans = n**3
print(ans)

Submission status: Accepted

Solution code:
import sys


def input():
    return sys.stdin.readline()[:-1]


def main():
    N = int(input())
    print(N**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N = int(input())
print(N ** 3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
def main():
    N = int(input())
    print(N*N*N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8

n=int(input())

print(pow(n,3))

Submission status: Accepted

Solution code:
#A
n = int(input())
print(n**3)

Submission status: Accepted

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

    print(N ** 3)
    
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    N = int(input())
    print(N**3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect
import heapq

#素因数を並べる
def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   
# 桁数を吐く
def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    # リスト要素と対象値の差分を計算し最小値のインデックスを取得
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

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

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

    def find(self, x):
        """
        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 と 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 is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

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

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())

# 多次元配列の宣言（あとでintにすること。）（タプルにすること。）
dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')

# 複数配列を並び替え
ABT = zip(A, B, totAB)
result = 0
# itemgetterには何番目の配列をキーにしたいか渡します
sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)

# 2進数のbit判定
(x >> i) & 1

# dp最小化問題
dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break
# 累積和
add = 1 # 問題によって決まる
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)

#２分探索
li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    

#ソート関数
org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)
# [3, 1, 4, 5, 2]
# [1, 2, 3, 4, 5]

#Distance Transformation
    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""


N= int(input())

    
def main(): 
    print(N**3)
                
                
                
            
            
                

    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#A

n = int(input())

ans = n ** 3
print(ans)

Submission status: Accepted

Solution code:
s = input()
n=int(s)
print(n**3)

Submission status: Accepted

Solution code:
input = raw_input


s = int(input())
print(s**3)

Submission status: Accepted

Solution code:
def solve():
  import sys
  import math

  sys.setrecursionlimit(10**7)
  readline=sys.stdin.readline

  print(int(input())**3)


if __name__ == '__main__':
  solve()

Submission status: Accepted

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


def main(n):
    return n**3


if __name__ == "__main__":
    n = int(input())
    print(main(n))

Submission status: Accepted

Solution code:
N = int(input())
print(str(N ** 3))

Submission status: Accepted

Solution code:
a = int(input())
b = pow(a, 3)
print(int(b))

Submission status: Accepted

Solution code:
def main():    
    n = int(input())
    print(n**3)
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from sys import stdin


def main():
    N = int(stdin.readline().rstrip())
    print(N ** 3)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N = int(input())
ans = N * N * N
print(ans)

Submission status: Accepted

Solution code:
num = int(input())

result = num **3
print(result)

Submission status: Accepted

Solution code:
N = int(input())

print(N**3)

Submission status: Accepted

Solution code:
# @author 

import sys

class APassword:
    def solve(self):
        n = int(input())
        print(n ** 3)

solver = APassword()
input = sys.stdin.readline

solver.solve()

Submission status: Accepted

Solution code:
N=int(input())
ans=0
ans=N**3
print(ans)

Submission status: Accepted

Solution code:
N=int(input())


print(N**3)

Submission status: Accepted

Solution code:
N = int(input())
ans = N**3

print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N = int(input())

print(N * N * N)

Submission status: Accepted

Solution code:

import sys,copy
input = sys.stdin.readline
#-------------------------------------

n = int(input())
print(n*n*n)

Submission status: Accepted

Solution code:
def f_a():
    n = int(input())
    print(n**3)

if __name__ == "__main__":
    f_a()

Submission status: Accepted

Solution code:
def func():
    N = int(input())
    print(N**3)

if __name__ == '__main__':
    func()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N):
    return N**3


def main():
    N = read_int()
    print(slv(N))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())

print(N * N *N )

Submission status: Accepted

Solution code:


if __name__ == '__main__':
    n = int(input())
    print(n**3)

Submission status: Accepted

Solution code:
N = int(input())
out = N * N * N
print(out)

Submission status: Accepted

Solution code:
from sys import stdin

def main():
    N = int(input())
    print(N ** 3)

input = lambda: stdin.readline()[:-1]
main()

Submission status: Accepted

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

def main():
    N = int(input())
    print(N**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

n = ni()
print(n**3)

Submission status: Accepted

Solution code:
import numpy as np
N=int(input())
print(N**3)

Submission status: Accepted

Solution code:
def main():
    N = int(input())
    print(N*N*N)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

def main():
    N = int(input())
    print(N**3)
     
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())
#S = list(input())

#N,K=map(int,input().split())
#A=list(map(int,input().split()))

ans=0

ans=N*N*N





print(str(ans))

Submission status: Accepted

Solution code:
# 2019/09/07
# AtCoder Beginner Contest 140 - A

# Input
n = int(input())

# Calc
ans = n ** 3

# Output
print(ans)

Submission status: Accepted

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


def solve(N):
    ans = N**3
    return ans


if __name__ == '__main__':
    N = int(input())

    ans = solve(N)

    print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
INF = float("inf")


def solve(N: int):
    print(N**3)
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

N = int(input())

Ans = N ** 3

print(Ans)

Submission status: Accepted

Solution code:
#coding:utf-8
n = int(input())
print(n*n*n)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True
#debug = False

def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    n = II()
    print(n*n*n)
solve()