{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "StatementSid1",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::182260599663:user/sang*****"
            },
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject"
            ],
            "Resource": "arn:aws:s3:::humble/*"
        },
        {
            "Sid": "StatementSid2",
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::humble/*"
        }
    ]
}

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "PUT",
            "POST",
            "DELETE"
        ],
        "AllowedOrigins": [
            "http://www.example1.com"
        ],
        "ExposeHeaders": [
            "ETag"
        ],
        "MaxAgeSeconds": 3000
    }
]

class ProjectView(View):
    @login_decorator
    def post(self, request):
        try:
            user = request.user
            data = request.POST

            image = request.FILES.get('image')
            #폼데이터로 받은 파일을 이미지 변수에 넣는다
            input_date = data.get('end_date')

            if not image:
                return JsonResponse({'MESSAGE' : 'IMAGE_EMPTY'}, status=400)

            upload_key = str(uuid.uuid4()) + image.name
            #uuid와 이미지 이름으로 키를 생성한다
            s3_client = boto3.client(
                's3',
                aws_access_key_id     = ACCESS_KEY_ID,
                aws_secret_access_key = SECRET_ACCESS_KEY,
            )
            #s3서버에 접근한다

            Project.objects.create(
                name           = data.get('name'),
                user_id        = user.id,
                aim_amount     = data.get('aim_amount'),
                description    = data.get('description'),
                end_date       = input_date[6:10]+'-'+input_date[:2]+'-'+input_date[3:5],
                category_id    = data.get('category_id'),
                main_image_url = 'https://humblebug.s3.us-east-2.amazonaws.com/' + upload_key
                #aws버킷경로와 업로드 키를 포함한 URL을 저장한다. 이렇게 하고 퍼블릭 엑세스를 해제하면 url을 클릭했을 때 브라우저에서 바로 이미지가 나온다.  
            )

            s3_client.upload_fileobj(
                image,
                BUCKET_NAME,
                upload_key,
                ExtraArgs = {
                    'ContentType' : image.content_type #확장자였나..?
                }
            )
            #s3서버에 이미지를 업로드한다

            return JsonResponse({'MESSAGE':'SUCCESS'},status = 201)
    
        except KeyError:
            return JsonResponse({'MESSAGE':'ERROR_INPUT_VALUE'}, status=404) 

class CloudStorage:
    def __init__(self, ACCESS_KEY_ID, SECRET_ACCESS_KEY, BUCKET_NAME):
        self.ACCESS_KEY_ID = ACCESS_KEY_ID
        self.SECRET_ACCESS_KEY = SECRET_ACCESS_KEY
        self.BUCKET_NAME = BUCKET_NAME
        self.client = boto3.client(
                's3',
                aws_access_key_id     = ACCESS_KEY_ID,
                aws_secret_access_key = SECRET_ACCESS_KEY,
            )
        self.resource = boto3.resource(
                's3',
                aws_access_key_id     = ACCESS_KEY_ID,
                aws_secret_access_key = SECRET_ACCESS_KEY,
            )
    #AWS 관련 데이터를 변수로 넣는다
        
    def upload_file(self, file):
        file_url = "사용하는 회사의 aws url.ap-northeast-2.rds.amazonaws.com/" + str(uuid.uuid1()) + file.name
        self.client.upload_fileobj(
                        file,
                        self.BUCKET_NAME,
                        file_url,
                        ExtraArgs={
                            "ContentType": file.content_type
                        }
        )
        return file_url

    def delete_file(self, file_url, project_id):
        main_image_url = Project.objects.get(id=project_id).file_url
        bucket = self.resource.Bucket(name=BUCKET_NAME)
        bucket.Object(key = file_url).delete()
    #AWS관련 액션들을 매쏘드로 넣는다

class ProjectUpload(View):
    @login_decorator
    def post(self, request):
        cloud_storage = CloudStorage(ACCESS_KEY_ID, SECRET_ACCESS_KEY, BUCKET_NAME)
        try:
            data = request.POST

            if request.FILES:
                file_url = (cloud_storage.upload_file(file))
                #그러면 이렇게 한 줄로 업로드하고 리턴 받은 url을 가져와서 사용할 수 있다.

            if not request.FILES:
                return JsonResponse({'MESSAGE' : 'IMAGE_EMPTY'}, status=400)

            Project.objects.create(
                    name           = data.get('name'),
                    user_id        = request.user.id,
                    aim_amount     = data.get('aim_amount'),
                    description    = data.get('description'),
                    end_date       = data.get('end_date')[0:4]+'-'+data.get('end_date')[5:7]+'-'+data.get('end_date')[8:10],
                    category_id    = data.get('category_id'),
                    main_image_url = file_url
                    #삭제하고 싶을 때는 앞에 url을 빼고 키값만 넣어줘야한다.
                    )
            return JsonResponse({'MESSAGE':'SUCCESS'}, status = 200)

        except KeyError:
            return JsonResponse({'MESSAGE':'ERROR_INPUT_VALUE'}, status=404)

class ProjectModify(View):
    @login_decorator
    def post(self, request, project_id):
        try:
            data = request.POST

            if not Project.objects.filter(id=project_id, user_id=request.user.id).exists():
                return JsonResponse({'MESSAGE':'NOT_EXISTS'}, status=400)

            if request.FILES:
                cloud_storage.delete_file(file, file_url)
                file_url = (cloud_storage.upload_file(file))
                
            if not file:
                main_image_url = Project.objects.get(id=project_id).main_image_url

            Project.objects.filter(id=project_id, user_id=request.user.id).update(
                    name           = data.get('name'),
                    user_id        = request.user.id,
                    aim_amount     = data.get('aim_amount'),
                    description    = data.get('description'),
                    end_date       = data.get('end_date')[0:4]+'-'+data.get('end_date')[5:7]+'-'+data.get('end_date')[8:10],
                    category_id    = data.get('category_id'),
                    file_url = file_url
                    )
            return JsonResponse({'MESSAGE':'SUCCESS'}, status = 200)

        except KeyError:
            return JsonResponse({'MESSAGE':'ERROR_INPUT_VALUE'}, status=404)

    @login_decorator
    def delete(self, request, project_id):
        cloud_storage = CloudStorage(ACCESS_KEY_ID, SECRET_ACCESS_KEY, BUCKET_NAME)
        user = request.user

        if not Project.objects.filter(id=project_id, user_id=user.id).exists():
            return JsonResponse({'MESSAGE':'NOT_EXISTS'}, status=400)
        
        file_url = Project.objects.get(id=project_id).file_url        
        cloud_storage.delete_file(file_url, project_id)

        Project.objects.get(id=project_id, user_id=user.id).delete()

        return JsonResponse({"MESSAGE": 'SUCCESS'}, status=204)

import boto3
ACCESS_KEY_ID = '**********'
SECRET_ACCESS_KEY = '******************'
BUCKET_NAME = '[name of your bucket]'
s3_client = boto3.client(
                 's3',
                 aws_access_key_id     = ACCESS_KEY_ID,
                 aws_secret_access_key = SECRET_ACCESS_KEY,
             )
s3_resource = boto3.resource(
                 's3',
                 aws_access_key_id     = ACCESS_KEY_ID,
                 aws_secret_access_key = SECRET_ACCESS_KEY,
             )
bucket = s3_resource.Bucket(name='버켓 이름')
#삭제하는 명령어1
bucket.Object('키값, 예를 들어 d457d1b0-169d-487a-950f-ef0cca576ad01.png').delete()
#삭제하는 명령어2
s3_client.delete_object(Bucket='humble', Key ='d457d1b0-169d-487a-950f-ef0cca576ad01.png')

class ProjectListView(View):
    def get(self, request):
        today = datetime.now()
        category_id = request.GET.get("categoryId")

        q = Q()

        if category_id:
            q &= Q(category_id = category_id)
        
        limit        = int(request.GET.get('limit', 12))
        #받는 limit값이 없으면 디폴트로 12개까지 부터 보여준다
        offset       = int(request.GET.get('offset', 0))
        #받는 offset값이 없으면 디폴트로 0개 부터 보여준다

        #하이라이트
        projects = Project.objects.annotate(total=Sum('patron__total_amount'), count=Count('patron')).prefetch_related('tag').select_related('user', 'category').filter(q).order_by('created_at')[offset:offset+limit]
        #패트론 테이블에서 레스토랑 아이디별로 total_amount컬럼 값을 합쳐서 저장하고 가상의 컬럼 patron__total_amount에 저장한다. 
        #정참조하는 user, category테이블의 내용을 골라서 가져오고 역참조하는 tag테이블의 내용을 미리 가져와서
        #q값(카테고리 아이디)으로 필터하고 예전에 만들어진 것부터 0부터12개 객체를 projects에 저장한다.  

        projects = [{
                'tag'             : [{'id':tag.id, 'name':tag.tag} for tag in project.tag.all()],
                'name'            : project.name,
                'id'              : project.id,
                'user_id'         : project.user_id,
                'user'            : project.user.nickname,
                'remaining_time'  : (project.end_date.replace(tzinfo=None) - today).days,
                #
                'main_image_url'  : project.main_image_url,
                'category_name'   : project.category.name,
                "aim_amount"      : project.aim_amount,
                'payment_date'    : project.end_date.strftime("%Y년 %m월 %d일"),
                #
                'collected_amount': project.total,
                'percentage' : '%.f%%'%(project.total/project.aim_amount*100) if project.total else '0%',
                #
                "created_at"      : project.created_at,
                "end_date"        : project.end_date, 
                "description"     : project.description
            } for project in projects]
            
        return JsonResponse({"project" : projects}, status=200)

def selectionSort(nums):
  for i in range(0,len(nums)):
      temp  = min(nums[i:])
      nums[nums.index(min(nums[i:]))] = nums[i]
      nums[i] = temp
  return nums

def bubbleSort(arr):
  for i in range(0, len(arr)-1):
    if arr[i] > arr[i + 1]: 
      arr[i], arr[i + 1] = arr[i + 1], arr[i]
  return(arr)

def bubbleSort(arr):
  n = len(arr)
  for i in range(n):
    for j in range(0, n - i - 1):
      if arr[j] > arr[j + 1]: 
        arr[j], arr[j + 1] = arr[j + 1], arr[j]
  return(arr)

def reverseString(str):
  print(str[:-1])
  return reverseString(str[:-1])

def reverseString(str):
    if len(str)==1:
        return str[0]
    return str[-1] + reverseString(str[:-1])

class Node:
  def __init__(self, value):
    self.val = value
    self.next = self.pre = None
        
  def getNext(self):
    return self.next
  

class MyLinkedList():
  
  def __init__(self):
    self.head = None
  
      
  def get(self, index):
    current = self.head
    while index > 0 :
      current = current.getNext()
      index -= 1
    return current.val
  
  
  def addAtHead(self, val):
    newNode = Node(val)
    newNode.next = self.head
    self.head = newNode
      
      
  def addAtTail(self, val):
    newNode = Node(val)
    current = self.head
    while current.next != None :
      current = current.getNext()
    
    current.next = newNode
      
  
  def addAtIndex(self, index, val):
    newNode = Node(val)
    current = self.head
    while index > 1 :
      current = current.getNext()
      index -= 1

    newNode.next = current.getNext()
    current.next = newNode
    
  
  def deleteAtIndex(self, index):
    current = self.head
    while index > 1 :
      current = current.getNext()
      index -= 1
    
    current.next = current.getNext().getNext()

def solution(N):
    arr = []
    count = 0
    max_count = 0
    arr = list(bin(N)[2:])
    for i in arr:
        if i == '0':
            count += 1
        if i == '1':
            if count > max_count:
                max_count = count
            count = 0
    print(max_count)
    return max_count

# 제일 작은 수를 먼저 찾고
# 배열을 그 뒤로 자름
# 자른 배열 안에서 가장 큰 값을 찾고
# 큰 값 - 작은 값 출력 
def maxProfit(prices):
    idx_min = prices.index(min(prices))
    new_arr = prices[idx_min:]
    return max(new_arr) - min(prices)

# unique set 리스트를 만들어서
# 해당하는 셋 리스트의 키값에 딕셔너리 밸류값으로 넣고 밸류만 출력 -> 잘 안됨
# unique set 리스트와 비교해서 같으면 새 리스트에 넣기

def groupanagrams(strs):
    strs_list = []
    unique_list = []
    answer_dict = {}
    for i in strs:
        strs_list.append(i)
        if i not in unique_list:
            unique_list.append(i)
    print(unique_list)

def groupAnagrams(strs):
    counter = {}

    for s in strs:
        # 정렬된 문자열을 key로 만들어준다.
        key = ''.join(sorted(s))
 
        if key not in counter:
            counter[key] = []
        # 그리고 문자열을 해당 key에 할당해준다.
        counter[key].append(s)
     
    result = []
    for key in counter:
        result.append(counter[key])
     
    return result 

def maxSubArray(nums):
  answers = []
  for m in range(0,len(nums)):
    for n in range(0,len(nums)):
      answers.append(sum(nums[m:n+1]))
      #m부터 n까지 합한 값 중에
  print(max(answers))
  #가장 큰 값을 출력
  return max(answers)

def maxSubArray(nums):
    for i in range(1, len(nums)):
        if nums[i-1] > 0:
            nums[i] += nums[i-1] 
            print(nums)
    return max(nums)

#상위 프로젝트
urlpatterns = [
    path("users",include("users.urls")),
    path("",include("restaurants.urls")),
    path("restaurant",include("reviews.urls")),
]
#user 앱
urlpatterns = [
    path('/signup', SignUpView.as_view()),
    path('/signin', SignInView.as_view()),
    path('/restaurant/<int:restaurant_id>/wish', WishView.as_view()), 
    path('/wishlist', WishListView.as_view()),
    path("/signin/kakao/callback", KakaoSignIn.as_view()),
]
#review 앱
urlpatterns = [
    path('/<int:restaurant_id>/review', ReviewView.as_view()),
    path('/<int:restaurant_id>/review/<int:review_id>', ReviewView.as_view()),
]
#restaurant 앱
urlpatterns = [
    path("restaurant/<int:restaurant_id>", RestaurantDetailView.as_view()),
    path("", RestaurantListView.as_view()),
    path("search", SearchView.as_view()),
]

"restaurant_img" : restaurant.review_set.last().reviewimage_set.last().image,

"rating"      : restaurant.review_set.all().aggregate(Avg('rating'))

"rating"         : restaurant.review_set.all().aggregate(rating = Avg('rating'))['rating']

"wish_count"     : WishList.objects.filter(restaurant_id = restaurant_id).annotate(cnt=Count('user_id')).count(),

from django.db    import models

class Restaurant(models.Model):
    name            = models.CharField(max_length=45)
    address         = models.CharField(max_length=100)
    phone_number    = models.CharField(max_length=50, null=True)
    location        = models.ForeignKey('Location',on_delete=models.CASCADE)
    category        = models.ForeignKey('Category', on_delete=models.CASCADE)
    serving_price   = models.ForeignKey('ServingPrice', on_delete=models.CASCADE)

    class Meta:
        db_table = 'restaurants'
    
    @property
    def latest_review(self):
        if not self.review_set.exists():
            return None

        return {
            "id"          : self.review_set.last().id,
            "user_id"     : self.review_set.last().user_id,
            "user_name"   : self.review_set.last().user.nickname,
            "description" : self.review_set.last().description,
            "image"       : self.review_set.last().reviewimage_set.last().image
        }

class ReviewView(View):
    @login_decorator
    @transaction.atomic
    def post(self, request, restaurant_id):
        try:
            data    = json.loads(request.body)
            user    = request.user

            if Review.objects.filter(user_id = user.id, restaurant_id=restaurant_id).exists():
                return JsonResponse({'MESSAGE':'REVIEW_EXIST'}, status=400)

            with transaction.atomic():
                review = Review.objects.create(
                    restaurant_id = restaurant_id,
                    user_id       = user.id,
                    description   = data['description'],
                    rating        = data['rating'],
                )

                with transaction.atomic():
                    ReviewImage.objects.create(
                        review_id = review.id,
                        image     = data['image'],
                        )

            return JsonResponse({'MESSAGE':'SUCCESS'},status = 201)
    
        except KeyError:
            return JsonResponse({'MESSAGE':'ERROR_INPUT_VALUE'}, status=404) 

def login_decorator(func):
    def wrapper(self, request, *args, **kwargs):
        try:
            token           = request.headers.get("authorization", None)
            if not token: # 토큰이 없으면 
                request.user = None #유저값에 none을 저장한다
            else:
                user            = jwt.decode(token, SECRET_KEY, algorithms='HS256')
                request.user    = User.objects.get(id = user['id'])

            return func(self, request, *args, **kwargs)

        except jwt.exceptions.DecodeError:
            return JsonResponse({"message" : "INVALID_TOKEN"}, status=400)

        except ObjectDoesNotExist:
            return JsonResponse({"message" : "INVALID_USER"}, status=400)

    return wrapper 

import os
import django
import csv
import sys

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tangoplate.settings")
django.setup()

from restaurants.models import Restaurant, Menu
from reviews.models import Review

CSV_PATH_LOCATION = 'review_images.csv'

def insert_restaurants():
    with open(CSV_PATH_LOCATION) as in_file:
        data_reader = csv.reader(in_file)
        for row in data_reader:
            Restaurant.objects.create(
                name = row[1], 
                address = row[2], 
                phone_number=row[3], 
                category_id = int(row[4]), 
                location_id = int(row[5]), 
                serving_price_id = int(row[6])
            )

def insert_menus():
    with open(CSV_PATH_LOCATION) as in_file:
        data_reader = csv.reader(in_file)
        for row in data_reader:
            Menu.objects.create(
                item=row[0], 
                item_price=row[1],
                restaurant_id=row[2]
            )

def insert_review():
    with open(CSV_PATH_LOCATION) as in_file:
        data_reader = csv.reader(in_file)
        for row in data_reader:
            Review.objects.create(
                description=row[0], 
                created_at=row[1],
                updated_at=row[2],
                restaurant_id=row[3],
                user_id=row[4],
            )

def insert_review_img():
    with open(CSV_PATH_LOCATION) as in_file:
        data_reader = csv.reader(in_file)
        for row in data_reader:
            Review.objects.create(
                image=row[0], 
                review_id=row[1],
            )

insert_review_img()

from django.db          import models

class User(models.Model):
    nickname     = models.CharField(max_length=50, null=True)
    email        = models.EmailField(max_length=200)
    password     = models.CharField(max_length=300)
    #비밀번호는 암호화되기 때문에 길게 주어야한다.
    phone_number = models.CharField(max_length=45)

    class Meta:
        db_table = 'users'

class Rating(models.Model):
    user       = models.ForeignKey('User', on_delete=models.SET_NULL, null=True)
    #참조하는 유저가 지워져도 별점 데이터는 남는다.
    restaurant = models.ForeignKey('restaurants.Restaurant', on_delete=models.CASCADE)
    #참조하는 레스토랑이 지워지면 별점 데이터가 지워진다.
    rating     = models.IntegerField()

    class Meta:
        db_table = 'ratings'

class WishList(models.Model):
    user       = models.ForeignKey('User', on_delete=models.SET_NULL, null=True)
    #참조하는 유저가 지워져도 위시리스트 데이터는 남는다.
    restaurant = models.ForeignKey('restaurants.Restaurant', on_delete=models.CASCADE)
    #참조하는 레스토랑이 지워지면 위시리스트 데이터가 지워진다.

    class Meta:
        db_table = 'wishlist'

from django.db    import models

class Restaurant(models.Model):
    name            = models.CharField(max_length=45)
    address         = models.CharField(max_length=100)
    phone_number    = models.CharField(max_length=50, null=True)
    location        = models.ForeignKey('Location',on_delete=models.CASCADE)
    category        = models.ForeignKey('Category', on_delete=models.CASCADE)
    serving_price   = models.ForeignKey('ServingPrice', on_delete=models.CASCADE)

    class Meta:
        db_table = 'restaurants'

class Menu(models.Model):
    restaurant     = models.ForeignKey('Restaurant', on_delete=models.CASCADE)
    item           = models.CharField(max_length=45)
    item_price     = models.DecimalField(max_digits= 10, decimal_places=0)
    #처음에 6으로 했더니 10만원이상이 입력이 안 되서 10으로 바꿨는데 PositiveIntegerField()로 했어도 될 것 같다. 

    class Meta:
        db_table = 'menus'

class Location(models.Model):
    area = models.CharField(max_length=45)

    class Meta:
        db_table = 'locations'

class Category(models.Model):
    name = models.CharField(max_length=45)

    class Meta:
        db_table = 'categories'

class ServingPrice(models.Model):
    price = models.PositiveIntegerField()
    #가격이라서 양수 정수 필드를 사용한다.

    class Meta:
        db_table = 'serving_prices'

from django.db          import models

class Review(models.Model):
    user        = models.ForeignKey('users.User', on_delete=models.SET_NULL, null=True)
    restaurant  = models.ForeignKey('restaurants.Restaurant', on_delete=models.CASCADE)
    description = models.CharField(max_length=500, null=True)
    created_at  = models.DateField(auto_now_add=True)
    #생성날짜는 자동으로 생기도록 했다.
    updated_at  = models.DateField(auto_now=True, null=True)

    class Meta:
        db_table = 'reviews'

class ReviewImage(models.Model):
    review     = models.ForeignKey('Review',on_delete=models.SET_NULL, null=True)
    image      = models.URLField(max_length=500)
    #500이면 충분하다고 생각했는데 url은 하도 길어서 길이 제한에 걸리는 경우가 종종 있었다.
    
    class Meta:
        db_table = 'review_images'

from django.db          import models

class Coupon(models.Model):
    name           = models.CharField(max_length=40)
    restaurant     = models.ForeignKey('restaurants.Restaurant', on_delete=models.SET_NULL, null=True)
    price          = models.DecimalField(max_digits= 6, decimal_places=0)
    description    = models.CharField(max_length=500, null=True)
    start_date     = models.DateField()
    end_date       = models.DateField()

    class Meta:
        db_table = 'coupons'

class CouponImage(models.Model):
    coupon        = models.ForeignKey('Coupon', on_delete=models.SET_NULL, null=True)
    image         = models.URLField(max_length=500)

    class Meta:
        db_table = 'coupon_images'

def complex_number_multiply(a, b):
    #(A+Bi)*(C+Di)
    list_a = a.split('+')
    A = int(list_a[0])
    B = int(list_a[-1][:-1])

    list_b = b.split('+')
    C = int(list_b[0])
    D = int(list_b[-1][:-1])

    num1 = str(A*C - B*D)
    num2 = str(A*D + B*C)

    return num1 +'+'+(num2 + 'i')

def reverse_string(s):
    print (list(reversed(s)))
    return list(reversed(s))

def min_path_sum(grid):
  m = len(grid)
  n = len(grid[0])
    
  ### 1
  for i in range(1, n):
      grid[0][i] += grid[0][i-1]
  for i in range(1, m):
      grid[i][0] += grid[i-1][0]
        
  ### 2
  for i in range(1, m):
      for j in range(1, n):
          grid[i][j] += min(grid[i-1][j], grid[i][j-1])
  return grid[-1][-1] 

def move_zeroes(nums):
    num_of_zero = nums.count(0)
    for i in range(num_of_zero):
      nums.remove(0)
      nums.append(0)
    return nums

def countdown(n):
  print(n)
  countdown(n-1)

countdown(10);

def countdown(n):
  print(n)
  
  if (n == 0):
    return None
  
  countdown(n-1)

countdown(10);

def factorial(n):
    if n <= 1:
      return 1
    return n * factorial(n-1)

def roman_to_num(s):
  roman = {
    'I' : 1,
    'V' : 5,
    'X' : 10,
    'L' : 50,
    'C' : 100,
    'D' : 500,
    'M' : 1000
  }
  a = 0
  for i in range(len(s)):
    a += roman[s[i]]
  if 'IV' in s or 'IX' in s:
    a -= 2
  if 'XL' in s or 'XC' in s:
    a -= 20
  if 'CD' in s or 'CM' in s:
    a -= 200
  return a

nums = [3,2,3]
return 3

nums = [2,2,1,1,1,2,2]
return 2

import statistics

def more_than_half(nums):
    key_list = list(set(nums))
    value_list = []
    for i in key_list:
        value_list.append(nums.count(i))
    arr = list(zip(key_list, value_list))
    return key_list[value_list.index(max(value_list))]  
    # arr = {x:y for x,y in zip(key_list, value_list)}

from collections import Counter

def more_than_half(nums):
  return Counter(nums).most_common(1)[0][0]
  # 카운터 매쏘드 내에 most_common함수를 사용하면 (n)개가 순서대로 출력됨

s = "()"
return true

s = "()[]{}"
return true

s = "(]"
return false

s = "([)]"
return false

s = "{[]}"
return true

def is_valid(string):
    paren_dict = {'(':')', '{':'}', '[':']'}
    temp = []
    for ch in string:
      if ch in list(paren_dict.keys()):
        #괄호가 열렸다면
        temp.append(ch)
        #열린 괄호를 템프에 넣는다
      else:
        #괄호가 열리지 않았다면
        if not temp:
          #템프리스트가 비어있다면(열린 적 없음)
          return False
        else:
          #템프리스트 안에 뭔가 들어있다면
          if ch != paren_dict[temp.pop()]:
            #템프리스트의 가장 마지막 원소를 빼낸 것이 parent_dict의 닫힌괄호와 짝이 맞지 않는다면
            return False
        if temp: #템프리스트 안에 내용물이 남아있다면
            return False
    return True

nums = [1,1,1,2,2,3],
k = 2

return [1,2]

nums = [1]
k = 1

return [1]

def most_common(nums,k):
    num_list = []
    ans_list = []
    for i in set(nums):
        num_list.append(nums.count(i))  
    ans_list = list(zip(num_list, set(nums)))
    ans_list = sorted(ans_list)
    print(ans_list)
    answer = []
    for i in range(k):
        answer.append((ans_list.pop()[1]))
        print(answer)
    return answer

def get_max_area(height):
    result = []

    for i in range(len(height)-1):
        for j in range(i+1, len(height)):
            if height[i] > height[j]:
                result.append(height[j]*(j-i))
            else:
                result.append(height[i]*(j-i))
    print(max(result))
    return max(result)