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:
n=int(input())
print(n**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    N = int(readline())

    print(N ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys


def main():
    input = sys.stdin.buffer.readline
    n = int(input())
    print(n * n * n)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
p=int(input())

print(p*p*p)

Submission status: Accepted

Solution code:
n = int(input())

res = set()

for i in range(1, n + 1):
    for j in range(1, n + 1):
        for k in range(1, n + 1):
            res.add(str(i) + str(j) + str(k))

print(len(res))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())

a = N ** 3

print(a)

Submission status: Accepted

Solution code:
# 問題：https://atcoder.jp/contests/abc140/tasks/abc140_a

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

Submission status: Accepted

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

    ans = N ** 3

    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

print((n**3))

Submission status: Accepted

Solution code:
N = int(input())

print(N*N*N)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#AOTコンパイルテスト
import sys
 
def solve(n):
    return n**3
 
if sys.argv[-1] == 'ONLINE_JUDGE':
    from numba.pycc import CC
 
    cc = CC('my_module')
    cc.export('solve', '(i8)')(solve)
    cc.compile()
    exit()
    
n=int(input())    
print(solve(n))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF =  float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353

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

Submission status: Accepted

Solution code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# # input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
# mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

n = inp()
print(n ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())

print(N**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools


#sys.setrecursionlimit(10**7)
#N, Q = map(int, input().split())
#G = [list(input()) for i in range(H)]
#INF = V * 10001
#A = [int(i) for i in input().split()]
#AB = [list(map(int, input().split())) for _ in range(K)]


N = int(input())
ans= 0

print(N**3)

Submission status: Accepted

Solution code:
n = int(input())

ans = n ** 3

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

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

Submission status: Accepted

Solution code:
N = int(input())

cnt = 0
for _ in range(1, N+1):
    for _ in range(1, N+1):
        for _ in range(1, N+1):
            cnt += 1
print(cnt)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
def main():
    N=ii()
    print(N**3)



if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
n = int(input())
ans = 0
# 1桁目
for i in range(1, n+1):
    # 2桁目
    for j in range(1, n+1):
        # 3桁目
        for k in range(1, n+1):
            #print(i, j, k)
            ans += 1
print(ans)

Submission status: Accepted

Solution code:
from sys import stdin

x = int(stdin.readline().rstrip())

print(x * x * x)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import itertools
n = int(input())
print(len(list(itertools.product(range(1,n+1), repeat=3))))

Submission status: Accepted

Solution code:
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    X = I()

    ans = X ** 3
    print(ans)

if __name__ == '__main__':
    resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))


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

Submission status: Accepted

Solution code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a=k()
print(a**3)

Submission status: Accepted

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

Submission status: Accepted

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

def main():

    N = int(input())

    ans = N ** 3

    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a=int(input())

print(a**3)

Submission status: Accepted

Solution code:
a = int(input())

print(a*a*a)

Submission status: Accepted

Solution code:
import heapq
t = 1
def max(a,b):
	if a > b:
		return a
	return b
while t > 0:
	t -= 1
	# n = map(int,input().split())
	n = int(input())
	# v = list(map(int,input().strip().split()))[0:n]
	print(n*n*n)
	# m = 1000
	# i = 0
	# while i < n:
	# 	j = i
	# 	while j+1 < n and v[j+1] >= v[j]:
	# 		j += 1
	# 	x = m//v[i]
	# 	m = m%v[i]
	# 	temp = x*v[j]
	# 	m += temp
	# 	i = j+1
	# print(m)

Submission status: Accepted

Solution code:
# abc140_a.py
# https://atcoder.jp/contests/abc140/tasks/abc140_a

# A - Password /
# 実行時間制限: 2 sec / メモリ制限: 1024 MB
# 配点 : 100点

# 問題文
# 高橋君は 3桁のパスワードを設定しようとしています。
# 使える文字が 1以上 N以下の数字のみであるとき、設定できるパスワードが全部で何種類であるかを答えてください。

# 制約
#     1≤N≤9
#     Nは整数である。

# 入力
# 入力は以下の形式で標準入力から与えられる。
# N

# 出力
# 設定できるパスワードが何種類であるかを出力せよ。

# 入力例 1
# 2

# 出力例 1
# 8

# 設定出来るパスワードは 111, 112, 121, 122, 211, 212, 221, 222 の 8種類です。

# 入力例 2
# 1

# 出力例 2
# 1

# 使える文字が 1種類しか無い場合、パスワードは 1 種類しか設定出来ません。


global FLAG_LOG
FLAG_LOG = False


def log(value):
    # FLAG_LOG = True
    # FLAG_LOG = False
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    # S = lines[0]
    N = int(lines[0])
    # N, M = list(map(int, lines[0].split()))
    # values = list(map(int, lines[1].split()))
    # values = list(map(int, lines[2].split()))
    # values = list()
    # for i in range(N):
    #     values.append(int(lines[i]))
    # valueses = list()
    # for i in range(N):
    #     valueses.append(list(map(int, lines[i+1].split())))

    result = N**3

    return [result]


# 引数を取得
def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines


# テストデータ
def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['2']
        lines_export = [8]
    if pattern == 2:
        lines_input = ['1']
        lines_export = [1]
    return lines_input, lines_export


# 動作モード判別
def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode


# 主処理
def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    # if mode > 0:
    #     print(f'lines_input=[{lines_input}]')
    #     print(f'lines_export=[{lines_export}]')
    #     print(f'lines_result=[{lines_result}]')
    #     if lines_result == lines_export:
    #         print('OK')
    #     else:
    #         print('NG')
    # finished = time.time()
    # duration = finished - started
    # print(f'duration=[{duration}]')


# 起動処理
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

print(n**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
import sys
import re
from collections import deque, defaultdict
from itertools import combinations, combinations_with_replacement
import bisect
from math import factorial, sqrt, log, ceil, floor
sys.setrecursionlimit(1000000)


def main():
    input = sys.stdin.readline
    #N, M = map(int, input().split())
    #N, K = map(int, input().split())
    #ps = list(map(int, input().split()))

    N = int(input())


    print(N ** 3)




if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main() -> None:
    print(int(input()) ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
N = int(input())
if not ( 1 <= N <= 9 ):sys.exit()

print(N**3)

Submission status: Accepted

Solution code:
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
print(N**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
n = int(input())
p = []
for i in range(1, n+1):
    p.append(i)

print(len(list(itertools.product(p, repeat=3))))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r = int(input())

print(r**3)

Submission status: Accepted

Solution code:
a = int(input())

print(a**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

N=int(input())

print(N*N*N)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
print(int(pow(int(input()),3)))

Submission status: Accepted

Solution code:
#<ABC.140>
N = int(input())
print(N ** 3)
#pattern = [i for i in range(1, N + 1)]

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 9)

# map(int, sys.stdin.read().split())


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


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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from itertools import *

N = int(input())
x = 1

N_list = [x+1 for x in range(N)]

n = list(product(N_list, repeat=3))

m = len(n)

print(m)

Submission status: Accepted

Solution code:
N = input()
i=0
if int(N)<=9:
  i = int(N)*int(N)*int(N)
  print(i)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

print(int(n ** 3))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
print(int(input())**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

n = int(input())

print(n ** 3)

Submission status: Accepted

Solution code:
N = int(input())

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

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())
    print(N ** 3)
    return


if __name__ == '__main__':
    main()

Submission status: Accepted

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

print(n * n * n)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N=int(input())

answer=N*N*N

print(answer)

Submission status: Accepted

Solution code:
N = int(input())
answer = N * N * N

print(answer)

Submission status: Accepted

Solution code:
n = int(input())

print(n ** 3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    print(N ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A - Password
def main():
    n = int(input())
    print(n**3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = int(input())

print(a ** 3)

Submission status: Accepted

Solution code:
# 140 A

n = int(input())
num = 0

for i in range(1, n+1):
    for j in range(1, n+1):
        for k in range(1, n+1):
            num += 1

print(num)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=input()
A=float(a)
x=A.is_integer()
if 1<=A<=9 and x==True:
    N=int(A)
    print(N**3)

Submission status: Accepted

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

import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline

# 再起回数上限変更
# sys.setrecursionlimit(1000000)

n = int(input())

print(n**3)

Submission status: Accepted

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

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
n = int(input())
l = list(itertools.product(range(1, n+1), repeat=3))
print(len(l))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

print (x**3)

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

print (n **3 )

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = int(input())

print(s**3)

Submission status: Accepted

Solution code:
from sys import stdin

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

Submission status: Accepted

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

res = n*n*n

print(res)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

input = lambda: sys.stdin.readline().rstrip()


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


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
import sys
import decimal # 10進法に変換，正確な計算

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

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

    
    
main()

Submission status: Accepted

Solution code:
# Python3 (3.4.3)
import sys
input = sys.stdin.readline

# -------------------------------------------------------------
# function
# -------------------------------------------------------------


# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(input())

print(N**3)

Submission status: Accepted

Solution code:
n = int(input())
ans = pow(n,3)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N = int(readline())
    ans = N**3
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# region header
import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 10 ** 9 + 7
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rf(): return float(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]
def rf_(): return [float(_) for _ in rs().split()]
def divisors(n, sortedresult=True):
    div = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            div.append(i)
            if i != n // i:
                div.append(n//i)
    if sortedresult:
        div.sort()
    return div
# endregion
N = ri()
print(N ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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:
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    print(int(input()) ** 3)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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:
print(pow(int(input()), 3))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

N = ri()

print(N**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict, deque
import sys


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


n = I()
print(n ** 3)

Submission status: Accepted

Solution code:
n=int(input())

print(n**3)

Submission status: Accepted

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

Submission status: Accepted

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

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


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
N = input()
n=int(N)
print (n*n*n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def password(n):

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
print(pow(int(input()),3))

Submission status: Accepted

Solution code:
n = int(input())

ans = n * n * n
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: <encode name> -*-

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

Submission status: Accepted

Solution code:
x = int(input())

y = x ** 3
print(y)

Submission status: Accepted

Solution code:
n = int(input().rstrip())
print(n * n * n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from itertools import combinations

# input
N = int(input())
print(len(set(combinations([i for i in range(1, N + 1)] * 3, 3))))

Submission status: Accepted

Solution code:

N=int(input())

print(N**3)

Submission status: Accepted

Solution code:
n=int(input())

print(n**3)

Submission status: Accepted

Solution code:
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:(input())

"""========main code==============="""
t=ii()
print(t*t*t)

Submission status: Accepted

Solution code:
max = int(input())+1
result = 0

for i in range(1, max):
    for j in range(1, max):
        for k in range(1, max):
            result += 1


print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())
t=0
a=1
while t<3:
    t+=1
    a*=n
print(a)

Submission status: Accepted

Solution code:
n = int(input())
answer = 1
for i in range(3):
  answer *= n
print(answer)

Submission status: Accepted

Solution code:
import math

print(int(math.pow(int(input()), 3)))

Submission status: Accepted

Solution code:
# ABC140A

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
a = []
for i in range(n):
	for j in range(n):
		for k in range(n):
			a.append(i+j+k)
			
print(len(a))

Submission status: Accepted

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


if __name__ == '__main__':

    ABC_140_A()

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
#from fractions import gcd
#from math import gcd
import sys
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = float('inf')


n = I()
print(n**3)

Submission status: Accepted

Solution code:
# A - Password

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

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()

print(N**3)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
N = int(input())
# S = input()
# A, B = map(int, input().split())
# A = list(map(int, input().split()))
print(N ** 3)

Submission status: Accepted

Solution code:
N = int(input())

print(N ** 3)

Submission status: Accepted

Solution code:
N=int(input())

print(N**3)

Submission status: Accepted

Solution code:
N = int(input())

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

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N = int(input())

ans = N ** 3
print(ans)