Python Sorted 2

#Sorted
 
l1 = [[1,'D',2018],
      [2,'A',2016],
      [3,'C',2017]]
print(sorted(l1,key=lambda a:a[2],reverse=True))
 
d1 = [{'id':1,'type':'D','year':2018},
      {'id':2,'type':'A','year':2016},
      {'id':3,'type':'C','year':2017}]
print(sorted(d1,key=lambda a:a['year'],reverse=True))

d1 = [{'id':1,'type':'D','year':2018},
      {'id':2,'type':'A','year':2016},
      {'id':3,'type':'C','year':2017}]
print(sorted(d1,key=lambda a:(-a['year'],a['type'])))

# 여러 요소로 소팅 시 튜플로 순서를 정함
# - 를 붙이면 reverse 효과

just/fill

# 8의 배수 자리로 글자 길이 맞추기

def form(a):
    return(a.rjust(8*(len(a)//8+1),'0'))
print(form('123'))

def form(a):
    return(a.zfill(8*(len(a)//8+1)))
print(form('123'))

List 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import random
row=col=5
picList=[]
for i in range(0,row):
    tmpList=[]
    for k in range(0,col):
        tmpList.append(random.randint(0,1000))
    picList.append(tmpList)
for i in range(0,row):
    print(picList[i])
#### 전체 값에 200을 더하기, 단, 1000 미만의 값이어야 함
for i in range(0,row):
    for y in range(0,col):
        if picList[i][y] + 200 < 1000:
            picList[i][y] += 200
##########################################
print()
for i in range(0,row):
    print(picList[i])
newList=[]
#### 각 값의 주변 8점과 차이의 절대값을 구한 배열 생성
#### 절대 값의 값이 가장 큰 것을 새로운 배열에 입력
newList=picList[:]
picList.insert(0,[0]*col)
picList.append([0]*col)
for i in range(0,len(picList)):
    picList[i].insert(00)
    picList[i].append(0)
# bigList=[]
# for i in range(0,row):
#     for k in range(0,col):
#         bigList[i+1][k+1]=picList[i][j]
print()
for i in range(0,len(picList)):
    print(picList[i])
diff=0
maxAbs = 0
for i in range(1,row):
    for y in range(1,col):
        tmpAbs=abs(picList[i][y]  picList[i1][y1])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i1][y])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i1][y+1])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i][y1])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i][y+1])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i+1][y1])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i+1][y])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        tmpAbs=abs(picList[i][y]  picList[i+1][y+1])
        if tmpAbs > maxAbs:
            maxAbs = tmpAbs
        newList[i][y] = maxAbs
###########################################
print()
for i in range(0,row):
    print(newList[i])
cs

Dictionary 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
  : 29
, : 4
– : 1
. : 2
a : 24
b : 2
c : 7
d : 11
e : 19
f : 2
g : 8
h : 3
i : 15
j : 1
l : 8
m : 15
n : 17
o : 11
p : 11
r : 17
s : 11
t : 16
u : 7
v : 2
y : 7
 
 
s1 = “Python features a dynamic type system and automatic”
s1+=“memory management and supports multiple programming “
s1+=“paradigms, including object-oriented, imperative, functional “
s1+=“programming, and procedural styles. “
s1+=“It has a large and comprehensive standard library.” 
 
 
dic = {}
 
chList = list(set(list(s1.lower())))
chList.sort()
for x in chList:
    dic[x] = s1.count(x)
 
 
for key, val in dic.items():
    print(“%s : %d” % (key, val)) 
 
 
cs

Sort 0

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
data = [‘0xA37B’,‘0x23cc’,‘0x88d9’,‘0xBBBF’,‘0x3a9a’]
print(data)
for i in range(0,len(data)1):
    for k in range(i+1,len(data)):
        if int(data[i], 16< int(data[k], 16):
            # tmp = data[i]
            # data[i] = data[k]
            # data[k] = tmp
            data[i], data[k] = data[k], data[i]
print(data)
cs

Character 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#문제4. 문자열에서 공백을 모두 없애기, 단, 숫자 앞의 공백은 그냥 두기
 
a=“안녕하세요? Hello? 12     3 안녕 못한데 왜!!! 그냥 안녕히 계세요99     9 Bye~”
= []
 
spaces = “”
 
for x in list(a):
    if x == ” “:
        spaces += x
    else:
        if x.isdigit() == True:
            b.append(spaces)
        b.append(x)
        spaces = “”
 
# print(b)
= .join(b)
print(a)
print(list(a))
print(b)
print(c)
 
cs

Rank 2

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
tranList = [
    (‘토마스’,5),
    (‘헨리’8),
    (‘에드워드’9),
    (‘에밀리’5),
    (‘토마스’4),
    (‘헨리’7),
    (‘토마스’3),
    (‘에밀리’8),
    (‘퍼시’5),
    (‘고든’13),
]
tDic = {}
for tup in tranList:
    tName = tup[0]
    tWork = tup[1]
    if tName in tDic:
        tDic[tName] += tWork
    else:
        tDic[tName] = tWork
print(tranList)
print(tDic)
import operator
tranList = sorted(tDic.items(), key=operator.itemgetter(1), reverse=True)
print(tranList)
curRank = 1
totalRank = 1
print(tranList[0], curRank)
for i in range(1len(tranList)):
    totalRank += 1
    if tranList[i][1== tranList[i1][1]:
        pass
    else:
        curRank = totalRank
    print(tranList[i], curRank)
cs

Rank

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
trainList = [
    (‘토마스’,5),
    (‘헨리’8),
    (‘에드워드’9),
    (‘에밀리’5),
    (‘토마스’4),
    (‘헨리’7),
    (‘토마스’3),
    (‘에밀리’8),
    (‘퍼시’5),
    (‘고든’13),
]
dd = {}
vv = [00]
import copy
for x in trainList:
    dd[x[0]] = copy.deepcopy(vv)
print(dd)
print(trainList)
for x in trainList:
    dd[x[0]][0+= x[1]
print(dd)
ss = sorted(dd, key=lambda a:a[1])
print(ss)
cs

Dictionary

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 문자열 발생 빈도, 내림 차순 정렬
inStr = “”“서시
죽는 날까지 하늘을 우러러
한점 부끄럼이 없기를,
잎새에 이는 바람에도
나는 괴로워했다.
별을 노래하는 마음으로
모든 죽어가는 것을 사랑해야지
그리고 나한테 주어진 길을
걸어가야겠다.
오늘밤에도 별이 바람에 스치운다.
“”
print(inStr)
dic={}
for x in list(inStr):
    if x in dic:
        dic[x] += 1
    else:
        dic[x] = 1
print(dic.items())
# sDic = sorted(dic.items(), key=lambda (k, v): v, reverse=True)
# for x in dic:
#     print(x, sDic[x])
cs

Character 2

1
2
3
4
5
6
7
8
9
10
11
12
13
inStr = “ABCD  abcd ## 1234”
outStr = “”
 
diff = ord(‘a’ ord(‘A’)
for ch in inStr :
    if  ord(‘A’<= ord(ch) <= ord(‘Z’) :
        outStr += chr( ord(ch) + diff)
    elif  ord(‘a’<= ord(ch) <= ord(‘z’) :
        outStr += chr( ord(ch)  diff)
    else :
        outStr += ch
 
print(outStr)
cs

Character

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
inStr = “ab1234CD#?456”
 
upStr, loStr, numStr, etcStr = [“”* 4
 
chlen = len(inStr)
for i in range(chlen) :
    ch = inStr[i]
    if  ord(‘A’<= ord(ch) <= ord(‘Z’) :
        upStr += ch
    elif ord(‘a’<= ord(ch) <= ord(‘z’) :
        loStr += ch
    elif ord(‘0’<= ord(ch) <= ord(‘9’) :
        numStr += ch
    else :
        etcStr += ch
 
print(upStr, loStr, numStr, etcStr)
cs

Mine

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 외톨이 찾기
# 0 0 0 0 0
# 0 1 0 0 1
# 0 0 0 0 0
# 1 0 0 1 1
# 0 0 1 1 0
# –> 1 1, 1 4, 3 0
= [
# [‘0′,’0′,’0′,’0′,’0’],
# [‘0′,’1′,’0′,’0′,’1’],
# [‘0′,’0′,’0′,’0′,’0’],
# [‘1′,’0′,’0′,’1′,’1’],
# [‘0′,’0′,’1′,’1′,’0’],
[0,0,0,0,0],
[0,1,0,0,1],
[0,0,0,0,0],
[1,0,0,1,1],
[0,0,1,1,0],
]
print(a)
mark = ‘+’
bigA=[]
x=len(a)
y=len(a[0])
for x in range(x+2):
    tmp = [mark] * (y+2)
    bigA.append(tmp)
print(bigA)
for x in range(len(a)):
    for y in range(len(a[x])):
        bigA[x+1][y+1= a[x][y]
print(bigA)
print(len(bigA))
for x in range(len(bigA)):
    for y in range(len(bigA[x])):
        if bigA[x][y] == mark:
            pass
        else:
            if bigA[x][y] == 1:
                if (bigA[x1][y1== 0 or bigA[x1][y1== mark) and \
                   (bigA[x1][y  ] == 0 or bigA[x1][y  ] == mark) and \
                   (bigA[x1][y+1== 0 or bigA[x1][y+1== mark) and \
                   (bigA[x  ][y1== 0 or bigA[x  ][y1== mark) and \
                   (bigA[x  ][y+1== 0 or bigA[x  ][y+1== mark) and \
                   (bigA[x+1][y1== 0 or bigA[x+1][y1== mark) and \
                   (bigA[x+1][y  ] == 0 or bigA[x+1][y  ] == mark) and \
                   (bigA[x+1][y+1== 0 or bigA[x+1][y+1== mark):
                    print(x1,y1)
cs

Array Mgmt

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
# 배열 회전
# 배열 확대
# 배열 축소
class ArrayList :
    listData = []
    size = 0
    def __init__(self, data, size):
        self.listData = data
        self.size = size
    def rotate(self, angle):
        ss = self.size
        # resData = [ [0 for _ in range(0,ss)]  for _ in range(0,ss)]
        resData = []
        for i in range (0, self.size) :
            tmp = []
            for k in range(0, self.size) :
                tmp.append(0)
            resData.append(tmp)
        for i in range(ss) :
            for k in range (ss) :
                ii = ss  i 1
                kk = ss  k 1
                resData[ii][kk] = self.listData[i][k]
        return resData;
    def scaleUp(self, scale):
        ss = self.size
        resData = [ [0 for _ in range(0,ss*scale)]  for _ in range(0,ss*scale)]
        for i in range(ss*scale) :
            for k in range (ss*scale) :
                resData[i][k] = self.listData[i//scale][k//scale]
        return resData;
    def scaleDown(self, scale):
        ss = self.size
        resData = [ [0 for _ in range(0,ss//scale)]  for _ in range(0,ss//scale)]
        for i in range(ss//scale) :
            for k in range (ss//scale) :
                resData[i][k] = self.listData[i*scale][k*scale]
        return resData;
## 회전 (180도)
array = [[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]]
myList = ArrayList(array, 4)
retList = myList.rotate(180)
for tmp in retList :
    print(tmp)
## 확대
retList = myList.scaleUp(3)
for tmp in retList :
    print(tmp)
## 축소
retList = myList.scaleDown(2)
for tmp in retList :
    print(tmp)
cs

Sort 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
data = [
    [34000],
    [41301],
    [04050],
    [18011],
    [40112]
]
 
row=col=5
#########################
def qSort(arr, start, end) :
    if end  start <= 0 :
        return
    pivot = arr[end]
    i = start
    for k in range(start, end) :
        if arr[k] <= pivot :
            arr[i], arr[k] = arr[k], arr[i]
            i += 1
    arr[i], arr[end]  = arr[end], arr[i]
    qSort(arr, start, i1)
    qSort(arr, i+1, end)
 
data1 = []
for i in range(0, row) :
    for k in range(0, col) :
        data1.append(data[i][k])
 
qSort(data1, 0len(data1)1)
 
print(data1)
idx = 0
data2 = []
for _ in range(0, row) :
    tmpList = []
    for _ in range(0, col) :
        tmpList.append(data1[idx])
        idx += 1
    data2.append(tmpList)
print (data2)
 
idx = 0
data3 = []
for i in range(0, row) :
    tmpList = []
    for k in range(0, col) :
        tmpList.append(data1[idx])
        idx += 1
    if i%2 == 0 :
        pass
    else :
        tmpList.reverse()
    data3.append(tmpList)
 
 
print(data3)
#########################
cs

Rotate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
= [
    [ 1 , 2 , 3 , 4  ],
    [ 5 , 6 , 7 , 8  ],
    [ 9 , 101112 ],
    [ 13141516 ],
    ]
 
for i in range(4):
    for j in range(4):
        print(‘%3d’%l[i][j], end=)
    print()
print()
for i in range(4):
    for j in range(3,1,1):
        print(‘%3d’%l[j][i], end=)
    print()
print()
for i in range(3,1,1):
    for j in range(3,1,1):
        print(‘%3d’%l[i][j], end=)
    print()
print()
for i in range(3,1,1):
    for j in range(4):
        print(‘%3d’%l[j][i], end=)
    print()
 
cs

Character Check

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 회문 찾기 (문자, 기호, 공백은 무시)
strList = [‘역삼역’‘기러기’‘일요일’‘다가가다’‘기특한 특기’‘다했냐? 했다!’‘다시 합창 합시다’‘러브’]
# 문자열 정리 (한글만 남기기)
for i in range(0len(strList)) :
    str= strList[i]
    newStr = 
    for ch in str :
        if ‘가’ <= ch <= ‘힣’ :
            newStr += ch
    strList[i] = newStr
# 큐 및 스택에 넣고 빼기
for str in strList :
    queue = []
    stack = []
    for ch in str :
        queue.append(ch)
        stack.append(ch)
    # 빼면서 비교
    check = True
    for _ in range(len(queue)) :
        q = queue.pop(0)
        s = stack.pop()
        if q != s :
            check = False
            break
    if check :
        print(str,‘ 은 회문O’)
    else :
        print(str‘ 은 회문X’)
cs

 

Sort 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
data = [
    [34000],
    [41301],
    [04050],
    [18011],
    [40112]
]
row=col=5
#########################
def qSort(arr, start, end) :
    if end  start <= 0 :
        return
    pivot = arr[end]
    i = start
    for k in range(start, end) :
        if arr[k] <= pivot :
            arr[i], arr[k] = arr[k], arr[i]
            i += 1
    arr[i], arr[end]  = arr[end], arr[i]
    qSort(arr, start, i1)
    qSort(arr, i+1, end)
data1 = []
for i in range(0, row) :
    for k in range(0, col) :
        data1.append(data[i][k])
qSort(data1, 0len(data1)1)
print(data1)
idx = 0
data2 = []
for _ in range(0, row) :
    tmpList = []
    for _ in range(0, col) :
        tmpList.append(data1[idx])
        idx += 1
    data2.append(tmpList)
print (data2)
idx = 0
data3 = []
for i in range(0, row) :
    tmpList = []
    for k in range(0, col) :
        tmpList.append(data1[idx])
        idx += 1
    if i%2 == 0 :
        pass
    else :
        tmpList.reverse()
    data3.append(tmpList)
print(data3)
#########################
cs

Sort Class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class SortMachine() :
    dataList = []
    data_txt = []
    data_num = []
    def __init__(self, data):
        self.dataList = data
    def __del__(self):
        print(self.dataList)
    def  sort(self): # 추상 메소드
        pass
    # selection Sort : 작은 것 찾아가며 정렬
    def SelectionSort(self):  # self.dataList를 선택 정렬하기
        n = len(self.dataList)
        for i in range(0, n1) :
            for k in range(i+1, n) :
                if int(self.dataList[i],16> int(self.dataList[k], 16) :
                    self.dataList[i], self.dataList[k] = self.dataList[k], self.dataList[i]
    # bubble Sort : 큰 것 찾아가며 정렬
    def BubbleSort(self): # self.dataList를 버블 정렬하기
        n = len(self.dataList)
        for i in range(0, n  1):
            for k in range(0, ni1):
                if int(self.dataList[k], 16> int(self.dataList[k+1],16):
                    self.dataList[i], self.dataList[k] = self.dataList[k], self.dataList[i]
import random
list16 = [] # 랜덤하게 16진수 10개 생성
list16b = [] # 랜덤하게 16진수 10개 생성
for x in range(16):
    list16.append(hex(random.randrange(0,int(‘0xFF’,16))))
    list16b.append(hex(random.randrange(0,int(‘0xFF’,16))))
sort1 = SortMachine(list16)
sort2 = SortMachine(list16b)
sort1.SelectionSort()
sort2.BubbleSort()
del(sort1)
del(sort2)
cs

Sort

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class SortMachine() :
    dataList = [];  data_txt = [];  data_num = []
    def __init__(self, data):
        self.dataList = data
    def __del__(self):
        print(self.dataList)
    def  sort(self): # 추상 메소드
        pass
# selection Sort : 작은 것 찾아가며 정렬
class SelectionMachine(SortMachine) :
    def sort(self):  # self.dataList를 선택 정렬하기
        n = len(self.dataList)
        for i in range(0, n1) :
            for k in range(i+1, n) :
                if int(self.dataList[i],16> int(self.dataList[k], 16) :
                    self.dataList[i], self.dataList[k] = self.dataList[k], self.dataList[i]
# bubble Sort : 큰 것 찾아가며 정렬
class BubbleMachine(SortMachine) :
    def sort(self): # self.dataList를 버블 정렬하기
        n = len(self.dataList)
        for i in range(0, n  1):
            for k in range(0, ni1):
                if int(self.dataList[k], 16> int(self.dataList[k+1],16):
                    self.dataList[i], self.dataList[k] = self.dataList[k], self.dataList[i]
# 16진수 10개짜리 만들기 (랜덤)
hexList = [] # 요것도 채우세요.
import random
for _ in range(10) :
    hexList.append(hex(random.randint(0,100)))
sort_selection = SelectionMachine(hexList)
sort_bubble = BubbleMachine(hexList)
sort_selection.sort()
sort_bubble.sort()
del(sort_selection)
del(sort_bubble)
cs

 

Class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Person : # 설계도
    # 속성 (==> 필드)
    name = 
    age = 0
    gender = 
    def  work(self): # 추상 메소드 개념
        pass
class Employee(Person) :
    company = 
    department = 
    def work(self):
        print(‘열심히 일합니다.’)
class Student(Person) :
    school = 
    year = 
    def work(self):
        print(‘열공중~~~’)
emp1 = Employee()
emp1.name = ‘회사원1’
emp1.company = ‘Google’
cs

 

Quick Sort

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def  quick(data) :
    if len(data) <= 1 :
        return data
    pivot = data[1]
    left = []
    right = []
 
    for i in range(0len(data)1) :
        if data[i] < pivot :
            left.append(data[i])
        else :
            right.append(data[i])
 
    return quick(left) + [pivot] + quick(right)
 
 
data = [ 68391012475]
retData = quick(data)
print(retData)
 
cs

Python Sorted

1
2
3
4
5
6
7
8
9
10
11
12
#Sorted
 
l1 = [[1,‘D’,2018],
      [2,‘A’,2016],
      [3,‘C’,2017]]
print(sorted(l1,key=lambda a:a[2],reverse=True))
 
d1 = [{‘id’:1,‘type’:‘D’,‘year’:2018},
      {‘id’:2,‘type’:‘A’,‘year’:2016},
      {‘id’:3,‘type’:‘C’,‘year’:2017}]
print(sorted(d1,key=lambda a:a[‘year’],reverse=True))
 
cs

Python ConnectBy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#Python ConnectBy
deptInfo = {
    ‘CEO’:,
    ‘CAO’:‘CEO’,
    ‘CFO’:‘CEO’,
    ‘CHO’:‘CEO’,
    ‘기술부’:‘CAO’,
    ‘품질부’:‘CAO’,
    ‘재무부’:‘CFO’,
    ‘회계부’:‘CFO’,
    ‘인사부’:‘CHO’,
    ‘교육부’:‘CHO’,
    ‘기술1팀’ :‘기술부’,
    ‘기술2팀’ :‘기술부’,
    ‘재무1팀’ :‘재무부’,
    ‘재무2팀’ :‘재무부’,
}
def findTopDept(d, di, ld):
    if di[d] == :
        return
    else:
        ld.append(deptInfo[d])
        findTopDept(di[d], di, ld)
listDept1 = []
findTopDept(‘기술부’, deptInfo, listDept1)
print(‘List of Dept: %s’ % (listDept1))
listDept2 = []
findTopDept(‘재무1팀’, deptInfo, listDept2)
print(‘List of Dept: %s’ % (listDept2))
for y in listDept1:
    for x in listDept2:
        if x == y:
            print(x)
            break
    else:
        continue
    break
cs

Python 동일 패턴, 중복된 숫자, 연속된 숫자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#동일 패턴, 중복된 숫자, 연속된 숫자
 
import re
 
#동일 패턴
= re.compile(r‘(\d+)\d*\1+’)
= a.findall(“1234123”)
print(b)
 
#중복된 숫자
= re.compile(r‘(\d)\1{2,}’)
= a.findall(“18881719”)
print(b)
 
#연속된 숫자
pattern1 = ‘01234567890123456789’
pattern2 = ‘98765432109876543210’
try:
    print(pattern1.index(“890”))
    print(pattern2.index(“1098”))
    print(pattern2.index(“089”))
except ValueError:
    print(‘OK’)
 
cs

Python pop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#pop
 
 
l1 = [7,1,6]
l2 = [5,9,2]
n1 = 0
n2 = 0
while len(l1) > 0:
    n1 = n1 * 10 + l1.pop()
    n2 = n2 * 10 + l2.pop()
print(n1)
print(n2)
 
n3 = n1 + n2
print(n3)
l3 = []
while n3 % 10 != 0:
    l3.append(n3 % 10)
    n3 //= 10
print(l3)
 
cs

Python re

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Python re
 
(1)
ADS27A7 –> 27
 
s=‘ADS27A7’
import re
a=re.compile(‘.*(\d{2,}).*’)
if a.match(s):
    print(‘OK’)
else:
    pass
print(a.findall(s))
 
print(a.sub(‘\g<1>’,s))
 
b=a.search(s)
print(b.group(1))
 
      
 
######
OK
[‘27‘]
27
27
 
cs

Python 숫자 여부 확인하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Python 숫자 여부 확인하기
 
def is_digit(str):
    try:
        tmp=float(str)
        return True
    except ValueError:
        return False
 
print(is_digit(“123”));
print(is_digit(“-123”));
print(is_digit(“23.45”));
print(is_digit(“a12”));
 
cs

Python 교육 노트

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
Python 교육 노트
■ 키워드
NONE
PASS
■ 리스트 내 문자열 일괄로 숫자로 변경
a=[‘1’,‘2’]
a=list(map(int, a))
print(a)
[1,2]
■ 클래스 내 생성자 생성
class Car:
    __init__(self, name, color, speed=0):
        selef.__name = name
        ….
■ 클래스 내 private 멤버 생성
** private 멤버 변경 시도시 에러 안나고 실제 변경은 안됨
class Car:
    __name = 
■ 클래스 변수
인스턴스 변수와는 다름
변수 선언할 때는 클래스 변수인지 알 수 없음
클래스 변수는 처음에 클래스 변수라고 사용될 때 선언됨
class Car:
    color = “”  # 인스턴스 변수
    speed = 0  # 인스턴스 변수
    count = 0  # 클래스 변수, 이 부분에서 클래스 변수인지는 알 수 없음
    def printMessage():
        print(“시험 출력입니다.”)
    def __init__(self):
        self.speed = 0
        Car.count = 0   # 이 부분에서 클래스 변수로 확정됨, 만약 생성자가 아닌 메소드에서 클래스 변수를 정의하려면 그 메소드를 static 메소드로 정의하여야 함
■ 상속
부모의 private 멤버는 자식에서 바로 사용 못 함. get/set 메소드 통해야 함
자식 클래스의 생성자에서 부모 클래스의 생성자 사용하기
class Sedan(Car):
    __seatNum = 0
    def __init__(self, name, color, speed, seatNum=1):
        super().__init__(name, color, speed)
        self.__seatNum = seatNum
        print(“init2”)
■ Getter, Setter
@를 이용한 Annotation 을 이용한 방법
class Menu:
    __order = 0
    @property
    def order(self):
        return self.__order
    @order.setter
    def order(self, value):
        self.__order = value
= Menu()
a.order = 1     # a.setOrder() 이 아닌 a.order 처럼 사용 가능
print(a.order)  # a.getOrder() 이 아닌 a.order 처럼 사용 가능
■ DB 접속 샘프
우선 python 디렉토리 밑의 scripts 디렉토리에서 다음을 실행하여 설치
pip install PyMySQL
아래는 샘플 코드
import pymysql
import sys
print(sys.stdin.encoding)
conn = pymysql.connect(host=‘localhost’, port=3306, user=‘root’, passwd=‘root’, db=‘python’, charset =‘utf8’)
cur = conn.cursor()
cur.execute(“SELECT name from dep”)
for row in cur:
    print(row[0])
cur.close()
conn.close()
■ import 할 모듈 설치
우선 python 디렉토리 밑의 scripts 디렉토리에서 다음을 실행하여 설치
pip install PyMySQL
■ 커멘드 실행 샘플
#!/usr/bin/python
from subprocess import call
call([“ls”“-l”])
cs

Python4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
Python4
 
#[문제1]
#당신은 러시아의 석유재벌이며, 유명한 희대의 바람둥이다.
#당신의 애인은 수시로 늘었다 줄었다하며, 최대 30명까지 관리하고자 한다.
#애인들을 조금 더 편하게 관리하기 위해 클래스를 생성하려고한다. 이 클래스는 다음과 같은 기능을 갖는다.
#
#* 클래스명 : Lmanager1
#
#1) 애인들의 이름과 집의 좌표를 저장할 수 있다. (동일한 이름의 애인은 등록할 수 없다. 30명이 넘을 순 없다.)
# > add_lover(‘name’, x, y)
#
#2) 애인이 마음에 안들면 관리대상에서 삭제할 수 있다.
# > delete_lover(‘name’)
#
#3) 애인의 집을 바꿔줄 수 있다.
# > modify_lover(‘name’, x, y)
#
#4) 전체 애인의 목록을 출력할 수 있다.
# >print_lover()
 
class Lmanager1:
    name = []
    x = []
    y = []
 
    def add_lover(self, n, x, y):
        if(n not in self.name):
            if(len(self.name) <= 30):
                self.name.append(n)
                self.x.append(x)
                self.y.append(y)
 
    def delete_lover(self, n):
        if(n in self.name):
            i = self.name.index(n)
            del(self.name[i])
            del(self.x[i])
            del(self.y[i])
 
    def modify_lover(self, n, x, y):
        if(n in self.name):
            i = self.name.index(n)
            self.x[i] = x
            self.y[i] = y
 
    def print_lover(self):
        for i in range(0,len(self.name)):
            print(self.name[i], end=‘/’)
            print(self.x[i], end=‘/’)
            print(self.y[i])
 
l1 = Lmanager1()
l1.add_lover(‘Jin’,1,2)
l1.add_lover(‘Lyli’,10,20)
l1.add_lover(‘Queue’,100,200)
l1.add_lover(‘Zoo’,1000,2000)
l1.delete_lover(‘Queue’)
l1.modify_lover(‘Lyli’3040)
l1.print_lover()
print(‘++++++++++’)
 
#[문제2]
#애인 관리 클래스를 이용하자 몇가지 불편한 점이 생겨 업그레이드를 하고자한다.
#대신 기존의 기능을 그대로 가져가고 몇가지 추가 기능을 넣고자 한다.
#
#* 클래스 명 : Lmanager2
#
#1) 애인들의 이름과 집의 좌표를 아래와 같이 저장할 수 있다.
# > l2 = lmanager2()
# > l2 += (‘name’, x, y)
#
#2) 애인들의 이름과 집의 좌표를 아래와 같이 삭제할 수 있다.
# > l2 -= ‘name’
#
#3) 애인의 집을 변경할 수 있다.
# > l2 /= (‘name’, x, y)
#
#4) 애인의 목록을 출력할 수 있다.
# > print(l2)
 
import mod_08_01
 
class Lmanager2(mod_08_01.Lmanager1):
    def __iadd__(self, other):
        self.add_lover(other[0],other[1],other[2])
        return self
 
    def __isub__(self, other):
        self.delete_lover(other)
        return self
 
    def __itruediv__(self, other):
        self.modify_lover(other[0],other[1],other[2])
        return self
 
    def __str__(self):
        output = 
        for i in range(0,len(self.name)):
            output += self.name[i] + ‘/’ + str(self.x[i]) + ‘/’ + str(self.y[i]) + ‘\n’
        return(output)
 
l2 = Lmanager2()
l2 += (‘TwoTwo’999)
l2 = ‘Zoo’
l2 /= (‘TwoTwo’81)
print(l2)
print(‘++++++++++’)
 
 
 
#[문제3]
#크리스마스를 맞아 헬기를 타고 모든 애인의 집에 선물을 주려고 한다.
#비용은 문제가 아니지만 시간을 최소화 하기 위해 최단 거리로 방문하려고 한다.
#
#위에서 생성한 lmanager2 클래스에 최단거리와 경로를 출력하는 기능을 추가하시오
#
#> visit(l2)
#
#(출력예제)
#—-home(0,0)
#janny (3,4)
#micheal(5,8)
#….
#hilton(6,9)
#chris (8,10)
#….
#—- home(0,0)
#
#total distance : 1000.34
#[문제3]
#크리스마스를 맞아 헬기를 타고 모든 애인의 집에 선물을 주려고 한다.
#비용은 문제가 아니지만 시간을 최소화 하기 위해 최단 거리로 방문하려고 한다.
#
#위에서 생성한 lmanager2 클래스에 최단거리와 경로를 출력하는 기능을 추가하시오
#
#> visit(l2)
#
#(출력예제)
#—-home(0,0)
#janny (3,4)
#micheal(5,8)
#….
#hilton(6,9)
#chris (8,10)
#….
#—- home(0,0)
#
#total distance : 1000.34
 
import mod_08_02, math
 
class Lmanager2(mod_08_02.Lmanager2):
    def short(self):
        # 2차원 리스트로 변환하여 처리
        l1 = []
        l2 = []
        for i in range(0,len(self.name)):
            l1.append(math.sqrt(self.x[i]**2 + self.y[i]**2))
            l1.append(self.name[i])
            l1.append(self.x[i])
            l1.append(self.y[i])
            l2.append(l1)
            l1 = []
        l2.sort()
        total_distance = 0
        for i in range(0,len(l2)):
            print(‘%s (%d, %d)’ % (l2[i][1],l2[i][2],l2[i][3]))
            total_distance += l2[i][0]
        print(‘total distance %.2f’ % (total_distance))
 
def visit(l):
    l.short()
 
l2 = Lmanager2()
visit(l2)
 
cs

Python3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
Python3
 
#1) 점들의 거리 구하기
#1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오.
#(결과가 여러개인 경우 모두 출력)
#- 입력 : 1, 3, 4, 8, 13, 17, 20
#- 출력: (3, 4)
#
 
# 입력 받기
l1 = list(map(intstr(input(‘? ‘)).split(‘,’)))
# l1 = [1, 3, 4, 8, 13, 17, 20]
l2 = []
l3 = []
print(l1)
 
# 쌍을 이루는 모든 경우의 수 생성 (차이, p1, p2)
for i in range(0len(l1)):
    for j in range(i+1len(l1)):
        d = abs(l1[i]  l1[j])
        l2.append(d)
        l2.append(l1[i])
        l2.append(l1[j])
        l3.append(l2)
        l2 = []
print(l3)
 
# 차이의 최소값 구하여 그 값과 같은 쌍 출력
for i in range(0len(l3)):
    if(l3[i][0== min(l3)[0]):
        print(‘%d, %d’ % (l3[i][1], l3[i][2]))
 
 
 
#2) 피보나치수열
#피보나치 수열이란, 첫 번째 항의 값이 0이고 두 번째 항의 값이 1일 때, 이후의 항들은 이전의 두 항을 더한 값으로 이루어지는 수열을 말한다.
#인풋을 정수 n으로 받았을때, n 이하까지의 피보나치 수열을 출력하는 프로그램을 작성하세요.
#- 입력 : 15
#- 출력 : 0, 1, 1, 2, 3, 5, 8, 13
#
= 15
 
a1 = 0
a2 = 1
a3 = a1 + a2
= []
l.append(a1)
l.append(a2)
l.append(a3)
 
while True:
    a1 = a2
    a2 = a3
    a3 = a1 + a2
    if(a3 > n):
        break
    else:
        l.append(a3)
print(l)
 
 
 
#3) 이름찾기
#주어진 문자열(공백 없이 쉼표로 구분되어 있음)을 가지고 아래 문제에 대한 프로그램을 작성하세요.
#>>s =  ‘이유덕,이재영,권종표,이재영,박민호,강상희,이재영,김지완,최승혁,이성연,박영서,박민호,전경헌,송정환,김재성,이유덕,전경헌’
# – 이름을 입력 받아 몇명이 있는지 출력하는 함수를 만들고 결과를 확인해보세요.
# – 각 성family name 별로 몇명인지 확인하는 함수를 만들고 결과를 확인해보세요.
# – 중복을 제거한 리스트를 오름차순으로 정렬하는 함수를 만들고 결과를 확인해보세요.
#
s=[‘이유덕’,‘이재영’,‘권종표’,‘이재영’,‘박민호’,‘강상희’,‘이재영’,‘김지완’,‘최승혁’,‘이성연’,‘박영서’,‘박민호’,‘전경헌’,‘송정환’,‘김재성’,‘이유덕’,‘전경헌’]
 
def countName(s1):
    return len(s1)
 
def countLastDistinct(s2):
    last1 = []
    last2 = []
    for x in range(0,len(s2)):
        last1.append(s2[x][0:1])
    for x in range(0,len(last1)):
        if(last1[x] not in last2):
            last2.append(last1[x])
    print(last2)
    return len(last2)
 
def sortDistinctName(s3):
    last1 = []
    for x in range(0,len(s3)):
        if(s3[x] not in last1):
            last1.append(s3[x])
    last1.sort()
    return last1
 
print(s)
print(countName(s))
print(countLastDistinct(s))
print(sortDistinctName(s))
 
 
 
# 4) 이진수 변경
# 아시다시피, 데이터는 컴퓨터에 이진수 형태로 저장됩니다. 우리가 토론할 문제는 양의 정수와 이 수의 이진 형태입니다.
#양의 정수 I가 주어지면, 당신이 할 일은 I보다 큰 수 중 가장 작은 수 J를 찾습니다. I의 이진수 형태에서의 1의 개수와 J의 이진수 형태에서의 1의 개수는 일치합니다.
#예를들어, “78”이 주어지면, 여러분은 “1001110”과 같은 이진수 형태로 쓸 수 있습니다. 이 이진수는 4개의 1을 가지고 있습니다.
#”1001110″ 보다 크고 4개의 1을 포함하는 가장 작은 정수는 “1010011”입니다. 출력값은 “83”이 되어야 합니다.
#- 입력 : 78 / 1001110
#- 출력 : 83 / 1010011
#i = 78
print(“%d / %s” % (i,bin(i)[2:]))
 
def cntOne(s):
    return str(bin(s)).count(‘1’)
 
# def cntOne(s):
#     i2 = bin(s)
#     ss = str(i2)
#     cnt = 0
#     for x in range(0,len(ss)):
#         if(ss[x] == ‘1’):
#             cnt += 1
#     return cnt
# print(“count=%d” % cntOne(i))
 
= i + 1
while cntOne(i) != cntOne(j):
    j += 1
print(“%d / %s” % (j,bin(j)[2:]))
 
 
cs

Python2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
Python2
 
#1) 소수 구하기
#- 2 이상 1000 이하 자연수 집합에서 소수의 개수를 구하는 알고리즘을 작성하시오.
cnt = 0
isSosoo = True
for i in range(21001):
    for j in range(2, i):
        isSosoo = True
        if(i%j == 0):
            isSosoo = False
            break
    if(isSosoo == True):
        cnt += 1
        print(i)
print(‘cnt = %d’ % (cnt))
 
 
 
#2) 마지막 죄수
#- 감옥에 120명의 죄수가 있다. 간수는 복도를 120번 동안 다음 조건에 지나간다.
# . 처음에 문은 모두 닫혀 있다.
# . N번째 지나갈 때에는 N의 배수인 문들이 열려 있으면 닫고, 닫혀 있으면 연다.
# .  마지막에 문이 열려 있으면 그 방의 죄수는 석방이다.
#마지막까지 남아있는 죄수는 몇 명일까?
 
room = {}
for i in range(1121):
    room[i] = ‘CLOSE’
print(room)
 
#N = int(input(‘? ‘))
= 120
for i in range(1, N+1):
    for j in range(1121):
        if (j%i == 0):
            if(room[j] == ‘OPEN’):
                room[j] = ‘CLOSE’
            elif(room[j] == ‘CLOSE’):
                room[j] = ‘OPEN’
print(room)
 
print(len(list(filter(lambda x: x == ‘CLOSE’, room.values()))))
 
 
 
#3) 자연수, 제곱수
#- 모든 자연수는 제곱수의 합으로 표현할 수 있다.
#ex) 7 = 4 + 1 + 1 + 1
#같은 자연수에 대해 여러 결과가 나오기도 한다.
#ex) 12 = 9 + 1 + 1 + 1 / 12 = 4 + 4 + 4
#어떤 자연수를 입력으로 받았을 때, 그 자연수의 최소 갯수의 제곱수의 양의 제곱근의 리스트를 반환하는 리스트를 작성하시오.
import math
= int(input(‘? ‘))
= []
 
s = int(math.sqrt(n))
for x in range(s, 1, -1):
    n -= pow(s, 2)
    l.append(s)
while(n > 0):
    s = int(math.sqrt(n))
    n = pow(s, 2)
    l.append(s)
print(l)
 
 
 
#4) 성냥개비 삼각형만들기
#- 같은 길이의 성냥개비가 여러 개 주어져 있다. 이것들을 평면에 늘어놓아서 삼각형을 만들려고 한다.
#삼각형의 한 변은 여러개의 성냥개비를 직선으로 이어서 만들 수 있지만 성냥개비를 꺾거나 잘라서 변의 한 부분을 만들 수는 없다.
#성냥개비 개수가 주어졌을 때, 이들 성냥개비를 사용하여 만들 수 있는 서로 다른 삼각형의 개수를 구하는 프로그램을 작성하시오.
#1) 주어진 성냥개비는 모두 사용하여 하나의 삼각형을 만들어야 한다.
#2) 삼각형을 한 개도 만들 수 없으면 0을 출력한다.(1,2,4인 경우에는 0이다.)
#3) 합동인 삼각형들은 같은 삼각형으로 본다. 예를 들어서 성냥개비 5개를 사용하여 만들 수 있는 그림 2의 삼각형들은 같은 삼각형으로 본다.
 
cnt = 0
= int(input(‘? ‘))
l1 = []
l2 = []
 
# 세변의 모든 경우의 수 생성
for a in range(1, n):
    for b in range(1, n  a):
        c = n  a  b
        l1.append(a)
        l1.append(b)
        l1.append(c)
        l2.append(l1)
        l1=[]
print(l2)
 
# 중복제거를 위한 소팅
for x in range(0len(l2)):
    l2[x].sort()
l2.sort()
print(l2)
 
# 중복 제거
l3 = []
for x in l2:
    if(x not in l3):
        l3.append(x)
print(l3)
 
# 삼각형이 되기 위한 조건 : a + b > c 여야 함 (c는 가장 긴 빗변)
for x in range(0len(l3)):
    if(l3[x][0+ l3[x][1> l3[x][2]):
        cnt += 1
        print(l3[x])
print(cnt)
 
cs

Python1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
Python1
 
# 3) 지뢰찾기 게임 만들기 –  M x N 크기의 지뢰밭에서 모든 지뢰의 위치를 찾아내는 게임이다.
# 이 게임에서 각 칸에 인접한 칸에 몇 개의 지뢰가 있는지 보여준다.  지뢰판의 크기와 지뢰의 위치를 표현하는 문자열을 입력하면아래와 같이 출력하라. (지뢰 ‘*’ , 공백 ‘.’ 으로 입력)
#
# *** test case 1
# >>> 입력 :  4 4
# * . . .
# . . . .
# . * . .
# . . . .
# >>> 출력 :
# * 1 0 0
# 2 2 1 0
# 1 * 1 0
# 1 1 1 0
#
#
#
# *** test case 2
# >>> 입력 : 3 5
# * * . . .
# . . . . .
# . * . . .
# >>> 출력 :
# * * 1 0 0
# 3 3 2 0 0
# 1 * 1 0 0
#
#
 
import random
# 입력 받기
= []
= input(‘입력 : ‘).split(‘ ‘)
= [int(i) for i in n]
yMax = n[0]
xMax = n[1]
print(n)
print()
 
#배열 생성 및 폭탄 입력
= []
mark = [‘*’, ‘.’]
for y in range(0, yMax):
    b.append([])
    for x in range(0, xMax):
        b[y].append(random.choices(mark)[0])
print(b)
print()
 
#배열 출력 (표 모양)
for y in range(0, yMax):
    for x in range(0, xMax):
        print(b[y][x]+‘ ‘, end=”)
    print()
print()
 
#셀 별로 반복하면서, 폭탄이면 * 출력, 아니면 주위 폭탄 갯수 출력
for y in range(0, yMax):
    for x in range(0, xMax):
        if(b[y][x]==*’):
            print(‘* ‘, end=”)
        else:
            xFrom=0
            xTo=0
            yFrom=0
            yTo=0
 
            if(y == 0):
                yFrom = 0
            else:
                yFrom = y – 1
            if(y == yMax – 1):
                yTo = yMax – 1
            else:
                yTo = y + 1
 
            if(x == 0):
                xFrom = 0
            else:
                xFrom = x – 1
            if(x == xMax – 1):
                xTo = xMax – 1
            else:
                xTo = x + 1
 
            #주위 폭탄 갯수 계산
            cnt = 0
            for yy in range(yFrom, yTo + 1):
                for xx in range(xFrom, xTo + 1):
                    if(b[yy][xx]==*’):
                        cnt += 1
            print(str(cnt)+‘ ‘, end=”)
    print()
 
cs