함함ː

[JavaScript] Promise

함s — Sun, 8 Jun 2025 01:18:14 +0900

A promise is an object that may produce a single value sometime in the future.

It is either a resolved value or a rejected one, with a reason for rejection.

And a promise may be in one of three possible states.

It can be fulfilled, rejected, or pending.

[1] new Promise

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("success");
  }, 4000)
});

promise.then(console.log)
// or
promise.then(resp => console.log(resp))

const promise = new Promise((resolve, reject) => {
	if (true) {
    	resolve('Stuff Worked');
    } else {
    	reject('Error, it broke');
    }
});

promise
	.then(result => result + '!')
    .then(result2 => result2 + '?')
    .catch(() => console.log('error!!')
    .then(result3 => {
    	//throw Error;
        console.log(result3 + + '!');
    })
    
    
// Stuff Worked!?!

catch 는 시작점부터 catch 전까지의 오류만 잡을 수 있다.

이후에 생기는 오류는 잡아내지 못한다.

[3] Promise.resolve() / Promise.reject()

const promise2 = Promise.resolve(
  setTimeout(() => {
    console.log("success");
  }, 4000)
);

Promise.reject('failed')
  .catch(console.log('Ooops something went wrong'))

[3] Promise.all()

const promise = new Promise((resolve, reject) => {
	if (true) {
    	resolve('Stuff Worked');
    } else {
    	reject('Error, it broke');
    }
});

cosnt promise2 = new Promise((resolve, reject) => {
	setTimeout(resolve, 100, 'after 0.1 second')
});

cosnt promise3 = new Promise((resolve, reject) => {
	setTimeout(resolve, 1000, 'after 1 second')
});

cosnt promise4 = new Promise((resolve, reject) => {
	setTimeout(resolve, 5000, 'after 5 seconds')
});

Promise.all([promise, promise2, promise3, promise4])
	.then(values => {
    	console.log(values);
    }
    
// 5초 뒤에
// ["Stuff Worked", "after 0.1 second", "after 1 second", "after 5 seconds"]

만약 promise 변수 선언과 Promise.all 호출이 시간차를 두고 진행된다면,

Promise.all 이 호출되기 이전에 변수에 promise 값이 할당되기 때문에

5초 라는 시간 차이 없이 바로 Promise.all 이 실행된다.

const url = [
	'https://jsonplaceholder.typicode.com/users',
    'https://jsonplaceholder.typicode.com/posts',
    'https://jsonplaceholder.typicode.com/albums'
]

Promise.all(urls.map(url =>
    fetch(url).then(people => people.json())
))
  .then(array => {
    console.log('1', array[0])
    console.log('2', array[1])
    console.log('3', array[2])
    console.log('4', array[3])
  })
  .catch(err => console.log('ughhhh fix it!', err));

[React] 클래스 컴포넌트 vs 함수형 컴포넌트

함s — Wed, 7 May 2025 10:20:48 +0900

0. 컴포넌트

React는 UI를 작고 이해하기 쉬운 컴포넌트 단위로 나눠 프로젝트를 구조화한다 (Structure).

기능별로 나눈 컴포넌트는 재사용성(Reusability)이 높고,
복잡한 로직이 있더라도 외부에서는 단순한 이름으로 사용할 수 있어 추상화(Abstraction)에 유리하다.

이로 인해 개발자는 전체 흐름에 집중할 수 있고,
UI가 변경될 경우 해당 컴포넌트만 수정하면 되므로 유지보수(Maintainability)가 쉬워지고 안정성도 높아진다.

React 에는 두 가지 종류의 컴포넌트가 있다. 클래스 컴포넌트와 함수형 컴포넌트이다.

두 컴포넌트는 동일한 작업을 수행할 수 있지만, 구문과 특정 기능 사용 방법에 차이가 있다.

import React from 'react';
import { createRoot } from "react-dom/client";
import './index.css';
import Hello from './Hello';
import 'tachyons';

const root = createRoot(document.getElementById('root'));
const element = <Hello greeting="Hello React King" />;	// props 전달
root.render(element);

1. 클래스 컴포넌트

import React, { Component } from 'react';
import './Hello.css'

class Hello extends Component {
    render() {
        return (
            <div className='f1 tc'>
                <h1>Hello World</h1>
                <p>{this.props.greeting}</p>
            </div>
        )
    }
}

export default Hello;

클래스 컴포넌트는 주로 래거시 프로젝트에서 볼 수 있는 방식이다.

클래스 컴포넌트는 생명주기(Lifecycle) 메서드를 지원하지만,

복잡하고 직관적이지 않으며 안전하지 않아서 향후 React 버전에서 지원되지 않을 예정이다.

또한, 일반적으로 Hooks 를 사용할 수 없다.

2. 함수형 컴포넌트

import React from 'react';
import './Hello.css'

const Hello = (props) => {
    return (
        <div className='f1 tc'>
            <h1>Hello World</h1>
            <p>{props.greeting}</p>
        </div>
    )
}

export default Hello;

함수형 컴포넌트는 현재 가장 많이 사용되는 방식이다.

문법이 간단하고 작성하기 쉬워서 빠르게 개발할 수 있으며,

useState, useEffect, useContext 등의 Hooks 를 사용할 수 있는 유일한 방식이다.

함수형 컴포넌트 + Hooks 조합이 현재 React 개발의 표준이라고 볼 수 있다.

[Mac] 터미널 꾸미기

함s — Sun, 4 May 2025 03:45:33 +0900

iTerm2 설치

Mac 에 깔린 기본 터미널 말고 iTerm2 를 쓰자.

탭기능과 분할 창을 쓸 수 있고 커스터마이징도 된다.

https://iterm2.com/

iTerm2 - macOS Terminal Replacement

iTerm2 by George Nachman. Website by Matthew Freeman, George Nachman, and James A. Rosen. Website updated and optimized by HexBrain

iterm2.com

oh my zsh 설치

- zsh 쉘 프레임워크

- 터미널 외관 및 플러그인(자동완성, 구문강조, Git 통합 등 다양한 기능 제공) 추가 가능

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

oh-my-zsh 플러그인 설치

# zsh-syntax-highlighting
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

# zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

# fzf (fuzzy file finding)
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

# zsh-z 디렉터리 자동 이동
git clone https://github.com/agkozak/zsh-z ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-z

▼ 자세한 내용은 아래 깃헙 링크 참조

zsh-syntax-highlighting

zsh-autosuggestions

fzf

zsh-z

.zshrc 파일 수정

vi ~/.zshrc

# insert
i

# finish
[esc 버튼 누르기]

# 나가기
:wq

# 설정내역 반영
source ~/.zshrc

plugins=(
  git
  zsh-syntax-highlighting
  zsh-autosuggestions
  fzf
  zsh-z
)

>> 이렇게 zshrc 문서를 수정했는데도 계속 적용이 안되어서 한참을 헤맸는데,

zshrc 중간에 plugins=( git ) 이렇게 정의한 부분이 있어서

중복 정의로 적용이 안되었던 것!

맨 마지막에 넣지 말고 중간에 정의된 부분을 수정하니까 잘 된다~~ 유후~~

font 및 theme 바꾸기

# font
brew install --cask font-hack-nerd-font

# theme
brew install starship

font 는

iTerm2 > Settings > Profiles > Text 에서 수정

다른 탭에서 상단바, 컬러 등 다양하게 수정할 수 있다.

theme 은

.zshrc 맨 아래에 하단 코드 추가

eval "$(starship init zsh)"

개발자 터미널 세팅하기

5 mins read 처음 개발을 시작했을 때 한 번쯤 터미널을 메인 작업 도구로 하는 것에 대한 로망이 다들 있(었)지 않을까요. 저도 약 2년에 한 번꼴로 개인이든 회사든 맥북을 새로 세팅할 일이 생

naubull2.tistory.com

[Mac] iTerm2, oh my zsh 설치 및 삭제, agnoster테마 설정

저도 이곳을 참고해서 설치했습니다~ 우리는 agnoster 테마를 설치하기 위해 아래 작업들을 해줄겁니다.agnoster 테마를 쓰면 터미널에서 git을 쓸때 매우 편리해진다고 합니다. 그전에 앞서일단 iterm

chokotingchock.tistory.com

터미널 꾸미기: Oh-my-zsh + iTerm2

이번 시간에는 맥북을 처음 세팅할 때 터미널 환경을 커스텀하게 설정하는 방법에 대해서 정리합니다. iTerm2 설치 MacOS 에서 기본으로 제공하는 터미널은 다소 아쉬운 부분이 있어 보통 iTerm2 어

kdohyeon.tistory.com

[Terminal] 맥북 터미널 호스트네임 변경 (터미널 상단 바 이름 변경)

맥 터미널이나 iTerm2을 사용할 때 상단 바에 [내계정이름]@[어쩌고저쩌고]:~/[어디어디]로 뜨는 게 보일 것이다.여기서 [어쩌고저쩌고]는 HostName인데 이것을 바꿔보자.참고로 호스트 이름은 컴퓨터

dykm.tistory.com

[Mac] 관리자 계정 추가, 맥북 계정 이름 및 홈 폴더 이름 변경하기

Linux에 대하여 공부한 내용을 블로그에 올리려고 하니까 터미널에서 경로 등 내 정보가 나타나는 게 싫어서 계정 이름이랑 디렉토리 이름을 변경하기로 하였다.. *** 작업 전 백업 필수 *** 맥북의

wonkang.tistory.com

[Git] 명령어 및 플로우 정리

함s — Sun, 27 Apr 2025 01:44:41 +0900

git clone

cd 원하는경로
git clone 리포지토리주소

1. 리포지토리 생성 후 url 복사

2. 원하는 경로로 이동

3. clone으로 리포지토리 파일 내려받기

git config

git config --global user.name 깃아이디
git config --global user.password 토큰

이때,

fatal: Authentication failed for '리포지토리주소'

에러가 뜰 경우, 깃 설정에서 토큰 발급 후

로컬 컴퓨터에 깃 정보 등록

▼ 추천 게시글

Github 에러 해결법: Authentication failed for ~ use a personal access token instead

Github 을 사용하다 보면 2021년 8월 이후로 git pull 을 하려 할때에 아래와 같운 에러가 발생할 때가 있다. remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.

wotres.tistory.com

4-1. 클론받은 파일에 바로 프로젝트를 생성해도 되고

4-2. 기존에 생성한 프로젝트가 있다면 이 파일로 옮김

git status

git status

On branch master
Your branch is up to date with 'origin/master'.

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	JS/

git status

명령어를 입력하면, 현재 자신의 브랜치와 변경점이 있는 파일을 보여줌

Untracked files: <- 깃에 등록되지 않은 파일들

git add

git add .
git add 파일/폴더 이름

5. 깃에 등록하지 않은 파일/폴더 를 깃에 추가

. 으로 하면 등록되지 않은 모든 파일을 추가하고

특정이름으로 하면 해당되는 파일만 추가됨

제대로 작동하면 파일의 상태가 변함 Untracked files -> new files

git commit

git commit -m "커밋메시지"

6. 등록한 파일들을 커밋함.

git push

git push

7.-1 커밋한 파일을 본인 브랜치의 깃 서버로 전송

git push origin master
git push origin main

7-2. 커밋한 파일을 메인 브랜치로 전송

git branch

git branch

* master

git branch 를 하면 현재 있는 브랜치의 리스트를 보여줌

git branch 새로운브랜치이름

새로운 브랜치 생성

git branch -m 기존이름 바꿀이름

브랜치 이름 바꾸기

!! 브랜치 이름을 바꾸면 깃의 모든 공유자는 업데이트를 받아야 함

git branch -m 기존이름 새이름
git fetch origin
git branch -u origin/새이름 새이름
git remote set-head origin -a

※ master -> main

깃의 기본 브랜치는 master 이지만, master 는 과거의 부정적인 역사(노예제도 등)와 연결될 수 있어서

더 포용적이고 중립적인 main 을 쓰기로 결정함.

기능이나 역할은 같고 이름만 바뀜.

20년도 이후 버전은 main 으로 프로젝트가 생성된다고 함

(난 master 로 만들어졌는데...... <- 그렇다면 main 으로 바꾸길 권장)

https://github.com/github/renaming?tab=readme-ov-file

GitHub - github/renaming: Guidance for changing the default branch name for GitHub repositories

Guidance for changing the default branch name for GitHub repositories - github/renaming

github.com

git checkout

git checkout 변경할브랜치이름

작업 브랜치 바꾸기

git merge

git merge 브랜치이름

git merge main

브랜치에서 작업한 내용을 메인 브랜치로 병합

https://docs.github.com/ko/repositories/configuring-branches-and-merges-in-your-repository/managing-branches-in-your-repository/renaming-a-branch

분기 이름 바꾸기 - GitHub Docs

리포지토리에서 분기의 이름을 변경할 수 있습니다.

docs.github.com

[JavaScript] findLast, toSorted, toReversed, toSpliced, with (ES2023)

함s — Thu, 10 Apr 2025 22:39:42 +0900

1. findLast / findLastIndex

find() 는 앞에서부터 조건을 만족하는 첫 요소를 찾고,

findLast() 는 뒤에서부터 찾는다.

const numbers = [1, 2, 3, 4, 5, 6];

console.log(numbers.find(n => n % 2 === 0));      	  // 2
console.log(numbers.findLast(n => n % 2 === 0));      // 6
console.log(numbers.findLastIndex(n => n % 2 === 0)); // 5

2. toSorted / toReversed / toSpliced / with

원본 배열은 변경하지 않고, 새로운 배열을 반환한다.

React 같이 불변성 유지가 중요한 프레임워크에서 유용히 쓰임.

const arr = [3, 1, 4];

// toSorted
console.log(arr.toSorted()); // [1, 3, 4]

// toReversed
console.log(arr.toReversed()); // [4, 1, 3]

// toSpliced(1, 1) → 1번 인덱스에서 1개 삭제
console.log(arr.toSpliced(1, 1)); // [3, 4]

// with(1, 8) → 1번 인덱스의 값을 8로 변경
console.log(arr.with(1, 8));	// [3, 8, 4]

console.log(arr); // [3, 1, 4] ← 원본 그대로!

arr.toSorted()

: 정렬된 새 배열 반환

arr.toReversed()

: 역순인 새 배열 반환

arr.toSpliced(start, deleteCount)

: splice() 처럼 작동하지만 원본 유지

: 삭제된 요소를 제외한 새 배열 반환

arr.with(index, value)

: 특정 인덱스 값을 교체한 새 배열 반환

[JavaScript] replaceAll (ES2021), at (ES2022)

함s — Thu, 10 Apr 2025 22:26:08 +0900

1. replaceAll

replace 는 첫번째 키워드만 바꿀 수 있지만

replaceAll 은 문자열의 모든 키워드를 바꿀 수 있다.

const str = "You are the best of the best";

const str_1 = str.replaceAll('best', 'worst');
// "You are the worst of the worst"

const str_2 = str.replace('best', 'worst');
// "You are the worst of the best"

문자열은 불변(immutable) 타입이기 떄문에 문자열 자체를 바꿀 수 없다.

대신, replace() 같은 메서드로 원본을 직접 수정하지 않고, 새로운 문자열을 반환해 사용한다.

이때, let 으로 선언한 문자열은 재할당이 가능해서 같은 변수에 새 문자열을 할당할 수 있지만,

const 로 선언한 문자열은 재할당이 불가능해서 새로운 변수를 선언해야 한다.

const str = "hello";
const newStr = str.replace("h", "y");

console.log(str);     // "hello" → 원본 안 바뀜!
console.log(newStr);  // "yello"


let greeting = "hi there";
greeting = greeting.replace("hi", "hello");

console.log(greeting); // "hello there"

그러면 여기서 궁금한 점이 생긴다.

let 변수는 새로운 문자열을 덮어써서 변수 값을 바꾸는 방식으로 작동한다.

하지만 문자열은 불변 타입이라, 원본 문자열 자체는 변경되지 않는다.

그렇다면, 덮어씌워진 원본 문자열은 어디로 갈까??

위의 예시에서 greeting 변수는

"hi there" 를 가리키던 참조(reference)를 잃고,

"hello there" 라는 새로운 문자열을 가리키게 된다.

이때 잃어버린 "hi there" 의 참조는 가비지 컬렉터 (Garbage Collector) 에 의해

자바스크립트 엔진은 필요없다고 판단하면 자동으로 메모리에서 삭제된다.

1. "hi there" → 메모리에 저장됨
2. greeting.replace(...) 실행 → "hello there"라는 새로운 문자열이 만들어짐
3. greeting은 이제 "hello there"를 가리킴
4. 더 이상 "hi there"를 가리키는 변수가 없으면, JavaScript가 메모리에서 치워버림

2. at

array.at(index)

배열이나 문자열에서 특정 위치의 값을 가져온다.

음수 인덱스를 지원한다.

const last1 = arr[arr.length - 1];	// 기존 문법
const last2 = arr.at(-1);

배열의 마지막 요소를 가져올 때 더 간단하게 가져올 수 있다.

// 배열
const numbers = [10, 20, 30, 40, 50];

console.log(numbers.at(0));   // 10  (첫 번째 요소)
console.log(numbers.at(-1));  // 50  (마지막 요소)
console.log(numbers.at(-2));  // 40  (뒤에서 두 번째 요소)

// 문자열
const greeting = "hello";

console.log(greeting.at(1));   // 'e'
console.log(greeting.at(-1));  // 'o'

[JavaScript] ES20 - '?.' 와 '??'

함s — Mon, 7 Apr 2025 00:43:01 +0900

1. Optional Chaining: ?.

: 값이 있을 수도 있고 없을 수도 있는 상황에서 주로 사용한다.

중첩 객체의 특정 속성에 접근하기 위해서 기존에는 일일이 And 로 연결해 속성의 존재 여부를 확인해야 했다.

하지만 이렇게 되면 코드가 너무 길어지고,

조건문 속 속성이 없을 경우 TypeError 에러가 뜰 수 있다.

옵셔널 체이닝 (A ?. B) 은

A가 undefined 나 null 이면 바로 undefined 를 반환하고 에러 없이 멈춘다.

또한, 코드가 간결하고 읽기 쉬우며

null 체크를 매번 하지 않아도 돼서 실수가 줄어든다.

let will_pokemon = {
    pikachu: {
        friend: { 
            charizard: {
                species: 'Dragon Pokemon',
                height: 1.7,
                weight: 90.5,
                power: 'fire'
            }
        }
    }
}


// And 연산자
if (will_pokemon 
	&& will_pokemon.pikachu 
	&& will_pokemon.pikachu.friend 
	&& will_pokemon.pikachu.friend.charizard) { 
    console.log('fight!')
} else {
    console.log('walk away...')
}

// 옵셔널 체이닝
if (will_pokemon?.pikachu?.friend?.charizard) {
    console.log('fight!')
} else {
    console.log('walk away...')
}

단, 옵셔널 체이닝은 존재하지 않아도 괜찮은 대상에만 사용하는 것이 좋다.

위의 예시에서, will_pokemon 에 pikachu 가 반드시 있어야 한다면,

will_pokemon.pikachu?.friend?.charizard 처럼 사용해야

에러를 조기에 발견할 수 있어 디버깅이 쉬워진다.

2. Nullish Coalescing Operator: ??

x = (a !== null && a !== undefined) ? a : b;
x = a ?? b

A ?? B : A 가 null 또는 undefined 일 경우에만 B를 사용한다.

: '값이 할당된' 변수를 빠르게 찾을 수 있다.

: ?? 연산자의 우선순위는 5 로, 대부분의 연산자보다 나중에 평가된다.

그래서 ?? 를 다른 연산자와 같이 쓸 때는 꼭 () 를 사용해야 한다.

let height = null;
let width = null;

// 괄호를 추가!
let area = (height ?? 100) * (width ?? 50);

2-1. || (Or 연산자) 와 ?? 의 차이

?? 는 null 과 undefined 만 체크하지만,

|| 는 0, '', false 등도 같이 체크한다.

const title = "";

// OR 연산자
console.log(title || "Untitled"); // "Untitled" ❗
// Null 병합
console.log(title ?? "Untitled"); // "" (빈 문자열 유지됨!) ✅

3. ?. 와 ?? 같이 사용하기

const city = user.address?.city ?? "No City";

user 객체에 address 는 꼭 있어야 한다.

user.address 에 city 가 있나?

있다면, null 이나 undefined 인가?

그렇다 -> "No City"

아니다 -> user.address.city 반환

(+) 응용

const theme = null;
const finalTheme = (theme ?? 'light') === 'dark' ? ' ' : '☀️';

console.log(finalTheme); // '☀️'

https://ko.javascript.info/optional-chaining

옵셔널 체이닝 '?.'

ko.javascript.info

https://ko.javascript.info/nullish-coalescing-operator

nullish 병합 연산자 '??'

ko.javascript.info

[JavaScript] array (2) - map

함s — Wed, 2 Apr 2025 23:01:54 +0900

0. map 이란

: 기존 배열을 변형(각 요소를 가공)해서 새로운 배열을 반환한다.

: 기존 배열은 변경되지 않는다. (불변성 유지)

: 콜백 함수를 인자로 받고, 원본 배열의 각 요소를 순회하면서 변형된 값을 새 배열에 저장한다.

- 숫자 변환, 데이터 매핑 등, 배열의 각 요소를 변형해야 하는 경우 유용하다.

※ reduce() 는 배열을 순회하며 하나의 최종 값을 반환할 때 쓰인다. (합계, 평균, 객체 변환 등)

※ forEach() 는 배열을 단순히 순회하고 작업을 수행할 뿐, 반환값은 없다.

const newArray = oldArray.map((element, index, array) => {
  return 변환된_값;
});

element - 현재 배열 요소
index - 현재 요소의 인덱스 (선택사항)
array - map()을 호출한 원본 배열 (선택사항)

예시 1) 모든 숫자 2배로 만들기

const numbers = [1, 2, 3, 4, 5];

const squaredNumbers = numbers.map(num => num ** 2);

console.log(squaredNumbers);	// [1, 4, 9, 16, 25]  (각 요소를 제곱한 새 배열)
console.log(numbers);  			// [1, 2, 3, 4, 5]  (원본 배열은 그대로 유지됨)

예시 2) 문자열을 대문자로 변환하기

const words = ['hell0', 'world', 'javascript'];
const upperCaseWords = words.map(word => word.toUpperCase());

console.log(upperCaseWords);	// ['HELLO', 'WORLD', 'JAVASCRIPT']

예시 3) 객체 배열에서 특정 속성 값만 추출하기

const users = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
  { name: 'Charlie', age: 35 }
];

const names = users.map(user => user.name);

console.log(names);		// ['Alice', 'Bob', 'Charlie']

예시 4) 배열 요소를 특정 형식의 문자열로 변환

const products = [
  { name: 'Laptop', price: 1000 },
  { name: 'Phone', price: 500 },
  { name: 'Tablet', price: 700 }
];

const productDescriptions = products.map(product => `${product.name} costs $${product.price}`);

console.log(productDescriptions);  
// ['Laptop costs $1000', 'Phone costs $500', 'Tablet costs $700']

예시 5) index 활용

const fruits = ['apple', 'banana', 'cherry'];

const numberedFruits = fruits.map((fruit, index) => {
  return `${index + 1}. ${fruit}`;
});

console.log(numberedFruits);	// ['1. apple', '2. banana', '3. cherry']

예시 6) array 활용해서 상대 평가하기

const scores = [90, 85, 78, 92, 88];

const relativeScores = scores.map((score, _, array) => {
  const highest = Math.max(...array); // 배열에서 가장 높은 점수 찾기
  return `Score: ${score} (${((score / highest) * 100).toFixed(2)}%)`;
});

console.log(relativeScores);
/*
[
  'Score: 90 (97.83%)',
  'Score: 85 (92.39%)',
  'Score: 78 (84.78%)',
  'Score: 92 (100.00%)',
  'Score: 88 (95.65%)'
]
*/

예시 7) 이중 map() - 내부 배열 (배열 > 객체 > 배열) 변형

객체를 변경할 때는 원본을 유지하기 위해 { ...user } 처럼 복사하는 게 좋다.

const users = [
  {
    name: "Alice",
    items: ["apple", "banana"]
  },
  {
    name: "Bob",
    items: ["pen", "notebook"]
  }
];

const updatedUsers = users.map(user => {
  return {
    ...user, // 기존 객체를 유지하면서
    items: user.items.map(item => item + "!") // 각 아이템에 "!" 추가
  };
});

console.log(updatedUsers);
/*
[
  { name: 'Alice', items: ['apple!', 'banana!'] },
  { name: 'Bob', items: ['pen!', 'notebook!'] }
]
*/

예시 8) 이중 map() - 다차원 배열 (행렬) 변형

const matrix = [
  [1, 2, 3],
  [4, 5, 6]
];

const doubledMatrix = matrix.map(row => 
  row.map(num => num * 2) // 각 요소를 2배로 변환
);

console.log(doubledMatrix);
/*
[
  [2, 4, 6],
  [8, 10, 12]
]
*/

[JavaScript] ES10 - flat/flatMap, Object.fromEntries, trimStart/trimEnd

함s — Wed, 2 Apr 2025 22:34:06 +0900

1. flat / flatMap

Array.prototype.flat(n)

: 중첩된 배열을 펼쳐서 1차원 배열로 만든다.

- n이 빈값이면 기본적으로 1단계만 펼침

- n단계까지 펼치고,

- 특정 숫자를 지정하기 어려울 때 Intinity 를 넣으면 배열의 depth 와 관계없이 1차원 배열로 만든다.

const array = [[1],[2],[3],[[[4]]],[[[5]]]]
console.log(array.flat(2))	// [1,2,3,[4],[5]]

const trapped = [[[[[[[[[[[[[[[[[[[[[[[[[[3]]]]]]]]]]]]]]]]]]]]]]]]]];
console.log(trapped.flat(Infinity))		// [3]

Array.prototype.flatMap()

: map()을 적용한 후, 결과를 flat() 한다.

const greeting = [["Hello", "young", "grasshopper!"], ["you", "are"], ["learning", "fast!"]];

// [ 'Hello young grasshopper!', 'you are', 'learning fast!' ]
console.log(greeting.flatMap(x => x.join(' ')))	

// 'Hello young grasshopper you are learning fast!'
console.log(greeting.flatMap(x => x.join(' ')).join(' '))

const arr = [1, 2, 3];

// [1, 2, 2, 4, 3, 6]  (각 요소를 2배로 늘리고 펼침)
console.log(arr.flatMap(num => [num, num * 2]));

2. Object.fromEntries

: 배열을 객체로 변환한다.

: Object.entries() 의 반대역할.

const users = { user1: 18273, user2: 92833, user3: 90315 }

// 객체->배열 [ [ 'user1', 18273 ], [ 'user2', 92833 ], [ 'user3', 90315 ] ]
const usersArray = Object.entries(users)

// [ [ 'user1', 36546 ], [ 'user2', 185666 ], [ 'user3', 180630 ] ]
updatedUsersArray = usersArray.map((user) => [user[0], user[1] * 2])

// 배열->객체 { user1: 36546, user2: 185666, user3: 180630 }
const updatedUsers = Object.fromEntries(updatedUsersArray)

3. trimStart / trimEnd

String.prototype.trimStart()

String.prototype.trimEnd()

: 앞뒤 공백을 제거하는 trim()의 확장

const userEmail3 = '     HELLO   '

console.log(userEmail3.trim())		// 앞뒤 공백 제거	'HELLO'
console.log(userEmail3.trimStart())	// 앞 공백 제거	'HELLO   '
console.log(userEmail3.trimEnd())	// 뒤 공백 제거	'     HELLO'

[JavaScript] 반복문 -- for-of / for-in (Iterating vs. Enumerating)

함s — Sun, 30 Mar 2025 23:07:30 +0900

const basket = ['apples', 'oranges', 'grapes']

// for
for ( let i = 0; i < basket.length; i++ ) {
	console.log(basket[i]);
}

// forEach
basket.forEach( item => {
	console.log(item);
}

// while
let i = 0;
while (i < basket.length) {
	console.log(basket[i]);
}

// do-while
let j = 0;
do {
	console.log(basket[j]);
    j++;
} while (j < basket.length);

자바스크립트에는 크게 기본 반복문(Traditional Loops)와 고급 반복문 (Modern Loops) 이 있다.

기본 반복문은 인덱스 기반으로 배열이나 숫자 범위를 반복할 때 사용되며,

for 문, while 문, do...while문 이 있다.

고급 반복문은 기본 반복문보다 더 직관적이고 선언적인 방식으로 사용되며,

forEach, for...of, for...in 이 있다.

그 중에서 가장 헷갈리는 for...of 와 for...in 에 대해 이해하는 시간을 가져보자.

1. for...of (Iterating)

Iterating 이란, 반복(iteration)하면서 값(value)을 가져오는 것이다.

배열, 문자열, Set, Map 등 반복 가능한(iterable) 요소를 순회하며, 순서를 보장한다.

const basket = ['apples', 'oranges', 'grapes']

for (item of basket) {
	console.log(item); // apples, oranges, grapes
}

for (char of 'basket') {
	console.log(char); // b, a, s, k, e, t
}

2. for...in (Enumerating)

객체(Object)의 속성(property)을 열거(하나씩 나열)할 때 사용한다.

객체의 키(key)를 가져오며, 순서를 보장하지 않는다.

const detailedBasket = {
	apples : 5,
    oranges : 10,
    grapes : 50
}

for (item in detailedBasket) {
	console.log(item);
}

// apples
// oranges
// grapes

for...in 과 Object.keys() 차이점

둘 다 객체의 키를 반복하는 기능은 같지만, 동작 방식이 다르다.

for...in 은 상속된 속성까지 포함할 수 있으며, 문자열을 리턴한다.

Object.keys() 는 상속을 제외하고 자신의 속성만 가져오며, 배열을 리턴한다.

const parent = { inherited: "I'm inherited!" };
const obj = Object.create(parent); // obj의 프로토타입에 parent를 추가
obj.name = "James";
obj.age = 25;


for (let key in obj) {
  console.log(key); // name, age, inherited (프로토타입 상속된 속성도 포함!)
}

for (let key in obj) {
  if (obj.hasOwnProperty(key)) {
    console.log(key); // name, age (inherited는 제외됨)
  }
}

console.log(Object.keys(obj)); // ["name", "age"]

[JavaScript] array (1) - reduce

함s — Fri, 28 Mar 2025 23:55:31 +0900

0. reduce 란?

array.reduce((accumulator, currentValue) => {
  // 콜백 함수 내용
}, initialValue);

reduce() 는 배열의 모든 요소를 하나로 축소하는 데 사용하는 메서드이다.

배열을 합치거나, 필터링하거나, 특정 조건을 만족하는 값을 찾을 때 유용하다.

accumulator (누적값): 배열의 요소들을 하나씩 처리하면서 누적되는 값. 처음에는 initialValue로 시작해.
currentValue (현재값): 배열에서 순차적으로 처리되는 각 요소.
initialValue(초기값): 누적값이 시작하는 초기값 (옵션, 생략 가능).
결과값: 배열을 모두 처리한 후 최종적으로 하나의 값이 반환됨.

첫번째 요소부터 마지막 요소까지 차례대로 순회하며 accumulator 값을 갱신한다.

마지막에 최종적으로 누적된 값을 반환한다.

※ 주의점

1. 초기값을 설정하지 않으면, 자동으로 초기값은 배열의 첫 번째 요소가 되고, 두 번째 요소부터 시작한다.

2. 배열이 비어있고 초기값이 제공되지 않으면 에러가 발생한다.

예시1) 배열의 합 구하기

const numbers = [1, 2, 3, 4];

const sum = numbers.reduce((acc, value) => acc + value, 0);

console.log(sum); // 출력: 10

예시2) 배열에서 가장 큰 숫자 찾기

const numbers = [1, 5, 3, 9, 2];

const max = numbers.reduce((acc, value) => 
  return currentValue > acc ? value : acc;
}, numbers[0]);

console.log(max); // 출력: 9

예시3) 배열에서 가장 긴 단어 찾기

const words = ["apple", "banana", "kiwi"];

const longestWord = words.reduce((a, b) => (a.length > b.length ? a : b));

console.log(longestWord); // 출력: "banana"

예시4) 배열의 평균 구하기

const numbers = [1, 2, 3, 4, 5];

const average = numbers.reduce((acc, currentValue, index, array) => {
  acc += currentValue;
  if (index === array.length - 1) {
    return acc / array.length;
  }
  return acc;
}, 0);

console.log(average); // 출력: 3

index : 현재 요소의 인덱스

array : 원본 배열

[JavaScript] ES8 (1) - Object.values, Object.entries, padStart, padEnd

함s — Fri, 28 Mar 2025 23:40:16 +0900

ES8 문법을 소개하기 앞서,

ES7 문법도 간략하게 짚고 넘어가기.

ES7

.includes()

const dragons = ['Tim', 'Johnathan', 'Sandy', 'Sarah'];

dragons.includes('John') // false
dragons.filter(name => name.includes('John')) // ['Johnathan']

거듭제곱 연산자 (Exponential Operator)

const square1 = (x) => Math.pow(x, 2);	// ES6
const square2 = (x) => x ** 2;	// ES7

square2(2);	// 4

ES8

.padStart() & .padEnd()

String 의 앞/뒤에 ()자릿수만큼 공백 넣기

const startLine = '     ||<- Start line';
let turtle = ' ';
let rabbit = ' ';

turtle = turtle.padStart(8);
rabbit = rabbit.padStart(8);

'     ||<- Start line'
'        '
'        '

turtle = turtle.trim().padEnd(9, '=');

'     ||<- Start line'
' ======='
'        '

Object.values()

Object.entries()

기존에는 Object.key() 만 있었음.

ES8 에 객체의 값만 꺼내오거나 키-값 을 쌍으로 꺼낼 수 있는 메서드가 생김.

const scores = { math: 90, english: 85, science: 95 };

// 270
const totalScore = Object.values(scores).reduce((acc, val) => acc + val, 0);

let obj = {
  my: 'name',
  is: 'Rudolf',
  the: 'raindeer'
}

// 'my name is Rudolf the raindeer'
const result = Object.entries(obj).map(value => value.join(" ")).join(' ')

[JavaScript] Pass By Value vs Pass By Reference (얕은복사, 깊은복사)

함s — Sun, 23 Mar 2025 00:37:39 +0900

자바스크립트에서 변수를 함수에 전달할 때 두가지 방식이 있다.

1. Pass By Value (값에 의한 전달)

2. Pass By Reference (참조에 의한 전달)

1. Pass By Value

: 원시 타입 (Primitive Types) 을 함수에 전달할 때 값이 복사됨.

: 적용 타입 - Number, String, Boolean, Null, Undefined, Symbol, BigInt

: 원시 타입은 값 자체를 복사해서 전달하기 떄문에 원본 데이터에 영향을 주지 않음!

var a = 5;
var b = a;

b++;

console.log(a);	// 5
console.log(b);	// 6

2. Pass By Reference

: 객체 타입 (Object) 을 함수에 전달할 때, 참조 (Reference) 가 전달됨

: 적용 타입 - Object, Array, Function

: 객체 타입은 메모리주소(참조)를 공유하기 떄문에 원본 데이터가 변경될 수 있음!

=> 원본 객체의 의도치 않은 변경을 막으려면 객체를 복사(Cloning)해서 사용하면 된다.

let obj1 = {name: 'Yao', password: '123'}
let obj2 = obj1;

obj2.password = 'easypeasy'

console.log(obj1);	// {name: 'Yao', password: 'easypeasy'}
console.log(obj2);	// {name: 'Yao', password: 'easypeasy'}

3. Cloning

var c = [1, 2, 3];
var d = [].concat(c);

d.push(4);

console.log(c);		// [1, 2, 3]
console.log(d);		// [1, 2, 3, 4]

3-1. Shallow Cloning

: 최상위 객체의 값만 복사하고, 중첩 객체는 참조로 복사하는 방식.

: 내부에 중첩된 객체가 있다면 원본과 공유됨.

let obj = {a: 'a', b: 'b'};
let clone = Object.assign({}, obj);
let clone2 = {...obj};

obj.b = 5;

console.log(obj);		// {a: 'a', b: 5}
console.log(clone);		// {a: 'a', b: 'b'}
console.log(clone2);	// {a: 'a', b: 'b'}

let obj = {
	a: 'a', 
    b: {
    	deep: 'try and copy me'
    } 
};
let clone = Object.assign({}, obj);
let clone2 = {...obj};

obj.b.deep = 'hahaha';

console.log(obj);		// {a: 'a', b: {deep: 'hahaha'}}
console.log(clone);		// {a: 'a', b: {deep: 'hahaha'}}
console.log(clone2);	// {a: 'a', b: {deep: 'hahaha'}}

내부 객체는 여전히 참조값으로 복사되기 떄문에, 값을 변경할 경우 모든 클론 객체의 내부객체가 다 변경됨.

3-2. Deep Cloning

: 객체 내부의 모든 값을 새롭게 복사해서 원본과 완전히 독립적인 객체를 만드는 방식.

: 원본을 변경해도 복사된 객체는 영향을 받지 않는다.

=> 연산비용이 크고 객체가 클수록 복사 속도가 느려지고 메모리를 더 많이 사용함. 신중히 사용 필요.

1) JSON.parse(JSON.stringify(obj))

- 간단하고 빠르지만

- undefined, function, Symbol, BigInt 같은 데이터는 복사되지 않음.

- 순환참조(자기 자신을 참조하는 객체)가 있으면 무한 루프 발생 가능

let obj = {
	a: 'a', 
    b: {
    	deep: 'try and copy me'
    } 
};
let clone = {...obj};
let superClone = JSON.parse(JSON.stringify(obj));

obj.b.deep = 'hahaha';

console.log(obj);			// {a: 'a', b: {deep: 'hahaha'}}
console.log(clone);			// {a: 'a', b: {deep: 'hahaha'}}
console.log(superClone);	// {a: 'a', b: {deep: 'try and copy me'}}

2) structuredClone(obj)

- function, undefined 도 복사 가능하지만, 최신문법이라 오래된 브라우저에서는 지원 안 됨.

- 순환 참조 문제 해결 가능

let obj2 = structuredClone(obj1);

3) lodash 라이브러리

- 가장 안정적이고 강력한 방법이지만, 외부 라이브러리를 설치해야 함.

- 복사 과정에서 손실되는 데이터가 없고 순환 참조 문제 해결 가능

let obj2 = _.cloneDeep(obj1);

[개발상식] lodash 알고 쓰자.

안녕하세요. 김용성입니다. 오늘은 lodash에 대해 포스팅해보도록 하겠습니다.

velog.io

[JavaScript] 인스턴스화 (Instantation)

함s — Sat, 22 Mar 2025 23:53:08 +0900

class Player {
	constructor(name, type) {
    	console.log(this);	// Wizard{}
    	this.name = name;
        this.type = type;
    }
    introduce() {
    	console.log(`Hi I am ${this.name}, I'm a ${this.type}`);
    }
}

class Wizard extends Player {
	constructor(name, type) {
    	super(name, type);		// Player 의 constructor 실행
        console.log('wizard', this);	// Wizard {name:"Shelly", type:"Healer"}
    }
    play() {
    	console.log(`WEEEE I'm a ${this.type}`);
    }
}

const wizard1 = new Wizard('Shelly', 'Healer');
const wizard2 = new Wizard('Shawn', 'Dark Magic');

wizard1.play();			// WEEEE I'm a Healer
wizard1.introduce();	// Hi I am Shelly, I'm a Healer (부모객체의 메서드 접근)

자바에서 배웠던 추상화 개념을 자바스크립트에서도 쓸 수 있다니.

실무에서 어떻게 쓰일지 궁금하다.

나중에 실무나 응용 예시를 추가할 예정.

[JavaScript] 클로저, 커링, 함수 조합

함s — Sun, 16 Mar 2025 23:00:17 +0900

1. 함수형 프로그래밍

함수형 프로그래밍(Function Programming)은 작은 문제를 해결할 수 있는 순수 함수(Pure Function)들을 조합하여 재사용성과 유지보수성을 높이는 프로그래밍 패러다임이다.

순수 함수의 대표적인 특징은 다음과 같다.

1. Deterministic

: 동일한 입력이 주어지면 항상 동일한 결과를 반환한다.

2. No Side Effects

: 프로그램의 실행 과정에서 전역 변수, 데이터베이스, 파일 시스템, UI, 네트워크 요청 등의 외부 상태를 변경하거나 의존하지 않아야 한다.

/* Side Effects가 있는 함수 (Impure Function) */
let total = 0;
function addToTotal(value) {
    total += value; // 외부 변수 total을 변경함 (Side Effect 발생)
    return total;
}

/* Side Effects가 없는 함수 (Pure Function) */
function add(a, b) {
    return a + b;
}

const multiply = (a, b) => a * b;

그렇다면, 이 순수 함수를 더 유연하게 재사용이 가능하도록 만들려면 어떻게 해야 할까?

2. Closure & Currying

자바스크립트는 함수도 value 로 여긴다. 즉, 함수의 리턴값을 함수로 하거나 함수의 인자값으로 함수를 받을 수 있다.

고차 함수(Higher-order Function): 함수를 인자로 받거나 반환하는 함수 활용

이런 고차함수의 특징을 활용한 방법으로 클로저와 커링이 있다.

//Closure
const addTo = x => y => x + y
var addToTen = addTo(10)
addToTen(3) 		// 13 -- 10을 기억했다가 추가인자 3과 덧셈 진행

//Currying
const sum = (a, b) => a + b
const curriedSum = (a) => (b) => a + b	// 다중인자를 단일인자로 변환

curriedSum(30)(1) 	// 31

const add5 = curriedSum(5)
add5(12) 			// 17

	Closure (클로저)	Currying (커링)
목적	내부 함수가 외부 함수의 변수를 기억하고 사용	여러 개의 인수를 하나씩 받는 함수로 변환
핵심 개념	함수가 선언될 때 외부 변수 값을 기억함	함수를 계속 리턴하여 한 번에 하나의 인수만 받음
예제 코드	const addTo = x => y => x + y;	const curriedSum = (a) => (b) => a + b;
사용 사례	비공개 변수 유지, 데이터 캡슐화	재사용성 증가, 부분 적용 가능

즉,

클로저: 외부 함수의 변수에 접근할 수 있는 내부 함수

커링: 다중 인수를 받는 함수를 하나의 인수만 받는 여러 개의 함수로 변환하는 기법.

커링은 함수를 여러 단계로 나누어, 각 단계에서 새로운 함수를 반환하는 방식인데, 이 과정에서 클로저가 활용된다.

3. 함수 조합(Function Composition)

고차 함수(Higher-order Function)는 함수를 인자로 받거나 반환하는 함수라고 했다.

함수가 value 면, 함수의 인자로 함수를 넣을 수도 있지 않을까?

함수 조합(Composing)은 이런 특징을 활용해 여러 개의 작은 함수를 결합하여 더 복잡한 함수를 만드는 기법이다.

즉, 여러 개의 함수를 순차적으로 실행하여 하나의 새로운 함수를 만드는 것이다.

//Composing
const compose = (f, g) => (a) => f(g(a));
const add1 = (num) => num + 1;
const add5 = (num) => num + 5;
compose(add1, add5)(10) // 16

함수형 프로그래밍.. 말은 많이 들어봤는데, 막상 접하고 나니 이런식으로 생각해본 적이 없어서 새로운 세상을 엿본 것 같다.

가독성은 모르겠지만 효율은 좋은 것 같다.

이런 방식의 프로그래밍에 익숙해진다면.......

정말 좋을지도...

더 자세히 알고싶다면..

7.3. 함수형 프로그래밍 활용

함수형 프로그래밍은 단순히 순수 함수, 불변성, 그리고 일급/고차 함수의 개념에 그치지 않고, 실제 문제 해결 및 시스템 설계에 응용될 수 있는 다양한 기법들을 제공합니다. 이 …

wikidocs.net

클로저와 함께 알아보는 curring 함수

JavaScript의 클로저를 통해 currying 함수를 알아보자.

pozafly.github.io

[JavaScript] ES6 문법 정리

함s — Wed, 12 Mar 2025 22:51:37 +0900

1. let, const

var 과 let 은 뭐가 다른가?

자바스크립트를 쓰면서 항상 궁금했는데, 이번에 그 궁금증이 풀렸다.

const num = 100;
var flag = false;

if (num > 90) {
	var flag = true;	// 재할당
}

console.log(flag)	// true

const num = 100;
let flag = false;

if (num > 90) {
	let flag = true;	// 존재범위 {}
}

console.log(flag)	// true

1. let, const 는 변수를 재선언 할 수 없다. -> 변수명의 중복을 막을 수 있다.

- var 은 같은 이름으로 재선언을 자유롭게 할 수 있다. 그러면 나중에 뭐가 뭔지 헷갈리겟져?

2. var 변수의 존재 범위는 function 단위이고, let, const 의 범위는 {} 단위이다.

3. const 는 값을 재할당 할 수 없다.

- 하지만, const 로 선언한 obj 의 내부 값은 변경할 수 있다.

즉, let 은 var 보다 최근에 나왔으며, 존재범위가 좁고 중복선언이 제한되어 있기 때문에

let 으로 변수를 선언해 사용하는 것이 변수사용의 명확도를 높일 수 있다. let 추천~

const a = 1;	
a = 100;		// 재할당 불가능

const human = { name : "mimi" }
human.name = "mickey";		// 재할당 가능

Object.freeze(human)
human.name = "park";		// 재할당 불가능

2. Destructing

const person = {
    firstName : "John",
    lastName  : "Doe",
    age       : 50,
    eyeColor  : "blue"
};

const { firstName, lastName, age, eyeColor } = person

console.log(firstName);		// "John"

var firstName = person.firstName;

이렇게 일일이 할당하지 않아도 한번에 할당할 수 있다!

대신, 변수명이 키값과 같아야 함.

반대로, obj 에 담으려는 값의 변수명이 키값과 같으면 생략해서 적을 수 있다.

let a = 'test';
let b = true;
const c = 789;

// var okObj = {
//   a: a,
//   b: b,
//   c: c
// };

const okObj = { a, b, c }

3. => arrow

function 대신 변수선언 형태로 간단하게 함수를 선언할 수 있다.

만약 파라메터값에 빈값이 들어올 경우 디폴트 값을 선언할 수 있다.

const whereAmI = (username, location) => {
    if (username && location) {
        return "I am not lost";
    }
    return -1
}

whereAmI("Jennie", "Seoul");	// "I am not lost"


const isValidAge = (age = 10) => age;
isValidAge();	// 10
isValidAge(20); // 20

4. `` backtick

이건 익숙한거.

"hi" + name + "!"

`hi ${name} !`

이렇게, 귀찮은 +를 쓰지 않을 수 있다.

const sendMessate = (firstName = '', city = 'Seoul') => {
    return `Hello ${firstName}! Have I met you before? I think we met in ${city} last summer no???`;
}

5. Symbol

Number, String, Boolean, Undefined, Null, Object 다음으로

ES6 에서 처음 도입된 타입이다.

변경 불가능하고 다른 값과 중복되지 않는 유일무이한 값이다.

따라서, 주로 이름의 충돌 위험이 없는 유일무이한 프로퍼티 키를 만들기 위해 사용한다고 한다.

고유성을 보장하고, 이름 충돌을 방지하며, 의미를 부여할 수 있다.

언제 쓰일지는 모르겠지만, 이런게 있다는 사실을 알고 넘어가자!

const symbol = Symbol('kakaotalk')

const Direction = {
    EAST: Symbol('east'),
    WEST: Symbol('west'),
    SOUTH: Symbol('south'),
    NORTH: Symbol('north')
};

자바스크립트 symbol은 언제 사용하면 좋을까?

의문이 든 이유 자바스크립트 symbol은 ECMAScript6(2015)에 도입된 7번째 타입이라고 들어는 봤지만, 그다지 깊게 파본적이 없었던 것 같아서 깊게 공부하는 중이다. 생각해 보니 (몰라서 그랬을 수도

dev-ellachoi.tistory.com

변수 신문법 총정리 1. var let const와 선언,할당,범위 - 코딩애플 온라인 강좌

0:00 var let const로 변수만들어 쓰는 법 1:30 선언이라는 특징 2:48 할당이라는 특징 4:25 재할당 불가능한 불변의 Object를 만들려면 6:52 존재범위라는 특징 10:10 변수나 함수 선언의 Hoisting 현상

codingapple.com

[Python] 입력값 빠르고 간단하게 받기 -- sys.stdin.readline() 과 lambda

함s — Fri, 10 Jan 2025 23:58:39 +0900

[1] input() V.S. sys.stdin.readline()

S, E = map(int, input().split())

import sys
S, E = map(int, sys.stdin.readline.strip().split())

(1) input()

- 입력을 한 줄씩 받아 문자열로 처리.

- 기본적으로 개행문자(\n) 제거함

- 간결하지만 여러줄 입력을 빠르게 받아야 할 때 속도가 느림

=> 알고리즘 문제에서 자칫하다 런타임 에러를 일으킬 수 있음 ㅠ

(2) sys.stdin.readline()

- 한 줄 입력을 받아 문자열로 처리.

- 개행문자(\n) 포함. -> .strip() 로 제거해야 함!

- 대량 입력 받을 때 빠름. for 나 while 문에서 반복 입력 받을 때 유리.

- 그렇지만 코드가 구구절절함 -> alias나 lambda 로 미리 선언해서 간결하게 쓰기!

[2] sys.stdin.readline()에 strip() 을 써야 하는 이유

1. 입력값 시작이나 끝에 포함된 개행 문자(\n)는 문자열 조작시 문제를 일으킬 수 있어서 지우는 게 좋음!

2. 예상치 못한 공백이나 개행문자가 포함된 경우에도 안정적으로 동작하도록 보장함!

=> 즉, 이상한 인풋을 정상적으로 만들 수 있으니 strip() 를 꼭 쓰지 않아도 되는 상황에서도 쓰도록 습관을 들이자~~

[3] sys.stdin.readline() 함수를 간결하게 호출하는 법

(1) 기존 함수에 별명(alias)를 붙여서 참조하기

import sys
input = sys.stdin.readline  # Alias 사용

N = int(input().strip())  # 개행 문자 제거
S, E = map(int, input().strip().split())

파이썬에서 함수도 일종의 객체이기 때문에 이름을 붙여줄 수 있다.

단, 이 경우에는 strip() 을 매번 적어주어야 한다.

input = sys.stdin.readline.strip 은 왜 안되는 걸까???

그 이유는,

1. sys.stdin.readline 자체가 함수 객체이고

2. strip 은 sys에 속하지 않은 문자열 메서드이기 때문에

=> 하나의 객체가 될 수 없어 alias 로 퉁칠 수 없다!

그래서 input.strip() 으로 쓰면 안되고 input().strip() 으로 써야 한다.

별명으로 함수 객체를 참조하기 때문에,

input()으로 호출해 반환값을 받고 그 다음 strip() 을 해주어야 하기 때문이다!

그러면 strip 까지 써서 최대한 간단하게 하려면 어떻게 해야 하냐?

↓

(2) lambda 로 새로운 함수로 정의

lambda 는 익명 함수를 정의하는 방법이다.

익명함수란, 이름이 없는 작은 함수를 선언할 때 사용한다.

lambda [parameters]: [expression]

def my_function():
    return sys.stdin.readline().strip()
input = my_function


input = lambda: sys.stdin.readline().strip()

N = int(input())
S, E = map(int, input().split())

def 로 정의할 수 있지만 한 줄 함수는 lambda 가 훨씬 간결하다!

그리고 새로운 함수를 정의하기 때문에 .strip 같은 문자열 메서드도 함께 추가할 수 있어서

호출 시 간결하게 쓸 수 있다!!

굿~~

[Backjoon] 2664 - 촌수계산 (BFS)

함s — Fri, 10 Jan 2025 23:12:09 +0900

0. 문제

'''
부모와 자식 사이를 1촌으로 정의하고 이로부터 사람들 간의 촌수를 계산한다.
예를 들면 나와 아버지, 아버지와 할아버지는 각각 1촌으로
나와 할아버지는 2촌이 되고,
아버지 형제들과 할아버지는 1촌,
나와 아버지 형제들과는 3촌이 된다.
여러 사람들에 대한 부모 자식들 간의 관계가 주어졌을 때, 주어진 두 사람의 촌수를 계산하는 프로그램을 작성하시오.

사람들은 1, 2, 3, …, n (1 ≤ n ≤ 100)의 연속된 번호로 각각 표시된다.
입력 파일의 첫째 줄에는 전체 사람의 수 n이 주어지고,
둘째 줄에는 촌수를 계산해야 하는 서로 다른 두 사람의 번호가 주어진다.
그리고 셋째 줄에는 부모 자식들 간의 관계의 개수 m이 주어진다.
넷째 줄부터는 부모 자식간의 관계를 나타내는 두 번호 x,y가 각 줄에 나온다.
이때 앞에 나오는 번호 x는 뒤에 나오는 정수 y의 부모 번호를 나타낸다.
각 사람의 부모는 최대 한 명만 주어진다.

입력에서 요구한 두 사람의 촌수를 나타내는 정수를 출력한다.
어떤 경우에는 두 사람의 친척 관계가 전혀 없어 촌수를 계산할 수 없을 때가 있다. 이때에는 -1을 출력해야 한다.
'''
'''
9
7 3
7
1 2
1 3
2 7
2 8
2 9
4 5
4 6

# 3

9
8 6
7
1 2
1 3
2 7
2 8
2 9
4 5
4 6

# -1
'''

1. 제출한 답

import sys
from collections import deque
input = lambda: sys.stdin.readline().strip()

#sys.stdin = open("input.txt", "r")

N = int(input())                    # 전체 사람 수
S, E = map(int, input().split())    # 촌수 계산 필요한 가족 구성원 2 (시작점-끝점)
M = int(input())                    # 총 관계 수

adj = [[] for _ in range(N + 1)]    # 부모 자식 쌍
for _ in range(M):
    x, y = map(int, input().split())
    # 부모자식 순이어도 어쨌거나 연결되어 있으니까 양방향 연결을 해야함!
    adj[x].append(y)
    adj[y].append(x)

# 한 번에 한 칸 씩 건너가서 최단거리 계산
def BFS(s, e):
    # 초기화 및 방문처리
    queue = deque([s])
    v = [0] * (N + 1)
    v[s] = 1

    while queue:
        c = queue.popleft()

        # 목적지에 도착하면 방문처리 뺀 촌수만 리턴
        if c == e:
            return v[e] - 1

        # c와 연결된 모든 노드 탐방
        for n in adj[c]:
            # 방문하지 않았다면 방문하기 (not v[e])
            if v[n] == 0:
                queue.append(n)
                # 방문처리 겸 촌수 계산
                v[n] = v[c] + 1

    return -1   # 연결된 가족이 없을 경우 -1 리턴

print(BFS(S, E))

하 진짜.. 리스트 받을 때 양방처리를 했어야 했는데!

로직 잘 짜고 계속 안 돼서 코드 수정하다가 결국 틀리고 답 봤는데

양방처리만 했으면 꽤나 수월하게 풀었을 거 같음

근데 방문처리에 카운트까지 같이 넣는건 생각도 못했다!!

GPT 까지 감탄한 지니어스적 면모;;

담에 비슷한 문제 나오면 꼭 써본다;;

[Backjoon] 2667 - 단지번호붙이기 (BFS)

함s — Thu, 9 Jan 2025 20:34:22 +0900

0. 문제

'''
정사각형 모양의 지도가 있다.
1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다.
철수는 이 지도를 가지고 연결된 집의 모임인 단지를 정의하고, 단지에 번호를 붙이려 한다.
여기서 연결되었다는 것은 어떤 집이 좌우, 혹은 아래위로 다른 집이 있는 경우를 말한다.
대각선상에 집이 있는 경우는 연결된 것이 아니다.
지도를 입력하여 단지수를 출력하고, 각 단지에 속하는 집의 수를 오름차순으로 정렬하여 출력하는 프로그램을 작성하시오.

첫 번째 줄에는 지도의 크기 N(정사각형이므로 가로와 세로의 크기는 같으며 5≤N≤25)이 입력되고,
그 다음 N줄에는 각각 N개의 자료(0혹은 1)가 입력된다.

첫 번째 줄에는 총 단지수를 출력하시오.
그리고 각 단지내 집의 수를 오름차순으로 정렬하여 한 줄에 하나씩 출력하시오.
'''
'''
7
0110100
0110101
1110101
0000111
0100000
0111110
0111000

#
3
7
8
9
'''

1. 제출한 답

import sys
from collections import deque

# sys.stdin = open("input.txt", "r")

# DFS 로 풀어도 됨! 다만, 맵이 커질 수록 반복 횟수가 커져서
# BFS 는 코드는 다소 길지만 효율적이어서 추천
def BFS(x, y):
    queue = deque([(x, y)]) # 큐 선언 및 초기데이터 삽입
    v[x][y] = 1             # 방문처리
    cnt = 1                 # 정답처리 관련 작업 -> 집 카운트

    d = [(-1, 0), (0, 1), (1, 0), (0, -1)]  # 4 방향 선언
    while queue:
        cx, cy = queue.popleft()
        for dx, dy in d:
            nx, ny = cx + dx, cy + dy
            # 4 방향, 범위 내, 미방문, 1이면 큐 삽입
            if 0 <= nx < N and 0 <= ny < N and v[nx][ny] == 0 and adj[nx][ny] == 1:
                queue.append((nx, ny))  # 방문할 수 있는 집을 queue 에 넣기
                v[nx][ny] = 1           # 방문처리
                cnt += 1                # 단지 수 카운트
    return cnt

# 지도의 크기, 지도 정보 입력 받기
N = int(sys.stdin.readline())
adj = [list(map(int, sys.stdin.readline().strip())) for _ in range(N)]

# 방문 여부 리스트, 카운트 담을 정답 리스트 초기화
v = [[0] * N for _ in range(N)]
ans = []

# 지도에서 집 탐방
for i in range(N):
    for j in range(N):
        # 집이 있고 방문하지 않았으면 BFS 시작
        if adj[i][j] == 1 and v[i][j] == 0:
            ans.append(BFS(i, j))

# 오름차순 정렬
ans.sort()

# 총 단지 수, 각 단지내 집의 수 출력
print(len(ans), *ans, sep="\n")

풀고 자신만만하게 제출했는데 틀려서 읭 했는데

초기에 방문처리랑 cnt 를 안올렸어..

예제는 맞게 나왔는데~

아직 참고 코드 없으면 바로 뚝딱 안나온다

반복만이 살길이다~

[Backjoon] 2606 - 바이러스 (DFS)

함s — Sat, 4 Jan 2025 23:24:56 +0900

0. 문제 및 입력값

'''
신종 바이러스인 웜 바이러스는 네트워크를 통해 전파된다.
한 컴퓨터가 웜 바이러스에 걸리면 그 컴퓨터와 네트워크 상에서 연결되어 있는 모든 컴퓨터는 웜 바이러스에 걸리게 된다.
어느 날 1번 컴퓨터가 웜 바이러스에 걸렸다.
컴퓨터의 수와 네트워크 상에서 서로 연결되어 있는 정보가 주어질 때,
1번 컴퓨터를 통해 웜 바이러스에 걸리게 되는 컴퓨터의 수를 출력하는 프로그램을 작성하시오.

1. 컴퓨터의 수 (100 이하인 양의 정수)
- 각 컴퓨터에는 1번 부터 차례대로 번호가 매겨진다.
2. 컴퓨터 쌍의 수
3. 한 줄에 한 쌍씩, 컴퓨터의 번호 쌍

1번 컴퓨터를 통해 웜 바이러스에 걸리게 되는 컴퓨터의 수를 첫째 줄에 출력한다.
'''
'''
7
6
1 2
2 3
1 5
5 2
5 6
4 7
# 4
'''

1. 제출한 답

import sys

sys.stdin = open("input.txt", "r")

# 개수만 알면 되니까 DFS! (최단거리는 BFS)
def DFS(c):
    # c 방문 처리
    v.append(c)

    # c와 연결된 노드 모두 처리
    for n in adj[c]:
        if n not in v:
            DFS(n)

N = int(input())    # 컴퓨터 수
P = int(input())    # 컴퓨터 쌍의 수

adj = [[] for _ in range(N+1)]
for _ in range(P):
    a, b = map(int, sys.stdin.readline().split())
    # 컴퓨터 쌍 양방 처리
    adj[a].append(b)
    adj[b].append(a)

v = []  # 방문 노드 저장 리스트
DFS(1)  # 1번 컴퓨터부터 시작

# 1번 컴퓨터를 뺀 방문한 컴퓨러의 수
print(len(v) - 1)

확실히 노트로 쓰면서 하니까.. 어.. 더 낫나?

암튼, 그림그리면서 하니까 더 나은 것 같다.

그림 보고 바로 코드로 옮기면 정말 좋을 것 같은데. 하다보면 쉬운 코드는 될지도?

확실히 입력받아서 자료구조를 제대로 잡아놔야 실행이 된다.

for 문을 얼마나 돌릴건지가 항상 헷갈린다.

(+) BFS 번외

def BFS(c):
    queue = deque([c])
    
    # queue 가 빌 때까지 진행
    while queue:
        n = queue.popleft() # 최하단 노드 뽑아서
        if n not in v:
            v.append(n) # 방문하지 않은 노드일 경우 방문 처리
            for a in adj[n]:    # 해당 노드와 연결된 노드 모두 방문
                if a not in v:
                    queue.append(a) # 방문하지 않은 노드일 경우 queue 삽입

[Backjoon] 2178 - 미로탐색 (BFS)

함s — Mon, 30 Dec 2024 23:27:49 +0900

0. 문제

'''
N×M크기의 배열로 표현되는 미로가 있다.
미로에서 1은 이동할 수 있는 칸을 나타내고, 0은 이동할 수 없는 칸을 나타낸다.
이러한 미로가 주어졌을 때,
(1, 1)에서 출발하여 (N, M)의 위치로 이동할 때 지나야 하는 최소의 칸 수를 구하는 프로그램을 작성하시오.
한 칸에서 다른 칸으로 이동할 때, 서로 인접한 칸으로만 이동할 수 있다.
칸을 셀 때에는 시작 위치와 도착 위치도 포함한다.

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다.
다음 N개의 줄에는 M개의 정수로 미로가 주어진다.
각각의 수들은 붙어서 입력으로 주어진다.

첫째 줄에 지나야 하는 최소의 칸 수를 출력한다.
항상 도착위치로 이동할 수 있는 경우만 입력으로 주어진다.
'''
'''
4 6
101111
101010
101011
111011
>> 15

4 6
110110
110110
111111
111101
>> 9

2 25
1011101110111011101110111
1110111011101110111011101
>> 38

7 7
1011111
1110001
1000001
1000001
1000001
1000001
1111111
>> 13
'''

1. 답

import sys
from collections import deque

sys.stdin = open("input.txt", "r")

# 최단거리 문제는 bfs 로 품!!
def bfs(sx, sy, ex, ey):
    # q, v 초기화
    q = deque()
    v = [[0] * M for _ in range(N)]

    # 시작점 큐에 넣고 방문 처리
    q.append((sx, sy))
    v[sx][sy] = 1

    # 큐가 다 빌 때까지 반복
    while q:
        # 최하단 값 꺼내기
        x, y = q.popleft()

        # 목적지 여부 확인 및 정답 반환
        if (x, y) == (ex, ey):
            return v[x][y]

        # 4방향 비교 -> 조건 맞으면 큐 삽입 및 방문 처리
        for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            nx, ny = x + dx, y + dy
            # 범위 안에 있고, 갈 수 있는 길이며, 아직 방문하지 않은 곳이면
            if 0 <= nx < N and 0 <= ny < M and miro[nx][ny] == 1 and v[nx][ny] == 0:
                q.append((nx, ny))
                v[nx][ny] = v[x][y] + 1


# 하나씩 나눠서 변수에 담기 -> split()
N, M = map(int, sys.stdin.readline().split())
# 한 줄 통째로 받기 -> strip() 
# 101111 -> [1, 0, 1, 1, 1, 1]
miro = [list(map(int, sys.stdin.readline().strip())) for _ in range(N)]
v = [[0 for _ in range(M)] for _ in range(N)]

print(bfs(0, 0, N -1, M -1))

혼자서 풀어보려고 노력해봤지만 잘 안됐다 ㅠ

그래서 해설 영상을 찾아서 보고... 안보고 쳐보는 방식으로 해서 겨우겨우 통과했다.

BFS 문제를 많이 연습해봐야겠다!

그리고 손코딩을 먼저 하도록 습관을 들여봐야겠다.

바로 코드를 치려고 하니까 생각전개도 잘 안되고 막막하고 답답하더라.

물론? 손코딩 해도 뭐가 안되긴 함...

하다보면 어떻게든 손에 익겠지 뭐~

[Backjoon] 1026 - DFS와 BFS (sys.stdin.readline())

함s — Sat, 28 Dec 2024 19:20:33 +0900

0. 문제

'''
그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오.
단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고,
더 이상 방문할 수 있는 점이 없는 경우 종료한다.
정점 번호는 1번부터 N번까지이다.

# 입력
첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다.
다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다.
어떤 두 정점 사이에 여러 개의 간선이 있을 수 있다. 입력으로 주어지는 간선은 양방향이다.

# 출력
첫째 줄에 DFS를 수행한 결과를,
그 다음 줄에는 BFS를 수행한 결과를 출력한다.
V부터 방문된 점을 순서대로 출력하면 된다.
'''

'''
예제 1

4 5 1
1 2
1 3
1 4
2 4
3 4

1 2 4 3
1 2 3 4
'''

'''
예제 2

5 5 3
5 4
5 2
1 2
3 4
3 1

3 1 2 5 4
3 1 4 2 5
'''

'''
예제 3

1000 1 1000
999 1000

1000 999
1000 999
'''

1. 첫번째 답

from collections import deque

# 정점의 개수, 간선의 개수, 시작 정점 입력받기
n, m, v = map(int, input().split())
arr = [list(map(int, input().split())) for _ in range(m)]

# 그래프 생성
graph = {i: [] for i in range(1, n + 1)}  # 1부터 n까지의 정점 초기화
for i, j in arr:
    graph[i].append(j)
    graph[j].append(i)


# 그래프 오름차순 정렬
for key in graph:
    graph[key].sort()


def DFS(v):
    visited_dfs.append(v)   # 현재 정점 방문 처리

    # 현재 정점과 연결된 정점 정렬 후 방문
    for node in graph[v]:
        if node not in visited_dfs:
            DFS(node)


def BFS(v):
    queue = deque()
    queue.append(v)

    visited_bfs.append(v)   # 현재 정점 방문 처리

    # queue 가 다 빌 때까지 그래프 방문
    while queue:
        q = queue.popleft()     # 최하단 노드 뽑기

        for node in graph[q]:
            if node not in visited_bfs:
                visited_bfs.append(node)    # 방문처리
                queue.append(node)      # 큐에 미방문 노드 넣기


# 방문할 정점을 기록할 리스트
visited_dfs = []
DFS(v)
print(*visited_dfs)

visited_bfs = []
BFS(v)
print(*visited_bfs)

1. 입력받은 그래프를 딕셔너리로 재구성함

1 2

1 3

-> {1: [2, 3], 2: [1], 3: [1]}

처음에는 입력받은 내용 자체로 진행하려고 했는데 코드 진행이 잘 안풀렸음.

그래서 노드 별 연결된 인접 노드를 딕셔너리로 묶기로 함. (키 값으로 호출하기 위해서)

정점이 1000개인데 연결 노드가 1 라면 딕셔너리에 {999: [1000], 1000: [999]} 이렇게만 넣고 싶었는데

이렇게 if 문을 매 노드마다 거니까 런타임 에러가 나는거임..

그래서 그냥 딕셔너리를 정점 개수만큼 만들고 간선이 있는 노드에만 값을 append 해줌.

나는 이렇게 하면 메모리 낭비가 많이 일어날 거라고 생각했는데,

뤼튼 왈, 수만개까지 해도 충분히 처리할 수 있다고 함..

맞히긴 했는데 시간이 .. 무엇?

코드 리팩토링이 필요해보임.

2. 두번째 답

from sys import stdin as s
from collections import deque

# 정점의 개수, 간선의 개수, 시작 정점 입력받기
n, m, v = map(int, s.readline().split())

# 그래프 생성
graph = [[] for _ in range(n + 1)]  # 1부터 n까지의 정점 초기화
for _ in range(1, m + 1):
    a, b = map(int, s.readline().split())
    graph[a].append(b)
    graph[b].append(a)

# 그래프 오름차순 정렬
for nodes in graph:
    nodes.sort()

def DFS(v):
    visited_dfs.append(v)   # 현재 정점 방문 처리

    # 현재 정점과 연결된 정점 정렬 후 방문
    for node in graph[v]:
        if node not in visited_dfs:
            DFS(node)


def BFS(v):
    queue = deque()
    queue.append(v)

    visited_bfs.append(v)   # 현재 정점 방문 처리

    # queue 가 다 빌 때까지 그래프 방문
    while queue:
        q = queue.popleft()     # 최하단 노드 뽑기

        for node in graph[q]:
            if node not in visited_bfs:
                visited_bfs.append(node)    # 방문처리
                queue.append(node)      # 큐에 미방문 노드 넣기


# 방문할 정점을 기록할 리스트
visited_dfs = []
DFS(v)
print(*visited_dfs)

visited_bfs = []
BFS(v)
print(*visited_bfs)

속도를 높일 수 있는 방법을 찾다가, sys 로 여러줄의 입력값을 빠르게 받는 방법을 찾음.

그리고 딕셔너리를 정점 개수만큼 만들거면 리스트와 별 차이가 없어서 리스트로 바꿔봄.

속도가 반으로 줄어듦!

근데 ; Pypy로 제출하니까 속도가 100ms 나 줄었는데 메모리가.. 거의 세배를 .. 씀..

찾아보니, Pypy 는 반복문에 최적화되어 있어서 (그것땜에 메모리 씀)

- 속도가 중요한 문제일 경우 Pypy

- 메모리가 제한적인 경우 Python3 로 제출하는게 좋다고 한다!

3. 세번째 답

왠지 속도와 메모리 사용량을 더 줄일 방법이 있을 것 같아서 GPT 한테 방법을 물어봄.

메모리 최적화
1. visited를 집합(set)으로 변경
- 리스트에서의 탐색 시간 O(n) → 집합에서 탐색 시간 O(1).
- 메모리 사용량도 줄어듦.
2. defaultdict를 사용한 그래프 저장
- 불필요한 리스트 초기화를 줄여 메모리를 절약.
3. 재귀 DFS를 스택 기반 반복으로 변환
- 재귀 호출로 인해 발생하는 추가 스택 사용을 제거.

속도 최적화
1. 입력 처리 개선
- stdin.read로 대량 입력을 빠르게 처리.
2. 정렬된 상태로 그래프 저장
- 탐색할 때마다 정렬하지 않도록, 초기 정렬 시 처리.
3. 방문 여부 체크 최적화
- 리스트 기반 체크 → 집합 기반 체크.

from sys import stdin
from collections import deque, defaultdict

# 입력 받기
n, m, v = map(int, stdin.readline().split())

# 그래프 생성
graph = defaultdict(list)
for _ in range(m):
    a, b = map(int, stdin.readline().split())
    graph[a].append(b)
    graph[b].append(a)

# 그래프 정렬 (정렬된 상태로 저장)
for key in graph:
    graph[key].sort()

def DFS_iterative(v):
    stack = [v]
    visited = set()
    result = []

    while stack:
        node = stack.pop()
        if node not in visited:
            visited.add(node)
            result.append(node)
            # 방문할 노드를 역순으로 추가 (그래야 작은 노드부터 탐색)
            stack.extend(reversed(graph[node]))

    return result

def BFS(v):
    queue = deque([v])
    visited = set([v])
    result = []

    while queue:
        node = queue.popleft()
        result.append(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

    return result

# DFS와 BFS 실행
print(*DFS_iterative(v))
print(*BFS(v))

와웅..

이번엔 파이썬이 훨씬 빨라..

어웅 근데 아직 이 코드가 잘.. 뭔가 이해가 안된다.. 아직. 능력치 부족!

[이.코.테] DFS/BFS

함s — Sat, 14 Dec 2024 22:31:54 +0900

대표 문제 유형

1. 경로탐색 유형 (최단거리, 시간)

2. 네트워크 유형 (연결)

3. 조합 유형 (모든 조합 만들기)

	DFS	BFS
알고리즘 검증	동작 검증을 하기 쉬움	어려움
	코드 간결, 버그 발생할 가능성 적음
수행 시간	복불복	대박날 확률도 적지만 쪽박 찰 확율도 적다
= 시간 복잡도	높다	낮다
문제 난이도	쉬운 문제일 경우 추천	난이도 있어보이거나 DFS로 풀기 오래걸릴 것 같은 경우 추천

=> 한 문제를 두 방식으로 풀어보며 익혀두기

백준 연습 문제

1260 -- DFS와 BFS : 그래프에서 DFS / BFS 연습

2606 -- 바이러스 : 그래프에서 DFS 활용 연습

2667 -- 단지번호붙이기 : DFS를 이용한 Flood Fill 연습

2178 -- 미로탐색 : BFS로 4방향 탐색 연습

7569 -- 토마토 : BFS로 6방향 탐색 연습

1. DFS (Depth-First Search)

- 깊이 우선 탐색

- 스택 방식으로 재귀 함수 이용 (한 놈만 끝까지 패는 유형)

-- 재귀를 계속 타다가 탈출 조건에 먼저 도달하고, 그 다음에 파라미터를 하나씩 바꿔 가면서 정답을 찾는 방식

-- 재귀 깊이가 지나치게 깊어지면 메모리 비용을 예측하기 어렵다.

=> 데이터 사이즈가 일정 이상이면 비추천.

- 모든 노드를 방문하고자 할 때 사용

--- 조합을 만들고 정답과 비교

=> 최단 경로를 알 수 없다.

- BFS (Breadth-First Search) 너비우선 탐색보다 간단하지만 단순 검색 속도 자체는 느리다.

1. 탐색 시작 노드를 스택에 삽입, 방문 처리

2-1. 스택의 최상단 노드에 방문하지 않은 인접노드가 있으면 그 인접노드를 스택에 넣고 방문 처리,
2-2. 방문하지 않은 인접노드가 없으면 스택에서 최상단 노드를 꺼냄
(인접노드 방문순서는 문제에서 주어진 조건으로. 없다면 관행적으로 번호가 낮은 순서부터 처리)

3. 2번 과정을 더 이상 수행할 수 없을 때까지 반복

def dfs(graph, v, visited):
	visited[v] = True	# 현재 노드 방문 처리
    print(v, end=' ')
    
    for i in graph[v]:	# 현재 노드와 연결된 다른 노드 방문
    	if not visited[i]:
        	dfs(graph, i, visited)


# 각 노드의 연결정보 (2차원 리스트)
graph = [
	[],			# 인덱스가 1부터 시작하기 때문에 [0]에 빈 리스트 삽입
    [2, 3, 8],
    [1, 7],
    [1, 4, 5],
    [3, 5],
    [3, 4],
    [7],
    [2, 6, 8],
    [1, 7]
]

# 방문 정보 (1차원 리스트)
visited = [False] * 9	# 인덱스 0을 사용하지 않기 위해 +1

dfs(graph, 1, visited)

2. BFS (Breadth-First Search)

- 너비 우선 탐색: 가까운 노드부터 탐색

- 큐 자료구조 사용 (여러 놈을 한대씩 때리면서 가는 유형)

-- 가장 먼저 넣은 것을 꺼내서 연결된 점을 큐에 넣는 방식으로 진행.

--- 순서가 보장되어야 하기 때문에 큐 사용

- 시간/공간 복잡도 면에서 안정적.

- 최단 거리를 구하는 목적으로 사용할 수 있음.

-- 간선의 비용이 모두 같을 경우

--- 각각 다를 경우, 다익스트라 알고리즘 등의 최단거리 알고리즘을 활용해야 한다.

1. 탐색 시작 노드를 큐에 삽입하고 방문 처리

2. 큐에서 노드를 꺼낸 뒤, 해당 노드의 인접 노드 중에서 방문하지 않은 노드를 모두 큐에 삽입하고 방문 처리

3. 2번 과정을 더이상 수행할 수 없을 때까지 (큐가 완전히 빌 때까지) 반복
3-1. 꺼낸 노드가 목표 지점이면 루프 종료
3-2. 목표 지점을 찾지 못했어도 더 갈 수 있는 지점이 없으면 루프 종료

from collections import deque

def bfs(graph, start, visited):
	queue = deque([start])
    visited[start] = True
    
    # 큐가 빌 때까지 반복
    while queue:
    	v = queue.popleft()
        print(v, end=' ')
        
        # 아직 방문하지 않은 인접한 원소들을 큐에 삽입
        for i in graph[v]:
        	if not visited[i]:
            	queue.append(i)
                visited[i] = True
      
      
# 각 노드의 연결정보 (2차원 리스트)
graph = [
	[],			# 인덱스가 1부터 시작하기 때문에 [0]에 빈 리스트 삽입
    [2, 3, 8],
    [1, 7],
    [1, 4, 5],
    [3, 5],
    [3, 4],
    [7],
    [2, 6, 8],
    [1, 7]
]

# 방문 정보 (1차원 리스트)
visited = [False] * 9	# 인덱스 0을 사용하지 않기 위해 +1

bfs(graph, 1, visited)

깊이 우선 탐색(DFS)

최근에 첨가된 노드를 선택하고, 트리에서 다음 수준의 한 개의 자식노드를 첨가하며 목표 노드일 때까지 앞의 자식 노드의 첨가 과정을 반복하는 알고리즘

velog.io

https://www.youtube.com/watch?v=7C9RgOcvkvo&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC&index=4

https://www.youtube.com/watch?v=BsYbdUnKZ-Y

https://www.youtube.com/watch?v=By77aC9Oe3Q

[이.코.테] DFS/BFS 사전 학습 -- 스택, 큐, 재귀 함수

함s — Fri, 13 Dec 2024 22:44:45 +0900

DFS/BFS 는 대표적인 탐색 알고리즘이다.

탐색이란, 많은 양의 데이터 중에서 원하는 데이터를 찾는 과정이다.

그래프, 트리 등의 자료구조 안에서 탐색을 하는 문제를 자주 다루기 때문에

기본 자료구조인 스택과 큐에 대해 제대로 이해하고 있어야 한다.

자료구조란, 데이터를 표현하고 관리하고 처리하기 위한 구조이다.

스택과 큐의 자료구조는 삽입(Push), 삭제(Pop), 오버플로, 언더플로 등을 고려해야 한다.

** 오버플로 - 수용 크기가 가득 찬 상태에서 삽입 연산 수행시 발생

** 언더플로 - 데이터가 전혀 없는 상태에서 삭제 연산 수행시 발생

1. 스택 (Stack)

- 선입후출, 후입선출 (ex. 박스 쌓기)

stack = []

stack.append(5)
stack.append(2)
stack.append(3)
stack.append(7)
stack.pop()			# 7 삭제
stack.append(1)
stack.append(4)
stack.pop()			# 4 삭제

print(stack)		# 최하단 원소부터 출력	# [5, 2, 3, 1]
print(stack[::-1])	# 최상단 원소부터 출력	# [1, 3, 2, 5]

2. 큐 (Queue)

- 선입선출 (FIFO) (ex. 대기줄)

- 기존 list 를 활용해서 구현할 수 있지만, 그러면 시간복잡도가 높아서 꼭 deque 라이브러리를 사용해 구현하도록 한다.

from collections import deque

queue = deque()

queue.append(5)
queue.append(2)
queue.append(3)
queue.append(7)
queue.popleft()	# 5 삭제
queue.append(1)
queue.append(4)
queue.popleft()	# 2 삭제

print(queue)	# 먼저 들어온 순서대로 출력	# deque([3, 7, 1, 4])
queue.reverse()	# 역순 변경
print(queue)	# 나중에 들어온 원소부터 출력	# deque([4, 1, 7, 3])

3. 재귀함수 (Recursive Function)

- 자기 자신을 다시 호출 (스택 방식)

-- 컴퓨터가 함수를 연속 호출하며 메모리 내부의 스텍 프레임에 쌓인다.

--- 그래서 스택 알고리즘을 구현할 때 재귀함수를 이용하는 경우가 많다!

- 재귀 함수의 종료 조건을 반드시 명시해야 한다. (무한호출 -> 오류발생)

- 코드가 더 간결하고 반복문 없이 같은 효과를 낼 수 있음.

- 다만, 경우에 따라 재귀함수가 반복문보다 유리하거나 불리할 수 있어서 신중히 사용해야 한다.

# 반복문으로 구현한 n!
def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
    	result *= i
    return result

# 재귀적으로 구현한 n!
def factorial_recursive(n):
    if n <= 1 :			# 0! == 1! == 1
    	return 1
    return n * factorial_recursive(n - 1)

# 최대공약수 계산 (유클리드 호제법)
def gcd(a, b)
    if a % b == 0:
    	return b
    else:
    	return gcd(b, a % b)

[이.코.테] 구현 (2) -- 시각, 왕실의 나이트, 게임 개발

함s — Wed, 4 Dec 2024 21:06:56 +0900

1. 시각

처음엔 시간 따로, 분 따로, 초 따로 정수를 체크했는데 ,

계속 답이 맞기 않길래 슬쩍 답지 봤더니 .. 체크를 마지막에 한 번만 하더라.

# 정수 N이 입력되면
# 00시 00분 00초 부터 N시 59분 59초까지의 모든 시각 중에서
# 3이 하나라도 포함되는 모든 경우의 수를 구하라
# hour : 00 ~ N
# minute : 00 ~ 59
# second : 00 ~ 59

def case_include_3():
    cnt = 0
    num = input("5 -- ")

    for h in range(int(num)+1):
        for m in range(60):
            for s in range(60):
                # 매 시각 안에 '3'이 포함되어 있다면 카운트 증가
                if '3' in str(h)+str(m)+str(s):
                    cnt += 1
    return cnt

# print(case_include_3())     # 5 -> 11475

2. 왕실의 나이트

8가지 경우의 수를 하나씩 생각하며 if 문 만들고 있으려니..

이게 답이 아닌 건 알겠는데, 어떻게 간추려야 할지를 모르겠더라.

그래서 기브업 치고 답지 봤는데 이동 경우의 수를 배열로 선언해놓고 .. 하나씩 꺼내가며..

이런 발상 예전에 접해본 적 있는데 아직 내 것이 안 된 것 같았다.

그래도 문자를 ord 로 숫자로 바꿔서 접근한 건 잘했다~

# 행 (1~8), 열 (a~h)
# 나이트는 8X8 밖으로 나갈 수 없다.
# 1. 수평 2칸 -> 수직 1칸 이동
# 2. 수직 2칸 -> 수평 1칸 이동
def royal_knight():
    # 8X8 좌표 평면 상 현재 나이트의 좌표 문자열 입력 -- 열+행 (a1)
    x, y = input("a1 -- ")
    x = ord(x) - ord('a') + 1
    y = int(y)
    steps = [(-2, -1), (-2, 1), (2, -1), (2, 1), (-1, -2), (1, -2), (-1, 2), (1, 2)]
    cnt = 0

    for step in steps:
        x, y = x + step[0], y + step[1]
        if 1 <= x <= 8 and 1 <= y <= 8:
            cnt += 1

    # 나이트가 이동할 수 있는 경우의 수 반환
    return cnt

# print(royal_knight())

'''
# 현재 나이트의 위치 입력받기
input_data = input()
row = int(input_data[1])
col = int(ord(input_data[0])) - int(ord('a')) + 1

# 나이트가 이동할 수 있는 8가지 방향 정의
steps = [(-2, -1), (-1, -2), (1, -2), (2, -1), (2, 1), (1, 2), (-1, 2) (-2, 1)]

# 8가지 방향에 대하여 각 위치로 이동이 가능한지 확인
result = 0
for step in steps:
    # 이동하고자 하는 위치 확인
    next_row = row + step[0]
    next_col = col + step[1]
    
    # 해당 위치로 이동이 가능하다면 카운트 증가
    if 1 <= next_row <= 8 and 1 <= next_col <= 8:
        result += 1

return result


# 8x8 좌표 평면 상 현재 나이트의 좌표 문자열 입력 -- 열+행 (예: "a1")
position = input("Enter the knight's position (e.g., a1): ")
x, y = ord(position[0]), int(position[1])  # x는 문자('a'-'h'), y는 숫자(1-8)
cnt = 0

# 나이트가 이동할 수 있는 8가지 방향 정의 (수평2칸+수직1칸 / 수직2칸+수평1칸)
moves = [
    (-2, -1), (-2, 1),  # 수직 2칸, 수평 1칸
    (-1, -2), (-1, 2),  # 수직 1칸, 수평 2칸
    (1, -2), (1, 2),    # 수직 1칸, 수평 2칸
    (2, -1), (2, 1)     # 수직 2칸, 수평 1칸
]

# 모든 방향에 대해 이동 가능 여부 확인
for move in moves:
    nx = x + move[0]  # 새로운 x좌표 (열)
    ny = y + move[1]  # 새로운 y좌표 (행)
    
    # 새로운 좌표가 8x8 체스판 범위를 벗어나지 않으면 카운트 증가
    if ord('a') <= nx <= ord('h') and 1 <= ny <= 8:
        cnt += 1
        
# 나이트가 이동할 수 있는 경우의 수 반환
return cnt
'''

3. 게임 개발

와 진짜 어려웠다.. 문제 읽는데 머리가 돌아버릴 것 같아서 난이도 보니까 Level.2 였다!!

역시 알고리즘 문제에서 제일 중요한 건,

** 조건을 잘 읽고

** 그룹화 하고 (나열 XXX)

** 전체 설계를 하고 덤벼야 한다!!

그리고 자기 수준에 맞는 난이도의 문제부터 잘 풀어야 함...

이제 Level.1 문제가 어느정도 만만하게 느껴질 때까지는 Level.1 문제만 주구장창 풀어야겠다.

이거 원... 문제를 이해하는 것도, 로직 짜는 것도, 짜여진 로직 읽는 것도 머리가 빙빙 돌더라

# N X M -- 육지(0) or 바다(1) (바다는 못 감)
# (A, B)
# 상하좌우 -- 순서가 되면
# 0. 일단 왼쪽으로 몸을 돌려
# 1. 아직 가보지 않은 칸 -> 앞으로 한 킨
# 2. 가본 칸 -> 멈추고 0번으로
# 3. 네 방향 모두 가봤거나, 앞이 바다일 경우 -> 한칸 뒤로 가고 0번으로
# 4. 3번일 때, 뒤가 바다라면 멈추기
# 캐릭터가 방문한 칸 수 출력

def game_map():
    # 맵 크기 N x M
    n, m = map(int, input("4 4 -- ").split())
    # 캐릭터 서있는 위치 A, B, 방향(북동남서 0123)
    a, b, d = map(int, input("1 1 0 -- ").split())
    # 전체 맵 정보 입력 -- 육지(0), 바다(1)
    field = [list(map(int, input().split())) for _ in range(n)]
    
    # 북동남서
    steps = [(-1, 0), (0, -1), (1, 0), (0, 1)]

    ''' 방문한 위치를 저장하기 위한 맵을 생성하여 0으로 초기화 '''
    done = [[0] * m for _ in range(n)]
    ''' 서있는 곳 가본 곳으로 체크 '''
    done[a][b] = 2

    ''' 방문한 칸 수 -> 시작점도 방문했다고 생각해야 함 '''
    result = 1
    ''' 네 방향 모두 가봤는 지 체크 '''
    turn_time = 0

    while True:
        # 왼쪽으로 회전
        d = 0 if d == 3 else d + 1
        # 한 칸 앞 위치
        new_a, new_b = a + steps[d][0], b + steps[d][1]

        # 맵 안에서만 움직이기
        if 0 <= a <= n and 0 <= b <= m:
            ''' 조건을 순서대로 생각하지 말고 그룹화를 잘 해야 함 '''
            # 정면에 가보지 않은 칸이 있다면
            if done[new_a][new_b] == 0 and field[new_a][new_b] == 0:
                done[new_a][new_b] = 2     # 가본 곳으로 체크
                a, b = new_a, new_b         # 앞으로 한 칸 가기
                result += 1
                turn_time = 0
                continue

            # 정면에 가보지 않은 칸이 없거나 바다인 경우
            else:
                turn_time += 1

            # 네 방향 모두 갈 수 없는 경우
            if turn_time == 4:
                new_a, new_b = a - steps[d][0], b - steps[d][1]
                # 뒤쪽이 바다가 아니라면 한 칸 뒤로 가기
                if field[new_a][new_b] == 1:
                    a, b = new_a, new_b  # 뒤로 한 칸 가기
                else:
                    break
                turn_time = 0

        else:
            break

    return result


# 입력 예시
"""
4 4
1 1 0
1 1 1 1
1 0 0 1
1 1 0 1
1 1 1 1
"""
print(game_map())  # 출력: 3


'''
# N, M을 공백으로 구분하여 입력받기
n, m = map(int, input().split())

# 방문한 위치를 저장하기 위한 맵을 생성하여 0으로 초기화
d = [[0] * m for _ in range(n)]
# 현재 캐릭터의 X 좌표, Y 좌표, 방향을 입력받기
x, y, direction = map(int, input().split())

# 현재 좌표 방문 처리
d[x][y] = 1

# 전체 맵 정보를 입력받기
array = []
for i in range(n):
    array.append(list(map(int, input().split())))

# 북, 동, 남, 서 방향 정의
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]

# 왼쪽으로 회번
def turn_left():
    global direction    # 전역변수 불러옴
    direction -= 1
    if direction == -1:
        direction = 3

# 시뮬레이션 시작
count = 1
turn_time = 0
while True:
    # 왼쪽으로 회전
    turn_left()
    nx = x + dx[direction]
    ny = y + dy[direction]
    
    # 회전한 이후 정면에 가보지 않은 칸이 존재하는 경우 이동
    if d[nx][ny] == 0 and array[nx][ny] == 0:
        d[nx][ny] = 1
        x, y = nx, ny
        count += 1
        turn_time = 0
        continue
    # 회전한 이후 정면에 가보지 않은 칸이 없거나 바다인 경우
    else:
        turn_time += 1
    
    # 네 방향 모두 갈 수 없는 경우
    if turn_time == 4:
        nx = x - dx[direction]
        ny = y - dy[direction]
        # 뒤로 갈 수 있다면 이동하기
        if array[nx][ny] == 0:
            x, y = nx, ny
        # 뒤가 바다로 막혀있는 경우
        else:
            break
        turn_time = 0
        
# 정답 출력
print(count)
'''

[Programers] 구현 / 최소직사각형 -- max(iterable), 리스트 병합 (+, extend, sum(_,[])

함s — Wed, 27 Nov 2024 20:50:28 +0900

1. 내 코드

def solution(sizes):
    answer = 0
    w, h = 0, 0

    for card in sizes:
        # 카드의 w, h 를 오름차순으로 정렬
        card.sort()

        # w, h 각각의 최댓값을 변수로 할당
        if card[0] > w:
            w = card[0]
        if card[1] > h:
            h = card[1]

    # w, h의 최댓값을 곱해 최소한의 크기를 반환
    return w * h

직관적이고 명확하지만,

sort() 를 굳이 쓰지 않아도 되는 부분에서 사용해서 다소 비효율적이다.

간단한 정렬은 조건문으로 처리하자!!

2. 다른 사람 풀이

def solution(sizes):
    return max(max(x) for x in sizes) * max(min(x) for x in sizes)

가장 간결하고 효율적이다.

1. sizes = [[10, 20], [30, 40], [50, 60]]

2. for 문으로 sizes 배열에서 값을 하나 꺼내온다. -- [10, 20]
3. 그 값 중 최댓값을 꺼낸다. -- max(10, 20) = 20

4. sizes 배열을 돌며 각 값들의 최댓값을 구해서 모은다. -- max(20, 40, 60) = 60

5. 같은 순서로 sizes 배열을 돌며 각 값들의 최솟값을 구해서 모은다. -- max(10, 30, 40) = 40

6. 그 둘의 곱을 반환한다.

max(max()) 구조도 처음 봤고,

max(iterable) 에 for 문을 넣을 수 있는 것도.. 분명 알고는 있었던 거 같은데

이번에는 왜 생각을 못했는지! 아쉽다!

너무 '정렬' 에만 꽂혀있었던듯!

def solution(sizes):
    row = 0
    col = 0
    for a, b in sizes:
        if a < b:
            a, b = b, a
        row = max(row, a)
        col = max(col, b)
    return row * col

직관적이고 효율적이다.

굳이 sort 를 쓸 필요 없이 조건문으로 간단하게 정렬한 부분이 인상깊다.

solution = lambda sizes: max(sum(sizes, [])) * max(min(size) for size in sizes)

sizes = [[10, 20], [30, 40]]
sum(sizes, [])  # Flattens to [10, 20, 30, 40]

왜 이 코드에 sum() 이 등장하나 했더니, 리스트 속 리스트를 평탄화하는, 즉, 리스트끼리의 덧셈 용으로 쓰였다.

sizes 의 모든 숫자 중 가장 큰 숫자를 구하고 <- 평탄화

sizes 속 값의 가장 작은 수 중 가장 큰 수를 구해서 서로 곱한다..

** 리스트 병합

A.extend(B)

: 가장 효율적이다. 기존 리스트 A의 값이 변형된다.

: O(B)

A + B (Concatenation)

: 리스트가 병합될 때마다 새로운 리스트가 만들어져 약간의 오버헤드가 발생한다.

: O(B)

sum(List, [])

: sum() 은 리스트에 최적화되어있지 않아서 병합 목적으로 사용하면 다른 메서드보다 느리고 오버헤드가 많이 발생한다.

: 병합될 때마다 새로운 리스트가 만들어진다.

: O(List)

https://blockdmask.tistory.com/558

[python] 파이썬 리스트 합치기 (+, extend, sum)

안녕하세요. BlockDMask입니다. 오늘은 파이썬에서 리스트를 합치는 방법에 대해서 알아보겠습니다. 1. +로 리스트 합치는 방법 2. extend로 리스트 합치기 3. sum으로 이중 리스트 합치기 1. 파이썬 리

blockdmask.tistory.com

[이.코.테] 구현 (1) -- 상하좌우

함s — Wed, 27 Nov 2024 10:12:52 +0900

구현 알고리즘이란?

풀이를 떠올리는 것은 쉽지만 소스코드로 옮기기 어려운 문제.

알고리즘은 간단한데 코드가 지나칠 만큼 길어지는 문제.

(ex. 특정 소수점 자리까지 출력, 문자열 입력을 한 문자 단위로 파싱 등 )

사소한 조건 설정이 많은 문제일 수록 코드로 구현하기 까다로움.

프로그래밍 문법을 정확히 숙지하고 라이브러리 사용 경험이 풍부해야 함.

* 구현이 핵심이 되는 유형

- 완전 탐색 : 모든 경우의 수를 주저 없이 다 계산하는 해결 방법

- 시뮬레이션 : 문제에서 제시한 알고리즘을 한 단계씩 차례대로 직접 수행

구현 시 고려해야 할 메모리 제약 사항

1. int 크기 제약

대체로 long long 에서 다룰 수 있는 수보다 더 큰 정수를 처리하는 문제는 잘 출제되지 않는다.

Java -- long long, BigInteger(클래스. 범위제한없음)

Python -- 직접 자료형을 지정할 필요가 벗으며 매우 큰 수의 연산 또한 기본으로 지원

2. 파이썬에서 리스트 크기

대체로 코딩 테스트에서는 128 ~ 512MB로 메모리 제한하고

문제 중 때로는 수백만 개 이상의 데이터를 처리해야 하는 문제가 출제되곤 함.

즉, 메모리 제한을 염두에 두고 코딩을 해야 함.

일반적인 코딩 테스트 수준에서는 메모리 사용량 제한보다 더 적은 크기의 메모리를 사용해야 한다.

구현 문제에 접근하는 방법

보통 문제에서 사소한 입력 조건 등을 명시해주기 떄문에 문제 길이가 꽤 긴 편.

그러나 고차원적인 사고력을 요구하는 문제는 나오지 않아서

문법에 익숙하면 오히려 쉽게 풀 수 있다.

파이썬은 기본 문법만 알아도 상대적으로 구현 유형의 문제를 쉽게 해결할 수 있다.

다만, C/C++ 이나 Java 에서는 문자열 처리가 까다롭고 큰 정수를 처리하는 라이브러리를 별도로 사용해야 하기 때문에

더 어렵게 다가올 수 있다.

# N x N 크기의 정사각형 공간에서 입력 방향대로 움직임
def up_down_left_right():
    position = [1, 1]

    N = int(input("5 -- "))
    direction = list(input("R R R U D D -- ").split())

    for d in direction:
        if d == 'L':
            if position[1] > 1:
                position[1] -= 1
        elif d == 'R':
            if position[1] < N:
                position[1] += 1
        elif d == 'U':
            if position[0] > 1:
                position[0] -= 1
        elif d == 'D':
            if position[0] < N:
                position[0] += 1

    return position

print(*up_down_left_right())

'''
# N을 입력받기
n = int(input())
x, y = 1, 1
plans = input().split()

# L, R, U, D 에 따른 이동 방향
dx = [0, 0, -1, 1]
dy = [-1, 1, 0, 0]
move_types = ['L', 'R', 'U', 'D']

# 이동 계획을 하나씩 확인
for plan in plans:
    # 이동 후 좌표 구하기
    for i in range(len(move_types)):
        if plan == move_types[i]:
            nx = x + dx[i]
            ny = y + dy[i]
            
    # 공간을 벗어나는 경우 무시
    if nx < 1 of ny < 1 or nx > n or ny > n:
        continue
    
    # 이동 수행
    x, y = nx, ny

print(x, y)
        
'''

[Programers] 그리디 / 예산 -- sorted()

함s — Tue, 26 Nov 2024 14:13:49 +0900

1. 내 코드

# 각 부서가 신청한 금액만큼을 모두 지원
# 최대 몇 개의 부서
def solution(d, budget):
    total = 0
    
    # 적은 금액부터 차례로 더해서 budget 이 커버 가능한 최대 개수 return
    for i, req in enumerate(sorted(d)):
        total += req
        
        # total 이 budget 을 넘을 경우
        if total > budget:
            return i

    # total 이 budget 보다 작을 경우
    return len(d)

sort 를 써서 복잡도는 배열길의 n 의 O(nlogn) 이 된다.

일차 반복문 -- O(n)

합 및 비교 연산 -- O(1)

=> 최종 복잡도는 O(nlogn) 이 된다.

2. 다른 사람 풀이

def solution(d, budget):
    d.sort()
    while budget < sum(d):
        d.pop()
    return len(d)

이 코드는 프로그래머스에서 좋아요 제일 많이 받은 코드.

sum() 자체는 복잡도가 O(n) 이지만,

while 문이 돌 때마다 매번 다른 값을 sum 해야 해서 복잡도가 O(n²) 이 된다.

그래도 d 에서 하나씩 뺀 다음 길이만 반환하는 로직이 흥미로움.

def solution(d, budget):
    d.sort()
    cnt = 0
    for i in d :
        budget -= i
        if budget < 0 :
               break
        cnt += 1
    return cnt

budget 에서 아이템을 하나씩 빼는 방식으로 풀이한 코드.

enumerate 썼으면 cnt 변수 선언할 필요 없이 더 깔끔하게 코드 나올 듯.

나처럼 계산 내역을 변수에 다 담아두지 않아도 되고!

[Programers] 그리디 / 체육복 -- [:], set, &

함s — Mon, 25 Nov 2024 14:07:02 +0900

1. 내 코드

for 문에서 리스트를 직접 수정할 경우 수정 직후 반복문이 끝나게 된다.

그래서 lost=[3,4] reserve=[4,3] 케이스에서 3만 없어지고 4는 남게 됨.

이럴 경우, [:] 를 써서 리스트 카피본으로 반복문을 돌리면 반복문이 끝까지 다 돌 수 있다.

내 코드의 복잡도는 이중 반복문 (X) 과 sort (log) 로,

L (lost size), R (reserve size) 라고 할 때,

O(L x R + LlogL) 이다.

def solution(n, lost, reserve):
    answer = 0

    # 여벌 체육복 중 하나만 도난당했을 경우
    for l in lost[:]:
        if l in reserve:
            lost.remove(l)
            reserve.remove(l)
            
    if len(lost) > 1: lost.sort()
     
    # 체육복 나누기
    for num in lost:
        # 여벌 학생이 없으면 반복문 탈출
        if not reserve:
            break

        # 앞 뒤로 도난 학생 여부 파악 -> 나눠주고 여벌 학생 리스트 제거
        if (num - 1) in reserve:
            reserve.remove(num - 1)
        elif (num + 1) in reserve:
            reserve.remove(num + 1)
        else:
            continue
        
        answer += 1
        
        
    answer += n - len(lost)
    
    return answer

2. GPT 코드

set 을 써서 중복을 제거하면 복잡도를 x -> + 로 낮출 수 있다.

list 자료형을 set(집합)으로 변환한 뒤

& 연산자를 통해 교집합을 추출하여 중복을 제거한다.

이렇게 하면 복잡도는 O(LlogL + R) 이 되어 이중반복문을 돌릴 때보다 낮은 복잡도를 갖게 된다.

def solution(n, lost, reserve):
    # Convert lists to sets for efficient operations
    lost_set = set(lost)
    reserve_set = set(reserve)
    
    # Remove students who have both lost and reserved a uniform
    overlap = lost_set & reserve_set
    lost_set -= overlap
    reserve_set -= overlap

    answer = n - len(lost_set)  # Start with the number of students who already have uniforms

    # Distribute uniforms
    for student in sorted(lost_set):
        if student - 1 in reserve_set:
            reserve_set.remove(student - 1)
            answer += 1
        elif student + 1 in reserve_set:
            reserve_set.remove(student + 1)
            answer += 1

    return answer

https://ctkim.tistory.com/entry/Python-%EC%9E%85%EB%AC%B8-%EA%B0%95%EC%A2%8C-12-%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%A7%91%ED%95%A9Set-%EC%A0%95%EB%A6%AC-%EB%B0%8F-%EC%82%AC%EC%9A%A9%EB%B2%95

[Python 입문 강좌 - 12] 파이썬 집합(Set) 정리 및 사용법

더보기 ##파이썬 입문 목차 1. 파이썬 이란? 2-1. 파이썬 윈도우 설치 2-2. 파이썬 맥북 설치 2-3. 윈도우 파이썬 IDE 파이참 설치하기 2-4. 맥북 파이썬 IDE 파이참 설치하기 3. 파이썬 변수(Variable)의 정

ctkim.tistory.com

[이.코.테] 그리디 (3) -- 1이 될 때까지

함s — Sun, 24 Nov 2024 22:15:49 +0900

# N이 1이 될 떄까지 1 혹은 2 과정을 수행해야 하는 횟수의 최솟값
# 1) N-1
# 2) N/K -- N이 K로 나누어떨어질 떄에만 선택 가능

def until_one():
    n, k = map(int, input("25 5 --").split())
    result = 0
    while n != 1:
        if n % k == 0:
            n /= k
        else:
            n -= 1
        result += 1
    return result

print(until_one())

'''
# K로 가능한 한 많이 나눴을 때 가장 빠르게 N=1 만들 수 있다.
# N이 K의 배수가 되도록 효율적으로 한 번에 빼는 방식

# N, K를 공백으로 구분하여 입력받기
n, k = map(int, input("25 5 --").split())
result = 0

while True:
    # (N == K 로 나누어 떨어지는 수)가 될 때까지 1씩 빼기
    target = (n // k) * k   # 25    # 5     # 0
    result += (n - target)  # 0     # 1+0   # 2+1
    n = target              # 25    # 5     # 0
    
    # N이 K보다 작을 때 (더이상 나눌 수 없을 때) 반복문 탈출
    if n < k:       # 25<5  # 5<5   # 0<5
        break       # result 가 3이 될 때 탈출
    
    # K로 나누기
    result += 1     # 1     # 2
    n //= k         # 5     # 1

# 마지막으로 남은 수에 대하여 1씩 빼기
result += (n - 1)   # 3-1
print(result)       # 2
'''

[이.코.테] 그리디 (2) -- 큰 수의 법칙

함s — Sat, 23 Nov 2024 23:55:58 +0900

# 배열의 수들을 M번 더하여 가장 큰 수를 만드는 법칙.
# 단, 특정 인덱스에 해당하는 수가 연속해서 K번 초과하여 더해질 수는 없음.
# 인덱스가 다른데 값이 같을 경우 서로 다른 값으로 간주함.
# N: 배열 크기, M: 숫자 더하는 횟수, K: 연속해서 더할 수 있는 횟수

# N, M, K 공백으로 구분하여 입력 받기
n, m, k = map(int, input().split())

# N개의 자연수 공백으로 구분하여 입력 받기
data = list(map(int, input().split()))

max_value = max(data)   # 가장 큰 수
data.remove(max_value)
next_max = max(data)    # 두 번째로 큰 수

result = 0
cnt = k
# 가장 큰 수를 더하는데, 연속해서 K번 더할 수는 없음
for i in range(m):
    if cnt == 0:
        # 두 번째로 큰 수를 한 번 더하기
        result += next_max
        cnt = k
    else :
        # 가장 큰 수를 k번 더하기
        result += max_value
        # 더할 때마다 1씩 빼기
        cnt -= 1

print(result)


'''
n, m, k = map(int, input().split())
data = list(map(int, input().split()))
data.sort()     # 입력받은 수들 정렬하기
first = data[n - 1]
second = data[n - 2]

# [1] 단순하게 푸는 방법

result = 0
while True:
    for i in range(k):  # 가장 큰 수 k번 더하기
        if m == 0:
            break
        result += first
        m -= 1  
    if m == 0:
        break 
    result += second
    m -= 1


# [2] 수학 공식 이용

# 가장 큰 수가 더해지는 횟수 계산
count = int(m/(k+1)) * k
count += m % (k+1)

result = 0
result += (count) * first   # 가장 큰 수 더하기
result += (m-count) * second    # 두 번째로 큰 수 더하기

print(result)

'''

[이.코.테] 그리디 (1) -- 숫자 카드 게임

함s — Fri, 22 Nov 2024 23:32:21 +0900

그리디 알고리즘이란?

어떠한 문제가 있을 때, 단순 무식하게, *탐욕적으로 푸는 알고리즘.

(탐욕적: 현재 상황에서 가장 좋은 것만 고르는 방법)

현재의 선택이 나중에 미칠 영향에 대해서는 고려하지 않는다.

즉, 사전에 외우고 있지 않아도 풀 수 있을 가능성이 높은 문제 유형.

단, 많은 유형을 접해보고 문제를 풀어보며 훈련을 해야한다.

창의력이 중요함!

그리고 문제 풀이를 위해 해법을 찾을 때, 이것이 정당한지 검토해야 답을 도출할 수 있다.

문제 유형 파악이 어렵다면 그리디 알고리즘을 의심하고,

오랜 시간 고민해도 그리디 알고리즘으로 해결방법을 찾을 수 없다면, 그때는 다른 알고리즘 방법을 떠올려보다.

# 여러 개의 숫자 카드 중 가장 높은 숫자가 쓰인 카드 한장을 뽑는 게임
# 행을 선택 -> 가장 숫자가 작은 카드 뽑음
# 행마다 가장 작은 숫자를 뽑지만, 최종적으로는 가장 높은 숫자를 뽑아야 한다.
# 즉, 각 행의 가장 작은 숫자들 중 가장 큰 수를 찾아야 한다.

# n: 행, m: 열
n, m = map(int, input("3 4").split())
num = []

# 한 줄 씩 입력을 받고, 거기서 가장 작을 수를 뽑는다.
for _ in range(n):
    num.append(min(map(int, input().split())))

# 가장 작은 수들 중에서 가장 큰 수를 리턴.
# 이렇게 결과물을 모두 담고 한번에 계산할 경우, 메모리를 필요 이상으로 쓰게 된다.
print(max(num))

'''
## min() 함수 이용

result = 0
for i in range(n):
    data = list(map(int, input().split()))
    min_value = min(data)
    result = max(result, min_value)
    # 이렇게 하면 숫자를 전부 담지 않고 그때그때 값을 비교하므로 메모리 사용이 덜할 것 같다.
'''
'''
## 2중 반복문 구조 이용  

result = 0
for i in range(n):
    data = list(map(int, input().split()))

    # 각 숫자는 1 이상 10,000 이하의 자연수 
    # => 나올 수 없는 가장 큰 수(10001)를 설정하여 무조건 첫 비교 시 min_value 에 값 할당하도록 함.
    min_value = 10001
    for a in data:
        min_value = min(min_value, a)

    result = max(result, min_value)
'''

[이.코.테] 알고리즘 문제 해결 과정

함s — Thu, 21 Nov 2024 23:32:07 +0900

파이썬 기초 문법 문제를 대략 180개 정도 풀었더니 약간 자신감이 생겨서

이젠 진짜 알고리즘 강의를 들어봐도 좋을 것 같다는 생각이 들었다.

유튜브에 이코테 강의가 있어서 한번 들어봤다.

시간제한(수행시간 요구사항)

시간 제한이 1초인 경우, (파이썬의 경우) 해당 시간 복잡도의 알고리즘을 구현하는게 좋다.

( 여기서 N은, [1, 2, 3, 4] 일 경우 4 가 된다.)

N의 범위	시간 복잡도	명칭
500	O(N3)	삼차 시간
2,000	O(N2)	이차 시간
100,000	O(NlogN)	로그 선형 시간
10,000,000	O(N)	선형 시간

알고리즘 문제 해결 과정

1. 지문 읽기. -- 컴퓨터적 사고를 통해 단계별로 접근

2. 요구사항(복잡도) 분석.

3. 문제 해결을 위한 아이디어 찾기

4. 소스코드 설계 및 코딩

: 대부분의 문제는 핵심 아이디어를 캐치한다면, 간결하게 소스코드를 작성할 수 있는 형태로 출제된다.

: 문제를 온전히 이해하고, 어떻게 코드를 작성할 지 확실히 정리가 된 다음에 코드 작성을 시작해야 한다.

[Python] Day 17 (1/5) -- rfind(), rindex(), endswith()

함s — Wed, 20 Nov 2024 21:00:26 +0900

문자열.find(부분값)

- 문자열의 왼쪽(앞)에서부터 부분값을 찾는다. 가장 처음 나온 인덱스를 리턴.

문자열.rfind(부분값)

- 문자열의 오른쪽(앞)에서부터 부분값을 찾는다. 동일.

문자열.index(부분값)

문자열.rindex(부분값)

- find, rfind 와 동일하게 진행된다.

- 단, find 는 문자열에 부분값이 존재하지 않아도 error 를 일으키지 않지만

index 는 error 를 일으킨다.

문자열.startswith(부분값)

문자열.endswith(부분값)

- 문자열에 부분값으로 시작하는지, 끝나는지 True/False 로 리턴

# pat로 끝나는 가장 긴 부분 문자열
# pat은 반드시 myString의 부분 문자열로 주어집니다.
# 대문자와 소문자를 구분합니다.

def longest_pat_ending(myString, pat):
    return myString[: myString.rfind(pat)+len(pat)]

    # if myString.endswith(pat): return myString
    # answer = ''
    # arr = myString.split(pat)
    # for i in range(len(arr) - 1):
    #     if arr[i] == '': arr[i] = pat
    #     answer += arr[i]
    # return answer if answer.endswith(pat) else answer + pat

'''
solution=lambda x,y:x[:x.rindex(y)+len(y)]

return myString[:len(myString) - myString[::-1].index(pat[::-1])]

answer = ''
for ch in myString:
    answer += ch
    if mem.endswith(pat):
        return answer
'''

print(longest_pat_ending("AbCdEFG", "AbCdEFG"))     # "AbCdEFG"
print(longest_pat_ending("ancdnc", "nc"))           # "ancdnc"
print(longest_pat_ending("AAAAaaaa", "a"))          # "AAAAaaaa"

print(longest_pat_ending("abcdefghidj", "d"))       # "abcdefghid"
print(longest_pat_ending("AbCdEFG", "dE"))          # "AbCdE"

print(longest_pat_ending("asdf", "a"))              # "a"
print(longest_pat_ending("aasdf", "a"))             # "aa"
print(longest_pat_ending("aaaaAAAA", "a"))          # "aaaa"
print(longest_pat_ending("OxOOo", "Ox"))            # "Ox"

https://hyunssssss.tistory.com/365

파이썬(Python) - 11.문자열 찾기(find(), rfind(), in)

●문자열 찾기 - find(), rfind() - 문자열 내부에서 특정문자가 어디에 위치하는지 찾을 때 사용한다. - find()함수는 왼쪽부터 찾고, rfind()함수는 오른쪽부터 찾는다. ex) ●in연산자 - 문자열 내부에

hyunssssss.tistory.com

https://www.w3schools.com/python/ref_string_endswith.asp

W3Schools.com

W3Schools offers free online tutorials, references and exercises in all the major languages of the web. Covering popular subjects like HTML, CSS, JavaScript, Python, SQL, Java, and many, many more.

www.w3schools.com

[Python] Day 16 (5/5) -- 부분 대소문자 변환 (replace(), swapcase())

함s — Tue, 19 Nov 2024 16:58:48 +0900

# 79) =================================================================
# a -> A, 나머지 모두 소문자 변환

def a_to_A(myString):
    return myString.lower().replace('a', 'A')

'''
JS
const solution = s => s.toLowerCase().replaceAll('a','A');
'''

print(a_to_A("abstract algebra"))   # "AbstrAct AlgebrA"


# 80) =================================================================
def find_alp_and_up(my_string, alp):
    return my_string.replace(alp, my_string[my_string.find(alp)].upper())

'''
return my_string.replace(alp, alp.upper())

return my_string.replace(alp, alp.swapcase())
'''

print(find_alp_and_up("programmers", "p"))   # "Programmers"

[Python] Day 16 (3/5) -- lower(), upper()

함s — Mon, 18 Nov 2024 21:04:35 +0900

# 76) =================================================================
def str_upper(myString):
    return myString.upper()

'''
solution = lambda n : n.upper()
'''
'''
JS
const solution = s => s.toUpperCase()

Java
return myString.toUpperCase();
'''

print(str_upper("aBcDeFg"))     # "ABCDEFG"


# 77) =================================================================
def str_lower(myString):
    return myString.lower()

print(str_lower("aBcDeFg"))     # "abcdefg"


# 78) =================================================================
# 홀수 인덱스 -> 소문자 변환, 짝수 인덱스 -> 대문자 변환
def odd_A_even_a(strArr):
    return [strArr[i].lower() if i%2==0 else strArr[i].upper() for i in range(len(strArr))]

'''
# range 보다 enumerate 를 사용하여 index 사용 권장
return [s.lower() if i % 2 == 0 else s.upper() for i, s in enumerate(strArr)]
'''

print(odd_A_even_a(["AAA","BBB","CCC","DDD"]))  # ["aaa","BBB","ccc","DDD"]

[Python] Day 15 (5/5) -- (JS) 단항연산자 (+)

함s — Sun, 17 Nov 2024 22:39:13 +0900

// myString의 연속된 부분 문자열 중 pat이 존재하면 1을 그렇지 않으면 0
return +(myString.toUpperCase().includes(pat.toUpperCase()));

단항연산자 (+)

문자열을 숫자로 변환해 줌

boolean 값을 숫자로 바꿀 때 용이할 듯!

'''
리스트(배열), 문자열
# 71) 조건에 맞게 수열 변환하기 1
# 72) 조건에 맞게 수열 변환하기 2
# 73) 1로 만들기
# 74) 길이에 따른 연산
# 75) 원하는 문자열 찾기
'''

# 71) ==========================================================================
# 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱합니다.

def compare_50(arr):
    for i, n in enumerate(arr):
        if n >= 50 and n % 2 == 0:
            arr[i] = int(n/2)
        elif n < 50 and n % 2 != 0:
            arr[i] = n * 2
    return arr

'''
n % 2 == 0
(=) not n % 2

0 == False
'''


print(compare_50([1, 2, 3, 100, 99, 98]))   # [2, 2, 6, 50, 99, 49]


# 72) ==========================================================================
# 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱하고 다시 1을 더합니다.
# arr(x) = arr(x + 1)인 x 중 가장 작은 값 반환

def compare_50_x(arr):
    # debugging & tracking states

    all_result = [arr[:]]
    i = 0
    while True:
        for j, n in enumerate(arr):
            if n >= 50 and not n % 2:
                arr[j] = n // 2
            elif n < 50 and n % 2:
                arr[j] = n * 2 + 1
        all_result.append(arr[:])

        if all_result[i] == all_result[i + 1]:
            break
        else:
            i += 1
    return i

'''
# efficiency & simplicity

answer = 0
old = arr
while True:
    new = []
    for i in old:
        if i >= 50 and i % 2 == 0:
            i = i / 2
        elif i < 50 and i % 2 == 1:
            i = i * 2 + 1
        new.append(int(i))
    if old == new:
        break
    else:
        old = new
        answer += 1
return answer
'''

print(compare_50_x([1, 2, 3, 100, 99, 98]))     # 5


# 73) ==========================================================================
# 짝수라면 반으로 나누고, 홀수라면 1을 뺀 뒤 반으로 나누면, 마지막엔 1이 됩니다.
# num_list의 모든 원소를 1로 만들기 위해서 필요한 나누기 연산의 횟수 총합 리턴.

def count_for_one(num_list):
    answer = 0
    for n in num_list:
        count = 0
        while n != 1:
            if n % 2 == 0:
                n = n // 2
                count += 1
            else:
                n = (n - 1) // 2
                count += 1
        answer += count

    return answer

'''
# 바이트 연산
return sum(len(bin(i)) - 3 for i in num_list)

# 홀수일 때 1을 빼고 2로 나눈다는 것 = 몫을 구하겠다는 것
for n in num_list:
    while n != 1:
        n //= 2
        answer += 1
'''
'''
JS
return num_list.map(v => v.toString(2).length - 1).reduce((a, c) => a + c);

Java
return Arrays.stream(num_list).map(i -> Integer.toBinaryString(i).length() - 1).sum();
'''


print(count_for_one([12, 4, 15, 1, 14]))    # 11


# 74) ==========================================================================
# 리스트의 길이가 11 이상이면 리스트에 있는 모든 원소의 합을, 10 이하이면 모든 원소의 곱을 return

def if_list_11(num_list):
    if len(num_list) >= 11:
        return sum(num_list)
    else:
        mul = 1
        for n in num_list:
            mul *= n
        return mul

'''
return eval('*'.join(map(str, num_list)))

from functools import reduce
return reduce(lambda x, y: x * y, num_list)

from math import prod
def solution(num_list):
    return sum(num_list) if len(num_list)>=11 else prod(num_list)
'''
'''
JS
const solution = n => n.reduce((a, v) => n.length > 10 ? a + v : a * v)

const mult = (acc, v) => acc * v;
const add = (acc, v) => acc + v;
return num_list.length > 10
    ? num_list.reduce(add, 0)
    : num_list.reduce(mult, 1);
'''

print(if_list_11([3, 4, 5, 2, 5, 4, 6, 7, 3, 7, 2, 2, 1]))  # 51
print(if_list_11([2, 3, 4, 5]))          # 120


# 75) ==========================================================================
# myString의 연속된 부분 문자열 중 pat이 존재하면 1을 그렇지 않으면 0

def is_there_pat(myString, pat):
    return int(pat.lower() in myString.lower())


'''
JS
return +(myString.toUpperCase().includes(pat.toUpperCase()));
'''

print(is_there_pat("AbCdEfG", "aBc"))   # 1
print(is_there_pat("aaAA", "aaaaa"))    # 0

[Python] Day 15 (4/5) -- 리스트의 모든 수를 곱하는 방법

함s — Sat, 16 Nov 2024 21:41:04 +0900

# for
result = 1
for n in numbers:
	result *= n

# while
result = 1
i = 0
while i < len(numbers):
	result *= numbers[i]
	i += 1

[1] 루프 사용

- 직관적이고 읽기 쉬움.

- 안전함

- 외부 모듈이 필요 없음.

- 코드가 다소 긴 편.

from functools import reduce

reduce(lambda x, y: x * y, numbers)

[2] functools.reduce

- 코드 간결.

- 외부 모듈 필요.

import math

math.prod(numbers)

[3] math.prod (Python 3.8 이상)

- 가장 간결하고 직관적. (가능하면 reduce 보다 prod 추천)

- 버전 확인 필요.

eval('*'.join(map(str, numbers)))
eval('*'.join([str(n) for n in numbers]))

[4] eval

- 코드가 짧은 편

- 보안 문제 발생 (입력값이 안전하지 않을 경우)

- 느림

# 리스트의 길이가 11 이상이면 리스트에 있는 모든 원소의 합을, 10 이하이면 모든 원소의 곱을 return

def if_list_11(num_list):
    if len(num_list) >= 11:
        return sum(num_list)
    else:
        mul = 1
        for n in num_list:
            mul *= n
        return mul

'''
return eval('*'.join(map(str, num_list)))

from functools import reduce
return reduce(lambda x, y: x * y, num_list)

from math import prod
def solution(num_list):
    return sum(num_list) if len(num_list)>=11 else prod(num_list)
'''
'''
JS
const solution = n => n.reduce((a, v) => n.length > 10 ? a + v : a * v)

const mult = (acc, v) => acc * v;
const add = (acc, v) => acc + v;
return num_list.length > 10
    ? num_list.reduce(add, 0)
    : num_list.reduce(mult, 1);
'''

print(if_list_11([3, 4, 5, 2, 5, 4, 6, 7, 3, 7, 2, 2, 1]))  # 51
print(if_list_11([2, 3, 4, 5]))          # 120

https://velog.io/@kim_sunnnny/python-int%ED%98%95-list-%EC%9B%90%EC%86%8C%EB%93%A4%EC%9D%98-%EA%B3%B1

[python] int형 list 원소들의 곱

traversal : for looptime complexity : O(n)Auxiliary space : O(1)numpy.prodtime complexity : O(n)Auxiliary space : O(1)lambda w/ numpy.arraytime comple

velog.io

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce

Array.prototype.reduce() - JavaScript | MDN

reduce() 메서드는 배열의 각 요소에 대해 주어진 리듀서 (reducer) 함수를 실행하고, 하나의 결과값을 반환합니다.

developer.mozilla.org

[Python] Day 15 (2/5) -- do-while, 리스트 복사

함s — Fri, 15 Nov 2024 19:06:12 +0900

[1] do-while

while True:
	# 실행문
    
    if 조건:
    	break

파이썬에서 do while 문은 while True 로 따라할 수 있다.

꼭 조건문과 break 를 써서 무한 루프를 만들지 말자.

[2] 리스트 복사

original = [1, 2, 3]

# 단순 복사
copy1 = original

# 얕은 복사
copy2-1 = original.copy()
copy2-2 = original[:]

# 깊은 복사
copy3 = copy.deepcopy(original)

1. 단순 복사

original 과 copy1 은 같은 주소값을 가리킨다. 단지 이름만 다를 뿐이다.

즉, original 을 변경하거나 copy1 을 변경할 경우 서로에게 동시에 영향을 준다.

2. 얕은 복사

copy2 를 수정해도 original 에는 반영되지 않는다.

하지만 copy2 의 특정 값을 수정하면 original 의 값도 같이 수정될 수 있다.

왜냐하면 얕은 복사는 새로운 리스트 객체를 생성하지만,

그 리스트 안에 있는 값들은 원래 리스트의 참조를 그대로 가져오기 때문이다.

그래서 리스트 안에 가변 객체가 들어있으면 같이 수정될 수 있다.

* 가변객체 (mutable object)

- 내부 값을 변경하면 같은 객체가 수정된다.

- 리스트(list), 딕셔너리(dict), 집합(set), 바이트 배열(bytearray)

* 불변 객체 (immutable object)

- 수정하려고 하면 항상 새로운 객체가 생서된다.

- 숫자형(int, float), 문자열(str), 튜플(tuple), frozenset, 불리언(bool)

# 원본 리스트: 2차원 리스트 (내부에 가변 객체인 리스트가 포함되어 있음)
original = [[1, 2], [3, 4]]

# 얕은 복사: 원본 리스트의 탑 레벨만 복사됨 (내부 리스트는 참조만 복사)
# copy[0]은 original[0]과 같은 객체를 참조함
copy = original[:]

copy[0][0] = 99			# 내부 리스트의 값을 수정
print(original)			# [[99, 2], [3, 4]] (원본도 영향을 받음)

# 탑 레벨 리스트의 첫 번째 요소를 새 리스트로 대체 
copy[0] = [5, 6]  		# copy[0]만 새로운 리스트을 참조하도록 변경
print(original)			# [[99, 2], [3, 4]] (원본은 영향을 받지 않음)



# 원본 리스트: 숫자로만 이루어진 1차원 리스트 (숫자는 불변 객체임)
original_list = [1, 2, 3]

# 얕은 복사: 원본 리스트의 모든 요소가 새 리스트에 복사됨 (값만 복사)
# shallow_copy와 original_list는 독립적임
shallow_copy = original_list[:]

shallow_copy[0] = 99	# 복사본의 첫 번째 요소를 변경
print(original_list)	# [1, 2, 3] (원본은 영향을 받지 않음)

3. 깊은 복사

불변 객체는 그대로 가져오고, 가변 객체는 새로운 공간에 값을 복사하여 가져온다.

원본 리스트와 복사본 리스트가 완전히 다른 객체가 된다.

그래서 어느 한 쪽을 수정해도 서로 영향을 주지 않는다.

단, 완벽한 복사를 위해 새로운 곳을 생성하기 때문에, 시간이 오래 걸리고 메모리 소모도 크다.

그래서 상황에 따라 얕은 복사와 깊은 복사를 가려 사용해야 한다.

* 문제 풀이

# 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱하고 다시 1을 더합니다.
# arr(x) = arr(x + 1)인 x 중 가장 작은 값 반환

def compare_50_x(arr):
    # debugging & tracking states

    all_result = [arr[:]]
    i = 0
    while True:
        for j, n in enumerate(arr):
            if n >= 50 and not n % 2:
                arr[j] = n // 2
            elif n < 50 and n % 2:
                arr[j] = n * 2 + 1
        all_result.append(arr[:])

        if all_result[i] == all_result[i + 1]:
            break
        else:
            i += 1
    return i
    
'''
[[1, 2, 3, 100, 99, 98], [3, 2, 7, 50, 99, 49]]
[[1, 2, 3, 100, 99, 98], [3, 2, 7, 50, 99, 49], [7, 2, 15, 25, 99, 99]]
[[1, 2, 3, 100, 99, 98], [3, 2, 7, 50, 99, 49], [7, 2, 15, 25, 99, 99], [15, 2, 31, 51, 99, 99]]
[[1, 2, 3, 100, 99, 98], [3, 2, 7, 50, 99, 49], [7, 2, 15, 25, 99, 99], [15, 2, 31, 51, 99, 99], [31, 2, 63, 51, 99, 99]]
[[1, 2, 3, 100, 99, 98], [3, 2, 7, 50, 99, 49], [7, 2, 15, 25, 99, 99], [15, 2, 31, 51, 99, 99], [31, 2, 63, 51, 99, 99], [63, 2, 63, 51, 99, 99]]
[[1, 2, 3, 100, 99, 98], [3, 2, 7, 50, 99, 49], [7, 2, 15, 25, 99, 99], [15, 2, 31, 51, 99, 99], [31, 2, 63, 51, 99, 99], [63, 2, 63, 51, 99, 99], [63, 2, 63, 51, 99, 99]]
5
'''

나는 반복문의 결과물을 배열에 모두 담고 그 결과물로 비교하는 방식으로 문제를 풀었다.

그러나 이런 방식은 메모리를 너무 잡아먹고 불필요하게 모든 과정을 기록해서 비효율적이다.

# efficiency & simplicity

answer = 0
old = arr
while True:
    new = []
    for i in old:
        if i >= 50 and i % 2 == 0:
            i = i / 2
        elif i < 50 and i % 2 == 1:
            i = i * 2 + 1
        new.append(int(i))
    if old == new:
        break
    else:
        old = new
        answer += 1
return answer

이렇게, 이전 것과 현재 것만 변수에 담은 뒤, 값을 비교하고, 다른 경우 값을 바꿔치기 해서 진행하면

비교적 메모리 효율이 좋고 로직도 단순해서 좋다.

쓸 데 없는 기록을 지양하고 목표 행위에만 초점을 맞추자.

https://www.freecodecamp.org/korean/news/pythonyi-do-whilemun-banbogmun-yeje/

Python의 Do While문 - 반복문 예제

모든 현대 프로그래밍 언어에서 반복문은 유용하게 자주 쓰입니다. 반복문을 사용하면 특정한 반복 작업을 자동화할 수 있고 프로그램에 반복적인 코드를 일일이 작성하지 않아도 됩니다. 반복

www.freecodecamp.org

https://black-hair.tistory.com/49

[기능] 파이썬 리스트 복사 (python copy)

Copy 파이썬에서 일반적으로 복사할 때 아래와 같은 형식으로 진행된다. list_A = ["ABC","DEF"] list_B = list_A 하지만 이렇게 복사를 하는 경우 단순한 값에 대해서는 문제가 없지만, 리스트를 복사할 때

black-hair.tistory.com

[Python] Day 14 -- full code

함s — Thu, 14 Nov 2024 21:29:05 +0900

'''
리스트(배열)
# 66) 홀수 vs 짝수
# 67) 5명씩
# 68) 할 일 목록
# 69) n보다 커질 때까지 더하기
# 70) 수열과 구간 쿼리1
'''

# 66) ====================================================================
# 가장 첫 번째 원소를 1번 원소라고 할 때, 홀수 번째 원소들의 합과 짝수 번째 원소들의 합 중 큰 값을 return

def odd_vs_even(num_list):
    odd, even = 0, 0
    odd = sum(num for num in num_list[1::2])
    even = sum(num for num in num_list[::2])

    return max(odd, even)

'''
return max(sum(num_list[::2]), sum(num_list[1::2]))
'''
'''
JS

num_list.map((val, idx) => { !(idx % 2) ? even += val : odd += val })
return odd > even ? odd : even;

num_list.forEach((val, idx) => idx % 2 == 0 ? even += val : odd += val);
return Math.max(odd, even);
'''

print(odd_vs_even([4, 2, 6, 1, 7, 6]))  # 17


# 67) ====================================================================
# 앞에서 부터 5명씩 묶은 그룹의 가장 앞

def group_leader(names):
    return names[::5]


# ["nami", "vex"]
print(group_leader(["nami", "ahri", "jayce", "garen", "ivern", "vex", "jinx"]))


# 68) ====================================================================
#  아직 마치지 못한 일들을 순서대로

def todo(todo_list, finished):
    return [t for t, r in zip(todo_list, finished) if not bool(r)]

'''
return [work for idx, work in enumerate(todo_list) if not finished[idx]]

return [x for x, b in zip(todo_list, finished) if not b]
'''
'''
JS
return todo_list.filter((e,i) => !finished[i]);

Java
for(int i=0; i<finished.length; i++){
    str = finished[i]==false ? str+todo_list[i]+"," : str;
}
return str.split(",");
'''

# ["practiceguitar", "studygraph"]
print(todo(["problemsolving", "practiceguitar", "swim", "studygraph"],  [True, False, True, False]))


# 69) ====================================================================
# 앞에서부터 하나씩 더하다가 그 합이 n보다 커지는 순간 리턴

def add_num(numbers, n):
    answer = 0
    for num in numbers:
        answer += num
        if answer > n:
            return answer

'''
return next(sum(numbers[:i + 1]) for i in range(len(numbers)) if sum(numbers[:i + 1]) > n)

from itertools import accumulate
def find_first_exceeding_sum(numbers, n):
    return next((s for s in accumulate(numbers) if s > n), None)
'''

print(add_num([34, 5, 71, 29, 100, 34], 123))   # 139
print(add_num([58, 44, 27, 10, 100],    139))       # 239


# 70) ====================================================================
#  s ≤ i ≤ e인 모든 i에 대해 arr[i]에 1을 더합니다.

def section_query(arr, queries):
    for s, e in queries:
        for i in range(s, e+1):
            arr[i] += 1
    return arr

'''
JS
queries.forEach(([s, e]) => {
    while (s <= e) arr[s++]++;
});
'''


# [1, 3, 4, 4, 4]
print(section_query([0, 1, 2, 3, 4],    [[0, 1],[1, 2],[2, 3]]))

이제 30문제 남았다아

내년 넘어가기 전에 끝내자~~!!

[Python] Day 14 (4/5) -- next(), accumulate()

함s — Wed, 13 Nov 2024 14:59:07 +0900

return next(sum(numbers[:i + 1]) for i in range(len(numbers)) if sum(numbers[:i + 1]) > n)

next(조건, 기본값)

- 조건에 맞는 가장 첫번째 값을 반환함.

- 조건에 반복자(iter) 를 넣으면 for 문처럼 사용할 수 있음.

from itertools import accumulate

def find_first_exceeding_sum(numbers, n):
    return next((s for s in accumulate(numbers) if s > n), None)

accumulate(리스트)

- 리스트의 값의 누적합을 리스트로 반환함.

- sum 의 반복 호출을 피할 수 있음.

- for 문으로 + 연산을 반복하는 것보다 훨씬 빠른 속도로 연산 가능.

# 앞에서부터 하나씩 더하다가 그 합이 n보다 커지는 순간 리턴

def add_num(numbers, n):
    answer = 0
    for num in numbers:
        answer += num
        if answer > n:
            return answer

'''
return next(sum(numbers[:i + 1]) for i in range(len(numbers)) if sum(numbers[:i + 1]) > n)

from itertools import accumulate
def find_first_exceeding_sum(numbers, n):
    return next((s for s in accumulate(numbers) if s > n), None)
'''

print(add_num([34, 5, 71, 29, 100, 34],	123))   # 139
print(add_num([58, 44, 27, 10, 100],	139))       # 239

https://dojang.io/mod/page/view.php?id=2408

파이썬 코딩 도장: 39.4 iter, next 함수 활용하기

이번에는 파이썬 내장 함수 iter, next에 대해 알아보겠습니다. iter는 객체의 __iter__ 메서드를 호출해주고, next는 객체의 __next__ 메서드를 호출해줍니다. 그럼 range(3)에 iter와 next를 사용해보겠습니

dojang.io

https://deok2kim.tistory.com/95

[python] accumulate(itertools), 누적 합

accumulate 뜻으로는 축적하다? 한마디로 누적된 합을 뽑아주는 녀석 사용법 from itertools import accumulate a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] b = list(accumulate(a)) print(a) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(b) # [

deok2kim.tistory.com

[Python] Day 14 (3/5) -- list comprehension 조건 걸기

함s — Tue, 12 Nov 2024 22:06:02 +0900

for 문을 한 줄로 작성할 수 있는 리스트 컴프리헨션에서

for 문 안에 조건문을 넣고 싶을 수 있다.

그 때 if 만 쓰거나 if - else 까지 넣고 싶을 수 있다.

return [t for t, r in zip(todo_list, finished) if not r]

# 틀린 문법
return [t if not r else continue for t, r in zip(todo_list, finished)]

if 만 쓸 경우에는 for 문 뒤에 적어준다.

참고로, continue, pass 와 같이 반복문 건너뛰는 명령어는 list comprehension 에서 쓸 수 없다.

else 문을 쓰려면 꼭 다른 반환되는 값이 필요하다.

[ num if num % 2 == 0 else 0 for num in num_list]

list comprehension 을 거치면 자동으로 해당되는 값이 담긴 리스트가 반환된다.

#  아직 마치지 못한 일들을 순서대로

def todo(todo_list, finished):
    return [t for t, r in zip(todo_list, finished) if not bool(r)]

'''
return [work for idx, work in enumerate(todo_list) if not finished[idx]]

return [x for x, b in zip(todo_list, finished) if not b]
'''
'''
JS
return todo_list.filter((e,i) => !finished[i]);

Java
for(int i=0; i<finished.length; i++){
    str = finished[i]==false ? str+todo_list[i]+"," : str;
}
return str.split(",");
'''

# ["practiceguitar", "studygraph"]
print(todo(["problemsolving", "practiceguitar", "swim", "studygraph"],	[True, False, True, False]))

https://wikidocs.net/22805

1) 리스트 컴프리헨션

## 리스트 생성하기 기존에 배운 문법으로 1부터 10까지 정수를 순서대로 가지고 있는 리스트를 생성하는코드는 다음과 같습니다. ``` numbers = [] for n i…

wikidocs.net

https://jinmay.github.io/2020/05/28/python/python-list-comprehension-with-if-statement/

[python]리스트 컴프리핸션에서 if문 사용하기

리스트 컴프리핸션(list comprehension)이란 pythonic 하다고 표현되는 대표적인 문법 중에 하나이다. 꽤 간단한 방법으로 리스트를 만들 수 있다는 장점이 있다. 기본적으로 for문을 사용하기 때문에 반

jinmay.github.io

https://itgilajavy.tistory.com/25

14. python 반복문 제어하기 - break, continue, pass

1. continue - continue는 반복문(for, while)에서 아래 code를 실행 시키지 않게 다음 반복 구문으로 넘어가도록 하는 제어자 입니다. - 보통 if구문(조건문)으로 조건에 따라 다음 반복문으로 건너 뛸지를

itgilajavy.tistory.com

[Python] Day 14 (1/5) -- sum()

함s — Mon, 11 Nov 2024 08:53:08 +0900

# 가장 첫 번째 원소를 1번 원소라고 할 때, 홀수 번째 원소들의 합과 짝수 번째 원소들의 합 중 큰 값을 return

def odd_vs_even(num_list):
    odd, even = 0, 0
    odd = sum(num for num in num_list[1::2])
    even = sum(num for num in num_list[::2])

    return max(odd, even)

'''
return max(sum(num_list[::2]), sum(num_list[1::2]))
'''
'''
JS

num_list.map((val, idx) => { !(idx % 2) ? even += val : odd += val })
return odd > even ? odd : even;

num_list.forEach((val, idx) => idx % 2 == 0 ? even += val : odd += val);
return Math.max(odd, even);
'''

print(odd_vs_even([4, 2, 6, 1, 7, 6]))  # 17

sum(iterable)

숫자(실수, 정수)로만 이루어진 순환 자료형 (리스트, 튜플)

즉, sum([1, 2, 3]) 형태로 가능

=> 굳이 굳이 for 문을 돌릴 필요가 없다~~~

sum(iterable, start = num)

숫자 순환 변수에 추가로 또 더해줄 num 을 지정할 수 있음

sum([1, 2, 3], start = 6) == 12

[Python] Day 13 (5/5) -- (JS) filter

함s — Sun, 10 Nov 2024 10:57:47 +0900

# 첫 번째 원소부터 마지막 원소까지 n개 간격

def interval_n(num_list, n):
    return num_list[::n]

'''
JS
const solution = (num_list, n) => num_list.filter((_, i) => !(i % n))

Java
int N = num_list.length % n == 0 ? num_list.length / n : num_list.length / n + 1;
int idx = 0;
int[] answer = new int[N];
for (int i = 0;i < num_list.length;i+=n)
    answer[idx++] = num_list[i];
return answer;
'''

print(interval_n([4, 2, 6, 1, 7, 6],	2))     # [4, 6, 7]

배열.filter((callback, index) => 조건식 )

_ 는 쓰이지 않는 매개변수를 뜻함.

index 자리에는 배열에서 처리중인 현재 요소의 인덱스가 담김.

... 에서는 배열 값을 선별할 조건식을 넣는다.

인덱스를 n (간격) 으로 나누었을 때 0 이 나온다는 건 그 간격의 인덱스라는 것.

! (index % n) 은, 즉, 원하는 간격의 인덱스가 아닌 것을 걸러내자! 는 거다!

'''
리스트(배열)
# 61) n 번째 원소부터
# 62) 순서 바꾸기
# 63) 왼쪽 오른쪽
# 64) n 번째 원소까지
# 65) n 개 간격의 원소들
'''

# 61) ===================================================================
def from_n(num_list, n):
    return num_list[n-1:]

'''
JS
return num_list.slice(n - 1);
'''

print(from_n([2, 1, 6],	3))             # [6]
print(from_n([5, 2, 1, 7, 5],	2))     # [2, 1, 7, 5]



# 62) ===================================================================
def change_order(num_list, n):
    return num_list[n:] + num_list[:n]

'''
JS
# removing n elements starting from index 0
# The removed elements are returned as an array

num_list.push(...num_list.splice(0, n));
return num_list
'''

print(change_order([2, 1, 6], 1))       # [1, 6, 2]
print(change_order([5, 2, 1, 7, 5],	3)) # [7, 5, 5, 2, 1]


# 63) ===================================================================
# str_list에는 "u", "d", "l", "r" 네 개의 문자열이 여러 개 저장
# "l"과 "r" 중 먼저 나오는 문자 --> "l" 왼쪽 문자열 / "r" 오른쪽 문자열 / 없으면 빈 문자열

def left_right(str_list):
    for i, val in enumerate(str_list):
        if val == "l":
            return str_list[:i]
        if val == "r":
            return str_list[i+1:]
    return []

'''
JS
for(let i = 0; i < arr.length; i++) {
     if (arr[i] === 'l') return arr.slice(0, i);
     if (arr[i] === 'r') return arr.slice(i + 1);
 }
 return [];
'''

print(left_right(["u", "u", "l", "r"])) # ["u", "u"]
print(left_right(["l"]))                # []



# 64) ===================================================================
# num_list의 첫 번째 원소부터 n 번째 원소까지의 모든 원소를 담은 리스트

def to_n(num_list, n):
    return num_list[:n]

'''
JS
return num_list.slice(0, n);

Java
return Arrays.copyOfRange(num_list,0,n);
'''

print(to_n([2, 1, 6],	1))     # [2]


# 65) ===================================================================
# 첫 번째 원소부터 마지막 원소까지 n개 간격

def interval_n(num_list, n):
    return num_list[::n]

'''
JS
const solution = (num_list, n) => num_list.filter((_, i) => !(i % n))

Java
int N = num_list.length % n == 0 ? num_list.length / n : num_list.length / n + 1;
int idx = 0;
int[] answer = new int[N];
for (int i = 0;i < num_list.length;i+=n)
    answer[idx++] = num_list[i];
return answer;
'''

print(interval_n([4, 2, 6, 1, 7, 6],	2))     # [4, 6, 7]

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Array.prototype.filter() - JavaScript | MDN

Array 인스턴스의 filter() 메서드는 주어진 배열의 일부에 대한 얕은 복사본을 생성하고, 주어진 배열에서 제공된 함수에 의해 구현된 테스트를 통과한 요소로만 필터링 합니다.

developer.mozilla.org

[Python] Day 13 (4/5) -- (Java) Array.copyOfRange

함s — Sat, 9 Nov 2024 20:24:12 +0900

# num_list의 첫 번째 원소부터 n 번째 원소까지의 모든 원소를 담은 리스트

def to_n(num_list, n):
    return num_list[:n]

'''
JS
return num_list.slice(0, n);

Java
return Arrays.copyOfRange(num_list,0,n);
'''

print(to_n([2, 1, 6],	1))     # [2]

Arrays.copyOfRange(원본배열, 시작 인덱스, 끝 인덱스)

원본 배열의 특정 범위만큼 복사해서 새로운 배열로 반환.

끝 인덱스가 원본 배열 길이보다 크면 이후의 값은 기본값으로 초기화됨.

ex)

String[] arr = new String[] ("a", "b", "c"};

String[] copy = Arrays.copyOfRange(arr, 0, 3);

// copy == {"a", "b", "c", null}

https://romcanrom.tistory.com/48

java/ copyOf(), copyOfRange(), arraycopy() : 배열을 복사하는 메서드

Arrays 클래스는 배열과 관련된 여러 메서드들을 지원한다. *java.util 패키지에 포함되어 있으므로 Arrays의 메서드들을 사용하기 위해서는 import가 필요하다. import java.util.Arrays; Arrays.copyOf() Arrays.copyO

romcanrom.tistory.com

[Python] Day 13 (3/5) 왼쪽오른쪽

함s — Fri, 8 Nov 2024 22:34:00 +0900

문자열 리스트 str_list에는 "u", "d", "l", "r" 네 개의 문자열이 여러 개 저장되어 있습니다.

str_list에서 "l"과 "r" 중 먼저 나오는 문자열이 "l"이라면 해당 문자열을 기준으로 왼쪽에 있는 문자열들을 순서대로 담은 리스트를,

먼저 나오는 문자열이 "r"이라면 해당 문자열을 기준으로 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 return하도록

solution 함수를 완성해주세요.

"l"이나 "r"이 없다면 빈 리스트를 return합니다.

def left_right(str_list):
    for i, val in enumerate(str_list):
        if val == "l":
            return str_list[:i]
        if val == "r":
            return str_list[i+1:]
    return []

'''
JS
for(let i = 0; i < arr.length; i++) {
     if (arr[i] === 'l') return arr.slice(0, i);
     if (arr[i] === 'r') return arr.slice(i + 1);
 }
 return [];
'''

print(left_right(["u", "u", "l", "r"])) # ["u", "u"]
print(left_right(["l"]))                # []

분명 맞게 접근한 거 같은데 테스트케이스 절반이 틀려서 왜인가 했더니,

[i:] 라고 했음.

자기 자신을 기준으로 왼쪽, 오른쪽이랬으니까 자기 자신은 포함되면 안됐음.

자꾸 범위설정하는 부분이 헷갈리는 듯~

[Python] Day 13 (2/5) -- (JS) splice()

함s — Thu, 7 Nov 2024 22:26:08 +0900

너무 간단한 코드여서 한 문제만 올릴 수 없었다.

다른사람 풀이에서 자바스크립트 코드도 겸사겸사 보고 있는데,

num_list.push(...num_list.splice(0, n));

이건 대체 무슨 코드냐고..

a배열.push(...b배열)

a배열 끝에 b배열의 값을 하나씩 넣어줌

... 없이 바로 배열을 넣으면 오류남.

배열.splice(시작인덱스, 범위, 추가)

원본 배열을 건드림.

특정 범위를 삭제하거나, 새로 추가하거나, 기존 값을 대체할 수 있음.

splice(시작) : 인덱스부터 전체 삭제

splice(시작, 범위) : 인덱스부터 범위까지 삭제

splice(시작, 0, 추가) : 인덱스 자리에 값 추가 -- splice(10, 0, a, b)

splice(시작, 범위, 추가) : 인덱스부터 범위까지 삭제하고 값을 추가 splice(10, 2, a, b) 일종의 값 대체.

num_list = [2, 1, 6]

n = 1

일 때,

num_list.splice(0, 1) --> num_list[0] 을 잘라냄. 즉, 반환값은 [2] 가 됨.

splice 는 원본 배열에 변경사항을 바로 반영하니까

num_list = [1, 6] 만 남아있음.

거기에 반환값 [2] 를 push 를 통해 끝에 붙임.

최종적으로 [1, 6, 2] 가 됨.

# 61) ===================================================================
def from_n(num_list, n):
    return num_list[n-1:]

'''
JS
return num_list.slice(n - 1);
'''

print(from_n([2, 1, 6],	3))             # [6]
print(from_n([5, 2, 1, 7, 5],	2))     # [2, 1, 7, 5]



# 62) ===================================================================
def change_order(num_list, n):
    return num_list[n:] + num_list[:n]

'''
JS
# removing n elements starting from index 0
# The removed elements are returned as an array

num_list.push(...num_list.splice(0, n));
return num_list
'''

print(change_order([2, 1, 6], 1))       # [1, 6, 2]
print(change_order([5, 2, 1, 7, 5],	3)) # [7, 5, 5, 2, 1]

https://www.daleseo.com/js-array-slice-splice/

자바스크립트 배열의 slice()와 splice() 함수

Engineering Blog by Dale Seo

www.daleseo.com

[Python] Day 12 -- get(), extend(), list(filter(lambda

함s — Sun, 3 Nov 2024 23:02:27 +0900

get(key, default)

딕셔너리에서 key 로 value 를 불러오는 함수. 값이 없으면 defalut 리턴.

original.extend(new_list)

리스트 합치기 -- 원본 리스트가 변함

(+ 연산자 -- 합쳐진 리스트를 새로 반환)

list(filter(lambda i: arr[i] == 2, range(len(arr))))

list에서 value 로 다중 index 찾기

'''
리스트 (배열)
# 56) 리스트 자르기
# 57) 첫 번째로 나오는 음수
# 58) 배열 만들기 3
# 59) 2의 영역
# 60) 배열 조각하기
'''

# 56) ===========================================================================
def cut_list(n, slicer, num_list):
    a, b, c = slicer
    if n == 1: return num_list[:b+1]
    elif n == 2: return num_list[a:]
    elif n == 3: return num_list[a:b+1]
    elif n == 4: return num_list[a:b+1:c]
    return num_list

'''
return [num_list[:b + 1], num_list[a:], num_list[a:b + 1], num_list[a:b + 1:c]][n - 1]

slices = {
    1: num_list[:b+1],
    2: num_list[a:],
    3: num_list[a:b+1],
    4: num_list[a:b+1:c]
}
return slices.get(n, num_list)
'''

# [2, 3, 4, 5, 6]
print(cut_list(3, [1, 5, 2], [1, 2, 3, 4, 5, 6, 7, 8, 9]))


# 57) ===========================================================================
def find_minus(num_list):
    for i, num in enumerate(num_list):
        if num < 0:
            return i
    return -1

'''
JS
const solution = num_list => num_list.findIndex(v => v < 0)
'''

print(find_minus([12, 4, 15, 46, 38, -2, 15]))  # 5
print(find_minus([13, 22, 53, 24, 15, 6]))      # -1


# 58) ===========================================================================
def two_arr(arr, intervals):
    answer = []
    for a, b in intervals:
        answer.extend(arr[a:b+1])
    return answer


'''
JS
const [[a,b],[c,d]] = intervals;
return [...arr.slice(a, b+1), ...arr.slice(c, d+1)];
'''

# [2, 3, 4, 1, 2, 3, 4, 5]
print(two_arr([1, 2, 3, 4, 5], [[1, 3], [0, 4]]))


# 59) ===========================================================================
def find_2_range(arr):
    index_list = list(filter(lambda i: arr[i] == 2, range(len(arr))))
    if not index_list:
        return [-1]
    return arr[index_list[0]:index_list[-1]+1]

'''
if 2 not in arr:
    return [-1]
return arr[arr.index(2) : len(arr) - arr[::-1].index(2)]
'''

'''
JS
const from = arr.indexOf(2);
const end = arr.lastIndexOf(2);
return from === -1 ? [-1] : arr.slice(from, end+1);
'''

print(find_2_range([1, 2, 1, 2, 1, 10, 2, 1]))  # [2, 1, 2, 1, 10, 2]
print(find_2_range([1, 2, 1]))      # [2]
print(find_2_range([1, 1, 1]))      # [-1]


# 60) ===========================================================================
# 짝수 -- 인덱스 뒷부분 버리기
# 홀수 -- 인덱스 앞부분 버리기
def cut_arr(arr, query):
    for i, q in enumerate(query):
        if i % 2 == 0:
            arr = arr[:q+1]
        else:
            arr = arr[q:]
    return arr

'''
JS
query.map((v,i)=>i%2?arr.splice(0,v):arr.splice(v+1))
'''

print(cut_arr([0, 1, 2, 3, 4, 5],[4, 1, 2]))    # [1, 2, 3]

https://velog.io/@ash5541/get-get%EB%A9%94%EC%84%9C%EB%93%9C%EB%9E%80

파이썬 get() get메서드란?

get() 메서드는 딕셔너리에서 주어진 키(key)에 해당하는 값을 반환하는 메서드입니다.get() 메서드는 두 개의 파라미터를 가질 수 있습니다. 첫 번째 파라미터는 찾고자하는 키(key)이고, 두 번째 파

velog.io

https://splayer.tistory.com/15

Python 두개 리스트를 하나로 합치기

리스트 두 개를 하나의 리스트로 합치는 방법에 대해서 알아보겠습니다. + 연산자를 사용하는 방법 기본적인 방법으로 아래와 같이 + 연산자를 사용하여 2개의 리스트를 합칠 수 있습니다. + 연

splayer.tistory.com

https://bill1224.tistory.com/228

[ python ] list 에서 value 값으로 다중 index 찾기

result = [1,2,3,4,5,3] result 라는 list 에서 원소값이 3인 index번호를 알고 싶을 때는??! print(test_list.index(3)) index() 를 사용하게되면 list안에 중복된 value가 있을 때에는 index 번호가 빠른 것만 결가값이 나

bill1224.tistory.com

https://dojang.io/mod/page/view.php?id=2360

파이썬 코딩 도장: 32.2 람다 표현식과 map, filter, reduce 함수 활용하기

람다 표현식 작성 방법을 알아보았으니 이번에는 람다 표현식과 map, filter, reduce 함수를 함께 사용해보겠습니다. 32.2.1 람다 표현식에 조건부 표현식 사용하기 먼저 람다 표현식에서 조건부 표

dojang.io

[Python] Day 11 -- ord(), not in, index(val, start)

함s — Thu, 31 Oct 2024 21:39:23 +0900

list_1 = [0] * 52

일차원 배열 만들기

list_2 = [[0] * w for _ in range(h)}

이차원 배열 만들기

ord(값)

값을 10진수 유니코드 값으로 출력 (아스키 코드로 변환)

A = 65

if val not in list

list 에 val 가 들어있지 않은 경우 가정

-- 자바스크립트에서는 if(!(val in list)) 이런식으로 씀

'''
리스트(배열)
# 51) 문자 개수 세기
# 52) 배열 만들기 1
# 53) 글자 지우기
# 54) 카운트 다운
# 55) 가까운 1 찾기
'''

# 51) ===========================================================================
# A의 개수 ~ z의 개수 == 총 52개의 정수 배열

def count_alphabet(my_string):
    answer = [0 for _ in range(58)]
    for char in my_string:
        answer[ord(char)-65] += 1
    return answer[:26] + answer[32:]

'''
answer=[0]*52
for x in my_string:
    if x.isupper():
        answer[ord(x)-65]+=1
    else:
        answer[ord(x)-71]+=1
return answer


answer = []
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
for i in alphabet:
    answer.append(len(my_string.split(i))-1)
return answer


return [my_string.count(alphabet) for alphabet in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz']
'''

# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0]
print(count_alphabet("Programmers"))


# 52) ===========================================================================
# 1 이상 n이하의 정수 중에서 k의 배수를 오름차순으로 저장한 배열
def make_arr(n, k):
    return [i for i in range(k, n+1, k)]

'''
return list(range(k, n + 1, k))
'''

print(make_arr(10,	3))     # [3, 6, 9]


# 53) ===========================================================================

def remove_char(my_string, indices):
    answer = list(my_string)

    for index in indices:
        answer[index] = ''

    return ''.join(answer)

'''
# 인덱스 없는 글자를 이어붙임
return "".join([v for i,v in enumerate(my_string) if i not in indices])

# 인덱스를 내림차순 정렬 후 뒤에서부터 리스트 값 삭제
my_string = list(my_string)
for i in sorted(indices, reverse=True):
    del my_string[i]
return ''.join(my_string)
'''

# "programmers"
print(remove_char("apporoograpemmemprs",	[1, 16, 6, 15, 0, 10, 11, 3]))


# 54) ===========================================================================
# start_num에서 end_num까지 1씩 감소하는 수
def countdown(start_num, end_num):
    return list(range(start_num, end_num-1, -1))

print(countdown(10, 3))     # [10, 9, 8, 7, 6, 5, 4, 3]


# 55) ===========================================================================

def near_one(arr, idx):
    for i in range(idx, len(arr)):
        if arr[i] == 1:
            return i
    return -1

'''
answer = 0
try:
    answer = arr.index(1, idx)
except:
    answer = -1
return answer
'''


print(near_one([0, 0, 0, 1], 1))            # 3
print(near_one([1, 0, 0, 1, 0, 0],	4))     # -1
print(near_one([1, 1, 1, 1, 0],	3))         # 3

[Python] Day 10 -- 문자열 슬라이싱

함s — Tue, 29 Oct 2024 20:55:07 +0900

수학적 사고가 정말 중요하다...

'''
문자열
# 46) 문자열의 앞의 n글자
# 47) 접두사인지 확인하기
# 48) 문자열 뒤집기
# 49) 세로 읽기
# 50) qr code
'''

# 46)===============================================================

def return_nlen_str(my_string, n):
    return my_string[:n]

print(return_nlen_str("ProgrammerS123", 11))    # "ProgrammerS"


# 47)===============================================================

def check_perfix(my_string, is_prefix):
    return int(my_string.startswith(is_prefix))

print(check_perfix("banana",	"ban"))     # 1

'''
return int(my_string[:len(is_prefix)] == is_prefix)
'''


# 48)===============================================================

def reverse_part(my_string, s, e):
    return my_string[:s] + my_string[s:e+1][::-1] + my_string[e+1:]

print(reverse_part("Progra21Sremm3",	6,	12))    # "ProgrammerS123"


# 49)===============================================================
# my_string을 한 줄에 m 글자씩 가로로 적었을 때 왼쪽부터 세로로 c번째 열에 적힌 글자들

def vertical_str(my_string, m, c):
    return my_string[c-1::m]

print(vertical_str("ihrhbakrfpndopljhygc",	4,	2)) # "happy"


# 50)===============================================================
# code의 각 인덱스를 q로 나누었을 때 나머지가 r인 위치의 문자

def QRCode(q, r, code):
    return ''.join(char if idx % q == r else '' for idx, char in enumerate(code))

'''
# index = x * q + r 임을 알 수 있고, 우리가 필요한 index는 [0q+r, 1q+r, 2q+r... xq+r]입니다. 
# 즉 [r, q+r, 2q+r... xq+r]임을 알 수있고, r로 시작해서 q씩 커지는 index만 가져오면 됩니다 :)
return code[r::q]
'''

print(QRCode(3,	1,	"qjnwezgrpirldywt"))    # jerry
print(QRCode(1,	0,	"programmers"))         # programmers

https://spirit0833.tistory.com/5

[Python] 문자열 인덱싱 (Indexing) & 슬라이싱 (Slicing)

해당 글은 문자열 인덱싱과 문자열 슬라이싱에 대한 개념과 활용 예제에 대해 자세하게 소개한 글입니다. 1) 문자열 인덱싱 (indexing)타 언어에서는 문자열 인덱스 번호가 0부터 시작합니다. 하지

spirit0833.tistory.com

https://www.tistory.com/event/write-challenge-2024

작심삼주 오블완 챌린지

오늘 블로그 완료! 21일 동안 매일 블로그에 글 쓰고 글력을 키워보세요.