클라우드 개발자 앙몬드

"""
디큐를 이용해 큐브 쌓기
"""
from collections import deque
if __name__ == "__main__" :
    총_테스트케이스 = int(input())
    for i in range(총_테스트케이스) :
        큐브개수 = int(input())
        큐브디큐 = deque(map(int, input().split()))
        아기가_쌓은_큐브 = []

        idx = 0
        종료인덱스 = len(큐브디큐)
        while idx < 종료인덱스 :
            뽑은_왼쪽큐브 = 0
            뽑은_오른쪽큐브 = 0
            if len(큐브디큐) == 1 :
                뽑은_왼쪽큐브 = 큐브디큐.popleft()
            else :
                뽑은_왼쪽큐브 = 큐브디큐.popleft()
                뽑은_오른쪽큐브 = 큐브디큐.pop()

            결정한_큐브 = 0
            if 뽑은_왼쪽큐브 >= 뽑은_오른쪽큐브 :
                큐브디큐.append(뽑은_오른쪽큐브)
                결정한_큐브 = 뽑은_왼쪽큐브
            else :
                큐브디큐.appendleft(뽑은_왼쪽큐브)
                결정한_큐브 = 뽑은_오른쪽큐브

            if len(아기가_쌓은_큐브) == 0 :
                아기가_쌓은_큐브.append(결정한_큐브)
            elif 아기가_쌓은_큐브[len(아기가_쌓은_큐브)-1] >= 결정한_큐브 :
                아기가_쌓은_큐브.append(결정한_큐브)
            else :
                break
            idx += 1
        #print(아기가_쌓은_큐브)
        #print(큐브개수)
        #print(*큐브디큐)
        #print(len(아기가_쌓은_큐브))
        if len(아기가_쌓은_큐브) == 큐브개수 :
            print("Yes")
        else :
            print("No")

"""
파이썬 세트의, 인터섹션 (교집합) & 디프런스 (여집합) 연산을 해보쟈
intersection
diffrence
sysmmetric_diffrence
_update
"""
exit(0)
if __name__ == "__main__" :
    세트A_사람수 = int(input())
    세트A = set(map(int, input().split()))
    세트B_사람수 = int(input())
    세트B = set(map(int, input().split()))
    print(len(세트A.intersection(세트B)))
    print(len(세트A.difference((세트B))))
    print(len(세트A.symmetric_difference(세트B)))

"""
정렬 해보기 (소문자 대문자 홀수 짝수) 순
"""
exit(0)
if __name__ == "__main__" :
    입력값 = list(input())
    최종 = []

    a = ""

    소문자리스트 = list(filter(lambda x : x.islower() , 입력값))
    소문자리스트.sort()
    최종.extend(소문자리스트)

    대문자리스트 = list(filter(lambda x: x.isupper(), 입력값))
    대문자리스트.sort()
    최종.extend(대문자리스트)

    홀수리스트 = list(filter(lambda x: x.isnumeric() and int(x) % 2 == 1, 입력값))
    홀수리스트.sort()
    최종.extend(홀수리스트)

    짝수리스트 = list(filter(lambda x: x.isnumeric() and int(x) % 2 == 0, 입력값))
    짝수리스트.sort()
    최종.extend(짝수리스트)

    print("".join(최종))
    

"""
람다식 기초
"""
exit(0)
if __name__ == "__main__" :
    # map, reduce, filter
    a = [[1,2,3] , [4,5,6] , [7,8,9], [1,2,1]]
    a.sort(key = lambda x: x[1])
    print(a)
    b = list(filter(lambda x : x[0] == 1 , a))
    print(b)

AWS 이용 시, 아마존 리눅스 이미지로 머신을 기동시키면, 몇몇개의 AWS 관련 데몬 및 에이전트가 실행됩니다.

이 때, 가만히 보면 SSM, 즉 simple system manager 라는 에이전트 또한 기동되는데

이 SSM을 이용해, AWS Systems Manager를 통한 일괄제어 방법 중 하나를 소개해드릴까 합니다.

(근데 항상 아마존은 Simple하다, 단순하다, 쉽다 하는데, 막상 까보면 하나도 쉬운거 없던디... 앙몬드만의 생각...)

머신들이 Systems Manager에 관리형 인스턴스로 들어오기 위해서는 몇가지 조건이 있는데, 

자세한 페이지는 AWS 백서를 참조해주시면 됩니다. (밑에 밑에..)

docs.aws.amazon.com/ko_kr/systems-manager/latest/userguide/setup-instance-profile.html

그 중 코어는 2가지입니다. 

  (1) (회피불가) 아마존 리눅스로..

 (2) 아마존 리눅스 머신의, SSM IAM

        - IAM : AmazonSSMManagedInstanceCore

특히 2번이 되어야, EC2 머신이, Systems Manager 관리대상 인스턴스에 등록이 되기 떄문에, Systems Manager에서 머신이 보이지 않는다면, 99.99999% 확률로 IAM 이슈일 가능성이 높습니다. (AWS는 IAM으로 시작해서 IAM으로 끝난다는 말이 있죠..)

그러면, Systems Manager에 등록된 머신들을 컨트롤링 할 때, 람다 혹은 기타 어플리케이션들은, 이 시스템 매니저와의 통신으로, 수많은 머신들을 한꺼번에 제어할 수 있습니다.

이런면에서 보면, Ansible 의 AWS버전 같기도 하네요 :)

밑에는 boto3를 이용한, 파이썬3 -> SystemsManager -> EC2_머신_프로세스 확인을 하는 코드입니다.

현재 상황은, Systems Manager에 Batch 어플리케이션 머신들을 등록하고, 이 어플리케이션이 죽었는지 살았는지를 검사하는 코드와 초간단 아키텍처 입니다. :)

ssm = boto3.client('ssm', region_name="ap-northeast-2",)

command = "ps -ef | grep java | grep -v 'grep'"
instance_id = "AWS의 머신 id가 들어가야합니다!"

# 커맨드로는, 자바 프로세스를 긁어오는 커맨드를 넣어봤습니다.

for 기준정보 in 배치머신_기준정보:
    instance_id = 기준정보["머신_id"]
    command_response = ssm.send_command(
                                InstanceIds = [ instance_id ],
                                DocumentName = "AWS-RunShellScript",
                                Parameters = {
                                    'commands':[command],
                                    'executionTimeout': ['3600'], },
                                TimeoutSeconds = 30, )
    command_id = command_response['Command']['CommandId']
    command_result = ''

    for sec in range(10):
        time.sleep(1)
        command_real_time_status = ssm.get_command_invocation(
            CommandId=command_id,
            InstanceId = instance_id, )

        if (command_real_time_status['Status'] == 'Pending') or (command_real_time_status['Status'] == 'In Progress'):
            continue
        else:
            command_result = command_real_time_status
            #print('아웃풋 컨텐츠 : ', command_result['StandardOutputContent'])
        break

    list_command_result_output = command_result['StandardOutputContent'].split('\n')
    list_command_result_output.remove('')

    # print("****결과물 정제****")
    # print(list_command_result_output)
    # print("****************\n\n\n")    

def swap_case(s):

    result = ""

    for i in s:

        if i.islower() :

            i = i.upper()

        elif i.isupper() :

            i = i.lower()

        result = result + i

    return result



if __name__ == '__main__':

    s = input()

    result = swap_case(s)

    print(result)


# 스트링 정규식 빌트인함수
# isalnum() isalpha() isdigit() islower() isupper()
exit(0)
def 빌트인_정규표현식(string, case):
    list_input = list(string)
    if case == 1:
         for e in list_input:
             if e.isalnum():
                 return True
    elif case ==2:
        for e in list_input:
            if e.isalpha():
                return True
    elif case ==3:
        for e in list_input:
            if e.isdigit():
                return True
    elif case ==4:
        for e in list_input:
            if e.islower():
                return True
    elif case ==5:
        for e in list_input:
            if e.isupper():
                return True
    return False

if __name__ == '__main__':
    s = input()
    print(f"{빌트인_정규표현식(s,1)}")
    print(f"{빌트인_정규표현식(s,2)}")
    print(f"{빌트인_정규표현식(s,3)}")
    print(f"{빌트인_정규표현식(s,4)}")
    print(f"{빌트인_정규표현식(s,5)}")

# 퍼뮤테이션.

# 콜렉션을 통해, 가능한 모든 조합 서브콜렉션을 탄생시키는 라이브러리



from itertools import permutations

def 퍼뮤테이션(string, k) :

    퍼뮤테이션_결과리스트 = list(permutations(string,k))

    정렬출력위한_리스트 = []

    for i in 퍼뮤테이션_결과리스트:

        정렬출력위한_리스트.append("".join(i))

    정렬출력위한_리스트.sort()

    for i in 정렬출력위한_리스트:

        print(i)



if __name__ == "__main__":

    입력값 = input().split()

    퍼뮤테이션(입력값[0], int(입력값[1]))