본문 바로가기
1-3. 코딩테스트(2025년 OPEN 예정)/PCCP(코딩전문역량인증)

[PCCP] 코딩테스트 소개 및 기본 문법

by cogito21_cpp 2024. 12. 14.
반응형

1. 특징

 

2. C Language

1. 자료형

- 자료형: bool/char/short/int/long long/float/double

- 자료형 확인: sizeof(변수)

- 형 변환: (자료형) 변수

더보기 
bool b1 = true;
char c1 = 'a';
int i1 = 10;
long long l1 = 1000;
float f1 = 10.0f;
double d1 = 10.0;

printf("bool: %d\n", b1);
printf("char: %c\n", c1);
printf("int: %d\n", i1);
printf("long long: %lld\n", l1);
printf("float: %f\n", l1);
printf("double: %lf\n", l1);

 

2. 연산자

- 산술연산

 

- 비교연산

 

- 비트연산

 

- 논리연산

 

3. 제어문

- 조건문

 

- 반복문

 

- continue, break

 

4. 배열

 

5. 문자열

 

6. 함수

 

7. 포인터

 

 

8. 구조체

 

9. 열거형

 

- 변수: int var = val;

- 연산자: 산술, 비교, 논리, 비트, 삼항

- 조건문: if(조건){...}else if(조건){...}else{...}, switch(조건){case val: ... break; ... default: ... break;}

- 반복문: do{}while(조건);, while(조건){}, for(초기화;조건;증감){...}, continue, break

- 함수: int func(int arg1, ...){ ... return val;}

- 배열: int arr[size][size]

- 포인터와 참조: *, &

- 문자열: \0(NULL)

- 구조체: struct, typedef

- 열거체: enum

- 입출력: printf, scanf, gets

- 전처리기/매크로: #include<헤더파일.h> #define X 5

- 주요라이브러리: strcmp, strcpy, atoi, atof, floor, ceil, sqrt 

3. C++

1. 자료형

- 자료형: bool/char/short/int/long long/float/double/auto
- 정수형: short, int(4), long long(8)

- 실수형: float(4), double(8)

- 유효소수점 자리수는 float는 7자리, double은 15자리

- auto: 변수의 타입을 자동으로 추론

- 변수 메모리 크기 확인: sizeof(변수). Byte 크기로 반환

- 형 변환: static_cast<자료형>(변수)

더보기 
// 변수 선언 및 초기화
int i = 10;
long long l = 1000;
float f = 10.3f;
double d = 10.5;
auto a = 42;  // int로 추론

std::cout << f << std::endl;

// 형변환
int a = 66;
float b = 5.1f;

std::cout << (a + b) << std::endl; // 암시적 형변환
std::cout << static_cast<int>(a + b) << std::endl;  // 명시적 형변환
std::cout << static_cast<char>(a + b) << std::endl; // 명시적 형변환

2. 연산자

- 부호/증감연산: 부호, 전위증감, 후위증감

더보기 
int i = 10;

// 부호 연산자
std::cout << +i << std::endl;
std::cout << -i << std::endl;

// 전위 증감 연산자
std::cout << ++i << std::endl;
std::cout << i << std::endl;

std::cout << --i << std::endl;
std::cout << i << std::endl;

// 후위 증감 연산자
std::cout << i++ << std::endl;
std::cout << i << std::endl;

std::cout << i-- << std::endl;
std::cout << i << std::endl;

- 산술연산: 덧셈, 뺄셈, 곱셈, 나눗셈, 모듈러연산

더보기 
// 정수형 사칙연산
std::cout << 10 + 4 << std::endl; // 덧셈
std::cout << 10 - 4 << std::endl; // 뺄셈
std::cout << 10 * 4 << std::endl; // 곱셈
std::cout << 10 / 4 << std::endl; // 나눗셈
std::cout << 10 % 4 << std::endl; // 모듈러연산

// 실수형 사칙연산
std::cout << 10.0 + 4.3 << std::endl; // 덧셈
std::cout << 10.0 - 4.3 << std::endl; // 뺄셈
std::cout << 10.0 * 4.3 << std::endl; // 곱셈
std::cout << 10.0 / 4.3 << std::endl; // 나눗셈
std::cout << 10.0 % 4.3 << std::endl; // 모듈러연산

- 비교연산

더보기 
std::cout << (1 == 1) << std::endl; // 같은지
std::cout << (1 != 2) << std::endl; // 같지않은지
std::cout << (2 < 2) << std::endl; // 왼쪽보다 크다
std::cout << (2 <= 2) << std::endl; // 왼쪽보다 크거나 같다
std::cout << (3 > 3) << std::endl; // 왼쪽보다 작다
std::cout << (3 >= 3) << std::endl; // 왼쪽보다 작거나 같다

- 비트연산: 

더보기 
int a = 8;
int b = 4;

std::cout << (a & b) << std::endl; // AND
std::cout << (a | b) << std::endl; // OR
std::cout << (a ^ b) << std::endl; // XOR
std::cout << (~a) << std::endl; // NOT
std::cout << (a << 1) << std::endl; // LEFT SHIFT(2의 제곱수로 곱한 것과 동일)
std::cout << (a >> 1) << std::endl; // RIGHT SHIFT(2의 제곱수로 나눈 것과 동일)

- 논리연산

더보기 
std::cout << (true && true) << std::endl; // AND
std::cout << (true | false) << std::endl; // OR
std::cout << (!true) << std::endl; // NOT

 

 

3. 제어문

- 조건문

더보기 
// if문
if (조건문) {
    std::cout << "true" << std::endl;
}

// if-else문
if (조건문) {
    코드
} else {
    코드
}

// if-else if-else문
if (조건문) {
    코드
} else if (조건문) {
    코드
} else {
    코드
}

// switch문
switch (변수) {
    case 값:
    case 값:
        코드
        break;
    case 값:
        코드
        break;
    default:
        break;
}

- 반복문

더보기 
// while문
int i = 0;
while (i < 10) {
    std::cout << i << " ";
    ++i;
}

// do-while문(무조건 1회 실행)
int i = 0;
do {
    std::cout << i << " ";
    ++i;
} while(i < 10);

// for문
for (int i = 0; i < 10; ++i) {
    std::cout << i << " ";
}

// ranged-for문(배열이나 컨테이너의 원소 순회)
for (const auto& i : vec) {
    std::cout << i << " ";
}

#include <vector>

std::vector<int> v = {1, 3, 5};

for (const auto& i: v) {
    std::cout << i << " ";
}

- continue, break

더보기 
i = 0;

while (i < 10) {
    if (i >= 5) {
        break;
    }

    std::cout << i << " ";
    ++i;
}
std::cout << std::endl;

int j = 0;
while (j < 10) {
    if (i <= 5) {
        continue;
    }
    
    std::cout << j << " ";    
    ++j;
}

 

4. 배열

- 정적 배열

더보기 
// 배열 선언 및 초기화
int a1[5];
int a2[3] = {1, 3, 5};

// 값 변경
a2[1] = 10;

// 값 확인
std::cout << a2[1] << std::endl;

- 동적 배열

더보기 
// 동적 배열 선언 및 초기화
int* arr1 = new int[5];   // 쓰레기값으로 초기화
int* arr2 = new int[5](); // 0으로 초기화
int* arr3 = new int[5]{1,2,3,4,5}; // 초기화리스트로 초기화(C++11부터 사용 가능)

// 값 변경
arr1[1] = 10;

// 값 확인
std::cout << arr1[1] << std::endl;

delete[] arr1;
delete[] arr2;

 

5. 문자열

- C언어 배열을 이용 혹은 string 자료형 이용

- 문자열: string.find(찾는 문자열, 탐색 시작 위치)

- 문자열 추가: string += "문자열"

- 문자열 수정: replace(시작위치, 바꿀 문자열 길이, "문자열")

더보기 
#include <string>

// 문자열 선언 및 초기화
char str1[6] = {'H', 'e', 'l', 'l', 'o' ,'\n'};  // c-style 선언 및 초기화
string str2; // 빈 문자열
string str3 = "Hello World!"; // 문자열 초기화
string str4(str3); // 문자열 복사
string str5(str2, 0, 5); // 문자열 부분 복사
string str6(10, '*'); // 반복된 문자열 초기화

// 문자열 찾기: O(N)
size_t pos1 = str3.find("Hello", 0);  //없는 경우 string::npos 반환
std::cout << pos1 << std::endl;

// 값 추가
str3 += "Fin";

// 값 수정
str3[4] = "x";
str3.replace(시작위치, 문자개수, 대체문자열);  // O(N)

// 값 삭제

 

6. 포인터 && 참조

- NULL: (void*)0 의미

- nullptr: 빈 포인터값 의미

- 상수 참조(Reference): 

 

7. 함수

- 함수 정의, 호출

더보기 
// 함수 정의
int add(int num1, int num2) {
    int result = num1 + num2;
    return result;
}

// 함수 호출
int res = add(3, 7);

- call by value: 함수의 인수로 값을 전달할 때 값을 복사

- call by address(포인터): 실 인수값 변경. 주소값을 저달 받은 변수의 주소와 실제 변수의 주소값이 다름

- call by reference(참조): 실 인수값 변경. 변수명과 동일하게 사용 가능(추가적 문법 불필요)

더보기 
void modify1(int val) {
    val = 10;
    std::cout << "주소: " << &val << std::endl;  // val 주소
    std::cout << "값: " << val << std::endl;    // val 값
}

void modify2(int& val) {
    val = 10;
    std::cout << "val 주소: " << &val << std::endl;
    std::cout << "val 값: " << val << std::endl;
}

int main(int argc, char* argv) {
    int val = 5;
    std::cout << "val 주소: " << &val << std::endl;   // val 주소
    std::cout << "val 값: " << val << std::endl;     // val 값
    
    modify1(val);  // call by value 
    std::cout << "값 변경확인: " << val << std::endl; // 값 변경 확인
    
    modify2(val);
    std::cout << "값 변경확인: " << val << std::endl; // 값 변경 확인
}

 

8. 구조체

 

9. 열거형

 

10. 클래스

 

11. STL

- STL은 C++에서 제공하는 템플릿 기반의 표준 라이브러리. 함수나 클래스를 구현할 때 여러 타입에 동작할 수 있도록 함

- Container(데이터를 담는 공간), Algorithm(데이터를 처리하고 제어), Iterator(컨체이너에 접근 및 순회시 사용)

- container: vector, map, set, unordered_map, unordered_set, stack, queue, priority_queue

- iterator: 컨테이너 종류에 무관하게 원소들을 순회하고 접근. 순방향 반복자(begin(), end()), 역방향 반복자(rbegin(), rend())

- vector: 데이터를 순차적으로 저장. 가변 길이 배열

더보기 
#include <vector>

// 1차원 벡터 선언 및 초기화
std::vector<int> vec1;
std::vector<int> vec2 = {1, 2, 3, 4, 5};
std::vector<int> vec3(4, 3); // 크기 4, 3으로 초기화
std::vector<int> vec4(v3);

// 벡터의 원소 변경
vec[2] = 10;

// 벡터의 값 확인
vec[0];    // O(1)

// 벡터 삽입
vec.push_back(val);  // O(N)
vec.insert(v.begin(), 10);  // O(N)

// 벡터 삭제
vec.pop_back();  // O(1)
vec.erase(v.begin()); // O(N)

// 벡터 원소 순회
for (const auto& v: vec) {
    std::cout << v << " ";
}

for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " " << std::endl;
}

for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
    std::cout << *it << " ";
}

// 탐색
auto res = find(vec.rbegin(), vec.rend(), val);
if (res != vec.rend()) {
    std::cout << "Found: " << *res << std::endl;
} else {
    std::cout << "Not Found" << std::endl;
}

// 2차원 벡터 선언 및 초기화
vector<vector<int>> v1;
vector<vector<int>> v2(3, vector<int>(4));    // 행은 3, 열은 4
vector<vector<int>> v3(4, vector<int>(3, 0)); // 행은 4, 열은 3, 초기값은 0
vector<vector<int>> v4 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

- map: 키와 값을 쌍(entry)으로 갖는 컨테이너. 쌍은 std::pair 타입. 내부는 균형 이진 트리로 구성

더보기 
#include <map>

// 맵 선언 및 초기화
std::map<string, double> m1;
std::map<string, int> m2 = {{"a", 1}, {"b", 2}, {"c", 3}};


// 삽입
m2["d"] = 4;  // O(logN), 키갑 없는 경우 삽입
m2.insert(make_pair(key, val));  // O(logN)
m2.insert({key, val}});         // O(logN)

// 삭제
m2.erase(key); // O(logN)

auto it = m2.find(key);
if (it != m2.end()) {
    m2.erase(it);     // O(1)
}

// 값 수정
m2["d"] = 10; // O(logN)

// 값 확인
m2[key];       // O(logN), 키가 없는 경우 0
m2.find(key);  // O(logN)


// 맵 원소 순회
for (const auto& i : m) {
    std::cout << i.first << ":" << i.second << " ";
}

for (auto it = m.begin(); it != m.end(); ++it) {
    std::cout << it->first << ": " << it->second << " ";
}

// 탐색
auto res = m.find("b");
if (res != m.end()) {
    std::cout << "Found: " << res->first << " -> " << res->second << std::endl;
} else {
    std::cout << "Not Found" << std::endl;
}

- set: 중복을 허용하지 않고 저장된 데이터를 정렬하는 컨테이너. 균형 이진 트리로 구성

더보기 
#include <set>

// 셋 선언 및 초기화
std::set<int> s1; // 비어있는 셋 선언
std::set<int> s2 = {1, 3, 2, 5};
std::set<int> s3(s2);

// 셋 삽입
s2.insert(10); // O(logN)

// 셋 삭제
s2.erase(2); // O(logN)

auto it = s2.find(1);
if (it != s.end()) {
    s.erase(it);
}

// 셋 원소 순회
for (const auto& i : s2) {
    std::cout << i << " ";
}

// 탐색
auto it = s2.find(3); // O(logN)

if (it != s2.end()) {
    std::cout << "Found: " << *it << std::endl;
} else {
    std::cout << "Not Found" << std::endl;
}

- unordered_map: 해시 기반. 정렬 X. 삽입, 삭제, 탐색 시간복잡도 O(1), 최악의 경우 O(N)

더보기 
#include <unordered_map>

// 정렬되지 않은 맵 초기화
unordered_map<string, int> um;

// 삽입
um[key] = val;

// 삭제

// 맵 순회
for (const auto& p : um) {
    std::cout << p.first << ": " << p.second << std::endl;
}

- unordered_set: 해시 기반. 정렬 X. 삽입, 삭제, 탐색 시간복잡도 O(1), 최악의 경우 O(N)

더보기 
#include <unordered_set>

// 정렬되지 않은 셋 선언 및 초기화
unordered_set<int> us;

// 삽입
us.insert(val);

// 삭제


// 순회
for (int n : us) {
    std::cout << n << " ";
}

- algorithm: count(), sort(), next_permutation(), unique(), binary_search(), max_element(), min_element()

- count(시작반복자, 끝반복자, 탐색할값): 컨테이너 내에서 특정 값이 나타나는 횟수를 셈. O(N)

더보기 
#include <algorithm>
#include <vector>


std::vector<int> vec = {1, 4, 3, 6, 22, 5, 4, 6};

int res = count(vec.begin(), vec.end(), 4);

std::cout << res << std::endl;

- sort(시작반복자, 끝반복자, 비교함수): 컨테이너를 정렬하는 함수. O(NlogN)

더보기 
#include <algorithm>
#include <vector>

std::vector<int> vec = {1, 5, 4, 3, 2};

sort(vec.begin(), vec.end());      // 오름차순 정렬
sort(vec.rbegin(), vec.rend());    // 내림차순 정렬

struct Point {
    int x, y;

    Point(int x, int y) : x(x), y(y) {}
}

bool compare(const Point& a, const Point& b) {
    if (a.x == b.x){
        return a.y < b.y;
    }
    return a.x < b.x;
}

std::vector<Point> points = {{3, 4}, {1, 2}, {3, 1}, {2, 5}};

sort(vecp.begin(), vecp.end(), compare);      // 사용자 정의 정렬

for (const Point& p : points) {
    std::cout << "(" << p.x << ", " << p.y << ") ";
}

- next_permutation(시작반복자, 끝반복자): 가능한 모든 순열을 생성. 데이터가 사전순으로 정렬된 상태. 가능한 순열이 있다면 true, 없다면 false 반환. O(N*N!)

더보기 
#include <algorithm>
#include <vector>

std::vector<int> v = {1, 2, 3};

do {
    for (int i : v) {
        std::cout << i << " ";
    }
} while (next_permutation(v.begin(), v.end()));

- unique(시작반복자, 끝반복자): 컨테이너 내 중복되는 원소들을 뒤로 밀어내고 중복되지 않은 원소들만 남겨 새로운 범위의 끝 반복자 반환. O(N)

더보기 
#include <algorithm>
#include <vector>

std::vector<int> v = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5};

auto newEnd = unique(v.begin(), b.end());

for (auto it = v.begin(); it != newEnd; ++it) {
    std::cout << *it << " ";
}

- binary_search(시작반복자, 끝반복자, 찾을값): 컨테이너에서 주어진 범위 내 원소에 이진 탐색을 수행합니다. 원소가 있으면 true, 없으면 false 반환. O(N)

더보기 
#include <algorithm>
#include <vector>

std::vector<int> v = {1, 2, 3, 4, 5};

std::cout << binary_search(v.begin(), v.end(), 3) << std::endl;

- max_element(시작반복자, 끝반복자), min_element(시작반복자, 끝반복자): 컨테이너 내에서 최댓값, 최솟값의 위치 반환. O(N)

더보기 
#include <algorithm>

std::vector<int> v = {1, 3, 5, 7, 2, 4, 6};

auto maxIt = max_element(v.begin(), v.end());
auto minIt = min_element(v.begin(), v.end());

std::cout << *maxIt << std::endl;
std::cout << *minIt << std::endl;

 

4. C#

 

 

 

5. Java

1. Primitive Type

- 정수형: int, long

- 실수형: float, double

더보기 
// 변수 선언 및 초기화
int i = 10;
long l = 1E+5;
float f = 10.5f;
double d = 10 / 3.0;

System.out.println(i);

2. Reference Type

- Primitive Type에 비해 속도가 느림

- 정수형: Integer, Long

- 실수형: Float, Double

더보기 
// 래퍼런스 타입
Integer I = 10;
Long L = 140;
Float F = 10.5f;
Double D = 10/6.0;

System.out.println(I);

3. 연산자

- 사칙연산: 덧셈, 뺄셈, 곱셈, 나눗셈, 모듈러연산

더보기 
// 정수형 사칙연산
System.out.println(14 + 3); // 덧셈
System.out.println(14 - 3); // 뺄셈
System.out.println(14 * 3); // 곱셈
System.out.println(14 / 3); // 나눗셈(소수점 버림)
System.out.println(14 % 3); // 나머지연산(소수점 버림)

// 실수형 사칙연산
System.out.println(2.4 + 3.9); // 덧셈
System.out.println(2.4 - 3.9); // 뺄셈
System.out.println(2.4 * 3.9); // 곱셈
System.out.println(10.0 / 3.9); // 나눗셈
System.out.println(10.0 % 3.9); // 나머지연산(표현과정 오차 발생)

- 부동소수점 연산시 epsilon(오차) 주의. == 대신 조건문 사용

더보기 
double epsilon = 1E-5;

// 부동소수점 수 오차 검사
if (Math.abs((0.1+0.2) - 0.3) < epsilon) {
    // 코드
} else {
    // 코드
}

- 비교연산: 같다, 같지않다, 크다, 크거나 같다, 작다, 작거나 같다

더보기 
// 비교 연산자
System.out.println(1 == 1);  // 같은지
System.out.println(1 != 4);  // 같지 않은지
System.out.println(1 > 5);  // 왼쪽이 더 큰지
System.out.println(1 >= 6);  // 왼쪽이 더 크거나 같은지
System.out.println(1 < 7);  // 오른쪽이 더 큰지
System.out.println(3 <= 8);  // 오른쪽이 더 크거가 같은지

- 비트연산

더보기 
// 비트 연산
int a = 8;
int b = 4;

System.out.println(a & b);  // AND
System.out.println(a | b);  // OR
System.out.println(a ^ b);  // XOR
System.out.println(~a);     // NOT
System.out.println(a << 1); // LEFT SHIFT(2의 제곱수로 곱한 것과 동인)
System.out.println(a >> 1); // RIGHT SHIFT(2의 제곱수로 나눈 것과 동일)

- 논리연산

더보기 
// 논리 연산
System.out.println(true && false); // AND
System.out.println(true || false); // OR
System.out.println(!true); // NOT

4. 제어문

- 조건문

 

-반복문

더보기 
// while문

// for문
for (int i = 1; i <= 100; ++i) {
    System.out.println(i);
}

 

5. 배열

- 데이터의 개수가 정해져 있을때 사용

- 배열의 인덱스로 특정 원소 접근/변경: O(1)

더보기 
import java.util.Arrays;

// 배열 선언 및 초기화
int[] array1 = {1, 2, 3, 4, 5};
int[] array2 = new int[] {1, 2, 3, 4, 5};
int[] array3 = new int[5];

// 값 변경
array3[0] = 10;

// 값 확인
System.out.println(Arrays.toString(array3));

 

6. 문자열

- 문자들을 배열 형태로 저장한 immutable 객체

- String

+) System.identityHashCode(변수): 객체의 식별값 반환

더보기 
// 문자열 선언 및 초기화(immutable 객체)
String string = "Hello, ";

// 문자열 추가(기존 객체 수정이 아닌 새로운 객체 반환)
string += "Java!";

// 문자열 수정(기존 객체 수정)
string.replace("Hello", "Hi");

// 문자열 삭제

- StringBuilder, StringBuffer: mutable 객체. 값 변경시 String보다 효율적

- 멀티스레드환경에서 StringBuffer는 Thread-Safe가 존재. StringBuilder는 Thread-Safe가 없어 미세하게 빠름

더보기 
// StringBuilder 생성
StringBuilder s = new StringBuilder();

// 문자열 추가
s.append(val);
s.insert(idx, val);

// 문자 삭제
s.deleteCharAt(4);

 

7. Method

- 메서드는 클래스 내부 정의 함수

더보기 
// 메서드 정의
public static int add(int param1, int param2) {
    int result = param1 + param2;
    return result;
}

// 메서드 호출
int res = add(3, 7);

 

8. 람다식(=익명함수)

- 람다식은 Java 1.8버전 이후 추가.

- 람다식은 코드에서 한 번 실행 혹은 함수를 다른 함수의 인수로 전달시 사용

- 정렬시 단순 뺄셈의 경우 오버플로우의 위험이 있으므로 compare() 메서드 사용 추천

더보기 
private static class Node {
    int dest, cost;
    
    public Node(int dest, int cost) {
        this.dest = dest;
        this.cost = cost;
    }
}

public static void main(String[] args) {
    Node[] nodes = new Node[5];
    nodes[0] = new Node(1, 10);
    nodes[1] = new Node(2, 20);
    nodes[2] = new Node(3, 15);
    nodes[3] = new Node(4, 5);
    nodes[4] = new Node(1, 25);
    Arrays.sort(nodes, (o1, o2) -> Integer.compare(o1.cost, o2.cost));
    
    Array.sort(nodes, new Comparator<Node>() {
        @Override
        public int compare(Node o1, Node o2) {
            return Integer.compare(o1.cost, o2.cost);
        }
    });   
}

 

9. Collection Framework

- 여러 값을 저장하여 처리하는 표준화 클래스 집합. 자료구조

- ArrayList, Stack, Queue, ArrayDeque, HashMap 등이 존재

- Generic: 빌드레벨에서 타입 체크. 타입 체크와 형변환. 레퍼런스 타입 사용

더보기 
ArrayList<Integer> arrayList = new ArrayList<>();
Stack<Long> stack = new Stack<>();
Queue<Float> queue = new Queue<>();
ArrayDeque<Double> arrayDeque = new ArrayDeque<>();

- List

더보기 
import java.util.List;

// 리스트 선언 및 초기화
List<Integer> list = new ArrayList<>();

// 삽입
list.add(val);

// 값 확인
list.get(idx);


// 비어있는지 확인
list.isEmpty()

// 크기 확인
list.size();

// +) 기능 구현
list.stream().mapToInt(i -> i).sum();

 

- ArrayList: 리스트. 크기가 가변적. 맨뒤에 값 삽입시 O(1). 데이터 삭제 및 중간 삽입시 O(N)

더보기 
// 배열 선언 및 초기화
ArrayList<Integer> list = new ArrayList<>();


// 삽입
list.add(10);

// 삭제


// 값 확인
list[idx];
list.get(idx);

// 정렬
ArrayList.sort(배열, 익명함수)

- Stack

 

- Queue

 

- ArrayDeque

 

- HashMap: 키와 값 쌍을 저장하는 해시테이블

더보기 
// 해시맵 선언 및 초기화
HashMap<String, Integer> map = new HashMap<>();

// 삽입 및 수정
map.put(key, val);

// 삭제
map.remove(key);

// 값 확인
map.get(key);

// 키 값 존재 여부
map.containsKey(key);

- HashSet: 키만 저장

 

6. Python

1. 빌트인 데이터 타입

2. 컬렉션 데이터 타입

3. 함수

4. 구현

7. JavaScript

1. Primitive Type: 숫자(정수, 실수, 무한), 문자열, 불리언

- typeof: 변수의 타입 확인

- 메모리 할당시 값 자체를 저장

- 숫자(number), 문자열(string), boolean, bigint, null, undefined, object, symbol

더보기 
let a = 10;     // 변수 선언 및 초기화
const b = 10;   // 상수 선언 및 초기화

console.log(typeof a);
console.log(typeof b);
console.log(typeof Infinity);
console.log(typeof NaN);

- 불리언, bigint, undefined, null

- boolean: true, false

- bigint: 큰 수를 다룰 때 사용

- undefined: 변수가 초기화 되지 않을 때

- null: 의도적으로 비어있다는 표현. 초기화

- NaN: not a number

더보기 
console.log(typeof true);
console.log(1000000000000000000000 - 123456);
console.log(1000000000000000000000n - BigInt(123456));
console.log(1000000000000000000000n - 123456);  // 에러 발생

2. Reference Type

- object와 함수 타입만 존재

- 배열은 object. 배열 변수에는 메모리 주소가 저장

- 메모리 할당시 힙 메모리 저장

- Object

더보기 
// 오브젝트 타입 선언
const obj = {
    name : "Lee",
    age : 30,
    major : "electronic"
};

console.log(obj.name);
console.log(obj['age']);  // 키가 문자일 경우 따옴표로 감싸야함

// 요소 추가
obj.birth = 20241230

// 요소 삭제
delete obj.birth

 

3. 연산자

- 산술연산: 예외일 경우 Infinity 혹은 NaN이 출력

더보기 
let a = 10;
let b = 20;

console.log(a + b);  // 덧셈
console.log(a - b);  // 뺄셈
console.log(a * b);  // 곱셈
console.log(a / b);  // 나눗셈
console.log(a % b);  // 나머지
console.log(-a);     // 부호 변환

console.log(Math.abs(-a));     // 절댓값
console.log(Math.ceil(10.3);   // 올림
console.log(Math.floor(10.3);  // 내림
console.log(Math.round(10.3);  // 반올림
console.log(Math.trunc(-3.4);  // 버림
console.log(Math.pow(10,2));   // 제곱

console.log(13 / 0);          // Infinity
console.log(13 % 0);          // NaN
console.log(13 / "string");   // NaN
console.log(13 % "string");   // NaN
console.log(13 / null);       // Infinity
console.log(13 % null);       // NaN
console.log(13 / undefined);  // NaN
console.log(13 % undefined);  // NaN

- 부동소수점 연산시 epsilon(오차) 주의. == 대신 조건문 사용

더보기 
console.log(Number.EPSILON);

let a = 0.1 + 0.1 + 0.1;
let b = 0.3;

if (Math.abs(a - b) < Number.EPSILON) {
    // 코드
} else {
    // 코드
}

- 비교연산

더보기 
console.log(1 == 1); // 같은지
console.log(1 == 1); // 같지않은지
console.log(3 < 3); // 왼쪽 값보다 큰지
console.log(3 <= 3); // 왼쪽 값보다 크거나 같은지
console.log(3 > 3); // 오른쪽 값보다 큰지
console.log(3 >= 3); // 오른쪽 값보다 크거나 같은지

- 비트연산: and, or, xor, not, left shift, right shift

더보기 
let a = 8;
let b = 4;

console.log(a & b); // AND
console.log(a | b); // OR
console.log(a ^ b); // XOR
console.log(~a);   // NOT
console.log(a << 1);     // LEFT SHIFT(2의 제곱수로 곱한 것과 동일)
console.log(a >> 1);     // RIGHT SHIFT(2의 제곱수로 나눈 것과 동일)

- 논리연산: and, or, not

더보기 
let a = 10;
let b = 5;

console.log(a && b);  // AND, 5
console.log(a || b);  // OR, 10
console.log(!a);      // NOT, false

4. 배열

더보기 
// 배열 선언 및 초기화
const arr = [1, 2, 3, 4];

// 요소 추가
arr.push(5);

// 요소 삭제
const val = arr.pop();

// 배열 길이
console.log(arr.length);

 

5. 문자열

- string으로 저장. 작은따옴표, 큰따옴표, 백틱으로 표현

더보기 
let a = "Hello, ";
let b = "JavaScript!";

console.log(a + b);    // 문자열 합치기
console.log(a + 10);   // 문자열로 변환
console.log(a + true); // 문자열로 변환

// 문자열 메서드
const c = "Welcome, JavaScript!";

console.log(a.length);     // 문자열 길이
console.log(a.split(",")); // 문자열 나누기
console.log(a.startsWith("Welcome"));   // 특정 문자열로 시작하는지 확인
console.log(a.endsWith("JavaScript!")); // 특정 문자열로 끝나는지 확인
console.log(a.includes("come,")) // 특정 문자열 포함 여부 확인
console.log(a.indexOf("JavaScript!")); // 특정 문자열의 시작 위치 확인 
console.log(a.lastIndexOf("p"));       // 특정 문자열의 마지막 위치

console.log(a.replace("Welcome", "Hello")); // 특정 문자열을 다른 문자열로 대체
console.log(a.toUpperCase()); // 대문자로 변환
console.log(a.toLowerCase()); // 소문자로 변환
console.log(a.trim());  // 양쪽 공백 제거
console.log(a.concat(" FIN")); // 문자열 연결

 

6. 함수

- 함수는 일급 객체이자 타입. 변수에 할당 가능

- 익명함수: 이름이 없는 함수

더보기 
// 함수 정의(일반적 함수, 화살표 함수)
function func_name(param1, param2) {
    // 코드
    return result;
}

const f = (param1, param2) => {
    // 코드
    return result;
};

// 함수 호출
const result = fun_name(val, val);

// 익명 함수
(a, b) => {
    return a + b;
};

 

7. 구조 분해 할당

- ES6에 추가된 문법으로 배열이나 객체에서 요소를 분해하는 기능

더보기 
// 배열 구조 분해 할당(인덱스 순서대로 진행)
const arr = ["apple", "banana", "cup"];
const [first, second] = arr;  // first(apple), second(banana)

// 객체 구조 분해 할다
const obj = {name : "lee", birth: 20241230}
const {name, birth} = obj;
const {name:auth} = obj;   // 변수이름 auth에 할당

 

8. 값 교환

더보기 
let a = 10;
let b = 5;
[a, b] = [b, a];

 

9. 비구조화 할당

- 객체를 인수로 전달할 때 필요한 것만 꺼내서 사용

더보기 
const Person = ({name, age, address}) => {
    return {
        name: `${name}: {age}`,
        address,
    };
};

const p = Person({
    name: 'Lee',
    age: 30,
    address: 'Seoul,
    country: 'Korea'
});

 

10. 스프레드 연산자

- 배열이나 객체 여러 개를 하나로 합쳐야할 경우 사용

더보기 
// 배열 병합
const odd = [1, 3, 5, 7, 9];
const even = [2, 4, 6, 8, 10];
const num = [...odd, ...even];


// 객체 병합
const person = {
    name: 'Lee';
    age: 30
};

const address = {
    country: 'Rebulic of Korea',
    city: 'Seoul'
};

const merge = {...person, ...address};

 

11. 배열 내 중복 요소 제거

- 스프레드 연산자와 Set 객체 이용

더보기 
const people = ['LEE', 'PARK', 'KIM', 'KIM', 'LEE'];
const unique = [...new Set(people)];

 

12. 조건문 대체

- &&, ||를 이용하여 조건문 대체

더보기 
// flag가 true일 때 func() 실행
flag && func();

// 객체 병합에 이용
cosnt func = () => {
    return {
        name: "Lee",
        ...address && {address: 'Seoul')
    }
};

console.log(func(true));
console.log(func(false));

 

 

 

 

반응형

'1-3. 코딩테스트(2025년 OPEN 예정) > PCCP(코딩전문역량인증)' 카테고리의 다른 글

[PCCP] 자료구조 - 링크드리스트  (0) 2024.12.14
[PCCP] 자료구조 - 배열  (0) 2024.12.14
[PCCP] 라이브러리  (0) 2024.12.14
[PCCP] 환경설정  (0) 2024.12.14
[PCCP] 소개 및 준비  (3) 2024.12.14

관련글

티스토리툴바