주제 선정

우선 주제를 먼저 고민해보았다. 3주 안에 만들어야하기때문에 복잡한 구현이 필요한 주제는 쓰질 못한다. (물론 플젝에만 시간을 갈면 어떻게 될 수도 있긴하지만 졸업을 위해 해야할게 너무 많다 ㅎㅎ)

고민을 해본 것은 '카드깡' 어플리케이션. 내가 직접 해본 적은 없지만 사람들이 보통 밥 값 내기를 하기 위해서 직원분들께 자신들의 카드를 보여주곤 직접 뽑으라고 한다. 그렇게 해서 뽑힌 카드로 결제하는 방식.. (요즘도 이런게 있는진 모르겠다.) 이걸 그냥 어플리케이션으로 지정해주면 좋지않을까 싶다. 구현도 random으로 돌리면 쉬울 것같기도 하고 .. 그리고 n빵 계산하는 기능도 넣으면 좀 더 그럴듯하지 않을까 싶었다.

디자인 선정

시간도 없고 디자인을 그렇게 잘하는 편은 아니다. 그래서 토스처럼 깔끔하게 ui를 만드는 것이 목표. 피그마를 통해 앱 아이콘과 기본 디자인을 만들어본다.

직관적으로 그냥 카드 이미지와 어플리케이션 이름, 그리고 시작 버튼을 넣어보았다.

안드로이드 스튜디오 직접 넣어보니까 나쁘지 않은 것 같긴 한데.. 좀 허전해보인다. 카드 이미지를 다시 만들던지 해야할 듯. 일단 지금은 이걸로 함.

대강 디자인을 마쳤다. 이제 개발을 시작해보자.

개발

한번 framgent로 도전해보자..!

Fragment는 framLayout으로 감싸져있어서 constriantLayout으로 바꿔주었다.

fragment 간의 이동이 안돼서 1시간동안 끙끙 앓았는데 name의 문제였다..^^ NavHostFragment로 해줬어야함 ㅎㅎ... 나 이제껏 뭐함?

피그마에 나온 대로 fragment를 추가하고 디자인하고.. 기능을 연결하였다. action 태그 달다가 헷갈려서 뇌정지 올뻔했다.

애니메이션을 넣어주면 더 퀄리티 있을 것같아서

implementation ("nl.dionsegijn:konfetti-xml:2.0.3")

를 gradles에 추가한 후, 오픈소스의 애니메이션도 넣어주었다. 그래도 하루만에 진도를 빨리 나가서 다행이다.

https://source-coding.tistory.com/

호기롭게 BFS로 접근하였지만 흠.. 일단 의식의 흐름대로 한번 써봤다

from collections import deque

def bfs(graph, words, begin, ct, target):
    count, c, i = 0, 0, 0
    queue = deque([words[i]]) # ["hot"]
    answer = []
    v = queue.popleft()
    while True:
        for w in v:
            if w in begin:
                count+=1
        if count == (ct-1):
            begin = v
            answer.append(begin)

        if len(set(target) - set(begin)) == 1:
            answer.append(target)
            break

        count = 0
        i += 1
        if i == len(words):
            break
        queue.append(words[i])
        v = queue.popleft()
    return len(answer)

def solution(begin, target, words):
    if not target in words:
        return 0
    visited = [False]*len(words)
    answer = bfs(words, words, begin, len(begin), target)
    return answer

만약 target과의 문자 차이가 1개일 경우, (그리고 target의 단어가 words안에 있으면) 바로 while문을 나가기. +1 만 해주면 과정은 차피 끝이니까 ㅇㅇ... 제출해보니 의외로 선방하긴했다..^^

의외로 시간초과가 안떴다. 그러면 내가 테스트케이스 무언가를 지금 고려 안했다는 것같은데.. 구글링을 해보니까 내가 words의 순서가 고정되어있다고 생각했던 것이 문제였다 그럼 이거 다 갈아엎어야 하나..? ㅎ 아님 그냥 리버스한걸 뒤에 하나 더 붙여서 해볼까 싶었다.

from collections import deque

def bfs(graph, words, begin, ct, target):
    count, c, i = 0, 0, 0
    queue = deque([words[i]]) # ["hot"]
    answer = []
    v = queue.popleft()
    while True:
        if len(set(begin) - set(v)) == 1:
            begin = v
            answer.append(begin)        
        elif begin == target:
            break

        if len(set(target) - set(begin)) == 1:
            answer.append(target)
            break

        count = 0
        i += 1
        if i == len(words):
            break
        queue.append(words[i])
        v = queue.popleft()
    return len(answer)

def solution(begin, target, words):
    if not target in words:
        return 0
    words += words[::-1]
    answer = bfs(words * len(words), words, begin, len(begin) * 2, target)

    return answer

응 안돼~ 돌아가.. 일단 set으로 비교하는 게 틀렸음 함수를 하나 더 만들어서 비교를 했고 하나의 자리에서만 차이가 나는거니까 인덱스도 확인해줬어야함

from collections import deque

def find(target, begin):
    count = 0
    for i in range(len(begin)):
        if begin[i] == target[i]:  
            count+=1
    return count

def bfs(words, begin, target):

    count= 0
    obj = len(begin)-1

    queue = deque(words) # ["hot", "dot", "dog", "lot", "log", "cog"]
    goal = target[:]
    answer = []
    v = queue.popleft()

    while queue:
        # 현재 단어랑 바꿀 단어랑 알파벳 비교
        # 만약 1개밖에 차이가 안나면 걔로 바꿈

        print("현재", begin, v, find(begin, v), obj)
        if v == target and find(begin,v) == obj:
            count += 1
            return count

        if find(begin, v) == obj:
            begin = v
            count += 1 # 바꾼 횟수
            # 근데 만약 바꾼 begin이랑 target이 차이가 1개 밖에 안나면
            # 한번만 더 바꾸면 되니까 끝내기
            if find(target, begin) == obj:
                count += 1
                return count
        else: 
            queue.append(v)
        v = queue.popleft()
    return count

def solution(begin, target, words):
    if not target in words:
        return 0
    answer = bfs(words, begin, target)
    return answer

백트래킹?? dfs?? bfs?? 일단 2차원배열 동서남북이니까 x,y 이동을 따로 리스트로 만들어야겠다고 생각 처음엔 무조건 dfs로 풀어봐야지~ 하고 해봤는데 답이 잘 안나오는 듯했다. 질문하기를 보니 BFS를 푸는 것같다. 맵의 최단경로같은거 구할 때는 BFS 생각해보기...

근데 bfs 툴은 외워서 쓰겠는데 그래서 이걸 어떻게하지? 생각 뿐

from collections import deque

def bfs(graph, start, visited):
    queue = dequeue([start])
    visited[start] = True
    while queue:
        v = queue.popleft()
        for i in graph[v]:
            if not visited[i]:
                queue.append(i)
                visited[i] = True

def solution(maps):
    answer = 0
    # 최단 경로, 백트래킹?
    n,m = len(maps), len(maps[0])

    dx = [-1,1,0,0] # 동 서 남 북
    dy = [0,0,1,-1] # 동 서 남 북

    visited = [[False] * m for _ in range(n)]


    return answer

결국 구글링의 도움 ㄱㄱㄱㄱ... 2차원배열이라 튜플형태를 활용하는 듯했다.

from collections import deque # queue 라이브러리 삽입

def bfs(maps, visited, n, m):

    if not maps[n - 2][m - 1]: #다 막혀있는 곳이면
        return -1

    queue = deque([(0, 0)]) # 현재 위치
    visited[0][0] = True # 방문 처리

    dx = [-1,1,0,0] # 동 서 남 북
    dy = [0,0,1,-1] # 동 서 남 북

    while queue:
        y, x = queue.popleft()

        for i in range(4):  # 동서남북

            nx = x + dx[i] # 가게 될 위치를 계산 (열)
            ny = y + dy[i] # 행

            # 갈 수 있는 방향이고 면적을 벗어나지 않는 경우
            if 0 <= nx < m and 0 <= ny < n and maps[ny][nx]:

                if not visited[ny][nx]:
                    visited[ny][nx] = True # 방문처리

                    queue.append((ny, nx)) # 큐 삽입
                    maps[ny][nx] = maps[y][x] + 1 # 최단경로 갱신


    return maps[n - 1][m - 1]

def solution(maps):
    n,m = len(maps), len(maps[0])

    visited = [[False] * m for _ in range(n)]
    answer = bfs(maps, visited, n, m)
    return answer

근데 무엇인가 통과가 안되고있다... 일단 효율성에서도 통과가 안되었고 ㅠ 결과에서도 실패가 떠서 단순히 시간초과 문제가 아닌듯

벽에 다 막혀있는 경우를 제대로 고려하지않아서인가 싶어서 좀 더 고쳐보았다.

from collections import deque # queue 라이브러리 삽입

def bfs(maps, visited, n, m):

    if (not maps[n - 2][m - 1]) and 
    (not maps[n-2][m-2]) and (not maps[n-1][m-2]): #다 막힘
        return -1

    queue = deque([(0, 0)]) # 현재 위치
    visited[0][0] = True # 방문 처리

    dx = [-1,1,0,0] # 동 서 남 북
    dy = [0,0,1,-1] # 동 서 남 북

    while queue:
        y, x = queue.popleft()

        for i in range(4):  # 동서남북

            nx = x + dx[i] # 가게 될 위치를 계산 (열)
            ny = y + dy[i] # 행

            # 갈 수 있는 방향이고 면적을 벗어나지 않는 경우
            if 0 <= nx < m and 0 <= ny < n and maps[ny][nx]:

                if not visited[ny][nx]:
                    visited[ny][nx] = True # 방문처리

                    queue.append((ny, nx)) # 큐 삽입
                    maps[ny][nx] = maps[y][x] + 1 # 최단경로 갱신


    return maps[n - 1][m - 1]

def solution(maps):
    n,m = len(maps), len(maps[0])

    visited = [[False] * m for _ in range(n)]
    answer = bfs(maps, visited, n, m)
    return answer

효율성은 다 통과가 되었으나 실행평가에서 아직도 막혔음 질문하기를 보니까 상대측 진영에서 벽으로 다 막히지않아도 도달하지못할 수도 있는 것을 고려해야함

그러면 내 쪽에서 벽이 생겼나??? 너무 단순하게 (0,1), (1,0) 쪽만 막히면 되나? 싶어서 조건을 걸었는데 런타임 에러나는 테스트 케이스도 있었다.

근데 조건을 보니까 n,m이 1인 경우는 없다고 한다. 그러면 최단경로의 거리는 최소 1보단 커야한다. (동서남북이니까 대각선은 못할테고) 그래서 만약 구한 경로의 길이가 1이면 안된다고 생각하고 return -1로 해볼까? 했는데 통과가 되었다;;; 이게 되네

코드를 더 다듬으려고 보니, 그럼 굳이 상대측 진영 근처도 막혀있는지 확인안해도 될 것같아서 지우고 돌려보니 통과가 된다.

from collections import deque # queue 라이브러리 삽입

def bfs(maps, visited, n, m):

    queue = deque([(0, 0)]) # 현재 위치
    visited[0][0] = True # 방문 처리

    dx = [-1,1,0,0] # 동 서 남 북
    dy = [0,0,1,-1] # 동 서 남 북

    while queue:
        y, x = queue.popleft()

        for i in range(4):  # 동서남북

            nx = x + dx[i] # 가게 될 위치를 계산 (열)
            ny = y + dy[i] # 행

            # 갈 수 있는 방향이고 면적을 벗어나지 않는 경우
            if 0 <= nx < m and 0 <= ny < n and maps[ny][nx]:

                if not visited[ny][nx]:
                    visited[ny][nx] = True # 방문처리

                    queue.append((ny, nx)) # 큐 삽입
                    maps[ny][nx] = maps[y][x] + 1 # 최단경로 갱신

    return maps[n - 1][m - 1]

def solution(maps):
    n,m = len(maps), len(maps[0])
    visited = [[False] * m for _ in range(n)]
    answer = bfs(maps, visited, n, m)
    if answer == 1 :
        return -1
    return answer

dfs중심으로 만들어보았다. 하지만 여기서 어떻게 답을 이끌어낼까 고민을 하는 중..

def dfs(graph, v, visited):
    visited[v] = True
    print(v, end=' ') #graph[v]가 아니다
    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)

def solution(n, computers):
    answer = 0
    n = len(computers)

    graph = [[] for _ in range(n+1)] # 그래프 생성

    for i in range(n):
        for j in range(n):
            if i!= j and computers[i][j]:
                graph[i+1].append(j+1)
    visited = [False] * (n+1)
    dfs(graph, 1, visited)    

    return answer

탐색한 경로는 다음과 같다 근데 내가 원하는건 탐색경로가 아닌 이어진거냐 아니냐인데... 이걸 어떻게 활용할수가 없을까.. 일단 output은 네트워크 대역을 계산하는거니까 연결되지 않은 것들만 전체 컴퓨터 개수에서 빼면 나오지 않나..

def dfs(graph, v, visited):
    visited[v] = True
    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)

def solution(n, computers):
    answer = 0
    n = len(computers)

    graph = [[] for _ in range(n+1)] # 그래프 생성

    for i in range(n):
        for j in range(n):
            if i!= j and computers[i][j]:
                graph[i+1].append(j+1)
    visited = [False] * (n+1)
    dfs(graph, 1, visited)

    answer = [ 1 for bol in visited if bol]
    answer = len(computers) - (len(answer)-1)
    return answer

머리가 빠개질것같다 ...... 결국 구글링의 힘을 썼다.

참고 링크

def solution(n, computers):
    answer = 0
    n = len(computers)

    visited = [False] * (n+1)

    def dfs(v):
        visited[v] = True
        for com in range(n):
            if not visited[com] and computers[v][com]:
                dfs(com)

    count = 0
    for i in range(n):
        if not visited[i]:
            dfs(i)
            count += 1

    return count

맞긴했는데.. 내 힘으로 푼게 아니라서 너무 찝찝하다..

그니까 처음 0번째 컴퓨터에서 연결된 네트워크들을 확인한다. visited[0] and ~ 하기도 전에 visited[0] 은 이미 지나갔으니 패스 visited[1] and computers[0][1] => dfs(1) => visited[1] = True => visited[2] and computers[2][1] => dfs(2) => visited[2] = True => None => dfs(2) 완료 (여기서 count 가 1 증가)=> visited[2] and computers[2][2] => dfs(2) 완료 => count 1 증가..?

*DFS로 최대한 탐색하고 빠져나가면 그것이 하나의 네트워크라고 한다. *

조금 더 찾아보니 아까 dfs 코드로 짠거랑 비슷한 코드가 있어서 다시 한번 써본다.

참고한 링크

def dfs(computers, visited, n, com):
    visited[com] = True
    for c in range(n):
        if c != com and computers[com][c] == 1:
            if not visited[c]:
                dfs(computers, visited, n, c)

def solution(n, computers):
    answer = 0
    n = len(computers)
    visited = [False] * (n+1)
    count = 0

    for i in range(n):
        if not visited[i]:
            dfs(computers, visited, n, i)
            count += 1

    return count

굳이 그래프를 따로 만드려고 고군분투하지 않아도 된다.. .그냥 있는거 잘 써보자. 그리고 이차원 배열 접근을 너무 어색해하지말고 ㅠㅠ

이거까지 풀고 dfs/bfs를 푼다음 다시 완전 탐색으로 넘어가야하나 고민된다.. 시간이 좀 많이 부족한 듯 ㅠ

(혼란 그 자체...)

24, 24 테스트 케이스를 골똘히 생각하다가 약수?? 라는 생각을 했다. 그러다가 질문하는 내용들을 보다가 약수로 고려하는 것들이 있길래 접근방법이 맞겠구나 싶어 약수를 구하는 쪽으로 해보았다.

def Div(x):
    div = []
    for i in range(1,(x//2)+1):
        if x%i == 0:
            div.append(i)
    a = div[len(div)//2]
    b = x//a
    return a,b

def solution(brown, yellow):
    answer = []
    bx, by = 0, 0
    if yellow > 1:
        a, b =Div(yellow)
        a += 2
        b += 2
        if a > b:
            bx, by = a, b
        else:
            bx, by = b, a
    else:
        bx = 1 + 2
        by = 1 + 2

    answer.append(bx)
    answer.append(by)

패기롭게 냈지만 테스트 케이스 몇 개가 통과되질 않는다 ㅠㅠ

일단 너무 임의로 잡은게 크다; 약수를 꼭 중간자리에서 찝어야해? 그리고 1이 고정이 아닐 수도 있고.. 쫌 엉망진창이긴 하다;

조건을 설정해주고 brown의 가로는 yellow 가로의 +2 .. 이런식으로 바꿔서 해주자.

def Div(x):
    div = []
    for i in range(1,x+1):
        if x%i == 0:
            div.append(i)
    return div

def solution(brown, yellow):
    answer = []
    yx, yy = 0, 0
    bx, by = 0, 0

    div = Div(yellow)
    for num in div:
        find = ((brown-num*2)//2)-2
        if (find in div) and (find*num == yellow):
            if find > num:
                yx, yy = find, num
            else:
                yx, yy = num, find
            break
    bx = yx + 2
    by = yy + 2

    answer.append(bx)
    answer.append(by)
    return answer

일단 라이브러리를 사용해서 조합을 구하는게 제일 첫번째인 것같다. 조합은 itertools에서 permutations을 import하면 사용할 수 있었다.

from itertools import permutations

만약 3개의 숫자가 있으면 1개만 뽑아서 쓰는 조합, 2개만 뽑아서 쓰는 조합, 3개만 뽑아서 쓰는 조합 이렇게 되니까 for문을 돌려 permutations 함수를 써야한다.

permutat = []
    for n in range(1, len(numbers)+1):
        permutat += list(permutations(numbers, n))

처음엔 append를 사용했는데 그러면 좀 드럽게 나온다 ㅡㅡ;

그다음은 join함수와 int변환을 통해 곧바로 숫자를 조합해서 정수로 만들도록 한다. 그리고 나선 소수 판별이 관건.

소수 판별이 제일 어렵지않을까 고민했는데 구글링해보니 간단했다.

for문을 돌리면서 2부터 루트(소수판별할 수)까지 나눠지는 경우가 있는지 확인하면 되는 것이다 (%연산자를 통해 0이면 나눠지니까 바로 소수가 아니니 False)

근데 왜 범위가 루트로 씌워서 할까? 일단 계산의 복잡도를 줄이기 위해서라는건 알겠다. 하지만 루트를 씌우면 모든 경우의 수를 고려할 수 있을까?

예를 들어 17를 생각해보자. 17은 1, 17으로만 약수가 나오기때문에 소수.

[9] 1 3 9 19 = 9 33 = 9

[10] 1 2 5 10 110 = 10 25 = 10 어차피 대칭이라는 특징을 갖고있으니까 반절만 보면 그만이라는 것. 그니까 루트를 잘 사용하자.

루트를 잘 쓸일이 없어 헷갈리니 좀 더 정리하다 math 라이브러리를 불러와야하고 sqrt함수를 사용하면 된다.

최종 코드다.

import math
from itertools import permutations

# 소수인지 판별
def prime(x):
    for i in range(2, int(math.sqrt(x)) + 1):
        if x % i == 0:
            return False
    return True

def solution(numbers):
    answer = 0
    permutat = []
    for n in range(1, len(numbers)+1):
        permutat += list(permutations(numbers, n))
    permutat = [int(("").join(p)) for p in permutat]
    permutat = list(set(permutat))

    ct = 0
    for num in permutat:
        if num == 0 or num == 1:
            continue
        if prime(num):
            ct += 1
    return ct

문제의 개수에 따라 수포자의 답안을 만들어준다. 수포자의 답안 패턴 개수보다 문제의 개수가 많을 경우, 나누기와 나머지를 통해 답안 작성 ..

그 후 루프를 통해 정답이 맞았는지 확인하면서 점수 매긴다. 그 다음은 가장 높은 점수를 얻은 학생들을 리스트에 넣어서 반환한다.

# 답안 작성
def sub_answers(answers, s):
    if len(answers) > len(s):
        div = len(answers) // len(s)
        res = len(answers) % len(s)
        sub_s = s[:]
        for i in range(div-1):
            s += s
        s += sub_s[:res]
    return s

# 채점
def grade(answers, s):
    score = 0
    for idx, answer in enumerate(answers):
        if answer == s[idx]:
            score += 1
    return score

def solution(answers):

    s1 = [1,2,3,4,5]
    s2 = [2,1,2,3,2,4,2,5]
    s3 = [3,3,1,1,2,2,4,4,5,5]

    # 1번 수포자 답안
    if len(answers) > len(s1):
        s1 = sub_answers(answers,s1)
        print(s1)
    else:
        s1 = s1[:len(answers)]

    # 2번 수포자 답안
    if len(answers) > len(s2):
        s2 = sub_answers(answers,s2)
    else:
        s2 = s2[:len(answers)]

    # 3번 수포자 답안
    if len(answers) > len(s3):
        s3 = sub_answers(answers,s3)
    else:
        s3 = s3[:len(answers)]

    # 채점 결과
    s1_grade = grade(answers,s1)
    s2_grade = grade(answers,s2)
    s3_grade = grade(answers,s3)


    answer = []
    max_grade = max(s1_grade, s2_grade, s3_grade)
    # 높은 점수 받은 사람이 여럿일 경우 고려
    if max_grade == s1_grade:
        answer.append(1)
    if max_grade == s2_grade:
        answer.append(2)
    if max_grade == s3_grade:
        answer.append(3)

    return answer

패기롭게 냈지만..

시간초과로 틀리게 되었다. 아슬아슬하긴 했는데.. 진짜 이렇게 되네 어디서부터 시간 초과가 되었을까.. max함수를 없애보았는데 그건 문제가 안되는듯

아무래도 sub_answers 함수에서 시간초과가 되는건가? 한번 오류가 나더라도 sub_answers를 없애고 돌려보았다.

이번에는 시간초과가 뜨지않았다. 결국 답안 작성에서 시간초과가 되었다는건데... for문을 돌려서 답안 작성하지않고 그냥 바로 곱하기로 때려박았다.

# 답안 작성
def sub_answers(answers, s):
    div = len(answers) // len(s)
    res = len(answers) % len(s)
    sub_s = s[:]
    s = s*(div)
    s += sub_s[:res]
    return s

# 채점
def grade(answers, s):
    score = 0
    for idx, answer in enumerate(answers):
        if answer == s[idx]:
            score += 1
    return score

def solution(answers):

    s1 = [1,2,3,4,5]
    s2 = [2,1,2,3,2,4,2,5]
    s3 = [3,3,1,1,2,2,4,4,5,5]

    # 1번 수포자 답안
    if len(answers) > len(s1):
        s1 = sub_answers(answers,s1)
    else:
        s1 = s1[:len(answers)]

    # 2번 수포자 답안
    if len(answers) > len(s2):
        s2 = sub_answers(answers,s2)
    else:
        s2 = s2[:len(answers)]

    # 3번 수포자 답안
    if len(answers) > len(s3):
        s3 = sub_answers(answers,s3)
    else:
        s3 = s3[:len(answers)]

    # 채점 결과
    s1_grade = grade(answers,s1)
    s2_grade = grade(answers,s2)
    s3_grade = grade(answers,s3)


    answer = []
    max_grade = max(s1_grade, s2_grade, s3_grade)
    # 높은 점수 받은 사람이 여럿일 경우 고려
    if max_grade == s1_grade:
        answer.append(1)
    if max_grade == s2_grade:
        answer.append(2)
    if max_grade == s3_grade:
        answer.append(3)

    return answer

(+) 더 효율적인 방식이 있을까? 하고 찾아봤는데

   for idx, answer in enumerate(answers):
        if answer == pattern1[idx%len(pattern1)]:
            score[0] += 1
        if answer == pattern2[idx%len(pattern2)]:
            score[1] += 1
        if answer == pattern3[idx%len(pattern3)]:
            score[2] += 1

이런식으로 풀 수도 있었다. 굳이 답안을 만들지않고 그냥 %연산을 통해서만 하면 제일 깔끔했다... ^_^ 넘 슬프고..

우선 가로 세로 중에 제일 큰 수를 구한다. 가로가 제일 클 경우, 명함들 중 가로보다 세로가 큰 경우를 찾아서 가로 -> 세로, 세로 -> 가로 스왑해준다. 세로가 제일 클 경우, 명함들 중 세로보다 가로가 큰 경우를 찾아서 세로 -> 가로, 가로 -> 세로 스왑해준다.

그 후, 스왑해준 세로(가로) 중에 제일 큰 수를 구한다음, 처음 구했던 제일 큰 수와 곱해서 면적을 구하면 된다.

def solution(sizes):
    w = [sizes[i][0] for i in range(len(sizes))]
    h = [sizes[i][1] for i in range(len(sizes))]
    max_w, max_h = max(w), max(h)
    if max_w > max_h:
        total_max = max_w   
        for i in range(len(sizes)):
            if sizes[i][1] > sizes[i][0]:
                w[i], h[i] = h[i], w[i]
        max_h = max(h)
        answer = max_h * total_max
    else:
        total_max = max_h
        for i in range(len(sizes)):
            if sizes[i][0] > sizes[i][1]:
                h[i], w[i] = w[i], h[i]
        max_w = max(w)
        answer = max_w * total_max
    return answer

처음으로 바로 통과가 되었다 ㅠ 사실 처음에 완전 탐색이라길래 백트래킹을 생각해야하나, dfs를 써야하나 별 생각을 다했는데 그냥 쉽게 생각하면 바로 풀리는 거였다.

(+) 좀 더 코드를 잘 정리할 순 없을까 싶어서 한번 찾아보았다. 굳이 w,h 리스트를 만들어서 max를 찾고...... 이렇게 할 필요는 없다. 해당 과정을 과감히 삭제하고 스왑 과정을 살린 다음, max함수를 때려버리면 된다.

def solution(sizes):
    r, c = 0,0
    for row, col in sizes:
        if row > col:
            row, col = col, row
        r = max(r, row)
        c = max(c, col)
    return r*c

내가 너무 단순하게 생각했다. 스왑할 때 리스트 요소를 직접 스왑해야한다고 생각했는데, 굳이 직접 스왑안하고 그냥 변수로써 임시저장 느낌으로 스왑을 해주고 max 함수를 통해 최대를 계속 구하기만 하면 되는 거였다. 이러니 코드가 훨씬 깔끔해졌다

우선 의식의 흐름대로 코드를 짜보았다. 사람들의 무게 리스트를 정렬해서 제일 먼저 태울 사람들을 묶었다. 그리고 누적된 kg이 초과되면 그룹을 자르고 다시 그룹 묶는 식으로

def solution(people, limit):
    people.sort() # 무게 정렬
    kg = 0 # 누적할 kg

    sub_list = []
    total = []
    idx = 0
    for idx, num in enumerate(people):
        kg += num
        #print(f"num = {num}, {kg}kg, limit = {limit}")
        if kg == limit:
            sub_list.append(num)
            total.append(sub_list)
            sub_list = []
            kg = 0
        elif kg > limit:
            total.append(sub_list)
            sub_list= []
            sub_list.append(num)
            total.append(sub_list)
            kg = 0
        else:
            if idx == len(people)-1:
                sub_list = []
                sub_list.append(num)
                total.append(sub_list)
                break
            sub_list.append(num)
    return len(total)

하지만 어림없지

슬라이싱을 통해 코드를 좀더 간결하게 해보았다.

def solution(people, limit):
    people.sort() # 무게 정렬
    kg = 0 # 누적할 kg

    sub_list = []
    total = []
    start = 0    
    for idx, num in enumerate(people):
        kg += num # kg 누적 

        if kg == limit: # 만약 limit에 딱 맞으면 그룹 나누기
            total.append(people[start:idx+1])
            sub_list, kg, start = [], 0, idx+1 # 초기화
        elif kg > limit: # 초과되어도 그룹 나누기
            total.append(people[start:idx])
            start = idx
        if idx == len(people)-1:
            total.append(people[start:])
            break
        sub_list.append(num)
    return len(total)

깔끔하게 그룹이 나눠지는 듯 함. 하지만 통과가 안되는 것은 여전히 마찬가지 .. 일단 시간초과는 안뜨긴했으니 (효율성에서 통과는 못했지만) 먼저 고려하지못한 테스트케이스에 대해서 생각해보자

질문하기에서 사람들의 질문을 찬찬히 보았다. 근데 아.. ㅋㅋㅋㅋㅋㅋㅋㅋ 다시 읽어보니 단 2명이다 ... 난독증 미쳤고 ㅎㅎ

그러면 왜 가장 큰 무게인 사람과 가장 가벼운 사람인 사람을 넣어야하는지 이해가 된다. 가장 큰 무게인 사람을 보트에 단 한명만 넣으면 너무 손해니까 어떻게든 끼역넣어야겠지..

참고한 링크

내 입맛대로 바꾸고있는데 계속 테케가 걸려서 될대로 되라 심정으로 일단 제출을 했는데 다 통과가 되었다. 않이 이게 왜 되는거지??

def solution(people, limit):

    people.sort() # 무게 정렬

    start, end = 0, len(people)-1
    boat = 0

    while (start <= end): # 반절을 넘기면 안됨
        if start == end : 
            boat += 1
            break
        if people[start] + people[end] <= limit:
            start += 1
            end -= 1
            boat += 1
            continue
        else:
            end -= 1
        boat += 1
    return boat

boat를 추가하는 타이밍이 애매해서 일단 닥치는대로 넣어보았다.

1. 우선 한도에 맞게 그룹이 짝지어진 경우 boat를 추가해서 넣어주기

2. 만약 한도 초과면 따로 넣어야하니까 boat 추가해서 넣어주기.. 뭐야 결국 다 boat 추가 아닌가?;;

코드를 다시 바꿔보았다.

def solution(people, limit):

    people.sort() # 무게 정렬

    start, end = 0, len(people)-1
    boat = 0

    while (start <= end): # 반절을 넘기면 안됨
        boat += 1
        if start == end :
            break
        if people[start] + people[end] <= limit:
            start += 1
            end -= 1
            continue
        else:
            end -= 1

    return boat

어차피 보트는 항상 나가게 되어있고 거기서 인원이 1명이나 2명이냐 그 뿐인 것같다.

코드가 좀 와닿진 않긴한데.. 튼 그렇다 찝찝하게 끝났다.. ㅎㅎㅎ Lv3까지 하기엔 시간이 너무 없기때문에 Lv2까지만 풀고 그리디의 고난도 문제 풀이는 끝

근데 이렇게 하면 문제점이 있다. 마지막 예시에서 걸린다는 점. 어쩐지 너무 단순하게 생각한다 했다.

우선 초기 코드는 다음과 같다. (코드 정리를 제대로 하지않아 필요없는 중복된 변수가 있다던지 .. 좀 엉망이다)

def solution(number, k):

    number = list(map(int, number))
    _number = number[:]
    __number = number[:]
    n = len(number) - k
    answer = list()

    while True: # 제일 앞 자리에 둘 숫자를 구하기
        max_number = max(_number)
        max_idx = number.index(max_number)
        if max_idx <= n:
            answer.append(max_idx)
            break
        else: # 만약 큰 숫자가 중복으로 나올 수 있으니, idx가 잘 안나올 수 있음을 방지
            number[max_idx] = -1
            del _number[max_idx]

    number = __number[:]
    _number = number[max_idx:]
    ct = k - max_idx
    while True: # 제일 작은 숫자 구하기
        if ct == 0:
            break
        min_number = min(_number)
        min_idx = _number.index(min_number)
        answer.append(min_number)
        ct -= 1
        _number[min_idx] = 100


    number = number[max_idx:]
    for i in answer[1:]:
        number.remove(i)  
    return ''.join(str(s) for s in number)

일단 실행시간도 걸리는지 확인할 겸 제출을 해보자. 음 당연하듯이 오래걸린다.. 실행시간도 오래 걸린다 ^^ 총체적 난국! 테스트 케이스 1,7,8,10 이 시간 초과로 걸린다.

아 생각해보니 정렬을 안했네. 정렬이 키워드일 것같다. 정렬을 해보고 다시 해보자. ... 라 했지만 잘 안된다.

구글링을 통해 좀더 생각 정리를 해보았다. 스택 이라는 방법이 있었다. 그렇지 ..애초에 리스트를 0번째부터 지나가면서 제거할 숫자를 고르는거니까 스택을 생각하는게 맞겠다 싶었다.

참고한 풀이 링크

하 진짜 다들 천재인가 싶다.. 내가 너무 복잡하게 생각했음 코드가 확 줄여지는 거 보고 자괴감이 들었다

def solution(number, k):
    answer = []
    for num in number: #1,9,2,4
        # 남은 자릿수가 있고, 스택이 비어있지 않으며, 
        # 스택의 마지막에 쌓인 것이 현재 num보다 작을 때
        print(answer, num)

        # answer[-1] < num 일 때 pop 하는 이유는?
        # 최적으로 큰 수를 구해야하는데 지금 나온 숫자가 더 크면 개를 써야지
        while k > 0 and answer and answer[-1] < num:
            answer.pop()
            k -= 1
        # 처음엔 스택이 비어있음 => [1]
        answer.append(num)
    print(answer)
    return ''

돌아가는 순서는 다음과 같다

가장 최적의 수를 계속해서 stack에 적립을 해주고 만약 더 큰게 있으면 걔를 넣어주고 그런식의 반복 while문을 통해서 만약 ct 범위 내에 가장 큰 수가 나오면 모두 pop해서 없애주는 형식임. ㄹㅇ 천재인가 ㅠ 진짜 왜 저렇게 생각을 못했지

def solution(number, k):
    answer = []
    for num in number: #1,9,2,4
        # 남은 자릿수가 있고, 스택이 비어있지 않으며, 
        # 스택의 마지막에 쌓인 것이 현재 num보다 작을 때        
        # answer[-1] < num 일 때 pop 하는 이유는?
        # 최적으로 큰 수를 구해야하는데 지금 나온 숫자가 더 크면 개를 써야지
        while k > 0 and answer and answer[-1] < num:
            answer.pop()
            k -= 1
        # 처음엔 스택이 비어있음 => [1]
        answer.append(num)
    return ''.join(num for num in answer)

근데 이렇게 해주니까 마지막 테스트 케이스에서 걸린다.

이번에도 열심히 구글링.. k를 중심으로 프린트 해보니까 오류나는 테스트케이스에서 k가 남아있었다. 그럼 걔를 제외해보고 프린트 해보았다. 답이 나오는 걸 볼 수 있었다. 그럼 다시 return값을 조정해주자.

드디어 완ㄹ료 ^^.... 나 코테 합격할 수 있을까.. 막막하다

def solution(number, k):
    answer = []
    n = k
    for num in number: #1,9,2,4
        # 남은 자릿수가 있고, 스택이 비어있지 않으며, 
        # 스택의 마지막에 쌓인 것이 현재 num보다 작을 때        
        # answer[-1] < num 일 때 pop 하는 이유는?
        # 최적으로 큰 수를 구해야하는데 지금 나온 숫자가 더 크면 개를 써야지
        while k > 0 and answer and answer[-1] < num:
            answer.pop()
            k -= 1
        # 처음엔 스택이 비어있음 => [1]
        answer.append(num)
    return ''.join(answer[:len(answer)-k])

아스키 코드를 확인해보면 다음과 같았다.

그럼 정렬을 해주고.. 그러면 되지않나? 근데 정렬해주기 전에 원래 위치는 기억을 해야할 것같고.. 그럼 복사를 해줘야할 것같고 ..

대문자 "A"의 아스키코드는 65란다. "Z"는 90

그러면 65 ~ 77는 A에서 이동 90 ~ 78는 Z에서 이동이 좋을 듯

근데 65에서 뺀 리스트들로 만들어줬으니 0 ~ 12까지가 A에서 이동 13 ~ 25까지가 Z에서 이동하면 되려나

그러면 이제 얘네를 중심으로 한번 최소값을 구하면 되지않나? 같은 애들은 set으로 해주면 나중에 위치 찾을 때 힘드려나? 고민.. 위치는 enumerate를 써서 튜플로 저장하는게 더 좋은가?? 그럼 dfs 나 bfs 느낌.. 혹은 최단 경로 느낌 나는데??

일단 위치 제외하고 대략 해봤다. Z에서부터도 해야하니까 min 함수를 활용하는 법이 있었다. 잘 기억하는게 좋을듯

위치가 제일 어려운 듯 최소한으로 어떻게 이동하냐고 ..? 근데 이게 그리디가 맞냐..?????? 물음표만 가득

내가 기억하는 dfs의 기본형태는 이거

def dfs(graph, v, visited):
    visited[v] = True
    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)

음... 사용할 수 있나? graph 형태가 이게 아닌 듯 하다. 일단 위치를 왼쪽갔다가 오른쪽 갔다가 해야하는 기준은 A가 얼마나 많이 있느냐의 차이일 것같은데 JAZ같은 경우는 3글자에서 딱 정가운데에 있으니까 왼쪽 오른쪽만 채우면 되니 처음에서 ~ 끝으로 이렇게 이동하는 건데..

결국 구글링의 힘을 빌려서 코드를 바꿔보았다.

def solution(name):
    answer = 0
    alph = [ min(ord(n) - ord("A"), ord("Z") - ord(n) + 1) for n in name]
    idx = 0 # start = 0

    while True:
        answer += alph[idx]
        alph[idx] = 0
        if sum(alph) == 0:
            break

        left, right = 1, 1

        # 왼쪽으로 가니까 -
        while alph[idx - left] == 0:
            left += 1

        # 오른쪽으로 가니까 +
        while alph[idx + right] == 0:
            right += 1

        # left가 최소면 left를 더하고, right가 최소면 right 더하기
        answer += left if left < right else right

        # 그다음 idx 계산하기
        idx += -left if left < right else right

    return answer

그런데 100점이 안나왔다. 아무래도 테스트케이스가 추가되어서 그런것같은데.. 이게 레벨 2라고..^^? 일단 보류해놓기.. 꼭 수욜전까진 해놓는다

근데 그래도 정렬해서 주지않을까? 하고 정렬안하고 쭉 풀어봤다.

초기 코드

def solution(n, lost, reserve):
    answer = n - len(lost)
    lost.sort(reverse = True)
    for l in lost:
        for r in reserve:
            if l - r < 0:
                answer+=1
                break
            elif l - r == 0:
                answer-=1  
                break
    return answer

응 어림없어~ 테케에서 다 걸려짐. 머리 싸매면서 풀이도 보고 하니까 보이는 점.

문제를 똑바로 읽자.. 전에 내 블로그에서 풀었던 방식을 보니까 set 의 연산을 통해 쉽게 끝낼 수 있었다. 국어 좀 잘하자 제발 ^^

def solution(n, lost, reserve):
    lost.sort() # 정렬
    reserve.sort() # 정렬  
    _reserve = list(set(reserve)-set(lost))
    _lost = list(set(lost)-set(reserve))
    for r in _reserve:
        if r+1 in _lost: # 내 뒷번호니까 빌려줌
            _lost.remove(r+1)
        elif r-1 in _lost:
            _lost.remove(r-1)
    return n - len(_lost)

엥 근데 아직도 100점은 맞지 못하고 있다. 어디 테스트케이스에서 걸리는 듯했다.

reserve를 reverse 했더니 해결

def solution(n, lost, reserve):

    _reserve = list(set(reserve)-set(lost))
    _lost = list(set(lost)-set(reserve))

    _reserve.sort(reverse=True)
    _lost.sort()

    for r in _reserve:
        if r+1 in _lost: # 내 뒷번호니까 빌려줌
            print(r+1, lost) # 확인용
            _lost.remove(r+1)
        elif r-1 in _lost:
            print(r-1, lost) # 확인용
            _lost.remove(r-1)
    return n - len(_lost)

5, [4, 2], [3, 5] 를 생각해보자. 그러면 _reserve = [3,5]

3부터 시작하면 4에서 빌려주고 2에서는 못 빌려줌 그다음 5는 아무도 빌려줄 수 없음 오히려 5부터 시작을 하면 4한테 빌려주고 3은 2한테 빌려줄 수 있음.

아까 첫문제로 포스팅한 문제를 생각해보자.. Filename이 링크 이름으로 바뀌니까 이걸 이용해서 flag를 찾을 수 있지 않을까? 라고 생각해보았다.

근데 코드를 아무리봐도 flag를 볼 수 있는 링크가 어디있는지 알 수가 없었다.. 결국 이번에도 구글링 ㅠㅠ 근데 문제를 잘 보면 걍 나오는거였다. flag.py를 다운받는다 이게 힌트였다. 그러면 flag.py로 갈 수 있게 링크 설정을 해주면 되는거였다.

디렉터리 이동이 필요하다. 그렇기 때문에

../flag.py 

이렇게 해주면 된다. 하지만 코드를 살펴보면

특정한 형식의 파일이름은 올라가지 못하게 막아놓았다. 얘를 통해 상위 폴더에 있는 flag.py가 있구나 눈치

그렇다면 url로 직접 조작하면 되지않나? 그래서 url로 직접 ../flag.py로 입력해주었다.

문제 여러 기능과 입력받은 URL을 확인하는 봇이 구현된 서비스이다. XSS 취약점을 이용해 플래그를 획득. 플래그는 flag.txt, FLAG 변수에 있다.

처음 페이지에 들어가게 되면 다음과 같은 화면을 볼 수 있었다.

vuln(xss) page 먼저 들어가보니 alert(1) 스크립트가 삽입되어 1이라는 내용의 alert을 확인할 수 있다.

memo에 들어가면 hello라는 문자를 볼 수 있다. 나갔다가 다시 들어오면 hello가 복제된다.

flag 페이지를 들어가니 입력폼이 보인다. 여기서 flag를 입력해야 하는 것같기도 하다.

첨부된 app 파일을 분석해본다.

저기의 flag.txt의 내용을 알아야한다. urllib 라이브러리에 쓰이는 함수들은 어떻게 실행되는 걸까 urllib.parse.quote는 글자로 URL 인코딩을 해준다고 한다.

감이 안와서 사람들의 질문을 통해 힌트를 얻어보았다. read_url에 집중해야한다고 한다. 아무래도 add_cookie가 신경쓰인다. 쿠키를 사용해서 flag를 알아내는건가 싶다.

document.cookie를 콘솔로 찍어내도 아무것도 안뜬다

어거지로 이렇게 넣어보았다 alert 창에 flag.txt 읽은 걸 띄울 순 없을까? 이렇게는 아닌가보다 ..

결국 구글링 찬스 .. ㅠㅠ

flag에서 memo페이지로 이동하여 flag 값이 있는 쿠키값을 출력하도록 해야하는 것이었다.

flag 페이지에서

<script>location.href="/memo?memo="+document.cookie;</script>

를 입력후 memo 페이지로 가면

이렇게 flag 값이 나오는 것을 확인할 수 있다.

넘 어렵다 8-8 이게 왜 레벨 1..?

보통 2년정도 보관 (default)

37. DBA

root와 비슷하다고 생각하면 된다.

38. LFI

Local File Inclusion

Local에 있는 파일을 읽는 공격 서버에 FTP나 자료실로 악성 코드를 업로드시켜 include 시킴.

39. RFI

Remote File Inclusion

Remote에 있는 파일을 읽는 공격 외부 서버의 악성 코드를 불러와 include 시킴.

40. 인증 VS 인가

인증 : 신분 확인 인가 : 권한 확인

41. 프록시 서버

클라이언트가 자신을 통해서 다른 네트워크 서비스에 간접적으로 접속할 수 있게 해 주는 컴퓨터 시스템이나 응용 프로그램

42. URL VS URI

URI= 식별자, URL=식별자+위치 출처 : https://www.elancer.co.kr/blog/view?seq=74

43. 윈도우 운영체제 프로세스

c:\windows\system32 폴더에 위치함

1. wininit.exe : 윈도우 시작 프로그램
2. services.exe : 윈도우 서비스 관리
3. lsm.exe : 시스템 관리,주요 함수 실행, 컴퓨터와 서버 연결 관리
4. lsass.exe : 로그인 검사, 비밀번호 변경관리 등
5. svchost.exe : 서비스 관리를 위한 프로세스
6. conhost.exe : 키보드, 마우스 입력허용 등

44. 이상적인 비밀번호

1. 영문 대소문자 구성된 문자열
2. 숫자
3. 특수문자

-> 1~3번 각각 한두개 이상 조합

공격자가 초기 침투에 성공한 장치와의 통신을 유지할 때 사용하는 도구 및 기술들

29. 오라클 감사로그 활성화

AUDIT_TRAIL 값을 'DB' 또는 'TRUE'로 지정한다

30. 오라클 데이터베이스 감사로그의 종류

1. 문장 감사 (statement auditing)
2. 권한 감사 (prvilege auditing)
3. 객체 감사 (object auditing)

31. lls

인터넷 정보 서비스 (Internet Information Services) 마이크로소프트 윈도우를 사용하는 서버들을 위한 인터넷 기반 서비스들의 모임

32. 네트워크 장비의 로그 관리

1. 네트워크 보안 로그 : 방화벽(침입차단시스템), IDS(침입탐지시스템), IPS(침입방지시스템)등이 로그를 생성 | SIEM(Security information and event management)
2. 네트워크 관리시스템 로그 : MRTG(트래픽 모니터링), NMS(네트워크 관리 시스템)
3. 네트워크 인증시스템 로그

33. 파일 접근 권한 >>> 디렉토리 접근 권한

34. 허용 권한 없음 != 거부 (윈도우)

거부 >>>> 허용

35. 질의문 종류

1. DDL (Data Definition Language) : CREATE, DROP, ALTER
2. DML (Data Manipulation Language) : SELECT, INSERT, UPDATE, DELETE
3. DCL (Data Control Language) : GRANT, DENY, REVOKE

시스템의 처리 내용이나 이용 상황을 시간의 흐름에 따라 기록한 것 (+) 대량으로 생성 되기 때문에 취약점 관리 시에 중요함

20. 로깅

로그를 생성하도록 시스템을 작성하는 활동

21. AAA

★ 로그 관리를 위해 알아야하는 개념

(1) Authentication (인증)

자신의 신원을 증명한다.

(2) Authorization (인가)

패스워드 등을 통해 로그인의 허락된 사용자로 판별됨.

(3) Accounting (책임 추적성)

로그인 이후 활동에 대한 기록을 남긴다.

22. SendMail

유닉스에서 메일을 처리하는 데몬 프로그램

23. 데몬

오랫동안 실행중인 백그라운드(background) 프로세스 => 서비스의 요청에 대해 응답을 위함

24. 텔넷(Telnet)

*사용자의 컴퓨터에서 네트워크를 이용하여 원격지에 떨어져 있는 서버에 접속을 통해 자료를 교환할 수 있는 프로토콜. *

텔넷 = 통신(tel) + 네트워크(net) 인터넷에서 사용되는 주요 네트워크 프로토콜 중 하나이다.

25. 윈도우 로그 종류

1. 개체 엑세스
2. 계정 관리
3. 계정 로그인 이벤트
4. 권한 사용
5. 로그인 이벤트
6. 디렉토리 서비스 액세스
7. 정책 변경
8. 프로세스 추적
9. 시스템 이벤트

26. 윈도우 로그 vs 유닉스 로그

윈도우 로그 : 중앙 집중화되어 관리된다 유닉스 로그 : 중앙 집중화 X. 로그 저장되는 위치도 각각 다르다.

27. 유닉스 로그 종류

1. UTMP : 현재 시스템에 로그인한 사용자의 상태 출력 (w, who, finger 명령어 사용)
2. WTMP : 사용자의 로그인/로그아웃, 시스템 재부팅 정보 출력 (last 명령어 사용)
3. secure : 원격 접속 내역, su 명령어 수행 내역
4. history
5. syslog

네트워크 컴퓨터 시스템에 의해 전송된 저장 위치로부터 또는 데이터로부터 패스워드를 복구

12. 로그인 계정을 목록화 명령어

(1) who (2) finger (3) w (ls-a는 아님!)

13. nmap

• port Scanning 툴이다.
• 네트워크 스캐너다.
• 취약점 스캔에서 쓰인다.
• 열려있는 포트를 확인한다.
• 컴퓨터와 서비스를 찾을 때 쓰인다.

14. 윈도우 패스워드 관련 용어

(1) LM(LAM Manager) (2) SAM (Security Accounts Manager) (3) NTLM (NT LAN Manager)

15. 접근통제

(1) MAC(Mandatory Access Control)

• 강제적 통제
• 해당 장소의 보안 등급은 잘 바뀌지 않는다.
• 주체는 인가 등급을 부여한다.
• 주로 군사용/정부에서 사용

(2) DAC(Discrentionary Access Control)

• 객체중심 통제
• 다양하게 세팅할 수 있다
• 파일이나 문서 등에 의해서 각각 퍼미션(CREATE, DELETE 등)을 준다.
• 주체에게도 권한을 줄 수 있다.
• OS에서 활용

(3) RBAC (Role Based Access Control)

• 역할단위 통제
• 조직 내 맡은 '역할'에 기초
• 팀에 권한을 주고 내가 그곳에 소속이 되면 자동으로 해당 권한을 상속받게 되는 것
• 기업이나 조직에서 활용

16. 계층적 방어

호스트 보안 E 네트워크 보안 E 물리적 통제 E 기업의 관리적 통제

17. 버퍼오버플로우 방지 함수

1. strncpy()
2. strncat()
3. fgets()
4. fscanf()
5. vfscnaf()
6. snprintf()
7. vsnprintf()

18. umask

• 모든 권한 소유 : rwx
• 하나식 빠질경우 : -로 표시
• 파일 생성시 마다 구너한 부여하는 번거로움을 해결하기 위해 Default 권한값을 가짐
• 보안상 가장 안전한 umask 설정 값 : umask 077

http : 80 https : 443 ssh : 22

2. OSI 7 계층

L7 응용 계층 L6 표현 계층 L5 세션 계층 L4 전송 계층 L3 네트워크 계층 L2 데이터 링크 계층 L1 물리 계층

3. 리눅스 라이브러리 관련 명령어

ldd 명령어 라이브러리 의존성 확인

4. AAA

인증(Authentication) 권한부여(Authorization) 계정관리(Accounting)

5. SAM

보안 계정 관리자(SAM: Security Account Manager)

6. 물리 페이지 프레임

*4KB == 4096 == 0X1000 == 12bit == 2^12 *

7. dos와 DDOS의 차이점

1. 공격자의 수
2. victim의 수

8. 랜섬웨어 방어

• 스팸 메일 차단
• 보안 업데이트
• 주기적인 백업

  (주의) 패스워드 변경으로는 방어하기 어렵다

9. 전자서명

(1) 은행 금융거래 (2) 문서나 파일 위조여부 확인 (3) 주민등록등본 발급

10. MFA의 인증수단

다중 인증 (MFA: Multi-Factor Authentication)

(1) otp 토큰 (2) 지문 (3) 인증서