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:
s = ''
for i in range(int(input())):
    s += 'ACL'

print(s)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
K = int(input())

if K == 1:
    print("ACL")
elif K == 2:
    print("ACLACL")
elif K == 3:
    print("ACLACLACL")
elif K == 4:
    print("ACLACLACLACL")
else:
    print("ACLACLACLACLACL")

Submission status: Accepted

Solution code:
K = int(input())
k = 'ACL'
ans = []
for i in range(K):
  ans.append(k)
  
ans = ''.join(ans)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(s * K)

Submission status: Accepted

Solution code:
K = int(input())

if K == 1:
    print("ACL")
elif K == 2:
    print("ACLACL")
elif K == 3:
    print("ACLACLACL")
elif K == 4:
    print("ACLACLACLACL")
else:
    print("ACLACLACLACLACL")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Kを受け取る
K = int(input())

# 文字列ACLを作るために、リストlを用意
l = ['A', 'C', 'L']

# 入力されたKの値に応じて、出力する文字列の分岐を作る
if 1<= K <= 5:
    K_letters = K*l
    out_letters = ''.join(K_letters)
    print(out_letters)

else:
    print('error')

Submission status: Accepted

Solution code:
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())
str = ""
for i in range(k):
  str = str + "ACL"
print(str)

Submission status: Accepted

Solution code:
k=int(input())
if k==1:
  print('ACL')
elif k==2:
  print('ACLACL')
elif k==3:
  print('ACLACLACL')
elif k==4:
  print('ACLACLACLACL')
elif k==5:
  print('ACLACLACLACLACL')

Submission status: Accepted

Solution code:
K = int(input())

print("ACL"*K)

Submission status: Accepted

Solution code:
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
import sys;input = sys.stdin.readline
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]

print('ACL'*inp())

Submission status: Accepted

Solution code:
K = int(input())

strings = []
for i in range(K):
    strings += 'ACL'

print(*strings,sep="")

Submission status: Accepted

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

Submission status: Accepted

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

print(s)

Submission status: Accepted

Solution code:
K = int(input())

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

print(str)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
n = int(input())

print('ACL' * n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())

print("ACL" * k)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

if(x < 1 or x > 5):
  print("")
else:
  for i in range(x):
    print("ACL",end='')

Submission status: Accepted

Solution code:
def func(K):
  result = ""
  for i in range(K):
    result += "ACL"
  return result

if __name__ == "__main__":
    K = int(input())
    print(func(K))

Submission status: Accepted

Solution code:
def read_int(x):
  return int(x)

def repeat(ch,n):
  return ''.join(list(map(lambda _: ch,range(n))))

def main():
  cnt = read_int(input())
  print(repeat("ACL",cnt))
  
main()

Submission status: Accepted

Solution code:
k = int(input())

print(k*'ACL')

Submission status: Accepted

Solution code:
N = int(input())

a = 'ACL'

for i in range(N-1):
	a+= 'ACL'
print(a)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import copy
import math
import time
import statistics
import math
import itertools
import bisect
import sys
from decimal import *
from collections import deque


def get_int():
    return int(input())

def get_string():
    return input()

def get_int_list():
    return [int(x) for x in input().split()]

def get_string_list():
    return input().split()

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

def get_string_char_list():
    return list(str(input()))

# print("{} {}".format(a, b))
# a_list = [0] * a
sys.setrecursionlimit(10 ** 6)

def main():
    start = time.time()

    n = get_int()
    s = ""
    for _ in range(n):
        s += "ACL"

    print(s)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
K = int(input())
list=[]
for i in range(K):
    list.append("ACL")
print("".join(list))

Submission status: Accepted

Solution code:
def repeat_acl(K: int) -> str:
    return "ACL" * K


if __name__ == "__main__":
    K = int(input())
    ans = repeat_acl(K)
    print(ans)

Submission status: Accepted

Solution code:
# input()
# int(input())
# map(int, input().split())
# list(map(int, input().split()))
# list(map(int, list(input()))) # スペースがない数字リストを読み込み
import math
import fractions
import sys
import bisect
import heapq  # 優先度付きキュー(最小値取り出し)
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

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

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

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

    return arr


# a^n
def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod


# n*(n-1)*...*(l+1)*l
def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a

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

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

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

        if x == y:
            return

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

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

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

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

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

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

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

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

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

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

    divisors.sort()
    return divisors

inf = 10 ** 18
mod = 10 ** 9 + 7

k = ir()
s = 'ACL'
a = [s for i in range(k)]
print(*a, sep='')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())
s = 'ACL'
retVal = ''

for _ in range(k):
    retVal += s

print(retVal)

Submission status: Accepted

Solution code:
K=int(input())

S='ACL'*K
print(S)

Submission status: Accepted

Solution code:
K = int(input())

print("ACL" * K)

Submission status: Accepted

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

def solve():
   return 'ACL'*int(input())

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

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 = ''
for i in range(K):
  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:
K = int(input())
s = ''
for i in range(K):
  s = s + 'ACL'
print(s)

Submission status: Accepted

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

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())
print(K*"ACL")

Submission status: Accepted

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

def main():
    n = int(input())
    ans = 'ACL'
    ans *= n

    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())
ans =[]
a ='ACL'
for i in range(k):
  ans.append(a)

print(''.join(ans))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(word * n)

Submission status: Accepted

Solution code:
K = int(input())

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

print(b)

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
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)
INF = 10**9
mod = 10**9+7

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

Submission status: Accepted

Solution code:
import math
import collections
import itertools
import copy

def YesNo(Bool):
    if(Bool):
        print("YES")
    else:
        print("NO")
    return

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

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

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

        if x == y:
            return

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

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

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

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

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

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

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

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

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

def resolve():
    K=int(input())

    ans="ACL"*K

    print(ans)
    
resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
_str = ""
_k = int(input())
for _i in range(_k):
  _str += "ACL"
print(_str)

Submission status: Accepted

Solution code:
k=int(input())
list=[str("ACL")]*k
ans = str()
for i in range(k):
  ans = ans+str(list[i])
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

    word = "ACL"
    k = I()
    print(word*k)

main()

Submission status: Accepted

Solution code:
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp

INF = inf
MOD = 1000000007

k = int(input())

tmp = 0
res = ""

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

print(res)

Submission status: Accepted

Solution code:
k = int(input())

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

print('')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
_int = int(input())
_string = ""
for i in range(_int):
  _string += "ACL"


print(_string)

Submission status: Accepted

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

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())

answer="ACL"*K
print(answer)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    import sys
    K=int(sys.stdin.readline())
    print('ACL'*K)



main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())
str1 = "ACL"
str2 = "ACL"
for i in range(k-1):
  str1 = "".join([str1,str2])
print(str1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

a=int(input())
print("ACL"*a)

Submission status: Accepted

Solution code:
a = int(input())

if a == 1:
    print("ACL")
elif a == 2:
    print("ACLACL")
elif a == 3:
    print("ACLACLACL")
elif a == 4:
    print("ACLACLACLACL")
else:
    print("ACLACLACLACLACL")

Submission status: Accepted

Solution code:
A = input()
B = "ACL"
C = "ACL"
for i in range(int(A)-1):
  B = B + C 
print(B)

Submission status: Accepted

Solution code:
x = int(input())

print ("ACL" * x)

Submission status: Accepted

Solution code:
k = int(input())

t = "ACL"*k
print(t)

Submission status: Accepted

Solution code:
#A

K = int(input())

print("ACL" * K)

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 i in range(K):

  print("ACL", end='')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#import collections
# c = collections.Counter()
#import itertools as it
#import math
#import numpy as np
#import sys 
#sys.exit()
 
#a = int(input())
 
k = int(input())
#a, b  = map(int, input().split())
'''
#  = list(map(int, input().split()))
'''
'''
n = input()
a = [int(input()) for i in range(n)]
'''
'''
n,m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
'''
 
#-------------------------------#
#len(t)==len(s)+1
#print(t[0:-1])
#print(a+pow(a,2)+pow(a,3))

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    K = int(input())
    result = solve(K)
    print(result)


def solve(K: int) -> str:
    return 'ACL' * K


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]


#-------------------------code---------------------------#
#vsInput()

print('ACL'*Int())

Submission status: Accepted

Solution code:
n = int(input())

output = 'ACL'*n
print(output)

Submission status: Accepted

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

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

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:
ary = 'ACL'
k = int(input())
count=''

for i in range(k):
    count += ary
    
print(count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

if __name__ == "__main__":
    N = int(input())
    ret = "ACL" * N
    print(ret)

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def main():
    n = int(input())
    s = ['ACL'] * n
    print(''.join(s))

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
K = int(input())

ans = "ACL" * K

print(ans)

Submission status: Accepted

Solution code:
#!python3.8
# -*- coding: utf-8 -*-
# abl/abl_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():
    K = i2n()
    print('ACL' * K)
    return

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())

print('ACL'*k)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = int(input())

print("ACL" * s)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k=int(input())

print("ACL"*k)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
K = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
input = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

A = str()
for i in range(x):
  A = A + 'ACL' 
  i += 1
 
print(A)

Submission status: Accepted

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

Submission status: Accepted

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

print(o)

Submission status: Accepted

Solution code:
moji = 'ACL'

K = int(input())
for i in range(K):
  if i==0:
    out = moji
  else:
    out = out + moji
print(out)

Submission status: Accepted

Solution code:

def resolve():
    import sys

    input = sys.stdin.readline

    n = int(input().rstrip())
    print("".join("ACL" for _ in range(n)))
    



if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
K = int(input())

acl = 'ACL'
op = ''
for k in range(K):
  op += acl

print(op)

Submission status: Accepted

Solution code:
K = int(input())
output = "".join(['ACL' for k in range(K)])
print(output)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = int(input())

if a == 1:
  b = "ACL"
elif a == 2:
  b = "ACLACL"
elif a == 3:
  b = "ACLACLACL"
elif a == 4:
  b = "ACLACLACLACL"
elif a == 5:
  b = "ACLACLACLACLACL"
  
  
print(b)

Submission status: Accepted

Solution code:
k=int(input())
a=[]
for i in range(k):
  a.append("ACL")
print("".join(a))

Submission status: Accepted

Solution code:
n=int(input())
if n==1:
  print('ACL')
if n==2:
  print('ACLACL')
if n==3:
  print('ACLACLACL')
if n==4:
  print('ACLACLACLACL')
if n==5:
  print('ACLACLACLACLACL')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
K=int(input())

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

Submission status: Accepted

Solution code:
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
# 
# 
# @stop_watch
def solve(K):
    print('ACL' * K)


if __name__ == '__main__':
    # S = input()
    K = int(input())
    # N, M = map(int, input().split())
    # A = [int(i) for i in input().split()]
    # B = [int(i) for i in input().split()]
    # AB = [[int(i) for i in input().split()] for _ in range(N)]
    solve(K)

    # # test
    # from random import randint
    # from func import random_str
    # solve()

Submission status: Accepted

Solution code:
N = int(input())
ACL_str = []
for i in range(N):
    ACL_str.append('ACL')
mojiretu = ''.join(ACL_str)
print(mojiretu)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

s = ''
for i in range(n):
  s += 'ACL'

print(s)

Submission status: Accepted

Solution code:
k = int(input())

print('ACL' * k)

Submission status: Accepted

Solution code:
K = int(input())

ans = 'ACL'

for i in range(0,K-1):
  ans = ans + 'ACL'

print(ans)

Submission status: Accepted

Solution code:
ans = ""

k = int(input())

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

print(ans)

Submission status: Accepted

Solution code:
import sys
import os
# import math
# input = sys.stdin.readline

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


def str_array():
    return input().strip().split()

def gcd(a,b):
    if b == 0:
        return a
    return gcd(b, a % b);x

def take_input():
	if os.environ.get("check"):
		sys.stdin = open('input.txt', 'r') 
		sys.stdout = open('output.txt', 'w')
		
take_input()
######################### TEMPLATE ENDS HERE #################################

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

Submission status: Accepted

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

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

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

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

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

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

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

#

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

Yes = 'Yes'
No = 'No'

def main():
    K = ii()
    print('ACL'*K)











main()

Submission status: Accepted

Solution code:
k = int(input())

i = 0
ans = ""

for i in range(k):

    ans += "ACL"
    #print(ans)

    i += 1

print(ans)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
# 幅優先探索（行きがけ）
import collections
import sys
import copy
import re
import math


def I(): return int(sys.stdin.readline().rstrip())


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


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


def LS(): return list(sys.stdin.readline().rstrip().split())


def main():
    K = I()

    ans = ""

    for _ in range(K):
        ans+="ACL"
    
    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:
#!/usr/bin/env python3
import sys


def solve(K: int):
    print(''.join(['ACL'] * K))
    return


# Generated by 1.1.7.1 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()
    K = int(next(tokens))  # type: int
    solve(K)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
K = int(input())

n = ''

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

print(n)

Submission status: Accepted

Solution code:
str = input()
K = int(str)

output = 'ACL' * K
print(output)

Submission status: Accepted

Solution code:
# cook your dish here
n=int(input())
s="ACL"*n

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:
k = int(input())
for i in range(k):
  print('ACL', end="")

Submission status: Accepted

Solution code:
# k : 文字列を繰り返す回数
k = int(input())
s = ""

for num in range(k):
    s += "ACL"

print(s)

Submission status: Accepted

Solution code:
num = int(input())

print('ACL'*num)