코드리뷰는 지적 하기 위함이 아닌 “코드 품질을 개선”하기 위한 행위이다!!

코드리뷰 방법

• 원칙에 기반하여 피드백하도록 노력하기
• 개선점이 보이면 이유와 방향 제시하기
• 좋은 아이디어는 꼭 칭찬해주기!
• 필수 반영사항이 아닌 코멘트일 경우 Nit (사소한것) 로 표기
• 한꺼번에 많은 코멘트로 공격x
  • 하이레벨(기본 기능 동작 여부, 전체 코드의 설계방식 개선의견, 복잡한 함수의 분리) → 로우레벨(UI, 변수명 변경, 주석필요여부, 컨벤션 등등)
  • 하이레벨 코멘트 먼저 등록 후 로우래벨 코멘트 등록하는 순으로 진행
  • 핵심 부분의 설계가 잘못되었다면, 나버지 코드를 보기 전에 즉시 공유!

승인 시점

• 사소한 이슈만 남았다면 승인하기 (master가 아닌 브랜치일 경우)
  • 변수명 변경, 오타
  • 선택적 제안 코멘트
• hofix 라벨이 붙었을경우에는 바로 승인하되, 테스트 및 코드 확인은 꼭하기!
  • 기존 코드에 영향을 주는 코드는 어떤 경우에도 허용되면 안된다고 생각

리뷰하기 좋은 pr 디스크립션 작성하기

• 작업 상세 내용과, 코어 파일 경로 명시
• 필요하다면 코멘트로 대체해도 좋음

코드리뷰 속도

• 가능한 리뷰 요청을 받자마자 한다.
• 업무일 기준 하루를 넘지 않는다.
• 시간이 오래 걸릴 경우 작성자에게 공유한다
• 추후 반영할 사항은 위키 추후 개선할 작업 리스트에 작성해두기

용어정리

• CL : changelist
• LGTM : Looks Good To Me
• Nit: nitpick,  사소한것

참고

• https://soojin.ro/review/pushback
• https://www.slideshare.net/slideshow/2018-01code-review-95601233/95601233

• MVC 패턴을 대체하기 위해서 페이스북이 사용한 Flux 패턴을 살짝 바꾼 것

• 한방향으로 흐르기 때문에 데이터의 흐름을 예측하기 쉬움 → 관리가 편함
• 데이터가 불변하여 예측하기 쉽고, 이전 상태로 되돌리기 쉬움

로그인 예시

• 로그인 버튼 클릭
• View : 로그인 form이 있는 화면
• Action : 폼에 로그인 Action 연결
  • Dispatcher을 통해서 데이터가 Action에서 Store로 넘어감
• Store
  • Middleware : Reducer에 가기 전 Action을 조작하고 처리된 데이터를 View로 넘겨줌
  • Reducer : 데이터를 처리

Login page ui 만들기

<div
      style={{
        display: "flex",
        justifyContent: "center",
        alignItems: "center",
        width: "100%",
        height: "100vh",
      }}
    >
      <form
        style={{
          display: "flex",
          flexDirection: "column",
        }}
        **onSubmit**={onSubmitHandler}
      >
        <label>Email</label>
        <input type="email" value={Email} **onChange**={**onEmailHandler**} />
        <label>Password</label>
        <input type="password" value={Password} onChange={**onPasswordHandler**} />

        <br />
        <button>Login</button>
      </form>
    </div>

• 이메일과 페스워드 인풋을 폼 태그로 감싸주기

이메일 패스워드 변경하면 state값 세팅

function LoginPage() {

  const [Email, setEmail] = useState("");
  const [Password, setPassword] = useState("");

  const onEmailHandler = (event) => {
    setEmail(event.currentTarget.value);
  };

  const onPasswordHandler = (event) => {
    setPassword(event.currentTarget.value);
  };

  const onSubmitHandler = (event) => {
    event.preventDefault();

  };

• 사용자가 이메일, 패스워드 변경하면 onEmailHandelr onPasswordHandler 가 실행되어서 이메일과 패스워드 변경된 값으로 세팅
• event.preventDefault() : 이벤트의 기본동작을 막아줌 (페이지 리프레시)

서버에 보낼 값 세팅

let body = {
      email: Email,
      password: Password,
    };

리덕스 패턴을 사용하는 컴포넌트 만들기

npm install redux react-redux

LoginPage.js

function LoginPage() {
  const dispatch = useDispatch();
  const navigate = useNavigate();

  const onSubmitHandler = (event) => {
    event.preventDefault();

    let body = {
      email: Email,
      password: Password,
    };

    dispatch(loginUser(body)).then((response) => {
      if (response.payload.loginSuccess) {
        // props.history.push("/");
        navigate("/");
      } else {
        alert(response.payload.message);
      }
    });
  };

login Action 만들기

user_action.js

import axios from "axios";
import { LOGIN_USER } from "./types";
export function loginUser(dataToSubmit) {
  const request = axios
    // 백엔드 서버 url에 dataToSubmit 데이터 보내주기
    .post("/api/users/login", dataToSubmit)
    .then((response) => response.data);

  return {
    // redux로 옮겨주기
    type: LOGIN_USER,
    payload: request,
  };
}

• then 메소드의 역할
  • then() 메서드는 Promise 를 리턴하고 두 개의 콜백 함수를 인수로 받음

login Action 순서

• LoginPage로부터 데이터(email, password)를 받아옴(dataToSubmit)
• axios를 사용하여서 백엔드 서버 url(/api/users/login)에 데이터(dataToSubmit)보내주기
  • 백엔드에서 로그인 과정 거쳐서 response를 받는 과정

server/models/User.js

        userSchema.methods.comparePassword = function (plainPassword, cb) {
          //plainPassword 1234567    암호회된 비밀번호 $2b$10$l492vQ0M4s9YUBfwYkkaZOgWHExahjWC
          bcrypt.compare(plainPassword, this.password, function (err, isMatch) {
            // 사용자가 입력한 비번(plainPassword)와 db에 저장된 비번과 비교
            // 틀리고, 에러가 나면 콜백함수에 err를 반환하고,
            // 같다면 콜백함수에 null값과 true값이 있는 isMatch를 반환
            if (err) return cb(err);
            cb(null, isMatch);
          });
        };

        userSchema.methods.generateToken = function (cb) {
          var user = this;
          // console.log('user._id', user._id)

          // jsonwebtoken을 이용해서 token을 생성하기
          var token = jwt.sign(user._id.toHexString(), "secretToken");
          // user._id + 'secretToken' = token
          // ->
          // 'secretToken' -> user._id

          user.token = token;
          user.save(function (err, user) {
            if (err) return cb(err);
            cb(null, user);
          });
        };

server/index.js

        app.post("/api/users/login", (req, res) => {
          // 요청된 이메일틀 데이터베이스에서 있는지 찾아보기
          // findOne() : 요소를 찾는 몽고DB 메소드
          User.findOne({ email: req.body.email }, (err, user) => {
            // 이메일에 해당하는 유저가 없으면
            if (!user) {
              return res.json({
                loginSuccess: false,
                message: "제공된 이메일에 해당하는 유저가 없습니다.",
              });
            }
            // 요청된 이메일이 데이터베이스에 있다면 비밀번호가 맞는 비밀번호인지 확인
            user.comparePassword(req.body.password, (err, isMatch) => {
              // isMatch가 없으면 비번이 틀림
              if (!isMatch)
                return res.json({
                  loginSuccess: false,
                  message: "비밀번호가 틀렸습니다.",
                });
              // 비밀번호까지 맞다면 토큰 생성
              user.generateToken((err, user) => {
                // status(400)->에러
                if (err) return res.status(400).send(err);

                // 토큰을 저장(쿠키, 로컬스토리지)
                // status(200)->성공
                res
                  .cookie("x_auth", user.token)
                  .status(200)
                  .json({ loginSuccess: true, userId: user._id });
              });
            });
          });
        });

• 이메일에 해당하는 유저가 없으면 loginSuccess가 false인 res(.json)를 리턴

• 비밀번호가 틀리면 loginSuccess가 false인 res(.json)를 리턴

• 비밀번호가 맞으면 토큰을 생성하고, loginSuccess가 true이고, userID가 있는

    res(.json)를 리턴

• 백엔드에서 받은 response.data를 request에 저장

• types 파일에서 받은 type과 백엔드 서버에서 받은 request를 payload로 리턴

• _actions/types.js

        export const LOGIN_USER = "login_user";

• 폼을 submit하면 dispatch 메소드(Dispatcher) 실행
  • LoginPage 컴포넌트의 onSubmitHandler 안에 있는 dispatch가 실행되는것!
  • dispatch(loginUser(body))
    • Dispatcher을 통해서 데이터가 login Action에서 Store로 넘어감

login reducer 만들기

_reducers/user_reducer.js

import { LOGIN_USER } from "../_actions/types";

export default function f(state = {}, action) {
  switch (action.type) {
    case LOGIN_USER:
      return { ...state, loginSuccess: action.payload };

    default:
      return state;
  }
}

• Reducer은 Action별로 state를 어떻게 바꿀지 결정함!
• (중요) 반드시 새로운 객체를 반환 해야됨!!!
• {…state} ⇒ 기존 state(비어있음)를 복사하는것 ⇒ 새로운 객체를 만들어야 현재, 이전 상태가 구분되기에 이전 상태로 쉽게 되돌릴 수 있음
• state만 바꾸면 알아서 View도 바뀜
• LOGIN_USER Action이 발생하면 loginSuccess에는 서버로부터 받은 유저 정보(action.payload)를 넣어줌

_reducers/index.js

import { combineReducers } from "redux";
import user from "./user_reducer";

// reducer가 나눠져 있는데 combineReducer을 이용하여
// root reducer에서 하나로 합침

const rootReducer = combineReducers({
  user,
});

export default rootReducer;

• Reducer는 여러 개를 사용할 수 있기 때문에 redux 패키지로부터 combineReducers 함수를 불러워서 합쳐주기
• 위에서 만든 reducer을 user로 가져오기

Store

다시 View

dispatch(loginUser(body)).then((response) => {
      if (response.payload.loginSuccess) {
        // props.history.push("/");
        navigate("/");
      } else {
        alert(response.payload.message);
      }
    });

• dispatch가 끝났으면 받아온 response값을 활용하여서 로그인에 성공하면 홈페이지(/)로 이동
• 로그인에 성공하지 못하면 json의 에러 메세지를 alert 해주기

props.history.push("/");

react-router-dom v6부터 useHistory 에서 useNavigate로 바뀜

1. useNavigate import

import { useNavigate } from "react-router-dom";

1. navigete로 이동

const navigate = useNavigate();

dispatch(loginUser(body)).then((response) => {
      if (response.payload.loginSuccess) {
        // props.history.push("/");
        navigate("/");
      } else {
        alert(response.payload.message);
      }
    });

참고

https://www.zerocho.com/category/React/post/57b60e7fcfbef617003bf456

• 탐색 : 많은 양의 데이터 중 원하는 데이터를 찾는 과정

스택 자료구조

• LIFO

• 시간복잡도 : O(1)
• list로 -> append(), pop()으로 스택 구현 가능

큐 자료구조

• FIFO
  • deque()로 큐 구현 => append(), popleft() 사용 => 가장 왼쪽에 있는 것 꺼내기
  • deque를 사용하는 것이 시간복잡도가 더 효율적임!!

재귀함수

• 자기 자신을 다시 호출하는 함수
• 종료조건 반드시 명시하기 => if i==100: return

최대공약수 계산(유클리드 호제법)

• A를 B로 나눈 나머지를 R A와 B의 최대공약수는 B와 R의 최대공약수이다

def gcd(a, b):
    if a%b == 0:
        return b
    else:
        return gcd(b, a%b)

def lcm(a, b):
    return (a*b) // gcd(a,b)

print(gcd(192, 162))
print(lcm(192, 162))

• 컴퓨터가 함수 연속적으로 호출 => 컴퓨터 메모리 내부의 스택 프레임에 쌓임 => 스택 라이브러리 대신 재귀함수 사용하는 경우 많음

DFS

• 깊이 우선탐색
• 스택자료구조(재귀함수) 이용

1. 탐색 시작 노드를 스택에 삽입하고 방문처리
2. 스택의 최상단 노드에 방문하지 않은 인접한 노드가 있으면 그 노드를 스택에 넣고 방문 처리. 방문하지 않은 인접 노드가 없으면 스택에서 최상단 노드를 꺼냄
3. 2번 수행할 수 없을 때까지 반복

출처

# DFS 메서드
def dfs(graph, v, visited):
#     현재 노드 방문 처리
    visited[v] = True
    print(v, end=' ')

#     현재 노드와 연결된 다른 노드를 재귀적으로 방문
# 2 3 8
    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)

graph = [
    [],
    [2,3,8],
    [1,7],
    [1,4,5],
    [3,5],
    [3,4],
    [7],
    [2, 6, 8],
    [1, 7],
]
# 0 1 0 0 0 0 0 0
visited = [False] * 9

dfs(graph, 1, visited)

BFS

• 너비 우선탐색
• 가까운 노드부터 우선적으로 탐색
• 큐 자료구조 이용

1. 탐색 시작 노드를 큐에 삽입하고 방문처리
2. 큐에서 노드를 꺼낸 후 해당 노드의 인접 노드 중에서 방문 하지 않은 노드를 모두 큐에 삽입하고 방문
3. 2 수행못할때까지 반복

출처

from collections import deque

# DFS 메서드
def bfs(graph, start, visited):

    queue = deque([start])

    # 현재 노드 방문처리
    visited[start] = True

#     큐가 빌때까지 반복
    while queue:
#         큐에서 하나의 원소를 뽑아 출력하기
#       1 => 2 3 8
        v = queue.popleft()
        print(v, end=' ')
#         아직 방문하지 않은 인접한 원소들을 큐에 삽입
        for i in graph[v]:
            if not visited[i]:
                queue.append(i)
                visited[i] = True


graph = [
    [],
    [2,3,8],
    [1,7],
    [1,4,5],
    [3,5],
    [3,4],
    [7],
    [2, 6, 8],
    [1, 7],
]
# 0 1 0 0 0 0 0 0
visited = [False] * 9

bfs(graph, 1, visited)

이때, 새로 입력 받는 c가 a보다 클 수도 있고 같을 수도 있고 작을 수도 있다.

문제설명

선분 세 개로 삼각형을 만들기 위해서는 다음과 같은 조건을 만족해야 합니다.

가장 긴 변의 길이는 다른 두 변의 길이의 합보다 작아야 합니다. 삼각형의 두 변의 길이가 담긴 배열 sides이 매개변수로 주어집니다. 나머지 한 변이 될 수 있는 정수의 개수를 return하도록 solution 함수를 완성해주세요.

제한사항

• sides의 원소는 자연수입니다.
• sides의 길이는 2입니다.
• 1 ≤ sides의 원소 ≤ 1,000

입출력 예

정답 및 풀이

i) c가 a보다 크면 대소관계는 c > a > b가 된다.

a + b > c 이므로 a + b > c > a가 된다.

즉 이때 가능한 c의 갯수는 b - 1개

ii) c가 a보다 작으면 대소관계는 a > b, a > c 가 된다.

b + c > a 이므로 b + c > a > c가 된다.

즉 이때 가능한 c의 갯수는 b - 1개

iii) c와 a가 같으면 c = a 한 가지 밖에 존재하지 않는다.

그러므로 다 합하면 (b - 1) + (b - 1) + 1 = 2 * b - 1 개가 된다.

이때 초기 조건에 따라 b는 a보다 작음

def solution(sides):
    return 2 * min(sides) - 1

출처

문자열 my_string이 매개변수로 주어집니다. my_string은 소문자, 대문자, 자연수로만 구성되어있습니다. my_string안의 자연수들의 합을 return하도록 solution 함수를 완성해주세요.

제안사항

1 ≤ my_string의 길이 ≤ 1,000 1 ≤ my_string 안의 자연수 ≤ 1000 연속된 수는 하나의 숫자로 간주합니다. 000123과 같이 0이 선행하는 경우는 없습니다. 문자열에 자연수가 없는 경우 0을 return 해주세요.

입출력 예

풀이

1. isdigit()함수 활용하여 join하기

def solution(my_string):
    s = ''.join(s if s.isdigit() else ' ' for s in my_string )
    return sum(int(n) for n in s.split())

• isdigit() => 숫자이면 1을 리턴 숫자가 아니면 0을 리턴
• my_string 값 중 숫자가 아니면 공백형태로 나눠서 문자열 s에 저장
• .split() => 엔터 혹은 띄어쓰기로 구분하여 리스트로 저장
• s값을 띄어쓰기로 구분하여 리스트에 저장한 후, 각 값을 int로 변경하고 더한 값을 리턴

2. isalpha()와 replac() 활용하기

def solution(my_string):
    for s in my_string:
        if(s.isalpha()):
#             알파벳이 있는 곳은 공백으로 구분시켜주기
            my_string = my_string.replace(s,' ')
    return sum (int(i) for i in my_string.split())

• isalpha() => 알파벳이면 1리턴, 아니면 0리턴

• 문자열.replace(s, 구분자) => 문자열안의 s를 구분자로 구분하여 리턴

• 알파벳이 있는 곳은 공백으로 구분하여 my_string에 저장

• my_string을 공백으로 구분하여 리스트에 저장하고, 값을 int로 계산하고 더한값을 리턴

외과의사 머쓱이는 응급실에 온 환자의 응급도를 기준으로 진료 순서를 정하려고 합니다. 정수 배열 emergency가 매개변수로 주어질 때 응급도가 높은 순서대로 진료 순서를 정한 배열을 return하도록 solution 함수를 완성해주세요.

제한사항

• 중복된 원소는 없습니다.
• 1 ≤ emergency의 길이 ≤ 10
• 1 ≤ emergency의 원소 ≤ 100

입출력 예

풀이 1

내림차순 정렬한 배열을 만들고, 원래 배열과 비교하여 인덱스 값 찾고, answer에 넣어주기

def solution(emergency):
    answer = []
    e = sorted(emergency, reverse=True)

    for i in emergency:
        answer.append(e.index(i)+1)
    return answer

list comprehension 사용

def solution(emergency):
    e = sorted(emergency, reverse=True)
    return [(e.index(i)+1) for i in emergency]

풀이2

딕셔너리, enumerate 함수 사용

def solution(emergency):
    answer = []
#     emergency 내림차순하기
#     i=> 키값(인덱스)
#     e => 수 정렬된 배열
#     enumerate => key와 value 값 반환
    emer_ls = {e: i + 1 for i, e in enumerate(sorted(emergency, reverse=True))}

        # 원래 수가 들어있는 emergency 값 e를 순서가 담겨있는 딕셔너리 emer_ls의
    # 배열 값과 비교해서 인덱스(위치)값을 추출 해냄 
    for e in emergency:
        answer.append(emer_ls[e])
    return answer

import numpy as np
def solution(numbers):
    return np.mean(numbers)

참고

del 함수

del 함수 - 리스트의 특정 요소 혹은 리스트 특정 범위를 삭제

최댓값 만들기

문제설명 : numbers의 원소 중 두 개를 곱해 만들 수 있는 최댓값을 return하도록 solution 함수를 완성해주세요.

def solution(numbers):
    m1 =max(numbers)
    index=0
    for i in numbers:
        if i == m1:
            del(numbers[index])
        index += 1
    m2 = max(numbers)
    answer = m1*m2
    return answer

 # 내림차순 정렬 후 첫번째, 두번째 값을 곱해주기
 def solution(numbers):
    numbers.sort(reverse=True)
    return numbers[0]*numbers[1]

list 총정리!

• 리스트 더하기, 곱하기 연산 가능 L = [1,2,3] * 3

• 인덱스, 슬라이싱 사용가능 L[3] L[2:5]

• List Comprehensions 방식으로 리스트를 만들 수 있음 L = [i*i for i in range(10)] L = [i for i in L if i%3 == 0]

• in, not in 사용가능 5 in L

추가 및 복사

.append(a) : 맨 뒤에 a 추가 .extend(a) : a 리스트합치기 .insert(n,a) : n번째에 a 추가 .copy() : 리스트 복사 => 리턴받아서 사용

제거 함수

.remove(n) : n 하나 제거 .pop() : 마지막 제거 => 인자값이 있으면 특정 인덱스 값 삭제 .clear() : 리스트값 모두 삭제(빈 리스트) del(L[2]) : 특정 인덱스 내용 삭제 del(L) : 리스트 자체 삭제

개수, 길이, 인덱스

.count(a) : a 값의 개수 확인 len(a) : a 리스트의 길이 확인 .index() : 해당 값의 인덱스값 찾기

순서

=> 매개변수는 iterable한 변수면 OK! a.reverse() : 리스트 a에 들어있는 값 역순으로 바꿔줌 (리턴x) reversed() : 기존 리스트의 역순을 갖는 배열 생성 => list(reversed(기존리스트)) => 리턴

최대 최소

max() : 최대값 출력 min() : 최소값 출력 list(range(2,101,2)) : 짝수만 갖는 데이터 만들기 list(range(10,0,-1) : 10부터 1까지 역순의 데이터 만들기

중복제거 하는 방법

set(리스트)을 이용

list(set(리스트))

• 순서 바뀜
• 집합 타입으로 변경

for문 이용

• for문 돌리고, in 연산자 써서 중복제거

dictionary를 이용하여 중복제거

• 딕셔너리는 key 값이 중복 불가!
• dict.fromkeys(iterable) => 인자로 들어온 iterable 데이터를 key 값으로 해서 딕셔너리 자료형을 만들어줌

# 중복된 문자 제거한 문자열 리턴하는 문제
def solution(my_string):
    return ''.join(dict.fromkeys(my_string))

lambda를 활용한 map, filter

map(람다식, 리스트나 튜플) => 반환 값은 map객체여서 list 혹은 tuple로 형 변환해야됨 filter(함수, 리스트나 튜플) => filter는 json을 반환

 def solution(array:list, height:int)->int:
    answer = len(list(filter(lambda x:x>height,array)))
    return answer

for in 딕셔너리

• 키와 값 모두 출력하고 싶을때는 이렇게 써보자!

  for 키, 값 in 딕셔너리.items():
    반복할 코드

  예시 => 옷가게 할인 받기

def solution(price): discount_rates = {500000: 0.8, 300000: 0.9, 100000: 0.95, 0: 1} for discount_price, discount_rate in discount_rates.items(): if price >= discount_price: return int(price * discount_rate)

List Comprehension 문법 정리

• 기본 구조 : 표현식 + for문 result = [표현식 for 변수 in 리스트]

• 표현식 + for문 + 조건문 result = [표현식 for 변수 in 리스트 조건문]

• 조건문 + for문 result = [조건문 for 변수 in 리스트]

• 중첩 for문 result = [조건문 for 변수1 in 리스트1 for 변수2 in 리스트2 ...]

• 중첩 List Comprehension

정렬

1. .sort() : 오름차순 정렬

• .sort(reverse = True) : 내림차순 정렬

2. sorted() : 오름차순 출력 => 기존 리스트 데이터 변경x => 괄호 안에는 iterable 자료형 입력(문자열, 리스트 등)

• sorted(정렬할 데이터)

• sorted(정렬할 데이터, reverse 파라미터)

• sorted(정렬할 데이터, key 파라미터)

• sorted(정렬할 데이터, key 파라미터, reverse 파라미터)

3. parameter

   reverse

sorted([리스트], reverse=True)

key

• 정렬을 목적으로 하는 함수를 값으로 넣기
• lambda 이용가능

예시문제 길이가 짧은것부터, 길이가 같으면 알파벳 순으로 정렬

data_list = ['but','i','wont','hesitate','no','more','no','more','it','cannot','wait','im','yours']

#중복 제거
data_list = list(set(data_list))

data_list.sort()
print(data_list)

# 길이를 기준으로 정렬
# 콜론 뒤에 있는 것을 기준으로 앞의 리스트를 정렬
data_list.sort(key=lambda x : len(x))

print(data_list)

• 두가지 이상 요소 순서대로 정렬할때는 key = lambda x: (기준1, 기준2 , ...) 방식로 사용

enumerate 함수

• enumerate => 순서와 리스트의 값을 전달하는 기능을 가집니다.
• 예제

dict1 = {'이름': '한사람', '나이': 33}
data = enumerate(dict1)
for i, key in data:
    print(i, ":", key, dict1[key]

# 출력결과
# 0 : 이름 한사람
# 1 : 나이 33

zip 함수

파이썬 zip( ) 함수 : 길이가 같은 리스트 등의 요소를 묶어주는 함수

문자열 함수

슬라이싱 함수 ::

• 문자열[시작인덱스 : 종료인덱스 : 증가할 수]

• 슬라이싱은 초과해도 에러가 나지 않는다!

문자열 뒤집기

문자열을 하나씩, 반대로 잘라서 다시 입력시킨후 출력 'aaa'[::-1]

모음제거

• 문제설명 영어에선 a, e, i, o, u 다섯 가지 알파벳을 모음으로 분류합니다. 문자열 my_string이 매개변수로 주어질 때 모음을 제거한 문자열을 return하도록 solution 함수를 완성해주세요.

문자치환함수 => replace

String.replace(찾는 문자, 바꿀문자, 바꿀 문자 개수)

def solution(my_string):
    answer = ''
    remove_string = ('a,e,i,o,u')
    for i in remove_string:
        my_string = my_string.replace(i,'')

    return my_string

join 함수

'구분자'.join(리스트) 리스트에 있는 요소 하나하나를 합쳐서 하나의 문자열로 바꾸어 반환하는 함수 ' 'join(값) : 값을 공백으로 구분하여 string으로 반환

# join 함수 사용하기
def solution(my_string):
    return "".join([i for i in my_string if not(i in "aeiou")])

count()

문자열.count(a) => 문자열에 a가 들어있는지 세는 함수

isdigit()

• 문자열이 숫자로 이루어졌는지 판별하는 함수 문자열.isdigit() => true, false 반환
• 알파벳과 숫자가 섞여있는 문자열에서 숫자를 찾아서 더해주는 코드

  def solution(my_string):
    return sum(int(i) for i in my_string if i.isdigit())

  짱 쉽쥬?

Python Array[::] 사용법

arr[::], arr[1:2:3], arr[::-1] 등으로 배열의 index에 접근하는 방법을 Extended Slices라고 함

• arr[A:B:C]의 의미는, index A 부터 index B 까지 C의 간격으로 배열을 만들라는 뜻

• 만약 A가 None 이라면, 처음부터 라는 뜻이고 B가 None 이라면, 할 수 있는 데까지 (C가 양수라면 마지막 index까지, C가 음수라면 첫 index까지가 되겠습니다.)라는 뜻입니다. 마지막으로 C가 None 이라면 한 칸 간격

대문자, 소문자

1. 문자열 대문자로 변경하는 함수 (string.upper())

2. 문자열 소문자로 변경하는 함수 (string.lower())

3. 문자가 대문자인지 확인하는 함수 (string.isupper()) => true, false 반환

4. 문자가 소문자인지 확인하는 함수 (string.islower()) => true, false 반환

swapcas()

string.swapcase() : 대소문자 상호 전환.

아스키코드, 문자열

• ord() => 문자열에서 아스키코드로 변환
• chr() => 아스키코드에서 문자열로 변환

  ord('a`) # 94
  chr(64) # a

find 함수

string.find(찾을 문자, 시작 Index, 끝 Index)

찾는 문자가 존재 한다면 해당 위치의 index를 반환해주고 찾는 문자가 존재 하지 않는다면 -1 을 반환

split함수

string.split(구분자)

• split함수는 list를 리턴한다.

int 함수

• int() => 매개변수값을 정수로 변환
• int(x, radix)는 radix 진수로 표현된 문자열 x를 10진수로 변환하여 리턴한다. 예를 들어 2진수로 표현된 "11"의 10진수 값은 다음과 같이 구할수 있다.

int('11', 2) # => 2진수 11을 10진수로 변환해라
# 결과3

16진수로 표현된 "1A"의 10진수 값은 다음과 같이 구할수 있다.

int('1A', 16)
# 결과 : 26

bin 함수

bin(number)

• 전달받은 integer 혹은 long integer 자료형의 값을 이진수(binary) 문자열로 돌려준다.
• 앞에 '0b'가 붙음 => 접두어 빼고 싶으면 format 함수 사용하기 👇

format 함수

(2진수, 8진수, 16진수) => 접두어 빼고 나옴 b = format(value, 'b') o = format(value, 'o') h = format(value, 'x')

eval 함수

• 매개변수로 받은 expression (=식)을 문자열로 받아서, 실행하는 함수

startswith & endswith

파이썬에서 문자열로 이루어진 리스트, 혹은 딕셔너리에서 특정 문자가 포함된 항목을 찾을 때 활용

str = 'final exam'

# startswith(특정 문자)
result = str.startswith('final')

str = 'final exam'

# endswith(특정 문자)
result = str.endswith('final')

deque

List 보다 deque의 속도가 훨씬 빠름

• import 해야됨

  from collections import deque
  a = deque()

deque 함수

• q.rotate() => 음수는 왼쪽 회전, 양수는 오른쪽 회전

math 함수

import math

math.pow(x, y)

x의 y제곱

math.sqrt(x)

x의 제곱근

math.prod(iterable, *, start=1)

입력 이터러블(iterable)에 있는 모든 요소의 곱을 계산. 곱의 기본 start 값은 1.

math.factorial()

• math.facorial(x) x의 팩토리얼 값을 return => x는 양의 정수!

gcd(a,b)

• a와 b의 최소공약수를 구해주는 함수
• from math import gcd => 바로 gcd 사용 가능

lcm(a,b)

• 최대공배수 구해주는 함수

비트 연산자

<< 정수를 2배로 곱하기 >> 정수를 2배로 나눠줌

• 예제

  print(n<<1)  #10을 2배 한 값인 20 이 출력된다.
  print(n>>1)  #10을 반으로 나눈 값인 5 가 출력된다.
  print(n<<2)  #10을 4배 한 값인 40 이 출력된다.
  print(n>>2)  #10을 반으로 나눈 후 다시 반으로 나눈 값인 2 가 출력된다.

수학 공식

서로 다른 n개 중 m개를 뽑는 경우의 수 공식

set함수

• set() => 집합 자료형 {}
• 괄호 안에 리스트 혹은 문자열 입력해서 만들 수 있음

set의 특징

• 중복 허용x
• 순서x

교집합

s1 = set([1,2,3,4,5,6])
s2 = set([4,5,6,7,8,9])
s3 = s1 & s2
print(s3)    #result : {4,5,6}

합집합

s3 = s1 | s2
print(s3)    #result : {1, 2, 3, 4, 5, 6, 7, 8, 9}

차집합

s3 = s1 - s2
print(s3)    #result : {1, 2, 3}

s3 = s2 - s1
print(s3)    #result : {8, 9, 7}

대칭 차집합

set1 = set([1,2,3,4,5,6])
set2 = set([3,4,5,6,8,9])

print(set1 ^ set2)

{1, 2, 8, 9}

집합 관련 함수

###1) 값 1개 추가히기(add) 이미 만들어진 set 자료형에 값을 추가할 수 있다.

s1 = set([1,2,3])
s1.add(4)
print(s1)    #result : {1, 2, 3, 4}

2) 값 여러개 추가하기(update)

s1 = set([1,2,3])
s1.update([4,5,6])
print(s1)    #result : {1, 2, 3, 4, 5, 6}

3) 특정 값 제거하기(remove)

s1 = set([1,2,3])
s1.remove(2)
print(s1)    #result : {1, 3}

Counter 클래스

• collections모듈의 Counter 클래스
• 리스트, 튜플에서 각 데이터가 등장한 횟수를 사전 형식으로 돌려줌

기본 예시

from collections import Counter
colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
cnt = Counter(colors)
print(cnt)
>> Counter({'blue': 3, 'red': 2, 'green': 1})

most_common()

• 등장한 횟수를 내림차순으로 정맇

  >>> numbers = [1, 2, 3, 3, 4, 4, 4, 5, 5]
  >>> from collections import Counter
  >>> cnt = Counter(numbers)
  >>> cnt.most_common()
  [(4, 3), (3, 2), (5, 2), (1, 1), (2, 1)]

상위 n개의 결과 도출

>>> cnt.most_common(3)
[(4, 3), (3, 2), (5, 2)]

최빈값

from collections import Counter

def modefinder(numbers):   #numbers는 리스트나 튜플 형태의 데이터
    c = Counter(numbers)
    mode = c.most_common(1)
    return mode[0][0]

• 최빈수가 2개 이상 존재할 때

from collections import Counter

def modefinder(numbers):
    c = Counter(numbers)
    order = c.most_common()
    maximum = order[0][1]

    modes = []
    for num in order:
        if num[1] == maximum:
            modes.append(num[0])
    return modes

permutaion

• 순열(순서를 고려)

import itertools arr = ['A', 'B', 'C] nPr = itertools.permutaions(arr, 2)

combination

• 조합(순서 고려x)

import itertools arr= ['A', 'B', 'C'] nCr = itertools.combinations(arr, 2)

DFS

• 경로 탐색

• 네트워크 유형

• 조합 유형

• 재귀함수

BFS

• queue

DP 동적계획

• 수행시간 단축 알고리즘
• 정수 삼각형
• 메모리를 사용해서 중복 연산을 줄이고 중복 연산을 줄여서 수행 속도를 개선

기억하며 풀기

• DFS/BFS로 풀 수 있지만 경우의 수가 너무 많은 경우
  • 500만개
• 경우의 수 중 중복이 많을 때

hash

• key, value

• 전화번호부

• 다양한 자료형으로 데이터 관리 가능

• 모든 데이터 타입으로 접근 가능

• String 기반으로 데이터 관리

String 알고리즘

1. 문자열 단순 구현

• "".equals()
• length()
• toUpperCase()
• toLowerCase()
• indexOf() => 문자열 있는지 판단
• substring(1, 3) => 1부터 3까지 추출
• replace(a,b) => a를 b로 바꾸기
• compareTo => 알파벳 순서 비교하기 => 뒤가 작으면 -, 뒤가 크면 +, 같으면 0
• startswith()
• endswith()
• contains

Greedy

• 현재 시점에 가장 좋은 선택을 하는 알고리즘

• 경주마 알고리즘

• 탐욕스러운 선택 조건

• 정렬 => 현재 최적

http란

• Hyper Text Transfer Protocol
• 인터넷에서 하이퍼텍스트 방식의 데이터를 교환하기위한 프로토콜(규칙체계)
• 서버간 통신에서 이해할 수 있는 공통의 통신 => 프로토콜 => http
• 통신방식, 통신구조

ip 주소

Internet Protocol address, IP address)

• 각 컴퓨터의 주소를 나타내는 것

• 컴퓨터 네트워크에서 장치들이 서로를 인식하고, 통신하기 위한 특수한 번호!

• 인터넷 접속할 때 ip 주소를 사용하고 있다!

ip 주소 테스트해보기

cmd 창에 다음 입력

Ping www.google.com [142.250.206.196] 32바이트 데이터 사용:
142.250.206.196의 응답: 바이트=32 시간=41ms TTL=56
142.250.206.196의 응답: 바이트=32 시간=38ms TTL=56
요청 시간이 만료되었습니다.
요청 시간이 만료되었습니다.

142.250.206.196에 대한 Ping 통계:
    패킷: 보냄 = 4, 받음 = 2, 손실 = 2 (50% 손실),
왕복 시간(밀리초):
    최소 = 38ms, 최대 = 41ms, 평균 = 39ms

컴퓨터가 Google을 동작시키는 컴퓨터 또는 서버에 ping 신호를 보내주는 것

구글 ip주소 : 142.250.206.196

• ip주소는 제한적이다.

• 관리자들이 정해놓은 이름을 IP주소 대신 사용하고, 그 이름을 도메인이라고함

  • .kr, .net. com

• 외부ip : 공유기를 거치기 전의 IP => isp가 나에게 할당한 고유의 ip주소, 인터넷 상에서 컴퓨터, 스마트폰을 식별할 수 있는 번호

• 내부ip : 공유기를 거친 후의 IP => 라우터(공유기)가 컴퓨터, 스마트폰에 자동으로 부여하는 가상의 ip주소, 속한 네트워크 안에서만 동작할 수 있음!

포트번호

• 컴퓨터 네트워크에서 서로 다른 프로그램이나 장치들이 통신위해 사용하는 번호
• 컴퓨터 식별 가능 => http://192.168.01:80

127.0.0.1:5500 => 예약된 IP주소

• 127.0.0.1 => 로컬호스트(OS에서 제공하는 시스템 실행하는 해당 컴퓨터)로 접속한 컴퓨터의 주소
• 5500 => 포트번호 사용하겠다는 뜻

HTTP 통신구조

웹 브라우저 동작, 웹서버 동작하는 두개의 컴퓨터

• 요청(Request)과 응답(Response)의 구조로 구성된다 HTTP 기반으로 통신할때 클라이언트가 먼저 HTTP요청을 서버에 보내면 서버는 요청에 관한 결과를 HTTP응답을 통해 클라이언트에 보냄으로 HTTP 통신이 이루어짐

• 요청하고 응답하는 관계를 클라이언트와 서버라고 함

• 웹서버 => Apache, IIs, Nginx => 비용지불

컴퓨팅 : 클라우드에서 처리하는 컴퓨터가 처리하는 양

클라우드

• 가상의 컴퓨터!
• 컴퓨터 원격으로 자동 수행
• 사용자 데이터 저장
• 버전관리에 유용

마이크로소프트 Azure란

클라우드 컴퓨팅 플랫폼

• IoT, 웹사이트 및 디비 호스팅, 데이터 저장소, 인공지능 등ㅇㄹ 제공
• 아이콘과 그래픽으로 표현하여 사용자가 더 쉽게 관리할 수 있도록 서비스 제공!
• 노드, 플라스크, 단넷 지원!

웹 애플리케이션

특징

• 웹브라우저 위에서 동작하는 애플리케이션
• 온라인 뱅킹, 온라인 클래스 등 다양한 영역에 뻗어있음

like 연산자 LIKE "강원도%"

limit 2 원하는 행만큼 출력

date 포맷 DATE_FORMAT(날짜 , 형식) : 날짜를 지정한 형식으로 출력

출처

소수점

• ROUND(값, 자릿수);

를 이용해 반올림을 해줄 수 있는데 자릿수를 넣지 않을 경우에는 소수를 모두 반올림 시켜버리고 자리수를 넣을 경우에는 자리수 위치까지 반올림을 수행하게 된다

avg decimal 시간 float 등과 병행할 시에도 값 위치와 자릿수만 기억해주면 된다

• 올림 => CEIL(값) 을 사용해주면 소수점을 모두 올려준다

• 내림은 FLOOR(값) 을 사용해주면 소수점을 모두 버려준다

• TRUNCATE(값, 자리수) 를 사용해주면 소수점을 모두 버리는 대신 자리수까지 버려줄 수 있다

• null일 때 문자열로 채워주기 => ifnull함수 이용하기 => oracle에서는 nvl 사용 => IS NOT NULL과 다름

IFNULL(TLNO,'NONE')

join, Using, 정규식 사용 => 과일

SELECT FLAVOR
FROM FIRST_HALF A JOIN ICECREAM_INFO B 
USING (FLAVOR)
WHERE A.TOTAL_ORDER > 3000 AND B.INGREDIENT_TYPE REGEXP '^fruit'
ORDER BY TOTAL_ORDER DESC

• 정규표현식 => LIKE연산자보다 검색 활용도 높음 REGEXP '' 출처

• join => a 테이블, b 테이블과 같은 레코드만 봄

• USING 키워드 => 두 테이블간 필드이름이 같은 경우에 사용

mysql과 oracle 헷갈리지 않기!

코딩테스트 연습을 하면서 유용했던 함수를 정리하였습니다.

나머지 구하기

내가 푼 방식

def solution(num1, num2):
    answer = num1 % num2
    return answer

다른 풀이1 => divmod 함수 사용하기

• divmod() : // 연산자와 % 연산자를 차례대로 인자로 받아서 튜플 형태로 반환

def solution(num1, num2):
    return divmod(num1, num2)[1]

다른 풀이2 => lambda 사용하기

lambda 매개변소 : (반환값으로 사용할 식)

solution = lambda num1, num2 : num1 % num2

섞어서?ㅎㅎ

solution = lambda num1, num2 : num1 % num2

두 수의곱

내가 푼 방식

def solution(num1:int, num2:int)->int:
    answer = num1 * num2
    return answer

수학을 위한 특수 메서드 활용

a + b       a.__add__(b)
a - b       a.__sub__(b)
a * b       a.__mul__(b)
a / b       a.__truediv__(b)
a // b      a.__floordiv__(b)
a % b       a.__mod__(b)
a << b      a.__lshift__(b)
a >> b      a.__rshift__(b)
a & b       a.__and__(b)
a | b       a.__or__(b)
a ^ b       a.__xor__(b)
a ** b      a.__pow__(b)
-a          a.__neg__()
~a          a.__invert__()
abs(a)      a.__abs__()

출처

람다

solution=lambda x,y:x*y

숫자 비교하기

• 내가 푼거

  def solution(num1, num2):
    if num1 == num2 : return 1
    else :  return -1

• if 삼항연산자 사용한거

  def solution(num1, num2):
    return 1 if num1==num2 else -1

두 수의 차

• lambda 사용

  solution = lambda num1, num2 : num1 - num2

• 특수메서드 활용

  solution = lambda num1, num2 : num1.__sub__(num2)

나이 출력

# 1.
# def solution(age):
#     answer = 2023 - age
#     return answer


# 2.
def solution(age):
    return 2022-age+1

# 3.
# solution = lambda age: 2023-age

두수의 합

내가 푼거

# def solution(num1, num2):
#     answer = num1 + num2
#     return answer


solution = lambda num1, num2: num1+num2

sum 활용

• 참고 => sum은 튜플이나 리스트에 있는 값만 처리해줄 수 있음. 그래서 람다식에 매개변수로 *를 붙여주면 num1과 num2로 들어오는 값을 튜플로 변경해준다.

  solution = lambda *x: sum(x)

두수의 나눗셈

• math 모듈 => import math abs : 절대값 max : 최댓값 min: 최솟값 pow: 멱승(제곱) round: 반올림(정수)

# // 사용
def solution(num1, num2):
     answer = 0
     answer = 1000 * num1//num2
     return answer

# int로 변환
solution = lambda num1, num2 : (int)(num1/num2 * 1000)

# trunc함수 사용
solution = lambda num1, num2 : math.trunc(num1/num2*1000)

각도기

• 삼항 연산자 적극 활용하기
• 조건을 dictionary안에 넣고 for in문으로 조건이 해당되는 값의 키를 리턴시키기

  # def solution(angle):
  #     if angle<=90:
  #         return 1 if angle<90 else 2
  #     else:
  #         return 3 if angle<180 else 4
  

return answer

람다로

solution = lambda angle : 2 if angle==90 else 1 if angle<90 else 4 if angle==180 else 3

간단한 방법

def solution(angle):

answer = (angle // 90) * 2 + (angle % 90 > 0) * 1

return answer

검색

def solution(angle):

angles = {180: 4, 91: 3, 90: 2, 0: 1}

for base, result in angles.items():

if angle >= base:

return result

# 짝수의 합
> **문제설명**
정수 n이 주어질 때, n이하의 짝수를 모두 더한 값을 return 하도록 solution 함수를 작성해주세요.

* for문 짚고가기
* for i in iterable
iterable한 타입 : list, dictionary, set, string, tuple, bytes

* for i in range(종료숫자) 
종료숫자-1까지 수행

```python
# 기본 풀이
def solution(n):
    answer = 0
    for i in range(2, n+1, 2):
        answer += i
    return answer


# n까지 수 중 짝수만 리스트에 넣어준 후 더해주기
solution = lambda n: sum([i for i in range(2, n + 1, 2)])

# 위의 방법과 비슷함
solution = lambda n: sum(range(0, n+1, 2))

# 등차수열 2n의 합 공식 이용하기
def solution(n):
    return 2*(n//2)*((n//2)+1)/2

표준 입력

• input() : 한줄의 문자열 입력
• map() : 리스트 모든 원소에 각각 특정한 함수 적용할때

공백을 기준으로 구분된 데이터 입력받을 때

# 입력 받은 후 공백 기준으로 구분하고, 원소를 정수형으로 바꿔주고 list형으로 만들어주기
list(map(int, input().split()))

공백 기준으로 구분된 데이터 개수가 많지 않을 때(정해진 양)

# 데이터 3개 들어올때
a, b, c = map(int, input().split());
print(a, b, c)

# 데이터의 개수 입력
n = int(input())

# 각 데이터를 공백을 기준으로 구분하여 입력
data = list(map(int, input().split()))

data.sort(reverse=True)
print(data)

# 65 90 75 34 99 => 입력
# [99, 90, 75, 65, 34] => 출력

빠르게 입력

• sys.stdin.realine() rstrip() => 줄바꿈 기호 제거

표준 출력

• print()함수
• 기본 줄바꿈 => 줄 바꿈 원치 않는경우! 'end' 속성 사용

f-string

• 문자열 앞에 f 붙여서 사용

a=1
b=2
print(a, b)
print(7, end=" ")
print(8, end=" ")

answer = 7
# 정수형 문자열로 바꾼 후 + 연산자 사용
print("정답 : " + str(answer) + "입니다.")

# f-string
print(f"정답은 {answer}입니다.")

조건문과 반복문

조건문

x=15;

if x>=10:
    print("x>=10")
if x>=0:
    print("x>=0")
if x>=30:
    print("x>=30")

코드의 블록을 들여쓰기로 지정!!

• tab, 스페이스 4개

x=15;

if x>=10:
    print("x>=10")
if x>=0:
    print("x>=0")
if x>=30:
    print("x>=30")

score = 85;
# 들여쓰기로 코드 블록 구분
if score>= 70:
    print('성적 70 이상')
    if score >= 90:
        print('우수한 성적')
else:
    print('성적 70 미만')
    print('분발할것')

조건문 기본형태

• if ~ elif ~ else

반복문

while

x=10

while x>5:
    print(x)

for in문 in 뒤에 오는 데이터에 포함되어있는 원소를 첫번째 인덱스부터 차례대로 방문

array = [1, 2, 3, 4, 5]

for x in array:
    print(x)

for range문

• 연속적인 값을 차례대로 순회할 때
• range(시작 값, 끝값+1)

result = 0

# i는 1부터 9까지의 모든 값을 순회
for i in range(1,10):
    result += i

print(result)

continue

• 반복문에서 남은 코드의 실행 건너뛸 때 continue를 사용

result = 0

# i는 1부터 9까지의 모든 값을 순회
for i in range(1,10):
    if i % 2 == 0:
        continue
    result += i

print(result)

break

• 반복문을 즉시 탈출하고자 할 때

  i = 1
  

while True: print("현재 i의 값:", i) if i == 5: break i+=1

* 간단한 예제

```python
scores = [90, 85, 77, 65, 97]
cheating_student_list = {2, 4}

# cheating_student_list 리스트에 있는 점수 건너뛰기
for i in range(5):
    if i+1 in cheating_student_list:
        continue
    if scores[i] >= 80:
        print(i+1, "번 학생은 합격입니다.")

구구단

for i in range(2, 10):
    for j in range(1, 10):    
        print(i, "X", j, "=", i*j)
    print()

함수

• 함수 형식

def func1(a):
    print(a)
    return 0



result = subtract(3,7) 

#result => -4

• 전역변수

a=0

def func():
    global a
    a += 1

for i in range(10):
    func()
    print(a)

• 여러개의 반환 값

람다 표현식

(->이해가 잘 안됨, 다시 공부하기)

print((lambda a, b: a+b)(3,7))

array = [('홍길동', 50), ('이순신', 32), (배서연, 74)]

def my_key(x):
    return x[1]

print(sorted(array, key=my_key))
print(sorted(array, key=lambda x: x[1]))

파라미터 저장

def add(a, b):
    print(a+b)

add(b=3, a=7)

람다 예시 : 여러개의 리스트에 적용

list1 = [1,2,3,4,5]
list2 = [6,7,8,9,10]

result = map(lambda a,b: a+b, list1, list2)

print(list(result))

라이브러리

• 내장함수 : 기본입출력함수 ~ 정렬함수까지 기본적인 함수제공
• itertools : 반복되는 형태의 데이터를 처리할때 유용한 기능 제공 => 순열, 조합 라이브러리
• heapq : 힙 자료구조 제공 => 우선순위 큐
• bisect : 이진 탐색
• collections : 덱(deque), 카운터(counter)등
• math : 팩토리얼, 제곱근, 최대공약수, 삼각함수, 파이 등

# sum() => 합
result = sum([1,2,3,4,5])
print(result)

# min(), max() => 최대 최소
min_result = min(7,3,5,2)
max_result = max(7,3,5,2)
print(min_result, max_result)

# eval() => 문자열을 식으로
result = eval("(3+5)*7")
print(result)

# sorted() => 정렬
result = sorted([9,1,8,5,4]) # 오름차순
reverse_result = sorted([9,1,8,5,4], reverse=True)  # 내림차순
print(result)
print(reverse_result)

# sorted() with key
array = [('홍길동, 50'), ('이순신', 32), ('배서연', 74)]
result = sorted(array, key=lambda x: x[1], reverse=True)
print(result)

순열과 조합

• 순열 : 서로 다른 n개에서 서로 다른 r개를 선택하여 나열
• 조합 : 서로 다른 n개에서 순서 상관x 서로 다른 r개를 선택 => 거꾸로 뒤집는거 안됨

permutations)

from itertools import permutations

data = ['A', 'B', 'C']  # 데이터 준비

result = list(permutations(data, 3))
print(result)

combination

from itertools import combinations

data = ['A', 'B', 'C']  # 데이터 준비

result = list(combinations(data, 2)) # 2개를 뽑는 모든 조합 구하기
print(result) 

중복 순열과 중복 조합

from itertools import product

data = ['A', 'B', 'C']

# 2개를 뽑는 모든 순열 구하기 (중복 허용)
result = list(product(data, repeat=2))
print(result)

from itertools import combinations_with_replacement

data = ['A', 'B', 'C']

# 2개를 뽑는 모든 조합 구하기 (중복 허용)
result = list(combinations_with_replacement(data, 2))
print(result)

최대 공약수와 최소 공배수

import math

# 최소 공배수(LCM)를 구하는 함수
def lcm(a, b):
    # 두 수를 곱하고 최대 공약수로 나눔
    # //는 소수점 이하 자릿수를 제거한 몫을 구하는 연산자(Floor Division)
    return a * b // math.gcd(a, b)

a=21
b=14

print(math.gcd(21, 14)) # 최대 공약수(GCD) 계산
print(lcm(21, 14))      # 최대 공배수(LCM) 계산

• 문자열 변수 초기화 할 때 => 큰따옴표(") 작은따옴표(')
  • " '' "
  • ' "" '

data = 'Hello World'
print(data)


data = "Don't you know \"Python\""
print(data)

문자열 연산

• 덧셈(+) 연산 => 연결
• 곱하기(*) 연산 => 문자열이 여러번 더해짐
• 인덱싱, 슬라이싱 이용 가능
  • but 인덱스값 변경x

a="Hello"
b="World"
print(a + " " + b)
print(a*3)

a= "ABCDEF"
# 문자열 a의 두번째부터 세번째 자리가 출력됨 => CD
print(a[2:4])

# 특정 문자열을 바꾸는 것은 안됨
# a[2] = 'a'

튜플 자료형

리스트와의 차이!

• 한번 선언된 값을 변경x
• 튜플은 소괄호 () 이용
• 리스트에 비해 공간효율적

a = (1,2,3,4,5,6,7,8,9)

# 네번째 원소만 출력
print(a[3])

# 1,2,3번재 값
# (2,3,4)
print(a[1:4])

# 오류발생
# a[2] = 7

튜플을 사용하면 좋은 경우

• 서로 다른 성질의 데이터를 묶어서 관리해야할 때
  • 최단경로 알고리즘(비용, 노드번호)의 형태로 튜플 자료형 사용
• 데이터의 나열을 해싱(Hasing)의 키 값으로 사용해야 할 때
  • 튜플은 변경x 리스트와 다르게 키값 으로 사용될 수 있다!!
• 리스트보다 메모리를 효율적을 사용해야할 때

딕셔너리 자료형

• 키(key)와 값(Value)의 쌍을 데이터로 가지는 자료형
• 키와 값의 쌍을 데이터로 가지며, 원하는 변경 불가능한 자료형을 키로 사용 가능 => 키값으로 접근 가능
• 딕셔너리는 해시테이블(Hash Table)을 이용하므로 데이터 조회, 수정에 있어서 O(1)의 시간에 처리가능

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
daata['코코넛'] = 'Coconut'

# 출력 됨
if '사과' in data:
    print("'사과'를 키로 가지는 데이터가 존재

• 특정한 키 존재하는지 저장하고 관리하고 검색할때 리스트보다 효육적

• 키 데이터만 뽑아서 리스트로 이용할 때 => keys()

• 값 데이터만 뽑아서 리스트로 이용할 때 => values()

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
daata['코코넛'] = 'Coconut'

# 키 데이터만 담은 리스트
key_list = data.keys()

value_list = data.values()
print(key_list)
print(value_list)

# 각 키에 따른 값을 하나씩 출력
for key in key_list:
    print(data[key])

# 이런식으로도 선언 가능
data2 = {
    '김미림' : 33,
    '이미림' : 44
}

집합 자료형

• 중복 허용

• 순서가 없다

• 리스트 혹은 문자열을 이용해서 초기화 가능 => set() 함수 이용

• 혹은 중괄호({})안에 각 원소를 콤마(,)를 기준으로 구분하여 삽입함으로써 초기화 가능

• 데이터의 조회 및 수정에 있어서 O(1)의 시간에 처리가능

# 집합 자료형 초기화 방법1
data = set([1,1,2,3,4,4,5])

#집합 자료형 초기화 방법 2
data = {1,1,2,3,4,4,5}

# 출력 결과(중복제거0
# {1,2,3,4,5}

집합자료형의 연산

• 합집합
• 교집합
• 차집합 A-B

a = set([1,2,3,4,5])
b = set([3,4,5,6,7])

# 합집합 => {1,2,3,4,5,6,7}
pritn(a | b)

# 교집합 => {3,4,5}
print(a & b)

# 차집합 => {1,2}
print(a-b)

집합 자료형 관련 함수

data = set([1,2,3])

# 추가
data.add(4)

# 여러개 추가
data.update([5,6])

# 삭제
data.remove(3)

딕셔너리 자료형, 집합 자료형의 특징

• 리스트, 튜플은 순서가 있기 때문에 인덱싱을 통해 자료형의 값을 얻을 수 있음
• 딕셔너리 자료형, 집합자료형은 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없음 => 딕셔너리의 키(Key) 혹은 집합의 원소(Element)를 이용해 O(1)의 시간 복잡도로 조회

• 정수형, 실수형, 복소수형, 문자열, 리스트, 튜플, 딕셔너리 등

정수형

• 양의 정수, 음의 정수, 0

  # 양의 정수
  a = 1000
  

음의 정수

b = -7

0

c = 0

## 실수형
* 소수점 아래의 데이터를 포함하는 수 자료형

``` python
a=157.93

b = -1837.2

# 0생략 가능
c= 5.

d = -.7

• 고정된 크기의 메모리 할당 => 실수값 달라질 수 있ㅇㅁ
• 해결방법 => round()함수를 사용하자
• 123.456을 소수 셋째 자리에서 반올림하면 round(123,456,2) => 소수점 자리 둘째자리까지 결과 : 123.46

지수 표현 방식

• e나 E를 이용한 지수 표현 방식을 이용할 수 있음
• 1e9 : 10의 9제곱 (10억)

# 1,000,000,000
b = int(1e9)

# 752.5
a = 75.25e1

수 자료형의 연산

• 나누기 연산자 /
  • 실수형으로 반환
• 나머지 연산자 %
  • a가 홀수인지 체크할때
• 몫 연산자 //
• 거듭 제곱 연산자 **

a = 7
b = 3

a*b
a/b
a//b
a ** b

리스트 자료형

• 여러개의 데이터를 연속적으로 담아 처리하기 위해 사용하는 자료형
• 뒤쪽에 데이터 붙이기 append()

리스트 초기화

• 대괄호 안에 원소를 넣어서 초기화
• list(), []를 이용 => 빈 리스트 선언
• 리스트 원소에 접근할때 인덱스 값을 괄호에 넣음

# 크기가 N이고, 모든 값이 0인 1차원 리스트 초기화

n=10
a = [0] * n

# [0,0,0,0,0,0,0,0,0,0]

리스트의 인덱싱과 슬라이싱

• 인덱스 값을 입력하여 특정한 원소를 접근 하는 것
• 양의 정수, 음의 정수 모두 사용 가능
• 음의 정수 => 거꾸로 접근

a = [1,2,3,4,5,6]

a[-1]

a[3] = 7

• 연속적인 위치 갖는 원소 가져올 때는 슬라이싱 이용
• 대괄호 안에 콜론을 넣어서 시작 인덱스, 끝 인덱스 설정 가능
• 끝 인덱스는 실제 인덱스보다 1을 더 크게 설정

a = [1,2,3,4,5,6,7,8,9]

# 2,3,4
print(a[1:4])

리스트 컴프리헨션

• 리스트 초기화
• 대괄호 안에 조건문, 반복문 적용

# 0,1,2,3,4,5,6,7,8,9
array = [i for i in range(10)]

# 0부터 19까지의 수 중에서 홀수만 포함하는 리스트
# 1,3,5,7,9,11,13,15,79,19
array2 = [i for i in range(20) if i % 2 ==1]

# 1부터 9까지들의 수들의 제곱 값을 포함하는 리스트
# 1,4,9,16,25,36,49, 64, 81
array3 = [i * i for i in range(1,10)]

리스트 컴프리헨션과 일반적인 코드 비교하기

• 리스트 컴프리헨션은 2차원 리스트를 초기화할 때 효과적으로 사용
• N * M의 크기의 2차원 리스트를 한번에 초기화 해야할 때 유용
• n번 반복을 할 때마다 길이가 m인 리스트를 새롭게 초기화 array = [[0]*m for _in range(n)]

• 잘못된 예시 : array = [[0]*m]*n 전체 리스트 안에 포함된 각 리스트가 모두 같은 객체로 인식

리스트 컴프리헨션으로 2차원 리스트 초기화 좋은예시

# N X M 크기의 2차원 리스트 초기화
# [0,0,0], [0,0,0], [0,0,0], [0,0,0]
n = 4
m = 3
array = [[0] * m for _ in range(n)]

리스트 컴프리헨션으로 2차원 리스트 초기화 나쁜예시

• 내부적 리스트 같은 객체로 인식됨

언더바

반복을 수행하되 반복을 위한 변수의 값을 무시하고자 할 때 언더바(_)를 자주 사용함

# 1부터 9까지 더하기
summary=0
for i in range(1, 10):
    summary +=i


# Hello world 5번 출력
for _ in range(5):
    print("Hello World")

리스트 관련 메소드

• append() 변수명.append() 리스트 원소 하나 삽입
• sort 정렬 변수명.sort() 변수명.sort(reverse=True)
• reverse 변수명.reverse() 리스트 원소 순서 뒤집기
• insert insert(삽입할 위치 인덱스, 삽입할 값) 특정한 인덱스 위치에 원소 삽입
• count 변수명.count(특정 값) 리스트에서 특정한 값을 가지는 데이터의 개수를 셀때
• remove 변수명.remove(특정값) 특정값을 갖는 원소제거, 값을 가진 원소가 여러개면 하나만 제거

a = [1,4,3]
b = [1,4,3]

print("기본 리스트 : ", a)


# 리스트에 원소 삽입
a.append(2)
print("삽입 : ", a)

# 오름차순 정렬
a.sort()
print("오름차순 정렬 : ", a)

# 내림차순 정렬
a.sort(reverse=True)
print("내림차순 정렬 : ", a)

print("=======================")

# 리스트 원소 뒤집기
b.reverse()
print("원소 뒤집기 : ", b)

# 특정 인덱스에 데이터 추가
b.insert(2, 3)
print("인덱스 2에 3 추가: ", b)

# 특정 값인 데이터 개수 세기
print("값이 3인 데이터 개수 : ", b.count(3))

# 특정 값 데이터 삭제
b.remove(1)
print("값이 1인 데이터 삭제: ", b)

print("=======================")

c = [1,2,3,4,5,5,5]
remove_set = {3,5}  # 집합 자료형

# remove_set에 포함되지 않은 값만을 저장
result = [i for i in c if i not in remove_set]
print(result)

• 그리디
• 구현(문자열)
• DFS / BFS

시간복잡도 / 공간복잡도

빅오 표기법 : 가장 빠르게 증가하는 항만을 고려

함수의 상한만을 나타낸다.

종류

• O(1) 상수시간
• O(logN) 로그시간
• O(N) 선형시간
• O(NlogN)로그선형시간
• O(N2) 이차시간
• O(N3) 삼차시간
• O(2n) 지수시간

시간 복잡도 계산해보기

N개의 데이터의 합을 계산하는 프로그램

• 수행시간은 데이터 개수 N에 비례
  • 시간복잡도 : O(N)

2중 반복문을 이용하는 프로그램

• 시간복잡도 : O(N2)
  • 모든 2중 반복문의 시간복잡도가 O(N2)인것은 아님

알고리즘 설계 Tip

• PyPy의 경우 때때로 C언어보다 빠르게 동작
• 코딩테스트 문제에서 시간제한은 1~5초 가량임을 유의하기!

요구사항에 따라 적절한 알고리즘 설계하기

시간제한(수행시간 요구사항) 먼저 확인하기!

• N의 범위가 500인 경우 - O(N3)
• N의 범위가 2,000인 경우 - O(N2)
• N의 범위가 100,000인 경우 - O(NlogN)
• N의 범위가 10,000,000인 경우 - O(N)

알고리즘 문제 해결과정

1. 지문 읽기 및 컴퓨터적 사고
2. 요구사항(복잡도) 분석
3. 문제 해결을 위한 아이디어 찾기
4. 소스코드 설계 및 코딩

한국중학교에 다니는 학생들은 각자 정수 번호를 갖고 있습니다. 이 학교 학생 3명의 정수 번호를 더했을 때 0이 되면 3명의 학생은 삼총사라고 합니다. 예를 들어, 5명의 학생이 있고, 각각의 정수 번호가 순서대로 -2, 3, 0, 2, -5일 때, 첫 번째, 세 번째, 네 번째 학생의 정수 번호를 더하면 0이므로 세 학생은 삼총사입니다. 또한, 두 번째, 네 번째, 다섯 번째 학생의 정수 번호를 더해도 0이므로 세 학생도 삼총사입니다. 따라서 이 경우 한국중학교에서는 두 가지 방법으로 삼총사를 만들 수 있습니다.

한국중학교 학생들의 번호를 나타내는 정수 배열 number가 매개변수로 주어질 때, 학생들 중 삼총사를 만들 수 있는 방법의 수를 return 하도록 solution 함수를 완성하세요.

제한사항

• 3 ≤ number의 길이 ≤ 13
• -1,000 ≤ number의 각 원소 ≤ 1,000
• 서로 다른 학생의 정수 번호가 같을 수 있습니다.

입출력 예

입출력 예 설명

입출력 예 #2

• 학생들의 정수 번호 쌍 (-3, 0, 3), (-2, 0, 2), (-1, 0, 1), (-2, -1, 3), (-3, 1, 2) 이 삼총사가 될 수 있으므로, 5를 return 합니다.

풀이

문제를 간단하게 분석하자면 배열에 있는 값 3개를 조합해서 더했을때 0인 개수를 구하는 것입니다. 삼중 for문으로 인덱스 값을 순서대로 비교해서 3개를 더했을 때 0이 된다면 answer을 더해줍니다.

1. 인덱스 변수 3개(i, j, k)와 조합한 배열의 값을 더해서 저장하는 변수 sum을 선언합니다.

2. 3중 for문을 돌립니다. 여기서 순서대로 비교해야하기 때문에 i는 0부터, j는 i+1, k는 j+1부터 시작합니다. 첫번째 인덱스 값 i가 마지막 배열 방번호에 와도 두번째 인덱스 값 j는 i+1이고, 배열 길이를 초과하므로 자동으로 for문을 나오게 됩니다.

3. 배열의 i, j, k번째 값을 더했을 때 0이면 answer값을 더해줍니다.

코드

int solution(int number[], size_t number_len) {
    int answer = 0;
    int i, j, k;
    int sum = 0;
    for (i = 0; i < number_len; i++) {
        for (j = i + 1; j < number_len; j++) {
            for (k = j + 1; k < number_len; k++) {
                sum = number[i] + number[j] + number[k];
                if (sum == 0) {
                    answer++;
                }
            }
        }
    }

    return answer;
}

마무리

복잡한 알고리즘이나 함수를 사용하지 않고, 3중 for문만 사용하면 해결하는 쉬운문제였습니다.

코딩테스트를 준비하는 머쓱이는 프로그래머스에서 문제를 풀고 나중에 다시 코드를 보면서 공부하려고 작성한 코드를 컴퓨터 바탕화면에 아무 위치에나 저장해 둡니다. 저장한 코드가 많아지면서 머쓱이는 본인의 컴퓨터 바탕화면이 너무 지저분하다고 생각했습니다. 프로그래머스에서 작성했던 코드는 그 문제에 가서 다시 볼 수 있기 때문에 저장해 둔 파일들을 전부 삭제하기로 했습니다.

컴퓨터 바탕화면은 각 칸이 정사각형인 격자판입니다. 이때 컴퓨터 바탕화면의 상태를 나타낸 문자열 배열 wallpaper가 주어집니다. 파일들은 바탕화면의 격자칸에 위치하고 바탕화면의 격자점들은 바탕화면의 가장 왼쪽 위를 (0, 0)으로 시작해 (세로 좌표, 가로 좌표)로 표현합니다. 빈칸은 ".", 파일이 있는 칸은 "#"의 값을 가집니다. 드래그를 하면 파일들을 선택할 수 있고, 선택된 파일들을 삭제할 수 있습니다. 머쓱이는 최소한의 이동거리를 갖는 한 번의 드래그로 모든 파일을 선택해서 한 번에 지우려고 하며 드래그로 파일들을 선택하는 방법은 다음과 같습니다 .

• 드래그는 바탕화면의 격자점 S(lux, luy)를 마우스 왼쪽 버튼으로 클릭한 상태로 격자점 E(rdx, rdy)로 이동한 뒤 마우스 왼쪽 버튼을 떼는 행동입니다. 이때, "점 S에서 점 E로 드래그한다"고 표현하고 점 S와 점 E를 각각 드래그의 시작점, 끝점이라고 표현합니다.

• 점 S(lux, luy)에서 점 E(rdx, rdy)로 드래그를 할 때, "드래그 한 거리"는 |rdx - lux| + |rdy - luy|로 정의합니다.

• 점 S에서 점 E로 드래그를 하면 바탕화면에서 두 격자점을 각각 왼쪽 위, 오른쪽 아래로 하는 직사각형 내부에 있는 모든 파일이 선택됩니다.

제한 사항

• 1 ≤ wallpaper의 길이 ≤ 50
• 1 ≤ wallpaper[i]의 길이 ≤ 50
• wallpaper의 모든 원소의 길이는 동일합니다.
• wallpaper[i][j]는 바탕화면에서 i + 1행 j + 1열에 해당하는 칸의 상태를 나타냅니다.
• wallpaper[i][j]는 "#" 또는 "."의 값만 가집니다.
• 바탕화면에는 적어도 하나의 파일이 있습니다.
• 드래그 시작점 (lux, luy)와 끝점 (rdx, rdy)는 lux < rdx, luy < rdy를 만족해야 합니다.

입출력 예

입출력 예 설명

• 예제 2번의 바탕화면은 다음과 같습니다.

(1, 3)에서 (5, 8)로 드래그하면 모든 파일을 선택할 수 있고 이보다 적은 이동거리로 모든 파일을 선택하는 방법은 없습니다. 따라서 가장 적은 이동의 드래그로 모든 파일을 선택하는 방법인 [1, 3, 5, 8]을 return합니다.

풀이

쉽게 생각해서 드래그했을 때 좌측상단의 (X,Y)값과 우측하단의 (X,Y)를 구한다고 생각하면 됩니다.

1. 좌측 상단 좌표와 우측 하단 좌표를 담을 변수 4개를 준비합니다.

   (배열에 #이 있는 경우 인덱스 값이)

• minX : x값이 가장 작고, 가장 상단에 있는 x값
• minY : y값이 가장 작고, 가장 좌측에 있는 y값
• maxX : x값이 가장 크고, 가장 하단에 있는 x값
• maxY : y값이 가장 크고, 가장 우측에 있는 y값

2. 배열을 순회하며 minX, minY, maxX, maxY값을 비교해줍니다.

• minX보다 x값이 작으면 x를 minX에 넣어줍니다.
• minY보다 y값이 작으면 y를 minY에 넣어줍니다.
• maxX보다 x값이 크면 x를 maxX에 넣어줍니다.
• maxY보다 y값이 크면 y를 maxY에 넣어줍니다.

3. 좌측상단의 (minX,minY) 좌표와 우측하단의 (maxX+1,maxY+1) 좌표를 answer 배열에 넣어줍니다.

• 좌측 상단의 x,y 좌표는 그대로
• 우측 하단의 x, y 좌표는 1을 더해줍니다. 드래그를 할 때 원래 인덱스 번호보다 한칸 밑으로 내려가기 때문이죠.

코드

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

int* solution(const char* wallpaper[], size_t wallpaper_len) {

    // 좌측 상단 y, 우측 하단 y, 좌측 상단 x, 좌측 하단 x
    int minY=50, maxY=0, minX=50, maxX=0;
    int len = strlen(wallpaper[0]);
    int* answer = (int*)malloc(sizeof(1));

    for(int i=0; i<wallpaper_len; i++){
        for(int j=0; j<len; j++){
            if(wallpaper[i][j] == '#'){
                // y축 좌표 j가 minw보다 작으면 minh(좌측상단 y)로
                if(minY > j) minY = j;
                if(maxY < j) maxY = j;
                if(minX > i) minX = i;
                if(maxX < i) maxX = i;
            }
        }
    }

    // 좌측 상단 x,y 좌표는 그대로
    // 우측 하단 x,y 좌표는 1더해줌 (드래그 하면 한칸 밑으로 떨어짐)
    answer[0] = minX;
    answer[1] = minY;
    answer[2] = maxX+1;
    answer[3] = maxY+1;

    return answer;
}

마무리

문제에서 구하고자 하는 것을 잘 파악하면 쉽게 풀 수 있는 문제였습니다.

주어진 코드

int solution(int day, int numbers[], int numbers_len) {
    int count = 0;
    for(int i = 0; i < numbers_len; i++)
        if(numbers[i]%2 != day%2)
            count++;
    return count;
}

한줄 수정 후

int solution(int day, int numbers[], int numbers_len) {
    int count = 0;
    for(int i = 0; i < numbers_len; i++)
        if(numbers[i]%2 == day%2)
            count++;
    return count;
}

실행 결과

완성 코드

int solution(int programs[][2], int programs_len) {
    int answer = 0;    
    int used_tv[25] = { 0, };

    for(int i = 0; i < programs_len; i++)
        for(int j = programs[i][0]; j < programs[i][1]; j++)
            used_tv[j]++;

    for(int i = 0; i < 25; i++)
        if(used_tv[i] >= 2)
            answer++;

    return answer;
}

if(used_tv[i] >= 1) 이 코드를 다음과 같이 변경해주자. if(used_tv[i] <= 2) TV를 동시에 두대 이상 트는 시간을 알아내야하기 때문에 2로 변경해야한다.

코드해석

가장 중요한 것은 a시부터 b시까지 TV를 틀었다면 b-1시간 틀었다는 것이다.

• answer : TV를 2대 이상 트는 총 시간을 return 할 변수이다
• used_tv : n시에 TV를 몇대 틀었는지 담을 배열이다 (0~24)
• 중첩 for문 i : 0 ~ programs_len -1 j : programs[i][0] ~ programs[i][1]-1까지 반복

used_tv는 [0, 1, 2, 3, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]이다.

used_tv 배열에 2 이상인 요소는 2, 3, 4, 5로 4개이므로 answer은 4이다.

완성 코드

include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

int compare(const void *a, const void *b){
    return ( *(int*)b - *(int*)a );
}

int func_a(int scores[], int scores_len, int score){
    for(int rank = 0; rank < scores_len; rank++)
        if(scores[rank] == score)
            return rank + 1;
    return 0;
}

void func_b(int arr[], int arr_len){
    qsort(arr, arr_len, sizeof(int), compare);
}

int func_c(int arr[], int n){
    return arr[n];
}
int solution(int scores[], int scores_len, int n) {
    int score = func_c(scores, n);
    func_b(scores, scores_len);
    int answer = func_a(scores, scores_len, score);
    return answer;
}
int main() {
    int scores[4] ={20, 60, 98, 59};
    int scores_len = 4;
    int n = 3;
    int ret = solution(scores, scores_len, n);

    printf("solution 함수의 반환 값은 %d 입니다.\n", ret);
}

실행결과