ANYPANG (list & tuple)

#애니팡
#타일의 종류는 4가지
#가로 세로 3개이상 연속 타일 사라짐 그자리는 위 타일들이 내려와서 메꿈

def overturnList(argList):
    argListTmp = list(zip(argList[0],argList[1],argList[2],argList[3],argList[4]))

    return[list(argListTmp[i]) for i in range(len(argList[0]))]

def pung(argList):
    argListTmp = [[]*5 for i in range(0,5)]
    argListTmp = list(argList)
    for i in range(0,5):
        if(len(set(argListTmp[i][0:5]))==1) and not(0 in argList[i][0:5]):
            argListTmp[i][0:5]=[-1,-1,-1,-1,-1]

        if (len(set(argListTmp[i][0:4])) == 1) and not (0 in argList[i][0:4]):
            argListTmp[i][0:4] = [-1, -1, -1, -1]
        if (len(set(argListTmp[i][1:5])) == 1) and not (0 in argList[i][1:5]):
            argListTmp[i][1:5] = [-1, -1, -1, -1]
        if (len(set(argListTmp[i][0:3])) == 1) and not (0 in argList[i][0:3]):
            argListTmp[i][0:3] = [-1, -1, -1]
        if (len(set(argListTmp[i][1:4])) == 1) and not (0 in argList[i][1:4]):
            argListTmp[i][1:4] = [-1, -1, -1]
        if (len(set(argListTmp[i][2:5])) == 1) and not (0 in argList[i][2:5]):
            argListTmp[i][2:5] = [-1, -1, -1]

    return argListTmp

 

튜플은 immutability 의 성질이 있어 수정이 불가능하다. 한번 생성된 튜플은 그 값을 변경 할 수 없다.

튜플은 () 을 사용하여 표현한다. 적은 메모리를 사용하고 읽기 전용, 작은 크기 데이터를 다룰 때 유리하다.

 

 

리스트는 가변성을 가지고 있어 값을 삭제 추가 변경 할 수 있다.  [] 를 사용하여 표현하고 동적인 크기 조절이 가능하여 메모리를 많이 사용한다.

# 튜플
my_tuple = (1, 2, 3)

# 리스트
my_list = [1, 2, 3]

# 튜플은 불변성을 가지고 있어 값 변경 불가능
# my_tuple[0] = 10  # 에러 발생

# 리스트는 가변성을 가지고 있어 값 변경 가능
my_list[0] = 10

# 튜플과 리스트의 메모리 사용 비교
import sys
print(sys.getsizeof(my_tuple))  # 튜플의 메모리 크기
print(sys.getsizeof(my_list))   # 리스트의 메모리 크기

 

 

튜플과 리스트의 메모리 사용량을 비교.

 

 

argListTmp = list(zip(argList[0],argList[1],argList[2],argList[3],argList[4]))

 

 

 

zip 함수는 여러 개의 iterable 한 객체를 받아 각 객체에서 동일한 인덱스 위치에 있는 원소들을 묶어 튜플을 생성한다. zip 함수에 전달된 각 객체의 길이가 동일하면 해당 길이만큼 묶어서 튜플을 생성한다.

 

argList = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15]
]

2차원 리스트 artLIst 에서 zip(argList[0], argList[1], argList[2])는 첫 번째 리스트, 두 번째 리스트, 세 번째 리스트에서 동일한 인덱스 위치에 있는 원소들을 묶어서 튜플을 생성한다.

 

 

 

# 원래 리스트
argList = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15]
]

# 튜플로 묶기
argListTmpTuple = list(zip(argList[0], argList[1], argList[2]))
print(argListTmpTuple)
# 출력: [(1, 6, 11), (2, 7, 12), (3, 8, 13), (4, 9, 14), (5, 10, 15)]

# 리스트로 변환하기
argListTmpList = [list(t) for t in argListTmpTuple]
print(argListTmpList)
# 출력: [[1, 6, 11], [2, 7, 12], [3, 8, 13], [4, 9, 14], [5, 10, 15]]

 

 

argListTmpTuple 은 각 인덱스 위치 있는 원소들을 튜플로 묶은 것이고, 

argListTmpList는 튜플을 리스트로 변환한 것이다.

 

 

 

 

def overturnList(argList):
    argListTmp = list(zip(argList[0],argList[1],argList[2],argList[3],argList[4]))
    return [list(argListTmp[i]) for i in range(len(argList[0]))]

 

 

overturnList 함수는 argList 인자를 받는다. argList를 리스트로 초기화 하여 반환된다.

 

 

 

def pung(argList):
    argListTmp = [[]*5 for i in range(0,5)]
    argListTmp = list(argList)
    for i in range(0,5):
        if(len(set(argListTmp[i][0:5]))==1) and not(0 in argList[i][0:5]):
            argListTmp[i][0:5]=[-1,-1,-1,-1,-1]

        if (len(set(argListTmp[i][0:4])) == 1) and not (0 in argList[i][0:4]):
            argListTmp[i][0:4] = [-1, -1, -1, -1]
        if (len(set(argListTmp[i][1:5])) == 1) and not (0 in argList[i][1:5]):
            argListTmp[i][1:5] = [-1, -1, -1, -1]
        if (len(set(argListTmp[i][0:3])) == 1) and not (0 in argList[i][0:3]):
            argListTmp[i][0:3] = [-1, -1, -1]
        if (len(set(argListTmp[i][1:4])) == 1) and not (0 in argList[i][1:4]):
            argListTmp[i][1:4] = [-1, -1, -1]
        if (len(set(argListTmp[i][2:5])) == 1) and not (0 in argList[i][2:5]):
            argListTmp[i][2:5] = [-1, -1, -1]

    return argListTmp

 

 

pung 함수는 argList를 받는다. argListTmp는 빈 리스트 5개를 가지는 리스트를 생성한다.

(len(set(argListTmp[i][0:5]))==1) 

는 리스트의 5개 원소가 중복되는지 확인하고  (0 in argList[i][0:5]) 리스트에 0이 있는지 확인한다. 이 둘을 모두 만족한다면 원소들을 -1값으로 변경한다.

 

 

 

Main 코드.

matrix = []

for i in range(5):
    matrix.append(list(map(int, input().split())))

matrixTmp = [[]*5 for i in range(0,5)]

isValidCalc = True
while isValidCalc:
    matrixTmp = list(matrix)
    verticalMatrix = overturnList(matrixTmp)
    verticalMatrix = pung(verticalMatrix)
    verticalMatrix = overturnList(verticalMatrix)


    matrix= pung(matrix)

    isValidCalc =False
    for i in range(0,5):
        for j in range(0,5):
            if(matrix[i][j]==-1) or (verticalMatrix[i][j]==-1):
                matrix[i][j]=-1
                isValidCalc =True

    matrixTmp = list(matrix)
    verticalMatrix = overturnList(matrixTmp)
    for i in range(0,5):
        if -1 in verticalMatrix[i]:
            cnt = verticalMatrix[i].count(-1)
            for j in range(0, cnt):
                verticalMatrix[i].remove(-1)
                verticalMatrix[i].insert(0,0)
    matrix = overturnList(verticalMatrix)


print("최종")
for i in range(0,5):
    print(matrix[i])

 

 

5*5 행렬을 입력받은 후 계산이 더 이상 필요하지 않을 때까지 반복한다.

 

 

verticalMatrix = overturnList(matrixTmp):  5*5 행렬을 수직으로 뒤집는 함수.

열의 원소를 행으로 변환하여 새로운 리스트를 생성한다.