DailyStudyNote

JSX(JavaScript XML)

나갱 — Fri, 21 Feb 2025 00:04:12 +0900

JSX(JavaScript XML)

[ JSX(JavaScript XML) 란 ]

JSX(Java Script XML) 은 React 에서 사용하는 문법으로, HTML 과 유사한 구조를 JavaScript 코드 안에서 작성할 수 있도록 해준다. JSX 는 React.createElement()를 보다 직관적으로 작성할 수 있도록 변환되는 JavaScript 문법이다.

[ React 컴포넌트와 JSX의 차이 ]

▪️ React 컴포넌트는 JSX를 반환하는 함수이다. JSX(JavaScript XML) 은 JavaScript 코드 안에서 HTML과 유사한 문법을 사용하게 해주며 React 컴포넌트는 이러한 JSX를 반환하여 UI를 구성한다.

▪️ JSX 는 단순히 Element 를 표현하는 문법일 뿐 실제로는 React.createElement 함수를 통해 Element 객체로 변환된다. 따라서, JSX 없이도 React를 사용할 수 있다.

▪️ React 컴포넌트는 독립적인 단위로 구성되며, 각 컴포넌트는 자신의 상태와 속성을 관리한다. 이러한 컴포넌트는 재사용이 가능하며, 복잡한 UI를 구성하는 데 매우 유용하다.

[ JSX 기본 문법 ]

① JSX를 사용하면 컴포넌트에서 HTML과 유사한 태그를 작성할 수 있다.

const element = <h1>Hello, JSX!</h1>;

위 코드는 내부적으로 React.createElement('h1', null, 'Hello, JSX!')로 변환된다.

const element = createElement(type, props, ...children)

// React Element
React.createElement("h1", { className: "title" }, "Hello!");

// type: <h1>
// props: {className: "title"} 
// children: "Hello!"

② 태그는 하나의 부모 요소로 감싸야한다.

JSX에서는 여러 개의 요소를 반환할 때 반드시 하나의 부모 요소로 감싸야 한다.

// 올바른 예시 1
// <div> </div> 로 감싸져있음.

function App() {
  return (
    <div>
      <h1>Title</h1>
      <p>This is a paragraph.</p>
    </div>
  );
}

// 올바른 예시 2
// <> </> 로 감싸져있음

function App() {
  return (
    <>
      <h1>Title</h1>
      <p>This is a paragraph.</p>
    </>
  );
}

// 잘못 된 예시

function App() {
  return (
    <h1>Title</h1>
    <p>This is a paragraph.</p> // 오류 발생 (두 개의 요소가 루트로 존재)
  );
}

③ JavaScript 표현 식 사용( { } )

const name = "React";
const element = <h1>Hello, {name}!</h1>;

// 배열이나 조건문도 { } 안에서 사용할 수 있다. 

const numbers = [1, 2, 3, 4, 5];
const listItems = numbers.map(num => <li key={num}>{num}</li>);

function App() {
  return <ul>{listItems}</ul>;
}

<li key={index}>에서 key={index}는 React에서 리스트를 렌더링할 때 사용하는 고유한 키 값을 배열의 인덱스로 설정한 것이다.

React에서 리스트를 렌더링할 때, 각 항목을 구분할 수 있도록 key 값을 설정해야 한다.

④ 속성(Attributes)

▪️ camelCase 사용

HTML 속성명과 다르게 JSX에서는 camelCase를 사용해야 한다.

const element = <button onClick={handleClick}>Click Me</button>;

▪️ class 대신 className

JSX에서는 class 가 아닌 className 을 사용해야한다.

const element = <div className="container">Hello, JSX!</div>;

▪️ style 속성(객체사용)

JSX에서 style 속성은 객체로 전달해야한다.

const element = <div style={{ color: "blue", fontSize: "20px" }}>Styled Text</div>;

⑤ 조건부 렌더링

JSX에서 조건문을 사용하는 방법은 여러가지가 있다.

▪️ 삼항 연산자 사용

const isLoggedIn = true;
const element = <h1>{isLoggedIn ? "Welcome!" : "Please log in"}</h1>;

▪️ && 연산자 사용

const messages = ["Hello", "React"];
const element = (
  <div>
    {messages.length > 0 && <h2>You have {messages.length} new messages.</h2>}
  </div>
);

&& 연산자는 왼쪽 조건이 true일 때만 오른쪽 값을 평가한다.

⑥ 이벤트 핸들링

JSX에서는 이벤트를 camelCase로 작성하며, 이벤트 핸들러는 함수로 전달된다.

function handleClick() {
  alert("Button clicked!");
}

const element = <button onClick={handleClick}>Click Me</button>;

⑦ 컴포넌트 사용

JSX에서 컴포넌트를 사용할 때는 대문자로 시작하는 컴포넌트명을 사용해야한다.

function Welcome(props) {
  return <h1>Hello, {props.name}!</h1>;
}

function App() {
  return (
    <div>
      <Welcome name="Alice" />
      <Welcome name="Bob" />
    </div>
  );
}

Reference

createElement – React

The library for web and native user interfaces

ko.react.dev

React 컴포넌트와 JSX의 차이점 이해하기

이 글에서는 React 컴포넌트와 JSX의 차이점을 명확히 이해하고, 이를 통해 더 나은 React 코드를 작성하는 방법을 알아봅니다. React 컴포넌트는 JSX를 반환하는 함수이며, JSX는 JavaScript 코드 안에서 H

f-lab.kr

TypeScript Introduction

나갱 — Wed, 19 Feb 2025 00:22:37 +0900

TypeScript

[ 타입스크립트(TypeScript)란 ]

TypScript 는 정적 타입 검사자 (TypeScript: A Static Type Checker) 이다. 프로그램을 실행시키지 않으면서 코드의 오류를 검출하는 것을 정적검사 라고 한다. 자바스크립트 코드가 실행(런타임) 중 오류를 발견하는 것과 달리 타입스크립트는 코드 작성(컴파일) 중 오류를 발견해 준다. 아래 예시를 참고하자 ‼️

// 자바스크립트 
// : 오류안남

let age = 25; // 숫자
age = "스물다섯"; // 문자

// 타입스크립트
// : 컴파일 오류발생 

let age : number = 25; // 숫자
age = "스물다섯"; // 컴파일 오류 발생(문자열 할당 불가능)

[ 타입스크립트(TypeScript)는 어떻게 실행될까? ]

타입스크립트를 컴파일하면 자바스크립트 코드가 만들어진다. 타입오류가 발생하고 있는 타입스크립트 코드는 컴파일 시 타입 검사를 통과할 수 없기 때문에 자바스크립트 코드로 변환되지 않아 실행할 수 없게 된다. 타입스크립트는 컴파일 결과 타입 검사를 거쳐 자바스크립트 코드로 변환되는데 이때 만약 코드에 오류가 있다면 컴파일 도중 실패하게 되므로 자바스크립트를 보다 더 안전하게 사용하기 위하여 미리 한번 코드를 검사하는 용도로 사용된다고 볼 수 있다.

✔︎ TypeScript 컴파일 과정 (.ts 코드에서 .js 코드로의 변환 )

① Parsing(구문 분석)

❶ TypeScript 코드를 읽고 AST(Abstract Syntax Tree; 코드를 트리 형태로 표현한 자료구조) 로 변환.

② Type Checking (타입 검사)

❶ AST를 기반으로 타입을 검사

❷ 타입 오류가 있으면 컴파일 실패.

③ Transformation (변환)

❶ AST에서 TypeScript의 타입 정보 제거

❷ TypeScript 고유 문법( interface, type, enum 등) 제거

④ Code Generation( JavaScript 코드 생성)

❶ AST를 기반으로 최종 JavaScript 코드 생성

[ 타입스크립트(TypeScript) 문법 ]

① 정적 타입(Static Typing)

: TypeScript는 변수를 선언할 때 타입을 지정할 수 있다.

let age: number = 25;
age = "twenty-five"; // ❌ 오류: 'string' 형식을 'number'에 할당할 수 없음

② 타입 추론(Type Inference)

: TypeScript는 명시적으로 타입을 선언하지 않아도 타입을 추론한다.

let name = "Alice"; // TypeScript는 'name'을 자동으로 'string'으로 추론
name = 10; // ❌ 오류: 'number' 형식을 'string'에 할당할 수 없음

③ 인터페이스(Interface)

: 인터페이스를 사용하여 객체의 구조를 정의할 수 있다.

interface User {
  name: string;
  age: number;
  isAdmin?: boolean; // 선택적 속성
}

const user: User = {
  name: "John",
  age: 30
};

console.log(user.name); // ✅ 정상 동작
console.log(user.isAdmin); // ✅ 선택적 속성이므로 undefined 가능

④ 제네릭(Generics)

: 제네릭을 사용하면 유연하고 재사용 가능한 코드 작성이 가능하다.

function identity<T>(arg: T): T {
  return arg;
}

console.log(identity<string>("Hello")); // ✅ "Hello"
console.log(identity<number>(123)); // ✅ 123

⑤ 유니온 타입(Union Type)

: 하나의 변수에 여러 개의 타입을 허용할 수 있다.

function printId(id: number | string) {
  console.log(`Your ID is: ${id}`);
}

printId(101); // ✅ 정상 동작
printId("abc123"); // ✅ 정상 동작
printId(true); // ❌ 오류: 'boolean'은 허용되지 않음

⑥ 타입 가드(Type Guards)

: 타입을 런타임에서 안전하게 구별할 수 있다.

function printLength(value: string | number) {
  if (typeof value === "string") {
    console.log(value.length); // ✅ 문자열일 때만 length 속성 사용 가능
  } else {
    console.log("숫자는 length 속성이 없음");
  }
}

printLength("Hello"); // ✅ 출력: 5
printLength(123); // ✅ 출력: "숫자는 length 속성이 없음"

⑦ 열거형(Enum)

: 열거형을 사용하면 명확한 값의 집합을 만들 수 있다.

(열거형을 사용하면 특정 상태값을 의미 있는 이름으로 관리할 수 있다.)

enum Status {
  Pending,
  InProgress,
  Done
}

let currentStatus: Status = Status.InProgress;
console.log(currentStatus); // ✅ 출력: 1

⑧ 클래스와 상속

: TypeScript는 객체지향 프로그래밍을 지원하며, 클래스와 상속을 사용할 수 있다.

class Animal {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  makeSound(): void {
    console.log("Some sound...");
  }
}

class Dog extends Animal {
  breed: string;

  constructor(name: string, breed: string) {
    super(name);
    this.breed = breed;
  }

  makeSound(): void {
    console.log("Woof! Woof!");
  }
}

const dog = new Dog("Buddy", "Golden Retriever");
dog.makeSound(); // ✅ "Woof! Woof!"

⑨ 타입 별칭

: 인터페이스와 비슷하지만, 유니온 타입을 포함한 다양한 타입을 정의할 수 있다.(객체, 유니온 타입, 튜플 등)

// UserRole처럼 특정 값만 가질 수 있도록 제약 가능
type UserRole = "admin" | "user" | "guest";

type User = {
  id: number,
  username: string,
  role: UserRole,
};



const user2: User = {
  id: 1,
  username: "Bob",
  role: "admin"
};

강의 실습 코드

➯ 타입스크립트 참고 강의

강의에서 사용되는 예시 실습 코드 1, 2 를 작성해 두었다.

위의 링크를 통해 강의를 확인할 수 있다.

[ TypeScript example 1 ]

// intro to pizza app


type Pizza = {
    id: number,
    name: string,
    price: number
}

type Order = {
    id: number,
    pizza: Pizza,
    status: "ordered" | "completed"
}


let cashInRegister = 100 // 계산대에 있는 현금 
let nextOrderId = 1
let nextPizzaId = 1


const menu : Pizza[] = [
    {id: nextPizzaId++, name: "Margherita", price: 8},
    {id: nextPizzaId++, name: "Pepperoni", price: 10},
    {id: nextPizzaId++, name: "Hawaiian", price: 10},
    {id: nextPizzaId++, name: "Veggie", price: 9}
]


let orderQueue : Order[] = []



function addNewPizza(pizzaObj : Omit<Pizza, "id">) : Pizza {
    const pizza : Pizza = {
        id: nextPizzaId++,
        ...pizzaObj
    }
    menu.push(pizza)
    return pizza
}

addNewPizza({name: "Chicken Bacon Ranch", price: 12})
addNewPizza({name: "BBQ Chicken", price: 12})
addNewPizza({name: "Spicy Sausage", price: 11})

console.log(menu)

function placeOrder(pizzaName: string) : Order | undefined{
    let selectedPizza = menu.find(pizzaObj => pizzaObj.name == pizzaName)
    if(!selectedPizza){
        console.error(`${pizzaName} does not exist in the menu`)
        return
    }
    cashInRegister += selectedPizza.price
    const newOrder : Order = {id: nextOrderId++, pizza: selectedPizza, status : "ordered" }
    orderQueue.push(newOrder)

    return newOrder
}


function addToArray<Type> (array: Type[], item: Type): Type[] | undefined{
    array.push(item)
    return array
}

// example usage:
addToArray<Pizza>(menu, {id: nextPizzaId++, name: "Chicken Bacon Ranch", price: 12})
addToArray<Order>(orderQueue, {id: nextOrderId++, pizza: menu[2], status: "completed"})

console.log(menu)
console.log(orderQueue)

function CompleteOrder(orderId : number) : Order | undefined {
    const order = orderQueue.find(order => order.id == orderId)
    if(!order){
        console.error(`${orderId} was not found in orderQueue`)
        return
    }
    order.status = "completed"

    return order

}


export function getPizzaDetail(identifier: string|number) : Pizza | undefined {
    if(typeof(identifier) === "string"){
        return menu.find(pizza => pizza.name.toLowerCase() === identifier.toLowerCase())
    }else if(typeof(identifier) === "number"){
        return menu.find(pizza => pizza.id === identifier)
    }else{
        throw new TypeError("parameter `identifier` must be either a string or a number")
    }
}





// placeOrder("Chicken Bacon Ranch")
// CompleteOrder(1)

// console.log("Menu", menu)
// console.log("Cash in register", cashInRegister)
// console.log("Order queue", orderQueue)



 // what we learnt
 // 01 basic, literal, and custom types
 // 02 optional properties
 // 03 unions
 // 04 type narrowing
 // 05 utility types
 // 06 generic

[ TypeScript example 2]

type UserRole = "contributor" | "member"| "admin"

type User = {
    id: number,
    username: string,
    role: UserRole

}

// type updatedUser = { // ? : means optional
//     id?: number,
//     username?: string,
//     role?: "contributor" | "member"| "admin"
// }

type updatedUser = Partial<User> // same meaning with the above codes

let userRole : UserRole = "member"


// 위에 선언한 type을 지켜줘야 함. 
// let userRole2: User = {
//     username: "exampleUser",
//     role: "guest"
// };

let nextUser = 1

const users: User[] = [
    {id: nextUser++, username: "john_doe", role: "member"},
    {id: nextUser++, username: "jane_doe", role: "admin"},
    {id: nextUser++, username: "guest_user", role: "contributor"},
    {id: nextUser++, username: "charlie_brown", role: "member"},
]


function updateUser(id: number, updates: updatedUser){
    const foundUser = users.find(user => user.id === id)
    if(!foundUser){
        console.error("USER NOT FOUND")
        return
    }

    // user object.assign to update the found user in place
    Object.assign(foundUser, updates)
}

// omit:  특정 속성만 제거한 타입을 정의
function addNewUser(newUser: Omit<User, "id" | "user">) : User {
    const user: User = {
        id: nextUser++,
        ...newUser //spreaad 
    }

    users.push(user)
    return user

}

// example usage:
addNewUser({username: "joe_schmoe", role:"member"})

// example updates:
// updateUser(1, {username: "new_john_doe"});
// updateUser(4, {role: "contributor"});

console.log(users)

// example updates



function fetchUserDetails(username: string): User{ 
    const user = users.find(user => user.username === username)
    if(!user){
        throw new Error(`user with username ${username} not found`);
    }

    return user
}



// let value : any = 1 // " type : any " means turning off typescript checking
// value = "hi"
// value.map()

// when should i use any? 
// in short: dont


// 개념정리

// utility types
// 01. like a function, they take other types in as a parameter and return a new type. with some changes made to it
// 02. built-in to typescript; perform commonly-needed modifications to existing types
// 03. use "generics" syntax using angle branckets (<>)

// what does the partial type do ?
// this modifies the type you pass in and turns all properties into optional properties

// what does the omit type do ?
// omit takes in a type AND a string(or union of strings)
// property name(s), and returns a new type with those
// properties removed


// Generics
// 01 add flecibility to existing functions, types, etc
// 02 act like function parameters, but for types
// 03 use angle blancket syntax(<>)



const gameScores = [14, 21, 33, 42 ,59]
const favoriteThings = ["raindrops on roses", "whiskers on kittens", "bright copper kettles", "warm woolean mittens"]

const voters = [{name: "Alice", age: 42}, {name:"Bob", age:77}]

function getLastItem<Type>(array: Type[]) : Type | undefined {
    return array[array.length-1]
}

console.log(getLastItem(gameScores))
console.log(getLastItem(favoriteThings))
console.log(getLastItem(voters))



let a = 258
a = "hi"

Reference

https://ts.winterlood.com/d67c7b28-c191-46ee-9bdc-2ae8643c2028

[보험 계약 법(기초)] 보험약관 교부설명의무 및 보험증권 교부의무

나갱 — Sun, 2 Jun 2024 20:25:07 +0900

보험약관,

1) 같은 위험을 대상으로 하는 수많은 보험계약을 체결하기 위하여 미리 작성한 보험계약의 내용을 이루는 정형적인 계약조항

보험약관의 성질,

보험자가 일방적으로 작성한 계약의 모형에 불과하므로, 당사자들이 이를 계약의 내용으로 하고자 하는 합의를 한 때에만 구속력을 가짐

보험증권,

보험계약이 체결되었을 때 보험자가 발급하는 계약의 증표

보험자 : 보험계약이 성립한 때에는 지체없이 보험증권을 작성하여 보험계약자에게 교부해야 함

보험계약의 당사자: 보험증권의 교부가 있는 날로부터 일정한 기간 내에 그 증권내용의 정부(옳고 그름)에 관한 이의를 할 수 있음을 약정할 수 있으나, 이 기간은 1월을 초과하지 못함

1. 보험약관 교부설명의무

◼ 보통보험약관이란 ?

" 같은 위험을 대상으로 하는 수많은 보험계약을 체결하기 위하여 미리 작성한 보험계약의 내용을 이루는 정형적 계약조항"

- 보통거래약관의 일종

- 보험계약의 일반적.보편적.표준적인 계약조항

- 특수한 보험: 보통보험약관 + 상세약정 (특별보통보험약관)

◼ 보통보험약관의 필요성

1) 보험계약내용의 정형화

- 보험계약의 성질:

다수의 가입자 대량 처리 → 정형화된 계약내용필요

2) 보험계약내용의 통일성

- 보험제도 = 법적 위험공동체를 전제로 함

- 기술적으로 가입자에 관한 위험을 종합평균 → 분산

- 법적 원칙: 모든 계약자를 동등하게 취급해야함

◼ 보통보험약관과 소비자보호

보험약관

1) 기업

- 거래와 관련된 모든 법적 관계를 약관을 통해 기업에 유리하게 형성 가능

→ 기업활동에서 발생하는 예측불가의 위험을 고객(소비자)의 불이익으로 전가할 수도 있음

- 집단 거래의 합리화

→ 법률적 수단에 의한 경제력 강화

- 개별 교섭 → 특별약관, 특약 형식(주문품적 계약)으로 약관 수정 가능

2) 고객(소비자)

- 대부분 약관의 존재를 모름

- 약관을 알아도, 내용의 이해 및 납득이 어려움

- 약관을 무조건 따를 수 밖에 없음(기성품적 계약)

❗ 약관현상의 근본적인 문제, 소비자 보호 측면에서 재고되어야 함

◼ 보험약관의 법적 성질

보험약관 구속력의 근거

- 보험계약자가 보통보험약관에 합의한 경우

계약내용으로서 당사자를 구속함

1) 보험자

- 약관을 작성하는 자

- 약관내용에 스스로 구속될 의사 있음

2) 보험계약자

- 보험사고 종류, 보험목적/기간/보험류/보험금액 등 합의

- 약관의 구체적 내용에는 대부분 관심없음

보험약관 법적 성질에 대한 학설

1) 규범설

- 보험계약: 다수계약으로서 보통보험약관에 따라 이루어짐

- 법사회학적으로,

◽ 객관적인 법과 유사함

◽ 보험계약상의 법원으로 다룸

→ 보통보험약관 구속력의 근거를 구하는 이론

2) 계약설(의사설)

- 보통보험약관,

◽ 보험자가 일방적으로 작성한 계약의 모형

◽ 약관의 구속력 주장 불가

◽ 당사자들간 합의가 있어야 구속력 가짐

→ 당사자들의 의사에서 구속력의 근거를 구하는 이론(주관주의적 이론)

→ 두 이론중 계약설이 타당함(대법원 판례)

3) 해석원칙/교부.설명의무

보험약관 해석원칙

- 객관해석원칙

- 선의성실해석원칙

- 개별약정 우선의 원칙

- 작성자불이익 원칙

보험약관의교부.설명의무(상법 제 638조의 3)

- 상법과 약관과 약관규제법과의 관계 문제

- 대법원

◽ 상법, 약관규제법 중첩 적용 → 약관 명시 설명하지 않음

◽ 보험계약자가 3월 내 취소하지 않은 경우

→ 설명하지 않은 내용은 계약내용으로 주장불가 (약관규제법 제 3조 제4항)

2. 보험증권 교부의무

◼ 보험증권

- 보험계약 체결시, 보험자가 발급하는 계약의 증표

- 보험약관(계약내용)과 별개의 것

◼ 보험자

- 보험계약 성립시, 보험증권 작성 후 교부 해야 함

- 보험계약자가 (최초)보험료 미납입 → 교부 의무 없음

◽ 보험대리상, 계속적 보험계약 중개자의 보험증권 교부권 인정(상법 제 646조의 2제 1항, 제 3항)

◽ 보험대리점, 보험설계사의 권한을 명확히 함

◼ 보험증권 교부의무 위반시 효과

보험증권

- 계약의 성립.효력에 영향을 미치지 않음

- 보험증권 교부자체에는 중요한 의미 없음

◼ 증권에 관한 이의약관의 효력

보험계약자

- 보험증권 교부일로부터 일정 기간 내(1월을 내리지 못함)에 한해, 증권내용의 정부(옳고 그름)에 관한 이의제기 약정 가능

◼ 증권의 재교부청구

보험증권을 멸실 또는 현저하게 훼손한 경우

보험계약자

- 보험자에게 증권 재교부 청구 가능

- 증권작성 비용: 보험계약자가 부담

* 법적위험공동체: 동질적 위험을 예견하는 다수가입자

[보험 계약 법(기초)] 보험 계약의 성립 및 책임 개시

나갱 — Tue, 28 May 2024 06:27:56 +0900

보험이란,

동질적 경제위험에 놓인 다수인이,

약정한 사고 발생 시 재산상의 손해를 줄이기 위해,

일정한 근거로 산출된 보험료로 위험공동체를 조성, 위험공동체를 관리하는 것이 보험회사

재해를 입은 사람에게 일정한 금액이나 정기금을 지급해

경제생활의 불안을 제거.감경 시키려는 사회적 고안물

안전을 추구하는 인간심리

합리적 이성의 무형상품

보험 계약의 성립,

1. 보험계약은 하나의 계약으로서 일방당사자의 청약과 상대방의 승낙으로 성립

2. 계약의 성립요건으로 특별한 요식행위를 요구하고 있지 않으므로, 낙성·불요식의 계약임

3. 보험료의 납입 및 보험증권의 작성여부와 상관없이 당사자 사이의 의사합치만으로 성립

낙부통지, 보험자의 책임 개시, 승낙 전 사고,

1. 상법 : 보험자가 보험계약자로부터 청약과 함께 보험료상당액의 전부 또는 일부를 지급받은 때에는 타 약정이 없을 경우 30일 내 낙부통지를 발송해야 하며, 이를 게을리 하면 승낙한 것으로 봄
2. 인보험 : 그 기간을 신체검사를 받은 날로부터 기산함
3. 다른 약정이 없으면 보험자는 최초보험료를 받은 때로부터 책임을 짐
4. 승낙 전 사고 시 예외적으로 책임을 지는 경우가 있음
(제1회 보험료를 받았으며 청약을 거절할 만한 사유가 없고, 유진단 계약일 경우는 건강진단까지 받아야 함)

1. 보험계약의 의의

◼ 보험계약이란 ?

보험계약 = 보험계약자의 청약 + 보험자의 승낙

" 당사자 일방이 약정한 보험료를 납입하고

상대방의 재산/생명/신체에 관해

불확정한 사고 발생 시, (우연성을 전제)

일정한 보험금이나 그 밖의 급여 지급을

약정함으로써 효력이 생기는 계약"

◼ 보험계약의 특성?

1) 불요식 낙성계약

- 의사표시의 합치만으로 성립(특별한 방식 필요 없음)

- 보험료의 선납입 없이도 보험계약은 유효

- 최초 보험료를 납입 해야 보험자 책임이 개시

2) 유상 쌍무계약

- 보험계약 성립 시

◾ 보험계약자: 보험료납입의무

◾ 보험자: 위험부담의무(사고발생시 보험금 지급의무)

3) 상행위

- 상법 제46조 제17호

◾ 보험을 영업적 상행위로 규정

4) 사행계약

- 사행계약:

◾ 우연한 이득을 얻는 것이 목적(도박, 복권)

◾ 그러나, 실제로 급여를 받을 수 있는지는 불확실

- 보험자(보험회사)의 보험금 지급 책임: 우연한 사고에 의존

5) 부합계약

- 계약당사자 일방의 결정에 타방이 따를 수 밖에없는 계약

- 보험:

◾ 대수의 법칙으로 성립 → 개개인과의 협상은 불가능

◾ 보험자는 미리정한 보험계약조건(약관)에 의해 보험 계약 체결

6) 계속적 계약

- 보험계약: 계약관계가 일정 기간 동안 지속됨

7) 독립계약

- 독립하여 존재하는 보험계약

- 매매.운송계약에 비용 추가하여 위험을 보장하는 것은 불가

- 위험보장자체가 별도의 계약으로 성립되어야 함

8) 선의계약(최대선의의 원칙)

- 보험계약: 당사자간의 최대 선의를 요함

2. 보험계약의 성립, 낙부통지의무, 승낙 전 사과와 책임개시

◼ 보험계약성립

1) 보험계약자의 청약을 보험자가 승낙함으로써

- 청약.승낙: 특별히 요구되는 방식은 없음

- 계약 형식:

보험 설계사의 권유 → 보험계약자가 청약서에 일정사항 기재 후 청약 → 보험자는 청약서 검토 후 승낙 여부 통지

2) 낙성. 불요식의 계약(상법 제 638조)

- 당사자 쌍방의 의사합치가 있으면 성립

- 특별한 요식행위를 요구하지 않음

3) 당사자 의사 합치만으로 성립

- 보험료 납입여부/보험증권 작성여부와 상관없음

[실제 거래계에서 보험계약 체결 시]

- 보험청약서 이용

- 보험자가 보험인수 시 서면으로 승낙 통지

- 승낙통지에 갈음하여 보험증권(증거증권, 보험계약성립과 무관) 교부

4) 계약성립 시기, 보험자책임개시 시기 구별

- 보험자 책임:

최초 보험료를 받을때로부터 개시됨(상법 제 656조)

5) 낙부통지 의무

- 민.상법상의 일반 원칙

◾ 상시 거래관계의 상인 사이의 청약(상법 제53조)이 아닌 한 당사자 승낙여부통지의무 없음

◾ 승낙통지가 없는 경우:

청약 → 효력 잃음

계약 → 성립 안됨

- 보험거래

◾ 승낙권한 없는 설계사 청약

일정요건 충족 시 승낙 없이도 보험계약 성립인정

◾ 청약과 동시에 보험료 납부

승낙전 사고 시에도 일정경우 보험보호를 받을 수 있음

- 상법

◾ 계약자가 청약과 함께 보험료 전부/일부를 수령한 때:

타 약정 없는 경우 → 30일 내 낙부통지 발송

30일 경과 → "승낙"으로 봄

인보험 → 신체검사 받은 날로부터 기산(상법 제 638조의2제 1항.제2항)

* 낙부통지의무 :

상인이 거래 관계에 있는 사람으로부터 거래와 관련된 계약의 청약을 받았을 때, 지체 없이 그에 대한 거절이나 승낙의 통지를 해야 하는 상법상의 의무.

* 상행위: 기업의 조직을 기초로 하여 수행되는 각종의 기업의 영업 활동

MDD (Model-Driven Development) 개요

나갱 — Mon, 3 Apr 2023 00:27:35 +0900

MDD (Model-Driven Development)

Model-driven development (MDD) is a format to write and implement software quickly, effectively and at minimum cost. The methodology is also known as model-driven software development (MDSD), model-driven engineering (MDE) and model-driven architecture (MDA).

The MDD approach focuses on the construction of a software model. The model is a diagram that specifies how the software system should work before the code is generated. Once the software is created, it can be tested using model-based testing (MBT) and then deployed.

Abstraction and automation are key concept of MDD.

In short, once the business model is created, the code is generated according to the business logic that created by modeling.

MDD (Model-driven Development) 란

Model-driven Development의 약자이며 모델을 생성하면 코드가 자동으로 생성되는 개발 방법 론이다. UML 모델을 Business logic 에 따라 생성하면 모델로 부터 소스코드를 자동 생성하게 된다. MDD는 성숙도에 따라서 level 2, 3로 나뉘는 데 100% 실행 가능한 소스코드를 생성할 수 있는 경우 성숙도 level 3 라고 하며 국내에서 level 3를 할 수 있는 곳은 LG CNS 이다.

소프트웨어 개발의 역사는 추상화 수준을 끌어 올리는 방식으로 발전해 왔다. 소프트웨어 개발은 코드 중심의 개발 방식에서 추상화 수준을 한 단계 끌어올린 모델 기반 개발 방식으로 변화되고 있다.

MDD (Model-driven Development) 특징

DevOn MDD는 모델로 부터 100% 실행 가능한 소스코드를 자동으로 생성한다. 즉 비즈니스 로직에 따라 생성한 UML 모델에서 자동으로 소스코드를 생성한다.
MDD 의 성숙도에 따라서 소스코드가 일부만 생성이 될 수도 있고 100% 실행가능한 소스코드가 생성될 수도 있다.
MDD는 개발 역량 중심에서 업무 역량 중심으로 변화를 주도한다.
개발 언어를 몰라도 업무를 잘 안다면 개발이 가능한 SW 개발 환경이다.
코딩 표준, 아키텍처 표준에 대한 자동 반영이 가능하다. 코딩 표준을 맞추지 않으면 코드 생성 자체가 되지 않도록 구조화 되어있기 때문에 설계 품질이 상향 평준화된다.
모델, 소스, 산출물이 항상 일치한다. 즉, 현행화가 자동화 되어있다.
업무 흐름이 다이어그램으로 표현되어 있어서 텍스트 기반의 소스코드보다 업무 흐름 파악이 용이하며, 프로그램 언어에 대한 지식이 없어도 업무 흐름 파악이 용이하다.
MSA 기반 프로젝트에도 MDD 적용이 가능하다.

MDD (Model-driven Development) 컴포넌트 기본 지식

컴포넌트 논리 아키텍처

UI > PBI > CPBI/IBI > EBI > DAO

https://wikidocs.net/130219

컴포넌트 종류

1) PBI(Process Business Interface) :

사용자에게 결과를 제공하기 위한 완전한 비즈니스 처리 흐름을 가지는 컴포넌트이다.
다른 컴포넌트를 조합하는 상호작용을 통해 설계한다.
사용자가 요청한 거래를 프레임워크 입장에서 바라보는 것이 서비스이고, 서비스를 관리하는 것이 PBI 이다.

2) CPBI(Common Process Business Interface) :

업무 내에서 공통적으로 사용하는 비즈니스 처리 흐름을 구현하기 위해 설계한다.
재 사용성을 고려하여 식별한다.
업무에서 동일한 비즈니스 처리 흐름이 반복적으로 사용될 때, 이를 공통 비즈니스로서 식별한다.
여러 비즈니스에서 공통으로 재 사용하는 프로세스를 CPBI 라고 한다.

3) EBI(Entity Business Interface) :

비즈니스 정보를 관리하는 컴포넌트이다.
비즈니스 정보를 데이터베이스에 저장하거나 수정, 삭제, 조회하는 작업을 처리한다.
시스템의 DBMS 를 핸들링하는 비즈니스 인터페이스를 EBI 라고 한다.

4) IBI 연동 컴포넌트 :

자신의 업무 기능을 타 업무에게 제공하기 위한 컴포넌트이다.
타 업무 구분의 컴포넌트 상호작용 결과는 해당 업무의 연동 비즈니스 컴포넌트를 통해서 제공 받아야 한다.
업무 도메인 간의 서비스 호출 시(기능 사용 시) 다이렉트로 호출을 할 수 없으며 IBI 연동 컴포넌트를 통해서 만 호출이 가능하다. IBI 는 프록시 같은 인터페이스 역할을 한다.
IBI 를 사용하는 경우 시스템을 물리적으로 분리하고 싶은 경우 IBI 로 되어 있기 때문에 접근 통제가 가능하게 된다. 즉 모듈 별 독립성을 높여준다. (현재는 논리적으로 만 독립이 되어 있는 경우이다. 실제로는 하나의 시스템 내에 업무 단위로 논리적으로 구분되어 있는 업무 도메인들이다.)

컴포넌트 상호 의존 관계

PBI, CPBI, EBI 는 위에서 아래로 쭉 내려가는 폭포수 모델하고 같다고 생각할 수 있다. 즉 EBI 가 PBI 를 호출하면 안되고, EBI 가 CPBI를 호출하면 안된다. CPBI 가 PBI를 호출하는 것도 안된다.
동일 레이어 간에 호출도 불가능 하다. 예를 들어, EBI 에서 EBI 호출, PBI 에서 PBI 호출은 불가능하다. 단, CPBI 는 비즈니스 재 사용이 목적이기 때문에 CPBI 만 유일하게 CPBI 간의 호출을 허용한다. PBI 간 호출은 서비스 연동만 가능하다.

Reference

https://www.youtube.com/watch?v=fY5jaSpT0Gc(MDD 소개)

https://www.youtube.com/watch?v=Q70A5lwVWF8(MDD 실습전 알면 도움되는 내용)

[이진 탐색] 파라메트릭 서치(Parametric Search)

나갱 — Sat, 12 Nov 2022 17:53:15 +0900

파라메트릭 서치(Parametric Search)

파라메트릭 서치(Parametric Search)는 최적화 문제를 결정 문제로 바꾸어 해결하는 기법이다. 결정 문제란, '예' 혹은 '아니오'로 답하는 문제를 말한다. '주어진 범위에서 원하는 조건을 만족하는 가장 알맞은 값을 찾는 문제'에 주로 파라메트릭 서치를 사용한다. 예를 들어 범위 내에서 조건을 만족하는 가장 큰 값을 찾으라는 최적화 문제라면 이진 탐색으로 결정 문제를 해결하면서 범위를 좁혀 나갈 수 있다.

* 이진 탐색 개념 참고

[알고리즘] 이진 탐색(Binary Search, 이분 탐색)

이진 탐색(Binary Search) 이진 탐색(Binary Search) 란? 정렬되어 있는 배열에서 특정한 값을 찾아내는 알고리즘이다. 배열의 중간에 있는 임의의 값을 선택하여 찾고자 하는 값 X 와 비교한다. X 가 중간

daily-progress.tistory.com

문1. 떡볶이 떡 만들기

[문제 요약]
절단기에 높이(H)를 지정하면 줄지어진 떡을 한 번에 절단한다. 높이가 H 보다 긴 떡은 H 위의 부분이 잘릴 것이고, 낮은 떡은 잘리지 않는다.

예를 들어, 높이가 19, 14, 10, 17cm인 떡이 나란히 있고 절단기 높이를 15cm 로 지정하면 자른 뒤의 떡의 높이는
15, 14, 10, 15cm가 될 것이다. 잘린 떡의 길이는 차례대로 4, 0, 0, 2cm이다. 손님은 6cm 만큼의 길이를 가져간다.

(출처) 이것이 코딩테스트다 with 파이썬

[입력 조건]
1) 첫째 줄에 떡의 개수 N과 요청한 떡의 길이 M이 주어진다. (1 <= N <= 1,000,000, 1 <= M <= 2.000,000,000)
2) 둘째 줄에는 떡의 개별 높이가 주어진다. 떡 높이의 총 합은 항상 M 이상이므로, 손님은 필요한 양만큼 떡을 사갈 수 있다. 높이는 10억 보다 적거나 같은 양의 정수 또는 0이다.

[출력 조건]
적어도 M 만큼의 떡을 집에 가져가기 위해 절단기에 설정할 수 있는 높이의 최댓값을 출력한다.

[입력 예시]
4 6
19 15 10 17

[출력 예시]
15

풀이 1.

# 2. 떡볶이 떡 만들기 

n, m = map(int, input().split())
arr = list(map(int, input().split()))

check_range = [i for i in range(1, max(arr))]
check_range.sort(reverse = True)

for i in range(len(check_range)):
  check = check_range[i]
  tteok = []
  for j in range(len(arr)):
    if arr[j] > check:
      tteok.append(arr[j]-check)

  if sum(tteok) >= m:
    print(check)
    break

입력 수가 많이 크지 않은 경우에는 위와 같은 풀이로 답을 찾아도 아무런 문제가 없다. 하지만 입력 수의 범위가 십 억대 이므로 이진 탐색 알고리즘을 생각하는 것이 보편적이다. 이진 탐색 알고리즘의 시간 복잡도는 O(logN)이다.

풀이 2. (이진 탐색)

# 떡볶이 떡 만들기
# 이진 탐색으로 문제 풀기


def binary_search(order, target, start, end):
  result = 0
  
  # 이진 탐색 수행(반복적)
  while start <= end:
    total = 0
    middle = (start + end)//2
	
    for x in order:
      # 잘랐을 때의 떡의 양 계산
      if x > middle:
        total += (x-middle)
	# 떡의 양이 부족한 경우 더 많이 자르기(왼쪽 부분 탐색)
    if total < target:
      end = middle-1
     # 떡의 양이 충분한 경우 덜 자르기(오른쪽 부분 탐색)
    else:
      result = middle
      start = middle + 1
  return result

n, m = map(int, input().split())
order = list(map(int, input().split()))

start, end = 0, max(order)

print(binary_search(order, m, start, end))

위의 문제와 같은 파라메트릭 서치 문제 유형은 이진 탐색을 재귀적으로 구현하지 않고 반복문을 이용해 구현하면 더 간결하게 풀 수 있다.

빠르게 입력 받기

이진 탐색 문제는 입력 데이터가 많거나, 탐색 범위가 매우 넓은 편이다. 예를 들어 데이터의 개수가 1,000만 개를 넘어가거나 탐색 범위의 크기가 1,000억 이상이라면 이진탐색 알고리즘을 의심해 보아야한다.

이렇게 수 많은 데이터를 입력 받을 때 input() 함수를 사용하면 동작 속도가 느려서 시간 초과로 오답 판정을 받을 수도 있다. 때문에 이처럼 입력 데이터가 많은 문제는 sys 라이브러리의 readline() 함수를 이용하면 시간 초과를 피할 수 있다. 다음 코드는 관행적으로 암기하여 사용하도록 하자.

import sys

# 하나의 문자열 데이터 입력 받기
input_data = sys.stdin.readline().rstrip()

# 입력 받은 문자열 그대로 출력
print(input_data)

# result
Hello, coding test!
Hello, Coding test!

[SW Intermediate] Array 1 - 문제풀이 위주

나갱 — Tue, 25 Oct 2022 23:41:00 +0900

Array1 - 문제풀이 위주

문1: 최빈수 구하기

# 1204. 최빈수 구하기

from collections import Counter

T = int(input())
for test_case in range(1, T + 1):
    n = int(input())

    counter_list = Counter(list(map(int, input().split())))
    max_v = max(counter_list.values())

    for k, v in counter_list.items():
        if v == max_v:
            print(f'#{test_case} {k}')
            break

풀이:

특정 자료에서 가장 여러 번 나타나는 값을 출력하는 코드이다. 주어진 특정 자료에서 각 원소의 발생 빈도를 확인하기 위하여 Collections 모듈의 Counter 을 사용하였다.

# Counter 사용 법

from collections import Counter

print(Counter(["hi", "hey", "hi", "hi", "hello", "hey"]))

# result 
Counter({'hi': 3, 'hey': 2, 'hello': 1})

문2: View

# 1206. View

T = 10
for test_case in range(1, T + 1):
    n = int(input())
    buildings = list(map(int, input().split()))
    answer = 0

    for i in range(2, len(buildings)):
        stand = buildings[i]
        right = [buildings[i-1], buildings[i-2]]
        left = []
        if i+2 < len(buildings):
            left.append(buildings[i+2])
        if i+1 < len(buildings):
            left.append(buildings[i+1])

        # 검사 오른쪽
        check = True
        if right:
            temp1 = []
            temp1.extend(right)
            temp1.append(stand)
            if max(temp1) != stand:
                continue
        if left:
            temp2 = []
            temp2.extend(left)
            temp2.append(stand)
            if max(temp2) != stand:
                continue
        max_left = 0 if len(left)==0 else max(left)
        max_right = 0 if len(right)==0 else max(right)

        answer += min(stand-max_left, stand-max_right)

    print(f'#{test_case} {answer}')

풀이:

왼쪽과 오른쪽으로 창문을 열었을 때, 양쪽 모두 거리 2 이상의 공간이 확보될 때 조망권이 확보될 경우 조망권이 확보된 세대의 수를 반환하는 코드이다. 구현문제이기 때문에 풀이가 다양하고 더 나은 풀이가 있을 거라고 생각하지만 우선 나의 접근 방식은 다음과 같다.

✔ 양 옆 두개 씩 살펴 보기
: left, right 리스트에 양 옆 두 개의 값들을 삽입한다.

1) left, right 리스트 둘 다에서 stand 값이 max value 여야 한다. (stand 는 기준 빌딩)

2) stand 값이 max value 인 경우, left, right 리스트 각각에서 stand 값을 제외 한 두 번째 max value 값을 구하여 stand 값에서 뺀다.
3) 둘 중에 작은 값이 조망 권 확보한 세대 이다.

문3: Flatten

T = 10
for test_case in range(1, T + 1):
    dump = int(input())
    arr = list(map(int, input().split()))

    for _ in range(dump):
        max_idx = arr.index(max(arr))
        min_idx = arr.index(min(arr))

        arr[max_idx] -= 1
        arr[min_idx] += 1

    print(f'#{test_case} {max(arr)-min(arr)}')

풀이:

높은 곳의 상자를 낮은 곳에 옮기는 방식으로 최고점과 최저점의 간격을 줄이는 작업을 평탄화라 한다. 평탄화 작업 횟수 만큼 수행한 후 최고점과 최저점의 차이를 출력하는 코드이다.

[SW Intermediate] Tree

나갱 — Wed, 5 Oct 2022 20:14:01 +0900

Tree

[Tree의 특징]

1) 한 개 이상의 노드로 이루어진 유한 집합

- 루트(Root): 노드 중 최상위 노드

- 나머지 노드들: n(>=0) 개의 분리 집합 T1....Tn 으로 분리 될 수 있다.

2) 이들 T1...Tn 은 각각 하나의 트리가 되며(재귀적 정의) 루트의 서브 트리(Sub Tree) 라고 한다.

[Tree의 구성 요소]

1) 노드

- 트리의 원소

2) 간선

- 노드를 연결하는 선

- 부모 노드와 자식 노드를 연결

3) 차수

- 노드에 연결된 자식 노드의 수

- 트리의 차수: 트리에 있는 노드의 차수들 중 가장 큰 값

- 단말 노드(리프노드): 차수가 0인 노드, 자식 노드가 없는 노드

이진 트리(Binary Tree)

[Binary Tree의 특징]

1) 모든 노드들이 2개의 서브 트리를 갖는 특별한 형태의 트리

2) 노드가 자식 노드를 최대 2개까지만 가질 수 있는 트리

- 왼쪽 자식 노드(left child node)

- 오른쪽 자식 노드(right child node)

3) 레벨 L 에서의 노드의 최대 개수는 2^L 개

4) 높이가 h 인 이진 트리가 가질 수 있는 노드의 최소 개수는 (h+1) 개, 최대 개수는 2^(h+1) -1 개가 된다.

포화 이진 트리

모든 레벨의 노드가 포화 상태로 차 있는 트리

1) 최대의 노드 개수인 (2^(h+1)-1)의 노드를 가진 트리

2) 루트를 1번으로 하여 2^(h+1)-1 까지 정해진 위치에 대한 노드 번호를 갖는다.

완전 이진 트리

높이가 h 이고 노드 수가 n개 일 때 Full 이진 트리의 노드 번호 1번 부터 n 번까지 빈자리가 없는 이진 트리이다.

편향 이진 트리

높이 h에 대한 최소 개수의 노드를 가지면서 한쪽 방향의 자식 노드 만을 가진 이진 트리이다.

순회

트리의 각 노드를 중복되지 않게 전부 방문(visit) 하는 것을 순회 라고 한다.

[3가지의 순회 방법]

1) 전위 순회

- VLR

- 자손 노드보다 루트 노드 먼저 방문

2) 중위 순회

- LVR

- 왼쪽 자손, 루트, 오른쪽 자손 순으로 방문

3) 후위 순회

- LRV

- 루트 노드보다 자손 노드 먼저 방문

전위 순회

1) 현재 노드 n을 방문하여 처리: V

2) 현재 노드 n의 왼쪽 서브 트리 이동: L

3) 현재 노드 n의 오른쪽 서브 트리 이동: R

def preorder_traverse(T):
	if T: # T is not None
    	visit(T) # print(T.item)
        preorder_traverse(T.left)
        preorder_traverse(T.right)

중위 순회

1) 현재 노드 n의 왼쪽 서브 트리로 이동: L

2) 현재 노드 n을 방문하여 처리: V

3) 현재 노드 n의 오른쪽 서브 트리로 이동: R

def inorder_traverse(T):
	if T:
    	inorder_traverse(T.left)
        visit(T) # print(T.item)
        inorder_traverse(T.right)

후위 순회

1) 현재 노드 n의 왼쪽 서브 트리로 이동: L

2) 현재 노드 n의 오른쪽 서브 트리로 이동: R

3) 현재 노드 n을 방문하여 처리: V

def postorder_traverse(T):
	if T:
    	postorder_traverse(T.left)
        postorder_traverse(T.right)
        visit(T) # print(T.item)

Expression Tree

List 또는 Linked List 를 이용하여 Tree 를 구현할 수 있다.

[노드 번호의 성질]

1) 노드 i 의 부모 노드 번호: i//2

2) 노드 i 의 왼쪽 자식 노드 번호: ix2

3) 노드 i의 오른쪽 자식 노드 번호: ix2+1

이진 탐색 트리(Binary Search Tree)

- 탐색 작업을 효율적으로 하기 위한 자료구조

- 모든 원소는 서로 다른 유일한 key를 가짐

- key(왼쪽 서브 트리) < key(루트 노드) < key(오른쪽 서브 트리)

- 왼쪽 서브 트리, 오른쪽 서브 트리도 이진 탐색 트리

- 중위 순회하면 오름 차순으로 정렬된 값을 얻을 수 있음

[탐색 연산]

1) 루트에서 시작

2) 탐색할 키 값 x를 루트 노드의 키 값과 비교

- 키 값 x == 루트 노드의 키 값:

원하는 원소를 찾았으므로 탐색 연산 성공

- 키 값 x < 루트 노드의 키 값:

루트 노드의 왼쪽 서브 트리에 대해 탐색 연산 수행

- 키 값 x > 루트 노드의 키 값:

루트 노드의 오른 쪽 서브 트리에 대해 탐색 연산 수행

3) 서브 트리에 대해서 순환적으로 탐색 연산을 반복

[삽입 연산]

1) 먼저 탐색 연산을 수행

- 삽입할 원소와 같은 원소가 트리에 있으면 삽입할 수 없으므로 같은 원소가 있는지 탐색하여 확인

- 탐색 시 탐색 실패가 결정되는 위치가 삽입 위치가 됨

2) 탐색 실패한 위치에 원소를 삽입

힙(Heap)

완전 이진 트리에 있는 노드 중에서 키 값이 가장 큰 노드나 가장 작은 노드를 찾기 위해서 만든 자료구조이다.

- 최대 힙(Max heap)

- 최소 힙(Min heap)

문1: subtree

from collections import defaultdict

def count_nodes(n):
    global count

    if len(tree_map[n]) == 0:
        return
    for item in tree_map[n]:
        count_nodes(item)
        count += len(tree_map[item])

T = int(input())
for test_case in range(1, T + 1):
    e, n = map(int, input().split())
    tree = list(map(int, input().split()))
    tree_map = defaultdict(list)


    for i in range(0, len(tree)-1, 2):
        tree_map[tree[i]].append(tree[i+1])
        
    # count 변수를 n과 n 자식 노드 수의 합으로 초기화 해준다.
    count = len(tree_map[n]) + 1
    count_nodes(n)

    print(f'#{test_case} {count}')

문2: 이진탐색

def make_tree(n):
    # 1~ n+1 까지 순회 하면서 위치를 찾아 넣어준다.
    # binary_search_tree: left < 현재노드 <right
    # 현재노드 : index , left : index*2, right: index*2 +1
    # 중위 순회로 구현한다.
    global number
    if n < N + 1:
        make_tree(2 * n)
        tree[n] = number
        number += 1
        make_tree(2 * n + 1)


T = int(input())

for test_case in range(1, T + 1):
    N = int(input())
    tree = [0 for _ in range(N + 1)]
    number = 1

    make_tree(1)
    print(f'#{test_case} {tree[1]} {tree[N // 2]}')

문3: 이진 힙

'''
heapify와 heappush 결과가 다를 수 있다는 점을
몰랐어서 잘못 된 풀이로 시간이 꽤 걸렸던 문제이다..

heapify는 리스트를 heap 구조로 바꿀 때 사용하는 함수인데
최소 값을 반환 하는데는 문제 없지만 heap 구조로 바꾼 상태에서 데이터를 가져와야하는 상황에서는
적합하지 않을 수 있다. 

heappush를 한 경우와 결과 값이 다를 수 있다.

'''



T = int(input())

import heapq
for test_case in range(1, T + 1):
    n = int(input())
    num_list = list(map(int, input().split()))
    heap_list = []
    sum_nums = 0
    
    for item in num_list:
        heapq.heappush(heap_list, item)
    heap_list = [0]+heap_list


    while n > 0:
        # 이진트리 부모 인덱스 = (자식노드 인덱스)//2
        n = n//2
        sum_nums += heap_list[n]

    print(f'#{test_case} {sum_nums}')

문4: 노드의 합

T = int(input())
for test_case in range(1, T + 1):
    n, m, l = map(int, input().split())
    tree_list = [0 for _ in range(n+1)]
    for _ in range(m):
        index, data = map(int, input().split())
        tree_list[index] = data
    for i in range(n, 0, -1): # n~1 까지 -1 씩 감소하며 반복
        if not tree_list[i]:
            if i*2+1 > n:
                tree_list[i] = tree_list[i*2]
                continue
            tree_list[i] = tree_list[i*2] + tree_list[i*2 + 1]
        else:
            continue
    print(f'#{test_case} {tree_list[l]}')

[SW Intermediate] Linked List - 활용

나갱 — Mon, 3 Oct 2022 17:08:28 +0900

Linked List - 활용

스택(Stack)

[스택의 원소: 리스트의 노드]

- 스택 내 순서는 연결리스트의 링크를 통해 연결됨

- push: 연결 리스트의 맨 앞에 노드 삽입

- pop: 연결 리스트의 맨 앞 노드 반환/삭제

[변수 top]

- 연결 리스트의 맨 앞 노드를 가리킴

- 초기상태: top = None

우선순위 큐(Priority Queue)

1) 우선순위 큐의 구현

- 연결리스트 이용한 우선순위 큐

2) 우선순위 큐의 기본 연산

- 삽입: enQueue

- 삭제: deQueue

[연결리스트 이용한 우선순위 큐 구현]

- 연결리스트를 이용하여 자료 저장

- 원소를 삽입하는 과정에서 리스트 내 노드의 원소들과 비교하여 적절한 위치에 노드를 삽입하는 구조

- 리스트의 가장 앞쪽에 최고 우선순위가 위치하게 됨

[배열 대비 장점]

- 메모의 삽입/삭제 연산 이후 원소의 재배치가 필요 없음

- 메모리의 효율적인 사용이 가능

문1: 숫자 추가

T = int(input())
for test_case in range(1, T + 1):
    n, m, l = map(int, input().split())
    num_list = list(map(int, input().split()))
    for _ in range(m):
        index, num = map(int, input().split())
        num_list.insert(index, num)

    print(f'#{test_case} {num_list[l]}')

문2: 수열 합치기

T = int(input())
for test_case in range(1, T + 1):
    n, m = map(int, input().split())
    # m개의 수열
    num_list = [list(map(int,input().split())) for _ in range(m)]
    new_list = num_list[0]

    for i in range(1, m):
        for index, data in enumerate(new_list):
            if data > num_list[i][0]:
                # 특정 위치에 삽입 시, 리스트의 슬라이싱을 이용할 수 있다.
                new_list[index:index] = num_list[i]
                break
            if index == len(new_list)-1:
                new_list = new_list + num_list[i]
                break
    res = []
    for item in new_list[::-1]:
        if len(res) == 10:
            break
        res.append(str(item))

    print(f'#{test_case} {" ".join(res)}')

문3: 암호

'''
조건을 다 찾아서 구현했지만,
문제에 대한 이해가 부족해서 잘못구현하느라
시간을 많이 썼던 문제이다.

Linked list 를 이용해서 구현하는 문제 파트인데..
Linked List 는 어떻게 활용해서 풀어햐 할까..?

'''

T = int(input())
for test_case in range(1, T + 1):
    n,m,k = map(int, input().split())
    num_list = list(map(int, input().split()))
    st = 0

    for _ in range(k):
        st = st + m
        if st > len(num_list):
            st -= len(num_list)
        if not st:
            num_list.insert(0, num_list[-1]+num_list[0])
        elif st == len(num_list):
            num_list.append(num_list[-1] + num_list[0])
        else:
            num_list.insert(st, num_list[st-1] + num_list[st])

    res = []
    for item in num_list[::-1]:
        if len(res)==10:
            break
        res.append(str(item))
    print(f'#{test_case} {" ".join(res)}')

문4: 수열 편집

T = int(input())
for test_case in range(1, T + 1):
    # n: 수열의 길이, m: 추가 횟수, l: 출력할 인덱스 번호
    n,m,l = map(int, input().split())
    num_list = list(map(int,input().split()))

    # I : Insert
    # D : Delete
    # C : replace

    for _ in range(m):
        # connad, index, num
        command = list(input().split())
        if 'I' in command:
            num_list.insert(int(command[1]), command[2])
            continue
        if 'D' in command:
            del num_list[int(command[1])]
            continue
        if 'C' in command:
            num_list[int(command[1])] = command[2]
            continue
    if l < len(num_list):
        print(f'#{test_case} {int(num_list[l])}')
    else:
        print(f'#{test_case} {-1}')

[SW Intermediate] Linked List - 정렬

나갱 — Mon, 3 Oct 2022 14:15:06 +0900

Linked List - 정렬

삽입 정렬

자료 배열의 모든 원소들을 앞에서 부터 차례대로 이미 정렬된 부분과 비교하여, 자신의 위치를 찾아냄으로써 정렬을 완성한다.

[ 삽입 정렬의 정렬과정 ]

1) 정렬할 자료를 두 개의 부분집합 S 와 U로 가정한다.

- 부분집합 S: 정렬된 앞부분의 원소들

- 부분집합 U: 아직 정렬되지 않은 나머지 원소들

2) 정렬되지 않은 부분 집합 U의 원소를 하나씩 꺼내며 이미 정렬되어 있는 부분집합 S의 마지막 원소부터 비교하면서 위치를 찾아

삽입한다.

3) 삽입 정렬을 반복하면서 부분집합 S의 원소는 하나씩 늘리고 부분집합 U의 원소는 하나씩 감소하게 한다.

4) 부분집합 U가 공집합이 되면 삽입 정렬이 완성된다.

✔ 시간 복잡도: O(n^2)

병합 정렬

여러 개의 정렬된 자료의 집합을 병합하여 한개의 정렬된 집합으로 만드는 방식이다.

1) 분할 정복 알고리즘 활용

- 자료를 최소 단위 문제까지 나눈 후에 차례대로 정렬하여 최종 결과를 얻어낸다.

- Top- Down 방식

2) 시간 복잡도

- O(nlogn)

[ 분할 과정/병합 과정의 알고리즘 ]

def merge_sort(m): 
    if len(m) <= 1: # 사이즈가 0이거나 1인 경우, 바로 리턴
        return 
    # 1. divide 부분
    mid = len(m)//2
    left = m[:mid]
    right = m[mid:]
    
    # 리스트의 크기가 1이 될때까지 merge_sort 재귀호출
    left = merge_sort(left)
    right = merge_sort(right)
    
    # 2. concuer 부분: 분할 된 리스트들 병합
    return merge(left, right)
    
def merge(left, rigt):
    result = [] # 두 개의 분할 된 리스트를 병합하여 result 만듦
    
    while len(left) > 0 and len(right) > 0:
        # 양쪽리스트에 원소가 남아있는 경우
        # 두 서브 리스트의 첫 원소들을 비교하여 작은 것부터 result에 추가함
        
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    
    if len(left) > 0:
        result.extend(left)
    if len(right) > 0:
        result.extend(right)
    
    return result