렛추고

CS - Data Structure

오쟝 — Sat, 1 Feb 2025 09:24:44 +0900

배열

연관된 데이터를 모아서 연속적으로 관리하기 위한 자료구조

- 배열은 메모리 상에 고정된 크기를 가지기 때문에 한 번 생성하면 크기 수정이 불가능

- 인덱스를 통해 배열에 접근할 때의 시간 복잡도는 O(1)

- 프로그램 작성 과정에서 데이터를 삽입/삭제 불가능, 변경만 가능

int main(){
	int a[5] = {0,};
	int a[] = {1, 2, 3, 4, 5};
}

위와 같이 미리 크기를 할당하고 사용해야 한다

LinkedList

포인터와 노드를 사용해 연속이 아닌 연결되어 있는 자료구조

각 노드는 데이터 필드와 주소 필드로 이루어져 있음

- 원하는 위치에 삽입/삭제가 가능함으로 동적으로 데이터를 관리할 수 있음

- 첫 번째 노드부터 순차적으로 요소에 접근해야함 임의로 액새스 불가능

struct Node {
    int data;
    struct Node* next;
}

int main() {
    char[] data = ['A', 'B', 'C', 'D', 'E'];
    int size = sizeof(data)/sizeof(data[0])
    
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    struct Node* current = head;
    
    head->data = data[0]
    head->next = null;
    
    for(int i = 1; i<size; i++){
    	struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
        new_node->data = data[i];
        new_node->next = null;
        
        current->next = new_node;
        current = new_node;
    }
}

위와 같은 방식으로 생성 가능

연결리스트에서 데이터를 삽입하려면

void push(struct Node** prev_node, int new_data) {
    if(prev_node == NULL) return;
    
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node))
    
    new_node->data = new_data;
    new_node->next = prev_node->next;
    prev_node->next = new_node;
}

위와 같은 방식으로 코드를 짤 수 있다

같은 방식으로 연결리스트에 데이터를 삭제하려면

void delete(struct Node* prev_node) {
    if (prev_node == NULL || prev_node->next == NULL) return;

    struct Node* temp = prev_node->next; 
    prev_node->next = temp->next;       
    free(temp);                      
}

위와 같이 코드를 짤 수 있다

Array VS LinkedList VS ArrayList

- Array : 인덱스로 자료에 빠른 접근이 가능하나 크기를 미리 할당하고 사용해야함

- LinkedList : 자료의 삽입/삭제가 빠르나 데이터를 접근할 때 순차 검색이기 때문에 데이터 검색이 느림

- ArrayList : 데이터를 빠르게 찾을 수 있으나 삽입/삭제가 느림

STACK

후입선출 구조의 자료구조

top은 -1부터 시작

void push(int data){
    if(top == size) return;
	stack[++top] = data;
}

int pop(){
    if(top == -1) return -1;
    return stack[top--];
}

QUEUE

선입선출 구조의 자료구조

front는 0부터 시작

rear는 -1부터 시작

void add(int index) {
    if(rear == size) return;
    queue[++rear] = index;
}

int delete(){
    if(rear < front) return -1;
    return queue[front++];
}

Django - DB 세팅을 해보자!!

오쟝 — Sat, 2 Nov 2024 22:54:35 +0900

venv 설치 방법은 전 게시물로 확인하기!

python manage.py startapp 만들고자 하는 프로젝트 이름

이때!startapp과 startproject가 있다!!!

django-admin startproject

startproject 명령어는 Django 프로젝트의 기본 구조를 생성
구성 요소: 프로젝트 디렉토리와 settings.py, urls.py, wsgi.py, manage.py 등을 포함하는 프로젝트의 루트 구조가 생성됨

python manage.py startapp

startapp 명령어는 Django 앱의 기본 구조를 생성 애플리케이션은 프로젝트 내에서 특정 기능(예: 블로그, 사용자 관리 등)을 구현하는 모듈
models.py, views.py, urls.py, admin.py, apps.py, migrations 디렉토리 등으로 구성됩니다.

만들고자 하는 앱에 필요한 기능에 따라 다운받기!!

Mysql 워크벤치에서 mysql connections 생성!

생성하기 버튼을 눌린 후 만드려는 벤치의 이름을 적어주기!

이때 포트 번호 수정시 오류가 발생할 수도 있기 때문에 되도록 건들지 않도록 하자!!

스키마를 생성한다!

만드려는 스키마의 이름을 설정!

Charset/Collation은 utf8, utf8_bin으로 설정한다!

Apply 버튼을 눌러 스키마 생성을 완료한다!

Users and Privileges를 눌러 Add Account를 한다!

Schema Privileges를 눌러

Add Entry를 해 스키마를 추가해준다!

그 다음

필요한 사항들에 체크해주면 mysql connections는 설정 끝!!

이제 vs code에 들어가서 프로젝트 파일에 있는 settings.py를 수정해준다!

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'settings를 포함하고 있는 폴더 이름'
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'MySql Connections 이름',
        'USER' : 'Add Account 할 때 입력해둔 user',
        'PASSWORD' : 'Add Account 할 때 입력해둔 password',
        'HOST' : '127.0.0.1',
        'PORT' : '3306'
    }
}

그 다음으로는 models.py에 데이터베이스를 설정해준다!

from django.db import models

class Combination(models.Model):
    user_name = models.CharField(max_length=100)
    menu_name = models.CharField(max_length=100)
    items = models.JSONField()

    def __str__(self):
        return self.menu_name

위와 같이 테이블을 정의해준다!

만약 사용자의 아이디와 비밀번호를 저장하는 테이블이라면

class Client(models.Model):
    user_id = models.CharField(maxLength=20)
    user_pw = models.CharField(maxLength=20)
    
    def __str__(self):
    	return self.user_id

이후 터미널에

 python manage.py makemigrations
 python manage.py migrate

코드를 통해 수정사항을 업데이트 해 준다!

정의된 테이블을 사용하기 위해서는

from .models import Combination

def save_combinations(request):
    if request.method == "POST":
        data = json.loads(request.body)
        user_name = data.get("user_name")
        menu_name = data.get("menu_name")
        items = data.get("items")

        print(data)
        
        combination = Combination.objects.create(
            user_name=user_name,
            menu_name=menu_name,
            items=items
        )
        combination.save()

        return JsonResponse({"status": "success", "message": "조합이 성공적으로 저장되었습니다!"})
    return JsonResponse({"status": "fail", "message": "잘못된 요청입니다."})

위와 같이 .models에서 Combination을 불러와 create를 사용하여 새로운 필드를 추가하고, save 함수를 통해 db에 저장하면 끝!!

Django - 장고에 대해서 탐구를 해보자..!

오쟝 — Wed, 30 Oct 2024 20:03:57 +0900

저는 vs code에서 프로젝트를 진행하기 때문에 vs code 기준으로 설명해 보겠습니다!!

먼저! 가상환경을 설치해 주어야 합니다!!

python -m venv 가상환경이름

그 다음!

가상환경을 실행시켜 줍니다!!

이때 사용하는 명령어는

가상환경이름/Scripts/Activate

가상환경 폴더의 Scripts 파일 속의 Activate 함수를 실행시킨다는 의미입니다!

다음으로는 장고 프로젝트를 생성해야 합니다!

mkdir 프로젝트 폴더 이름

cd 프로젝트 폴더 이름

django-admin startproject 프로젝트 이름

python manage.py makemigrations
python manage.py migrate

까지 하면 장고 프로젝트를 위한 초기 세팅 완료!

실행시킬 때 코드는

python manage.py runserver

입니다~!!

여기까지는 장고 프로젝트 세팅 방법이었고 이제 주요 개념에 대해서 이해해 봅시다!

먼저 startproject를 통해 만든 폴더에는 크게 4가지의 파일이 있습니다!

- View : 사용자의 요청을 처리하여 적절한 응답을 반환하는 부분

- Model : 데이터베이스 구조를 정의하는 부분

- Template : HTML과 같은 정적 파일로 사용자가 볼 화면을 구성

- URL : 특정 URL이 어떤 View와 연결되는지 설정하는 부분

CS 1주차 - Database

오쟝 — Mon, 14 Oct 2024 21:12:02 +0900

Key란?

키는 검색, 정렬 시 튜플을 구분할 수 있는 기준이 되는 속성

1. Candidate Key (후보키)
튜플을 유일하게 식별하기 위해 사용하는 속성들
유일성, 최소성이라는 조건을 만족
* 최소성 : 하나의 키로만 튜플을 찾아냄

2. Primary Key (기본키)
후보키 중 선택한 주요 키
Null이나 중복된 값은 될 수 없음

3. Alternate Key (대체키 = 보조키)
후보키 중 기본키를 제외한 나머지 키

4. Super Key (슈퍼키)
유일성은 만족, 최소성은 불만족
* 학생을 찾을 때, 나이와 생일을 사용해 찾는다면 최소성은 불만족

5. Foreign key (외래키)
데이터가 일관될 수 있도록 돕는 역할
보통 두 개 이상의 DB를 연결할 때 사용하는 키

JOIN

A 테이블			B 테이블
이름	개수	종	이름	종
사과	5	과일	고양이	동물
딸기	8	과일	고슴도치	동물
포도	3	과일	돼지	동물
고양이	2	동물	강아지	동물

1. INNER JOIN (교집합)
중복된 값만 보여줌

고양이

동물

2. LEFT OUTER JOIN
왼쪽 테이블과 오른쪽 테이블 중 중복된 왼쪽 테이블만 보여줌

고양이

동물

3. RIGHT OUTER JOIN
오른쪽 테이블과 왼쪽 테이블 중 중복된 오른쪽 테이블만 보여줌

고양이

동물

4. FULL OUTER JOIN (합집합)
왼쪽 테이블과 오른쪽 테이블의 모든 데이터를 검색함

1	사과	5
2	딸기	8
3	포도	3
4	고양이	2	동물
5	고슴도치		동물
6	돼지		동물
7	강아지		동물

5. CROSS JOIN
왼쪽 테이블과 오른쪽 테이블의 모든 경우의 수 표현

A 테이블 튜플 4개
B 테이블 튜플 4개
=> 16개의 경우의 수 표현

6. SELF JOIN
자기자신과 자기자신을 조인 = 하나의 테이블을 여러번 복사에서 조인

INJECTION이란?

INJECTION은 악의적인 사용자가 보안상의 취약점을 이용해 임의의 SQL문을 주입해 실행되게 하여 데이터 베이스가 정상적으로 작동하지 않도록 하는 행위

공격 방법

1. 논리적 오류

2. 데이터 노출

방어 방법

1. input값을 받을 떄, 특수문자 여부 검사하기

2. SQL 서버 오류 발생 시 발생하는 에러 메시지 숨기기 -> 데이터 노출 공격을 막기 위해

3. preparestatement 구문 사용

SQL VS NoSQL

SQL이란?

관계형 데이터를 저장

정해진 데이터 스키마에 따라서 테이블에 저장 -> 정해진 스키마에 맞지 않는 값은 추가가 불가능
관계를 통해 여러 테이블에 분산
데이터의 중복을 피하기 위해서 관계를 사용

=> 관계를 맺고 있고 자주 변경되는 데이터를 저장하는 경우, 변경될 여지가 없고 정확한 스키마와 데이터가 중요한 경우

NoSQL이란?

비관계형 데이터를 저장

다른 구조의 데이터 추가 가능
SQL처럼 여러 테이블에 나누어 담지 않고 하나의 컬렉션에 담음
데이터의 중복 위험이 있기 때문에 조인을 자주 사용하지 않고 잘 변경되지 않는 데이터일 시 효율적

=> 정확한 데이터 구조를 알 수 없거나 변경/확장 될 수 있는 경우, 데이터 변경이 자주 없는 경우, 데이터 베이스를 수평적으로 확장해야하는 경우

장점

SQL	NoSQL
스키마 덕분에 데이터가 일관성을 가짐	스키마가 없어 유연하고 언제든 조정 가능
데이터를 중복 없이 딱 한 번만 저장	어플리케이션이 필요로 하는 형식으로 저장해 빠름
	수직/수평 확장이 가능해 어플리케이션의 모든 읽기/쓰기 처리

단점

SQL	NoSQL
데이터 스키마를 사전에 계획하고 알려야 해 덜 유연함	유연성으로 데이터 구조 결정을 미룰 수 있음
관계가 정의되어 있어 복잡한 조인문을 사용해야 할 수 있음	데이터 중복으로 인해 주기적인 업데이트가 필요함
보통 수직적 확장만 가능	데이터 중복으로 인해 수정시 모든 컬렉션에서 수정

** 수직적 확장? 수평적 확장?

수직적 확장 : 단순히 데이터 베이스 서버의 성능을 향상시키는 것

수평적 확장 : 더 많은 서버가 추가되고 데이터 베이스가 전체적으로 분산

정규화

데이터의 중복을 줄이고 무결성을 향상시키는 역할 + 테이블 구성을 논리적이고 직관적이게, 확장을 용이하게!

제 1 정규화

테이블의 컬럼이 원자값을 가지도록 테이블을 분해하는 것

이름	반
오지은	3반, 4반
추다율	1반, 2반
안민선	2반
배주연	4반

이런 테이블이 있을 때

오지은과 추다율은 반이 여러 개이기 때문에 제 1 정규화에 대해서 불만족

제 1 정규화를 진행하게 되면

이름	반
오지은	3반,
오지은	4반
추다율	1반
추다율	2반
안민선	2반
배주연	4반

제 2 정규화

제 1 정규화를 진행한 테이블에 대해 기본키의 부분집합이 결정자가 되지 않게 테이블을 관리하는 것

중복데이터로 인해 학생번호나 강좌이름 단독으로 성적을 알 수 없음

학생번호와 강좌이름을 합친 기본키로만 성적을 알 수 있음

이때 강의실은 강좌이름에 종속되어 있음

이렇게 기본키 중에 특정 컬럼에만 종속된 컬럼이 존재할 경우 제 2 정규화에 맞지 않음

따라서 테이블을 이와 같이 관리하게 되면 학생번호와 강좌이름이 성적을 결정하고, 강좌이름이 강의실을 결정하는 형태가 되게 됨

따라서 특정 컬럼에 종속된 컬럼이 존재하지 않기 때문에 제 2 정규화에 위배되지 않음

제 3 정규화

제 2 정규화를 진행한 테이블에 대해 이행적 종속을 없애도록 테이블을 분해하는 것

** 이행적 종속 : A -> B이고, B -> C일 때, A -> C가 성립하는 것

이런 테이블이 있을 때 학생번호는 강좌이름을 결정, 강좌이름은 수강료를 결정

만약 학생이 강좌를 바꾸게 되었을 때 이행적 종속에 의해 수강료가 2만원이 되기 때문에 다시 변경하는 번거로움을 해결하기 위해 제 3 정규화 사용

이상현상 (Anomaly)

테이블을 설계할 때 잘못 설계하여 데이터를 삽입, 삭제, 수정할 때 생기는 논리적 오류

1. 삽입 이상 (Insertion Anomaly)

자료를 삽입할 때 의도치 않은 자료까지 삽입해야만 자료를 테이블에 추가가 가능한 현상

2. 갱신 이상 (Update Anomaly)

중복된 데이터 중 일부만 수정되어 데이터 모순이 일어나는 현상

3. 삭제 이상 (Deletion Anomaly)

어떤 정보를 삭제하면 의도치 않게 다른 정보까지 삭제 되어버리는 현상

:: 이상현상을 해결하기 위해 제 1, 2, 3 정규화를 진행

인덱스

추가적인 저장 공간을 활용하여 테이블의 검색 속도를 향상시키기 위한 자료구조

인덱스를 사용하게 되면 SELECT, UPDATE, DELETE 문의 성능도 향상되는데 이는 레코드를 전체 스캔하지 않기 때문이다!

장점

테이블 조회 속도를 줄이고, 성능을 향상시킬 수 있다
시스템의 부하를 줄일 수 있다

단점

한 페이지를 동시에 수정할 수 있는 병행성이 줄어든다
인덱스된 필드의 데이터를 업데이트하거나 새로운 레코드를 추가할 시 성능이 떨어진다
데이터가 자주 변경되는 경우 인덱스를 재작성 해야하기 때문에 성능이 떨어진다

인덱스를 사용하면 좋은 경우 -> 평소에는 레코드를 전체 스캔해서 데이터를 찾는 경우

WHERE 절이 자주 사용되는 column
외래키가 사용되는 column
JOIN에 자주 사용되는 column

인덱스를 사용하면 좋지 않은 경우

데이터의 중복이 많은 경우
DML이 자주 일어나는 column -> 데이터가 새로 추가, 수정 또는 삭제 되면서 인덱스를 재작성 해야하기 때문에 성능 저하

** DML : 데이터 조작어 (SELECT, INSERT, DELETE, UPDATE 등 데이터를 어떻게 활용할 지 정해주는 명령어)

인덱스의 자료구조

1. 해시 테이블 - 키를 해싱하여 저장하는 방식

만약 등호(==) 연산이 자주 사용될 경우 인덱스의 자료구조로 적합하지만, 부등호 연산이 자주 사용되는 경우에는 적합하지 않음

: 키 값이 하나라도 틀려지면 새로운 키를 만들어 내기 때문에

2. B+Tree - 값은 리프노드에만 저장되어 있는 구조

리프노드끼리는 연결 리스트로 연결되어 있어 부등호 연산에 유리

3. B-Tree - 이진 트리와 유사하지만 자식의 수가 N개

자료구조에 대한 내용은 다음 포스트에서 정리!

트랜잭션

데이터베이스의 상태를 변화시키기 위해 수행하는 작업 단위

특징

원자성 : 트랜잭션이 데이터베이스 전체에 반영되거나, 아예 반영되지 말아야 한다
일관성 : 트랜잭션의 작업 결과는 항상 일정해야 한다
독립성 : 둘 이상의 트랜잭션이 동시에 실행될 때, 각 트랜잭션은 서로의 연산에 영향을 주지 말아야 한다
지속성 : 트랜잭션이 성공적으로 마무리 되었을 때, 이 결과는 영구적으로 반영되어야 한다

- commit : 트랜잭션 하나가 성공적으로 끝났을 때 이를 알리기 위해 사용하는 연산

- rollback : 트랜잭션의 처리가 비정상적으로 끝나 원자성이 깨진 경우

트랜잭션 관리를 위한 DBMS 전략!

** DBMS : 데이터베이스를 관리하고 운영하는 소프트웨어

1. UNDO - 어떠한 이유로 트랜잭션이 정상적으로 종료될 수 없을 때, 트랜잭션이 변경한 페이지를 원상복구하는 작업

수정된 페이지들이 버퍼 교체 알고리즘에 의해 디스크에 출력될 수도 있음 -> 버퍼 교체는 트랜잭션과 무관하게 버퍼 상태에 따라 결정

STEAL : 수정된 페이지를 언제든지 디스크에 쓸 수 있는 정책 -> 작업 도중 틀린 작업이 있어도 계속 저장
¬STEAL : 수정된 페이지를 최소한 트랜잭션 종료시점까지는 버퍼에 유지하는 정책 -> 작업이 완료된 후에 저장

2. REDO - commit한 트랜잭션의 수정을 재반영하는 복구 작업

FORCE: 수정했던 모든 페이지를 트랜잭션 커밋 시점에 디스크에 반영하는 정책 -> 작업이 끝나자마자 바로 저장
¬FORCE: 수정했던 페이지를 트랜잭션 커밋 시점에 디스크에 반영하지 않는 정책 -> 작업이 끝나도 시간이 지난 후 저장

DBMS 구조

1. 외부 단계 - 사용자와 데이터베이스 연결하는 단계

사용자가 데이터에 접근할 때 사용하는 인터페이스

사용자가 직접적으로 다루는 SQL 질의나 API를 통해 DB에 접근하는 영역
실제 데이터가 저장된 방식(내부 구조)은 전혀 신경 쓰지 않게 추상화된 단계

2. 개념 단계 - 데이터 전체를 관리하고 설계하는 단계

데이터베이스 전체의 논리적 설계 관리

테이블, 열, 데이터 타입, 제약조건 등을 설계

ERD로 테이블을 설계하거나, 테이블 간 관계를 정의하는 단계
데이터 모델링에서 이 단계가 매우 중요하며, 실제 물리적인 저장 방식과는 독립적

3. 내부 단계 - 데이터를 실제로 저장하고 관리하는 단계

데이터를 실제로 디스크에 저장하고 관리하는 단계

데이터 저장 구조, 페이지 관리, 캐싱, 버퍼 관리 등 성능 최적화에 필요한 기술이 여기에 포함

데이터가 어떻게 저장되고, 어떻게 읽어올지 결정하는 단계로 성능에 가장 중요한 역할

물리적 저장 방식이나 인덱스 설계, 파티셔닝, 샤딩 등 DB 최적화 작업

트랜잭션 격리 수준

여러 트랜잭션이 동시에 처리될 때, 특정 트랜잭션이 다른 트랜잭션에서 수정중인 데이터를 볼 수 있는 허용 여부 결정

READ UNCOMMIT - SELECT문이 실행되는 동안 해당 데이터에 Shared Lock이 걸리지 않음

트랜잭션 A, B가 실행될 때 트랜잭션 B가 commit되기 이전 update된 데이터를 읽을 수 있음

다른 사용자는 트랜잭션이 아직 처리중이거나 commit되지 않아도 읽는 것이 허용됨

READ COMMIT - SELECT문이 실행되는 동안 해당 데이터에 Shared Lock이 걸림

트랜잭션 A에서 update된 내용을 다른 트랜잭션이 바로 읽을 수는 없음

트랜잭션 A가 커밋되었지만 트랜잭션 B가 아직 커밋되지 않은 경우, 다시 조회하면 반영이 됨

다른 사용자는 트랜잭션이 아직 처리중이면 대기해야함

REPETABLE READ - 트랜잭션이 완료되기 전까지 SELECT문이 사용하는 모든 데이터에 Shared Lock이 걸림

트랜잭션이 범위 내에서 조회한 데이터에 대해서는 일관성 유지

다른 사용자는 트랜잭션 영역에 해당되는 데이터에 대해서 수정 불가능

SERIALIZABLE - 트랜잭션이 완료되기 전까지 SELECT문이 사용하는 모든 데이터에 Shared Lock이 걸림

다른 사용자는 트랜잭션 영역에 해당되는 데이터에 대해서 수정 및 입력 불가능

동시성이 증가하면 무결성이 감소하고, 동시성이 감소하면 무결성이 증가하기 때문에 선택시 고려해야함

낮은 단계의 격리 단계를 사용하게 되면 생기는 문제

Dirty Read - 커밋되지 않은 수정 중인 데이터를 다른 트랜잭션에서 읽을 수 있게 하면 발생하는 현상 (READ UNCOMMIT LEVEL)

Non-Repeatable Read - 한 트랜잭션에서 같은 쿼리를 두 번 이상 반복 할 때, 다른 트랜잭션이 사이에서 값을 수정 또는 삭제하면 쿼리의 결과가 다르게 나오는 현상 (READ COMMIT LEVEL)

Phantom Read - 한 트랜잭션이 일정 범위의 레코드를 두 번 이상 읽었을 때, 첫번째 쿼리에서 읽은 값이 두 번째 쿼리에서도 나오는 현상 (REPEATABLE READ LEVEL)

저장 프로시저

쿼리문의 집합으로, 어떤 동작을 여러 쿼리를 통해 일괄적으로 처리할 때 사용

장점

- 성능 및 캐시 : 최초 실행 시 캐시에 저장이 되며, 이후 사용시 캐시에서 받아오기 때문에 성능이 향상

- 유지보수 : 작업 변경 시 프로시저 내부만 수정을 하면 됨

- 보안 강화 : 프로시저 내에서 참조중인 테이블의 접근을 막을 수 있음

- 네트워크 부하 감소 : SQL문이 아닌 프로시저에 매개변수만 담아서 전달하기 때문에 트래픽 감소

프로시저 예시

SELECT * FROM USER_TABLE WHERE NAME = "오지은"

이런 SQL 구문이 있다고 가정했을 때, 이를 프로시저로 만들면

CREATE PROC SELECT_BY_NAME @Name VARCHAR(10)
AS SELECT * FROM USER_TABLE WHERE NAME = @Name

형식이 되게 됨

이후 프로시저를 사용하게 되면

EXEC SELECT_BY_NAME '오지은'

과 같이 사용할 수 있음

Redis

key, value 구조의 비관계형 데이터를 저장하고 관리하기 위한 DBMS

보통 데이터베이스는 SSD에 저장해서 사용하지만, redis는 RAM에 저장하여 사용하기 때문에 속도가 매우 빠름

SSD 저장의 장점은 물리 디스크에 직접 저장하기 때문에 서버에 문제가 생겨 다운되더라도 데이터 손실이 없지만 사용자가 증가하게 되면 느려질 수 있음

RAM 저장의 장점은 디스크 스캐닝이 없어 매우 빠르지만 서버에 문제가 생겨 다운되게 되면 데이터가 날라감

그래서!

백업 과정

- snapshot : 특정 시점을 설정하고 디스크에 백업

- AOF : 쿼리들을 저장해두고 서버가 다운되면 재실행해서 다시 만들어 놓는 것

redis value에 들어갈 수 있는 값

- String

- Set (String의 집합)

- Sorted Set

- Hash

- List

** 캐시 : 자주 사용하는 데이터를 미리 복사해두는 임시 장소

프로그래머스 - 구명보트 (탐욕법)

오쟝 — Mon, 10 Jun 2024 20:59:08 +0900

이 문제는 '탐욕법'을 사용해야 합니다!

탐욕법이란 현재 상황에서 가장 좋은 선택을 하는 것을 말합니다. 탐욕법은 이미 알고리즘이 있기 때문에 알고리즘을 기반으로 코드를 작성해 보았습니다!

function solution(people, limit) {
    let answer = 0; 
    let sortedPeople = people.sort((a, b) => a - b) 

    while (sortedPeople.length !==0) { 
        if (sortedPeople[0] + sortedPeople[sortedPeople.length-1] <= limit) { 
            answer++ 
            sortedPeople.shift();
            sortedPeople.pop();
        } else {
            answer++
            sortedPeople.pop();  
        }
  }
    
  return answer; 
}

코드 설명!!

1. 탐욕법을 하기 위해서는 오름차순 정렬을 해야하기 때문에 sort()를 사용해 people 배열을 오름차순 정렬을 해줍니다.

2. sortedPeople 배열이 0이 아닐 때까지 -> 만약 조건이 맞는다면 sortedPeople 배열의 요소를 하나씩 제거해 줄 예정!

3. 조건

- 만약 sortedPeople 배열의 0번째 요소와 마지막 요소의 합이 limit보다 작다면 answer을 더해주고 더했을 때 참인 수를 지우기 위해 shift()와 pop()을 사용한다!

- 그게 아니라면 맨 마지막 값은 혼자서 limit을 채우기 때문에 pop()을 해줍니다!

4. 이 과정을 반복하게 되면 sortedPeople 배열의 원소가 남지 않게 되고 결과값 answer를 리턴해주면 됩니다~!!

예제 - people = [70, 50, 80, 50], limit = 100, sortedPeople = [50, 50, 70, 80]

1회 반복 - 50 + 80 <= 100 -> false => answer = 1, sortedPeople = [50, 50, 70]

2회 반복 - 50 + 70 <= 100 -> false => answer = 2, sortedPeople = [50, 50]

3회 반복 - 50 + 50 <= 100 -> true => answer = 3, sortedPeople = []

--- 반복 종료 ---

이 문제는 탐욕법을 모른다면 어렵겠습니다! 이 문제를 통해 탐욕법을 알았으니 다음 문제도 수월하게 풀 수 있을 것 같습니다!!!

알고리즘 공부는 끝이 없다!!! 앞으로도 계속 꾸준히 하다보면 언젠가는 알고리즘을 마스터할 수 있다!! 화이팅~~ (●ˇ∀ˇ●)

MAGIC CARD

오쟝 — Thu, 21 Mar 2024 21:30:41 +0900

매직카드! 마술 같지만 사실 코딩과 관련이 있다는 사실~!

DS 시간에 배운 알고리즘 표현법을 사용해 코드를 짜는 방법을 생각해봅시다!

1. 사용자로부터 몇 개의 숫자에서 고를 것인지를 n에다가 입력받습니다!

2. log 함수를 사용해 몇 번의 반복이 필요한지를 계산하고, 배열을 선언해줍니다.

3. log만큼 반복합니다.

4. 1, 2, 4, 8...을 2진수로 표현하면 (1), (10), (100), (1000)과 같이 규칙이 존재합니다. 이 규칙을 바탕으로 & 연산자를 사용해 1부터 n까지 수를 비교해 & 연산 결과가 수와 같다면 출력합니다.

5. 출력한 수에 생각한 숫자가 있다면 y를, 없다면 n를 입력받아 배열에 참일 경우 1을, 거짓을 경우 0을 입력받습니다.

6. 반복문이 종료된 후 배열의 이진수를 계산해 출력해줍니다.

import java.util.Scanner;

class MagicCard {
	public static void main(String args[]){
    	Scanner sc = new Scanner(System.in);
        
        System.out.print("원하는 숫자를 입력해 주세요 > 1~");
        int num = sc.nextInt();
        int logNum = (int)(Math.log(num)/Math.log(2)) + 1; // log를 사용해 2의 몇 승인지 계산
        int arrNum[] = new int[logNum];
        
        System.out.println("매직카드로 맞출 숫자를 생각해 주세요");
        
        int k = 1, cnt = 0, res = 0;
        for(int i = 0; i<logNum; i++){
        	System.out.println((i+1)+"번째 카드");
            for(int j = 1; j<=num; j++){
            	if((k&j) == k) {
            		System.out.print(j + "\t");
                    cnt++;
                    if(cnt%4 == 0) System.out.println();
            	}                
            }
            
            System.out.println();
            System.out.print("생각하신 숫자가 있나요? (y/n) ");
            String answer = sc.next();
            
            if(answer.equals("y")) arrNum[i] = 1;
            else arrNum[i] = 0;
            
            cnt = 0;
            k *= 2;
        }
        
        k = 1;
        
        for(int i = 0; i<arrNum.length; i++){
        	if(arrNum[i] == 1) res += k;
            k *= 2;
        }
        
        System.out.println("생각하신 숫자는 " + res + "입니다");
    }
}

- & 연산자는 2진수가 둘 다 1일 때만 1이 됩니다.

예를 들어 24의 2진수는 (0b011000), 19의 2진수는 (0b010011)입니다.

011000

010011에 & 연산자를 사용하게 되면 010000이 나오게 됩니다.

매직카드는 생각한 수가 19라면 19를 2의 0승이 모두 1인 수부터 2의 4승이 모두 1인 수까지 보여주면서 19의 2진수를 알아내는 원리입니다.

해설을 하고 나니 생각보다 간단한 코드 같습니다!

그럼 20000!~

프로그래머스 - 짝지어 제거하기

오쟝 — Mon, 11 Mar 2024 19:01:04 +0900

처음에 생각한 방법은 함수를 따로 빼 중복 확인을 하고, 중복 제거를 위해 splice를 사용하는 방법이었습니다.

그렇게 짠 코드는

function solution(s)
{
    return check(s).length == 0 ? 1 : 0
}

function check(s){
    let str = s.split('')
    for(let i = 0; i<str.length; i++){
        if(str[i] === str[i + 1]) {
            str.splice(i, 2)
            i = -1
        }
    }
    return str
}

i를 -1로 준 이유는 1로 주면 i++ 때문에 0부터가 아닌 1부터 배열이 돌기 때문이었습니다.

이 코드의 문제는 -1로 돌아감으로써 불필요한 반복이 늘어났습니다. 따라서 효율성 테스트를 통과하지 못 했습니다. 그래서 생각한 방법은

stack을 사용하는 방법입니다.

stack은 LIFO (Last In First Out)의 형태입니다. 따라서 나중에 넣은 데이터가 먼저 나오게 됩니다.

function solution(s)
{
    const stack = []
    for(let i = 0; i<s.length; i++){
        if(!stack.length || stack[stack.length - 1] !== s[i]) stack.push(s[i])
        else stack.pop()
    }
    return stack.length ? 0 : 1
}

stack이 비어있거나 stack 안의 마지막 값이 s[i]과 다르면 stack에 s[i] 값을 넣어줍니다. 만약 stack에 값이 들어있고, stack 안의 마지막 값과 s[i]이 같다면 stack의 마지막 값을 제거해줍니다. (중복 제거)

이 과정을 통해 마지막 stack의 길이를 확인해 만약 stack에 값이 들어있다면 짝지어 제거하기가 실패했기 때문에 0을, 값이 들어있지 않다면 성공했기 때문에 1을 리턴해줍니다.

오늘의 코테는 여기서 마무리~

그럼 20000~

프로그래머스 - 숫자 문자열과 영단어

오쟝 — Sun, 10 Mar 2024 18:57:45 +0900

이 문제와 비슷한 유형의 문제를 풀어본 적이 있어 쉽게 풀었습니다.

먼저 숫자 문자열 배열을 하나 선언해준 후 문자열에 배열 요소가 포함되어 있다면 바꾸어 주는 방식으로 풀어봤습니다.

class Solution {
    public int solution(String s) {
        String strArr[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
        for(int i = 0; i<strArr.length; i++) s = s.replace(strArr[i], Integer.toString(i));
        return Integer.parseInt(s);
    }
}

strArr의 길이만큼 반복하면서 s 문자열의 숫자 문자열들을 바꿔주었습니다. return 값이 int이기 때문에 마지막에 parseInt를 사용해 문자열을 숫자로 바꿔주는 센스~~

같은 방법을 사용해 js로도 풀어보았습니다.

function solution(s) {
    var alphabet = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]
    alphabet.forEach((val, idx) => s = s.replaceAll(val, idx))
    return +s;
}

js는 forEach를 사용해 한 번에 요소와 인덱스를 받았고, 처음에 replace를 사용해 문제가 틀렸었는데 js는 자바와 다르게 replace를 쓰게 되면 하나의 요소에 한해 replace를 해주기 때문에 replaceAll을 사용해야 합니다. 문자열을 숫자로 바꾸는 방법은 여러가지가 있는데 그 중 '+문자열'을 사용해 봤습니다. 다른 방법으로는 Number()과 parseInt()가 있습니다.

오늘의 코테는 20000~

프로그래머스 - 추억 점수

오쟝 — Fri, 8 Mar 2024 19:53:59 +0900

photo 배열 안에 인물이 들어있는지 확인하기 위해서 name 배열 indexOf를 사용하였고, 만약 있다면 name 배열의 인덱스를 yearning 배열에 맞추면 되기 때문에 yearning의 인덱스를 name.indexOf()를 주었습니다.

function solution(name, yearning, photo) {
    var answer = new Array(photo.length).fill(0);
    for(let i = 0; i<photo.length; i++){
        for(person of photo[i]){
            if(name.indexOf(person) > -1) answer[i] += yearning[name.indexOf(person)]; 
        }
    }
    return answer;
}

결과는 정답!

다른 분의 코드를 보니까 map을 사용한 것도 있던데 저는 아직 map을 완벽하게 이해하지는 못 했기 때문에 다음 번에 map에 대한 지식이 더 늘면 리뷰해보도록 하겠습니다.

그럼 20000~

프로그래머스 - 문자열 다루기 기본

오쟝 — Thu, 7 Mar 2024 18:36:53 +0900

문자열의 길이는 간단하게 비교할 수 있지만 문자열이 전부 숫자로 이루어져 있는지는 어떻게 할 지 고민을 했습니다.. 그러던 중 정규식을 사용하면 어떨까? 라는 생각이 들었습니다.

* 정규식은 정해진 패턴과 일치하는 문자열을 찾을 때 사용하는 것입니다.

저는 숫자인지를 확인하는 정규식을 사용했습니다.

^[0-9]*$

제가 사용한 정규식입니다. 이것을 한 번 해석해보겠습니다!

^는 시작에 포함되는지 $는 끝에 포함되는지를 의미합니다!

[]는 괄호 사이에 있는 문자를 포함한다는 의미, 0-9는 0부터 9까지, *은 없거나 있거나 입니다!

정규식을 사용해 작성한 코드는

class Solution {
    public boolean solution(String s) {
        return (s.length() == 4 || s.length() == 6) && s.matches("^[0-9]*$");
    }
}

입니다!

결과는 정답!!

문제를 푼 후 다른 분의 코드도 살펴보았습니다.

가장 상단에 있는 코드를 한 번 보겠습니다.

class Solution {
  public boolean solution(String s) {
      if(s.length() == 4 || s.length() == 6){
          try{
              int x = Integer.parseInt(s);
              return true;
          } catch(NumberFormatException e){
              return false;
          }
      }
      else return false;
  }
}

s의 길이가 4 또는 6일경우 try ~ catch문을 사용해 예외를 처리했습니다.

여기서 try는 예외가 발생할 수도 있는 구문을 적고, catch는 예외가 발생했을 때 처리할 내용을 적어줍니다.

만약 문자열이 숫자로만 이루어져 있지 않다면 NumberFormatException 예외가 발생하고 예외 발생시 false를 리턴, 예외가 발생하지 않으면 true를 리턴하는 방법으로 문제를 해결했습니다!

오늘은 저와 다른 분 코드 모두 만족스러워서 따로 코멘트는 달지 않겠습니다!

그럼 20000~