Problem:


Score : 100 points

Problem Statement

You are given an integer K.
Print the string obtained by repeating the string ACL K times and concatenating them.

For example, if K = 3, print ACLACLACL.

Constraints

1 \leq K \leq 5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

K

Output

Print the string obtained by repeating the string ACL K times and concatenating them.

Sample Input 1

3

Sample Output 1

ACLACLACL



Sample input:
3


Sample output:
ACLACLACL

Submission status: Accepted

Solution code:
def main():
    import sys
    def input():
        return sys.stdin.readline()[:-1]
    K=int(input())
    moji="ACL"
    ans=""
    for i in range(K):
        ans+=moji
    print(ans)
    
   


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
k = int(input())

for i in range(k):
    print("ACL", end="")

Submission status: Accepted

Solution code:
k=int(input())
s=""
for i in range(k):
    s=s+"ACL"

print(s)

Submission status: Accepted

Solution code:
import sys
K=int(input())
ans=[]
for i in range(K):
    ans+="ACL"
print(''.join(ans))

Submission status: Accepted

Solution code:
k =int(input())

for i in range(k):
    print("ACL",end="")

Submission status: Accepted

Solution code:
s = "ACL"*int(input())
print(s)

Submission status: Accepted

Solution code:
N=int(input())
for i in range(N):
  print('ACL',end='')

Submission status: Accepted

Solution code:
input = int(input())
ans = "ACL"
print(ans*input)

Submission status: Accepted

Solution code:
N = int(input())
for i in range(N):
    print('ACL',end="")

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
K = int(input())
A = ''
for i in range(K):
  A += 'ACL'
print(A)

Submission status: Accepted

Solution code:
s=int(input())
for i in range(s):
  print("ACL", end="")
print()

Submission status: Accepted

Solution code:
def main():
    import sys
    sys.setrecursionlimit(311111)
    # import numpy as np
    ikimasu = sys.stdin.buffer.readline
    ini = lambda: int(ins())
    ina = lambda: list(map(int, ikimasu().split()))
    ins = lambda: ikimasu().strip()
    tmp = ini()
    print(("ACL"*tmp))

    
    



    


        
        
        


    
        


        


    




















if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
N = 300005
 
# array to store inverse of 1 to N 
factorialNumInverse = [None] * (N + 1) 
 
# array to precompute inverse of 1! to N! 
naturalNumInverse = factorialNumInverse.copy() 
 
# array to store factorial of  
# first N numbers 
fact = factorialNumInverse.copy() 
 
# Function to precompute inverse of numbers 
def InverseofNumber(p): 
    naturalNumInverse[0] = naturalNumInverse[1] = 1
    for i in range(2, N + 1, 1): 
        naturalNumInverse[i] = (naturalNumInverse[p % i] * 
                                (p - int(p / i)) % p) 
# Function to precompute inverse  
# of factorials 
def InverseofFactorial(p): 
    factorialNumInverse[0] = factorialNumInverse[1] = 1
  
    # precompute inverse of natural numbers 
    for i in range(2, N + 1, 1): 
        factorialNumInverse[i] = (naturalNumInverse[i] * 
                                  factorialNumInverse[i - 1]) % p 
  
# Function to calculate factorial of 1 to N 
def factorial(p): 
    fact[0] = 1
  
    # precompute factorials 
    for i in range(1, N + 1): 
        fact[i] = (fact[i - 1] * i) % p 
  
# Function to return nCr % p in O(1) time 
def Binomial(N, R, p): 
    
      
    # n C r = n!*inverse(r!)*inverse((n-r)!) 
    ans = ((fact[N] * factorialNumInverse[R])% p * 
                      factorialNumInverse[N - R])% p 
    return ans 


def main():
    starttime=datetime.datetime.now()
    if(os.path.exists('input.txt')):
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    
    
    for _ in range(1):
        n=ri()
        print("ACL"*n)
        
        
        
        
        
                    
        
    #<--Solving Area Ends
    endtime=datetime.datetime.now()
    time=(endtime-starttime).total_seconds()*1000
    if(os.path.exists('input.txt')):
        print("Time:",time,"ms")  
    
                
class FastReader(io.IOBase):
    newlines = 0

    def __init__(self, fd, chunk_size=1024 * 8):
        self._fd = fd
        self._chunk_size = chunk_size
        self.buffer = io.BytesIO()

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
            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, size=-1):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
            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()


class FastWriter(io.IOBase):

    def __init__(self, fd):
        self._fd = fd
        self.buffer = io.BytesIO()
        self.write = self.buffer.write

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


class FastStdin(io.IOBase):
    def __init__(self, fd=0):
        self.buffer = FastReader(fd)
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


class FastStdout(io.IOBase):
    def __init__(self, fd=1):
        self.buffer = FastWriter(fd)
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.flush = self.buffer.flush


if __name__ == '__main__':
    sys.stdin = FastStdin()
    sys.stdout = FastStdout()
    main()

Submission status: Accepted

Solution code:
print("ACL" * int(input()));

Submission status: Accepted

Solution code:
K = int(input())
print('ACL' * K)

Submission status: Accepted

Solution code:
k = int(input())
ans = ""
for i in range(k):
    ans+="ACL"
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
string = "ACL"

print(string * n)

Submission status: Accepted

Solution code:
def main():
    K = int(input())
    print('ACL'*K)
    return
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
num=int(input())

for i in range(num):
    print("ACL",end="")

Submission status: Accepted

Solution code:
k = int(input()); a = ""
for i in range(k):
    a += "ACL"
print(a)

Submission status: Accepted

Solution code:
K = int(input())
a = ''
for i in range(K) :
    a += 'ACL'
print(a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())
# k = 4

ans = ""
for x in range(k):
    ans += "ACL"
    
    
print(ans)

Submission status: Accepted

Solution code:
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
INF = float('inf')
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
K = int(input())

s = 'ACL' * K
print(s)

Submission status: Accepted

Solution code:
def main():
    K = int(input())
    print('ACL' * K)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
K = int(input())

ans = ''
for i in range(K):
  ans += 'ACL'
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
strr = ""
for num in range(n):
  strr += "ACL"
  
print(strr)

Submission status: Accepted

Solution code:
n = int(input())
ans = ''
for i in range(n):
  ans += 'ACL'
print(ans)

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
  print("ACL", end="")

Submission status: Accepted

Solution code:
def readInt():
    return int(input())
def readList():
    return list(map(int,input().split()))
def readMap():
	return map(int,input().split())
def readStr():
    return input()
inf=float('inf')
mod = 10**9+7
import math
from itertools import permutations
def solve(K):
    return "ACL"*K

K=readInt()
print(solve(K))

Submission status: Accepted

Solution code:
N = int(input())

X = ""
for i in range(N):
    X += "ACL"
print(X)

Submission status: Accepted

Solution code:
k=int(input())
tmp='ACL'
ans=''
for i in range(k):
    ans+=tmp
print(ans)

Submission status: Accepted

Solution code:
k = input()
q = ''
for i in range(int(k)):
    q += 'ACL'
print(q)

Submission status: Accepted

Solution code:
K = int(input())

ans = "ACL" * K

print(ans)

Submission status: Accepted

Solution code:
K = int(input(""))
print("ACL"*K)

Submission status: Accepted

Solution code:
K = int(input())
c = 'ACL'
s = c * K
print(s)

Submission status: Accepted

Solution code:
k = int(input())
s = "ACL"
ans = ""
for i in range(k):
    ans += s
print(ans)

Submission status: Accepted

Solution code:
k=int(input())
string = 'ACL'

print(string*k)

Submission status: Accepted

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

Submission status: Accepted

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

print("ACL" * K)

Submission status: Accepted

Solution code:
N= int(input())
a = ''
b = 'ACL'
for i in range(N):
  a+=b
  
print(a)

Submission status: Accepted

Solution code:
print('ACL'*(int(input())))

Submission status: Accepted

Solution code:
n=int(input())
s = ""
for i in range(n):
  s += "ACL"
print(s)

Submission status: Accepted

Solution code:
n=int(input())
for i in range(n):
    print("ACL",end='')

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
    print('ACL', end="")

Submission status: Accepted

Solution code:
K=int(input())
L=''
for i in range(K):
    L+='ACL'
print(L)

Submission status: Accepted

Solution code:
k = int(input())

ans = "ACL"*k
print(ans)

Submission status: Accepted

Solution code:
k = int(input())
a = "ACL"
print(a * k)

Submission status: Accepted

Solution code:
import sys
from sys import stdin
def I():
    return stdin.readline().rstrip()
def MI():
    return map(int,stdin.readline().rstrip().split())
def LI():
    return list(map(int,stdin.readline().rstrip().split()))
#main part
k=int(I())
s='ACL'
ans=''
for i in range(k):
    ans=ans+s
print(ans)

Submission status: Accepted

Solution code:
K = int(input())

A = str()

for _ in range(K):
    A += 'ACL'

print(A)

Submission status: Accepted

Solution code:
A="ACL"
K=int(input())
print(A*K)

Submission status: Accepted

Solution code:
def run(s):
    '''

    '''
    print('ACL'*s)

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

    run(s)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 26 17:29:23 2020

@author: divyarth
"""

import sys
import heapq
import math

#sys.setrecursionlimit(100000)
#input=sys.stdin.readline
#print=sys.stdout.write

from collections import deque
from collections import defaultdict
from collections import Counter

modH=int(10**9)+7
I=lambda : list(map(int,input().split(' ')))
def PRINT(lst,sep=' '): print(sep.join(map(str,lst)))


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

Submission status: Accepted

Solution code:
K = int(input())


def main():
    ans = "ACL" * K
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
k = int(input())

str = ""

for cnt in range(k):
    str += "ACL"

print(str)

Submission status: Accepted

Solution code:
K = int(input())
ans = ""
for _ in range(K):
  ans += "ACL"
print(ans)

Submission status: Accepted

Solution code:
k = int(input())
ans = ''
for i in range(k):
  ans += 'ACL'
print(ans)

Submission status: Accepted

Solution code:
K = int(input())
w = ""
for i in range(K):
  w += "ACL"
print(w)

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
    print("ACL",end = "")

Submission status: Accepted

Solution code:
# 2020/09/26
# ACL Beginner Contest - A

# Input
n = int(input())
ans = ''

# Calc
for i in range(n):
    ans = ans + 'ACL'

# Output
print(ans)

Submission status: Accepted

Solution code:
s='ACL'
n=int(input())

print(s*n)

Submission status: Accepted

Solution code:
str = "ACL"
result = ""
K = int(input())
for i in range(K):
  result += str
print(result)

Submission status: Accepted

Solution code:
k = int(input())
k2 = "ACL"*k
print(k2)

Submission status: Accepted

Solution code:
def main():
    moji = "ACL"
    ans = ""
    K = int(input())
    for i in range(K) :
        ans = ans + moji

    print(ans)


if __name__ == '__main__':
    main()

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 inplt(n): return [tuple(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

k = inp()
ans = 'ACL' * k
print(ans)

Submission status: Accepted

Solution code:
# aclbc_a.py
N = int(input())
ans =list("ACL")
print("".join(ans*N))

Submission status: Accepted

Solution code:
a = int(input())
for data in range(a):
    print("ACL", end="")

Submission status: Accepted

Solution code:
#                               #
    # author : samars_diary #
    # 26-09-2020 │ 17:30:28 #
#                               #

import sys, os.path

#if(os.path.exists('input.txt')):
    #sys.stdin = open('input.txt',"r")
    #sys.stdout = open('output.txt',"w")

sys.setrecursionlimit(10 ** 5)

def mod(): return 10**9+7
def ii(): return int(sys.stdin.readline())
def si(): return sys.stdin.readline().strip()
def li(): return list(sys.stdin.readline().strip())
def mii(): return map(int, sys.stdin.readline().split())
def lii(): return list(map(int, sys.stdin.readline().strip().split()))

#print=sys.stdout.write

def solve():
    a = ii()
    print(a*"ACL")

for _ in range(1):
    solve()

Submission status: Accepted

Solution code:
#A
k = int(input())
print('ACL'*k)

Submission status: Accepted

Solution code:
K = int(input())
a = ''
for i in range(K):
  a = a + 'ACL'
print(a)

Submission status: Accepted

Solution code:
def main():
    k = int(input())
    ans = ""
    for _ in range(k):
        ans += "ACL"
    return ans


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

Submission status: Accepted

Solution code:
# A
k = int(input())
print('ACL' * k)

Submission status: Accepted

Solution code:
def solve(k):
    return "ACL" * k


def main():
    k = int(input())
    res = solve(k)
    print(res)


def test():
    assert solve(3) == "ACLACLACL"


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

Submission status: Accepted

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

import sys

input = iter(sys.stdin.read().splitlines()).__next__

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

Submission status: Accepted

Solution code:
K = int(input())
s = ''
for i in range(K):
    s = s + 'ACL'
print(s)

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
    print("ACL", end="")
print()

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
    print('ACL',end="")

Submission status: Accepted

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

print('ACL' * int(input()))

Submission status: Accepted

Solution code:
k = int(input())
ans = ""

for i in range(k):
    ans += "ACL"

print(ans)

Submission status: Accepted

Solution code:
k = int(input())
word = ''

for i in range(k):
    word += 'ACL'
    
print(word)

Submission status: Accepted

Solution code:
k = int(input())
ans = "ACL"*k
print(ans)

Submission status: Accepted

Solution code:
K = int(input())
ans = ""
for i in range(K):
  ans += "ACL"
print(ans)

Submission status: Accepted

Solution code:
a = 'ACL'
k = int(input())
print(a * k)

Submission status: Accepted

Solution code:
N = int(input())

print('ACL'*N)

Submission status: Accepted

Solution code:
k=int(input())

ans=""
for i in range(k):
    ans+="ACL"

print(ans)

Submission status: Accepted

Solution code:
s = "ACL"
K = int(input())

ans = ""
for i in range(K):
    ans += s

print(ans)

Submission status: Accepted

Solution code:
K = int(input())

for i in range(K):
  print("ACL", end = "")

Submission status: Accepted

Solution code:
K = int(input())
for _ in range(K):
    print("ACL", end="")
print()

Submission status: Accepted

Solution code:
k=int(input())
result = ''
for i in range(k):
  result += 'ACL'
print(result)

Submission status: Accepted

Solution code:
i = int(input())
print("ACL" * i)

Submission status: Accepted

Solution code:
k = int(input())

ans = ''
for i in range(k):
    ans += 'ACL'

print(ans)

Submission status: Accepted

Solution code:
s = int(input())
ss = 'ACL'*s
print(ss)

Submission status: Accepted

Solution code:
n = int(input())
a = ""
for i in range(n):
    a = "ACL" * n
print(a)

Submission status: Accepted

Solution code:
import sys

K = int(sys.stdin.readline())
print("ACL" * K)

Submission status: Accepted

Solution code:
aaa="ACL"
x=int(input())
print(aaa*x)

Submission status: Accepted

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

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

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

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

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

def main():
    k = int(input())
    print("ACL" * k)

main()

Submission status: Accepted

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

import sys


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


def main():
    n = int(std_in())
    print("ACL" * n)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
S = int(input())
print('ACL'*S)

Submission status: Accepted

Solution code:
K = int(input())

acl = "ACL"
ans = ""

for i in range(K):
    ans += acl
print(ans)

Submission status: Accepted

Solution code:
k = int(input())
a = ""
for _ in range(k):
  a += 'ACL'
print(a)

Submission status: Accepted

Solution code:
from collections import Counter
import string
import math
import sys
def array_int():
    return [int(i) for i in sys.stdin.readline().split()]
def vary(number_of_variables):
    if number_of_variables==1:
        return int(sys.stdin.readline())
    if number_of_variables>=2:
        return map(int,sys.stdin.readline().split()) 
def makedict(var):
    return dict(Counter(var))
mod=100000007
import math
fact=[1]
MAX=100001
mod=998244353
for i in range(1,MAX):
	fact.append((fact[-1]*i)%mod)
def ncr(n , k): 
    global mod,fact
    num=fact[n]
    den=((fact[n-k])*(fact[k]))%mod
    return (num*pow(den,mod-2,mod))%mod
k=vary(1)
print('ACL'*k)

Submission status: Accepted

Solution code:
x = input()

print('ACL' * int(x))

Submission status: Accepted

Solution code:
K = int(input())

ans = ''
for i in range(K):
    ans += 'ACL'

print(ans)

Submission status: Accepted

Solution code:
ans=[]
K=int(input())
for i in range(K):
    ans.append("ACL")
print(*ans,sep="")

Submission status: Accepted

Solution code:
K = int(input())


s = ""

for i in range(K):
    s += "ACL"

print(s)

Submission status: Accepted

Solution code:
### ----------------
### ここから
### ----------------

import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    #n,m,k=map(int, readline().rstrip().split())
    #arr=list(map(int, readline().rstrip().split()))
    n=int(readline())
    ans=""
    for _ in range(n):
        ans+="ACL"
    print(ans)
    #ss=readline().rstrip()
    #yn(1)

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

### ----------------
### ここまで 
### ----------------

Submission status: Accepted

Solution code:
import math

#N = map(int,input().split())
#AB=[]
N = int(input())
#C = input()
s = ""
for i in range(N):
    s+="ACL"
print(s)

Submission status: Accepted

Solution code:
k=int(input())
ans=""
for i in range(k):
    ans=ans+"ACL"
print(ans)

Submission status: Accepted

Solution code:
K=int(input())
ans='ACL'*K
print(ans)

Submission status: Accepted

Solution code:
s = "ACL"
k = int(input())
ans = ""
for _ in range(k):
    ans += s
print(ans)

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
  print('ACL', end='')

Submission status: Accepted

Solution code:
import sys
import bisect
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
  return int(readline())
def reads():
  return map(int, readline().split())

K=read()

a="ACL"
print(a*K)

Submission status: Accepted

Solution code:
for i in range(int(input())):
    print("ACL", end="")
print()

Submission status: Accepted

Solution code:
k = int(input())
for i in range(k):
    print('ACL', end='')
print('')

Submission status: Accepted

Solution code:
K = int(input())
s = ''
for i in range(K):
    s += 'ACL'
print(s)

Submission status: Accepted

Solution code:
import sys,math,collections
from collections import defaultdict

#from itertools import permutations,combinations
    
def file():
    sys.stdin = open('input.py', 'r')
    sys.stdout = open('output.py', 'w') 
def get_array():
    l=list(map(int, input().split()))
    return l
def get_ints():   
    return map(int, input().split())
    #return a,b
def get_3_ints():   
    a,b,c=map(int, input().split())
    return a,b,c    
def sod(n):
    n,c=str(n),0
    for i in n: 
        c+=int(i)
    return c    
def isPrime(n):
    if (n <= 1):
        return False
    if (n <= 3):
        return True
    if (n % 2 == 0 or n % 3 == 0):
        return False
    i = 5
    while(i * i <= n):
        if (n % i == 0 or n % (i + 2) == 0):
            return False
        i = i + 6
  
    return True
def getFloor(A, x):

    (left, right) = (0, len(A) - 1)

    floor = -1
    while left <= right:
        mid = (left + right) // 2
        if A[mid] == x:
            return A[mid]
        elif x < A[mid]:
            right = mid - 1
        else:
            floor = A[mid]
            left = mid + 1
            
    return floor
def chk(aa,bb):
	f=0
	for i in aa:
		for j in bb:
			if(j[0]>=i[0] and j[1]<=i[1]):
				f+=1
			elif(j[0]<=i[0] and j[1]>=i[1]):	
				f+=1
			elif(i[0]==j[1] or i[1]==j[0]):
				f+=1
			else:
				continue
	return f			

#file()
def main():
	n=int(input())
	for i in range(n):
		print("ACL",end="")


	
	



		




				





		


	





        
            
        























    

    
    

        











        
        

        























































                

            







            
            
































        








if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

n = int(input())

ans = ""

for i in range(n):
    ans = ans + "ACL"

print(ans)

Submission status: Accepted

Solution code:
k = int(input())

print(k * 'ACL')

Submission status: Accepted

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

import sys

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_str_split(): return list(sys.stdin.readline().strip())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))

def Main():
    k = read_int()
    print('ACL' * k)

if __name__ == '__main__':
    Main()

Submission status: Accepted

Solution code:
k = int(input())

word = "ACL"* k
print(word)

Submission status: Accepted

Solution code:
(N, ) = [int(n) for n in input().split()]
print('ACL'*N)

Submission status: Accepted

Solution code:
k = int(input())
ans = ""
for i in range(k):
    ans += "ACL"
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys


# \n
def input():
    return sys.stdin.readline().rstrip()


def main():
    K=int(input())
    print("ACL"*K)






if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
k = int(input())

for i in range(k):
    print('ACL', end='')

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
def main():
    K = int(input())
    print('ACL' * K)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
K=int(input())

str=[]
for _ in range(K):
  str=str+["ACL"]
print("".join(str))

Submission status: Accepted

Solution code:
from sys import stdin, stdout
from collections import defaultdict
input = stdin.readline
k = int(input())
print("ACL"*k)

Submission status: Accepted

Solution code:
def resolve():
    k = int(input())
    print("ACL"*k)
resolve()

Submission status: Accepted

Solution code:
k=int(input())
ans=''
for _ in range(k):
    ans+='ACL'
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = "ACL"

K = int(input())
s = ""
for _ in range(K):
  s += a
  
print(s)

Submission status: Accepted

Solution code:
def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

k = int(input())
ans = "ACL"*k
print(ans)

Submission status: Accepted

Solution code:
K = int(input())
ans = ""
for i in range(K):
    ans += "ACL"

print(ans)

Submission status: Accepted

Solution code:
from math import gcd

from math import factorial as f

from math import ceil, floor, sqrt
import math

import bisect
import re
import heapq

from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

yes = "Yes"
no = "No"


def main():
    a = 'ACL'
    n = ii()
    ans = ''
    for i in range(n):
        ans += a
    print(ans)


main()

Submission status: Accepted

Solution code:
k = int(input())
s = str()
for i in range(k):
    s += 'ACL'
print(s)

Submission status: Accepted

Solution code:
k=int(input())
ans=''
for i in range(k):
  ans+='ACL'
print(ans)

Submission status: Accepted

Solution code:
import math
import sys
import os

sys.setrecursionlimit(10**7)

def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))

if os.getenv("LOCAL"):
    inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
    sys.stdin = open(inputFile, "r")
INF = float("inf")


a = I()
ans = ''

for _ in range(a):
    ans += 'ACL'

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
I=lambda:int(input())
MI=lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))


K=I()
print('ACL'*K)

Submission status: Accepted

Solution code:
k = int( input() )
a = 'ACL'
print( a * k )

Submission status: Accepted

Solution code:
K = int(input())

A = 'ACL'

print(A*K)

Submission status: Accepted

Solution code:
import sys

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

K = INT()
ans = 'ACL' * K
print(ans)

Submission status: Accepted

Solution code:
k=int(input())
for i in range(k):
  print("ACL",end="")
print()

Submission status: Accepted

Solution code:
K=int(input())
ans=""
for i in range(K):
  ans+="ACL"
print(ans)

Submission status: Accepted

Solution code:
k = int(input())

ans = ""
for i in range(k) :
    ans += "ACL"
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math

n = int(input())

print("ACL" *n)

Submission status: Accepted

Solution code:
K = int(input())
S = ""
for i in range(K):
    S += "ACL"
print(S)

Submission status: Accepted

Solution code:
k = int(input())
s = ''
for i in range(k):
    s += 'ACL'
print(s)

Submission status: Accepted

Solution code:
n=int(input())
s=[]
for i in range(n):
  s.append('A')
  s.append('C')
  s.append('L')
print(''.join(s))

Submission status: Accepted

Solution code:
def main():
    k = int(input())
    print("ACL" * k)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
k=int(input())
acl='ACL'
s=''
for i in range(k):
    s+=acl
print(s)

Submission status: Accepted

Solution code:
k = 'ACL' * int(input())
print(k)

Submission status: Accepted

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


k = int(input())
ans = ""
for i in range(k):
    ans += "ACL"
print(ans)

Submission status: Accepted

Solution code:
def main():
    K = int(input())
    print('ACL' * K)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = int(input())
#a,b = map(int,input().split())
#a = list(map(int,input().split()))
ans = 0
cnt = 0
print("ACL"*s)