• ps : 현재 터미널에서 사용자가 실행한 프로세스의 정보를 출력

• *ps -f *: 프로세스의 상세 정보 출력 (UNIX 옵션)

• *ps a *: 터미널에서 실행한 프로세스의 정보 출력 (BSD옵션)

• ps au : 터미널에서 실행한 프로세스(a)의 상세정보 출력(u)

• ps -e : 전체 프로세스 목록 출력 (UNIX 옵션)

• ps ax : 전체 프로세스 출력

• ps -u : 특정 사용자가 실행한 프로세스 목록 출력

pgrep 명령어

• pgrep : 지정된 패턴과 일치하는 프로세스의 정보 출력

• 형식 : pgrep [option] < pattern >

• pgrep -x bash : 패턴과 정확히 일치하는 CMD를 가진 프로세스 출력

• -> 프로세스의 CMD가 정확히 bash와 일치하는 프로세스 출력 "정확히 일치한다" bash!=ssbash

• pgrep -l bash : 패턴과 정확히 일치하는 프로세스의 PID와 이름 출력

• -> -x 옵션과의 차이점 : 프로세스 이름이 함께 표시

• *ps -fp $(pgrep -x bash) *: 찾고자 하는 프로세스의 상세 정보 확인이 필요한 경우에 사용

  --> pgrep 명령으로 bash의 PID를 검색한 결과를 -p 옵션의 인자로 사용

  --> pgrep -x bash 명령으로 검색된 각 PID에 해당하는 프로세스의 상세 정보 출력

• pgrep -fp $(pgrep -u ryanhan bash) : ryanhan 사용자가 실행한 bash 프로세스의 자세한 정보 확인

Kill 명령어

1. 먼저 종료할 프로세스의 PID를 확인

• ps -ef 나 ps aux 명령으로 종료하고자 하는 프로세스 PID를 알아냄

2. PID 확인 후 kill 또는 pkill을 사용하여 종료 시킴

• kill & pkill 명령은 프로세스에 시그널을 보내는 방식으로 프로세스를 종료

• 시그널 : 프로세스에 무엇인가가 발생했음을 알리는 간단한 메세지

• -> kill -l 명령어를 통해 시그널 목록 확인 가능

kill 명령 : 지정한 시그널을 프로세스에게 보냄

단순 kill = kill -15

--> 형식 : kill [ - < signal > ] < pid > --> < signal > 에 작성한 시그널이 가진 처리 방식으로 프로세스를 종료

kill -2 < ____ >---> 인터럽트 신호를 보냄 (SIGINT)

kill -9 < ____ > ---> 프로세스를 강제 종료 (SIGKILL)

kill -15 <____> ---> 프로세스와 관련된 파일을 정리한 후 종료(SIGTERM

• kill 명령 사용법

--> ps -fp $(pgrep -x man) 을 통해 실행중인 man 프로세스의 PID를 확인한다

• 프로세스 강제 종료 ( 9 )

• kill < PID > 로 종료를 해도 sh 프로세스는 종료되지 않음
• sh 는 15번 시그널 (SIGTERM)을 무시함

pkill 명령 사용법

• pkill : kill 명령과 마찬가지로 시그널을 보냄
• -> PID가 아니라 프로세스의 명령 이름(CMD) 로 프로세스를 찾아 종료

- 여기서 기존 kill은 PID를 통해 프로세스를 종료하는 반면 pkill은 CMD 즉 man을 통해 pkill man 으로 man프로세스를 종료시킨다.

포그라운드 및 백그라운드 작업

• 포그라운드 프로세스 : 입력한 명령의 결과가 출력될때까지 기다리는 프로세스

--> 작업이 완료될 때까지 기다려야 함.

--> sleep 명령으로 확인 ex) sleep 10 --> 10초 뒤 sleep 이 종료되기 이전에는ㅍ ㅡ롬프트가 다른 명령 받을 수 없음

• 백그라운드 작업 : 프로세스가 실행되는 동안 다른 프로세스의 실행이 가능

실행방법 : 명령 끝에 & 기호 추가

ex) sleep 10 & --> sleep 명령을 백드라운드로 실행

--> 백드라운드 단점 : 작업 결과가 뒤섞여 결과 확인 어려움

작업 제어

• 작업 전환 : 포그라운드 <--> 백그라운드

• 작업 일시 중지 : 작업을 잠시 중단

• 작업 종료 : 프로세스를 종료하는 것처럼 작업을 종료

• jobs 명령어 : 현재 백그라운드에서 실행중인 작업 목록 출력

--> 형식 : jobs [ &id ] ( id에는 jobs 명령으로 확인한 작업 번호 작성

• ^Z([ Ctrl ]+x) 또는 stop 명령은 현재 포그라운드 작업을 Stopped 상태로 바꿔 잠시 정지시킴(종료하는 것이 아님)

• 작업 종료: ctrl + c , kill 명령

시스템 성능 모니터링

• top 명령 : 현재 실행 중인 프로세스의 정보를 주기적으로 출력

--> 형식 : top [ option ]

• htop 명령 : top 명령의 그래픽 버전( 색깔 추가 가시성 보완 )

시스템 사용자 관리

• 런레벨 : 시스템 관리의 용이함을 위하여 서비스의 실행을 단계별로 구분하여 적용한 것

사용자 계정 관련 파일

• /etc/passwd 파일 : 리눅스에 생성되어 있는 모든 사용자 계정의 간단한 정보를 저장 (7가지 항목) --> 비번은 x로 표시됨 --> 파일 유출된 경우에도 계정의 비밀번호를 알지 못하도록 하기위해 !

• /etc/shadow 파일 : 사용자 암호에 대한 정보를 별도로 관리하는 파일(9가지 항목)

• /etc/login.defs/ 파일 : 계정에 필요한 기본값을 정의

-/etc/group/ 파일 : 시스템에 생성된 그룹에 관한 정보가 저장된 파일

• /etc/gshadow/ 파일 : 각 그룹에 대한 비밀번호가 저장된 파일

• /etc/skel 디렉터리 : 사용자 홈 디렉터리에 공통으로 배포해야할 파일 가지고 있음

사용자 관리 명령어

사용자 생성 명령어

• useradd 명령 : 사용자 계정 생성
• -> 사용법 : useradd [ options ] < user >
• -> 옵선 없이 사용하면, sh 쉘을 사용하고, 사용자명과 동일한 이름의 그룹에 속하며, 홈 디렉터리가 없는 상태를 기본값으로 가진 새로운 계정이 생성

--> 홈 디렉터리를 가진 bill 계정생성 : sudo useradd -m bill ( -m 은 사용자의 홈 디렉터리를 생성하는 옵션 )

• passwd 명령 : 계정의 새로운 비밀변호를 설정
• -> 사용법 : passwd < user >
• -> < user >로 비밀번호를 변경할 사용자를 지정하지 않으면, 현재 로그인한 계정의 비밀번호를 변경

• su 명령 : 현재 계정을 로그아웃 하지 않고 다른 계정으로 전환

--> 사용법 : su [ option ] < user >

사용자 정보 수정 명령어

• usermod 명령 : 사용자 계정 정보를 수정

--> 사용법 : usermod [ options ] < user >

사용자 삭제 명령어

• userdel 명령 : 사용자 계정을 삭제.

---> 사용법 : userdel [ option ] < user > ---> 옵션 : *-r *: 사용자의 홈 디렉터리까지 삭제

그룹 관리 명령어

그룹 생성 명령어

• groupadd 명령 : 그룹 생성

--> 사용법 : groupadd [ options ] < groupname >

--> 옵션 : -g < gid > : 생성할 그룹의 GID 지정

그룹 정보 수정 명령어

• groupmod 명령 : 그룹 정보 수정

--> 사용법 : groupmod [ options ] < group >

그룹 암호 변경 명령어

• gpasswd 명령 : /etc/passwd/ 와 /etc/gshadow/ 파일을 관리

--> 사용법 : gpasswd [ options ] < group >

sudo gpasswd -a linus itgeeks --> itgeeks 그룹의 linus 라는 그룹원 추가

sudo gpasswd -d linus itgeeks --> itgeeks 그룹의 linus 라는 그룹원 삭제

기본 그룹 변경 명령어

- newgrp 명령 : 현재 사용자의 기본 그룹을 변경 --> 사용법 : newgrp < group >

그룹 삭제 명령어

• groupdel 명령 : 그룹 삭제
• -> 사용법 : groupdel < group >

사용자 식별 명령어

---> 리눅스에서 사용자의 신원을 식별하고, 파일 시스템 및 프로세스 권한을 관리하는데 사용

– UID(User ID) : 사용자의 고유 식별 번호 – RUID(Real User ID) : 프로세스를 시작한 실제 사용자의 UID --> who am i 명령을 통해 확인 – EUID(Effective User ID) : 프로세스가 현재 수행 중인 작업에 대해 실제로 적용되는 UID --> whoami 명령을 통해 확인

사용자 정보 관리 명령어

• who 명령 : 현재 시스템을 사용하는 사용자의 정보 출력
• -> who [ option ]

• w 명령 : 현재 시스템을 사용하는 사용자의 정보와 작업 정보 출력

--> 사용법 : w [ option ] [ user ]

• last 명령어 : 시스템에 사용자들이 로그인/로그아웃한 정보를 출력

--> last [ user ]

• groups 명령 : 사용자 계정이 속한 그룹 출력

--> 사용법 : groups [ user ]

파일 소유권 변경 명령어

• chown 명령 : 파일/디렉터리 소유자나 소유 그룹을 변경

--> 사용법 : 사용법 : chown [ option ] < user > < file >

--> 옵션 : -R : 서브 디렉터리의 소유자와 소유 그룹도 변경

** 소프트웨어의 배포 모델과 라이선스

• 상용 소프트웨어를 사용할 때 비용을 지불한다

• -> 비용 지불 = 라이선스 획득 ( SW 사용에 대한 권리만 획득)

• 오픈소스 소프트웨어는 사용할 때 비용을 지불하지 않는 경우 많음

• -> 사용, 수정, 배포를 위해서는 오픈소스 라이선스를 준수해야한다.

• -> 준수하지 않는다 ? -> 법적 리스크 발생

** 소프트웨어의 배포모델

1. 독점 소프트웨어

• 저작권 소유자가 완전히 통제, 소스코드 비공개.
• 사용자는 소프트웨어를 사용하기 위해 라이선스를 구매.
• 사용자는 소프트웨어를 수정하거나 재배포할 수 없다.

2. 프리웨어

• 사용자에게 _무료로 제공_되는 소프트웨어
• 독점 소프트웨어와 유사하게 소스코드 비공개
• -> 단점 : 업데이트 불확실, 기술 지원 부족

3. 쉐어웨어

• _일정 기간 동안 무료_로 사용할 수 있는 소프트웨어
• 기간이 끝나면 라이선스를 구입해야한다.

4, 오픈소스 소프트웨어

• 소스코드가 공개되어 누구나 수정하고 배포할 수 있는 소프트웨어
• 사용자가 소스코드에 접근, 수정, 사용, 재배포할 수 있는 권리를 가지고 있음.

5. 프리 소프트웨어

• 사용자에게 자유롭게 사용, 수정, 복사, 배포 권리 부여

오픈소스 소프트웨어 장단점

장점

• 초기 개발비용이 작다
• 독점 프로그램에 비해 기술 발전 속도가 빠르다.
• 다른 SW간의 상호 연동성이 보장된다.
• 강력한 네트워킹 기능 지원

단점

• GUI 애플리케이션이 부족
• 상용 프로그램에 비해 체계적인 문서를 가지고 있지 못하다.
• 독점 프로그램에서 볼 수 있는 로드맵을 기대하기 어려움
• Royalty-free 요구( 라이선스 구매 등의 권한 획득시 지속적으로 사용할 수 있는 것)

오픈소스 라이선스의 정의

** 오픈소스 라이선스의 정의

• 소프트웨어의 소스코드를 공개하고, 누구나 해당 코드를 자유롭게 사용, 수정, 배포할 수 있는 권리를 부여하는 법적 합의.

** 오픈 소스 소프트웨어의 기본 원칙

• 소스코드의 공개
• 자유로운 재 배포
• 소스코드의 무결성 유지
• 개별 사용자 및 단체가 변경된 버전을 배포할 수 있는 권리

** 오픈 소스 라이선스의 순기능

• 개발자 간의 협업을 강화 --> 지식의 확산
• 사용자와 개발자 모두가 기술 발전에 기여 --> 기술 혁신을 촉진

주요 오픈소스 라이선스

** 상호적/전염성 라이선스 : 배포시 소스코드 제공의무 있음

** 허용적 라이선스 : 배포 시 소스코드 제공의무 없음

** GNU : 자유 소프트웨어 재단에서 개발

** 전염성 라이선스 : 수정된 버전 재배포 시 라이선스 공개

** AGPL : GPL을 기반으로 네트워크를 통해 서비스를 제공하는 경우 소스코드 접근 권한이 추가된 라이서스

** 허용적 라이선스 : 사용자와 개발자에게 광범위한 자유를 제공, 수정된 소스코드는 동일한 라이선스 하에 공개할 필요 없음.

** BSD : SW 사용, 복사, 수정 및 재배포에 상대적으로 제약이 적다. --> 개발자가 법적 책임 지지 않음.

소프트웨어의 빌드 과정

빌드 = 소스코드를 바이너리로 만드는 과정

소스코드 = 개발자가 프로그래밍 언어로 개발한 SW 문서

목적파일 = 소스코드를 컴파일해서 생긴 파일(실행되지 않음, .obj)

바이너리 = 컴퓨터가 이해할 수 있는 기계어

• 실행파일 (.exe) : main 함수가 포함되어 실행할 수 있는 바이너리
• 라이브러리 : main 함수 없이 함수로만 구성된 바이너리
• -> 정적 라이브러리 : 실행파일에 포함되어 메모리에 적재
• -> 동적 라이브러리 : 실행파일과 별도로 메모리에 적재

** 소프트웨어의 빌드 과정

• 컴파일러 : 소스코드를 목적파일로 변환
• 링커 : 목적파일과 라이브러리를 묶어 실행파일 생성

** 오픈소스 소프트웨어 활용과 라이선스 정책

• GPL 소스코드 포함

• -> GPL 소스코드를 본인 코드와 결합하여 배포하는 경우, 결과물 전체는 GPL 라이선스를 따라야 한다. 따라서 배포시 전체 소스코드를 공개해야한다.

• GPL 라이브러리 링크

• -> 본인 코드가 GPL 라이선스 라이브러리와 링크될 경우, 전체 결과물은 GPL 라이선스를 따라야 하며, 소스코드 공개해야함

• LGPL 소스코드 포함

• -> 본인 코드와 LGPL 소스코드를 결합하여 배포하면, 결합된 결과물은 혼합 라이선스가 됨. LGPL 부분에 대해서는 소스코드 공개가 필요하지만, 내 코드는 독립적으로 유지할 수 있음.

• LGPL 라이브러리 링크

• -> 본인 코드가 LGPL 라이브버리와 링크될 경우, 본인 코드를 공개할 필요 없지만, LGPL 라이브러리에 대한 수정 사항은 공개해야한다.

• BSD 소스코드 포함

• -> 본인 코드와 BSD 소스코드를 결합하여 배포하면, BSD 라이선스 조건을 따르되 개발한 코드는 비공개로 유지 가능, BSD는 소스코드 공개를 강제하지 않지만, 저작권 고지를 해야함.

• MPL 소스코드 포함

• -> 본인 코드와 MPL 소스코드를 결합하여 배포하면, MPL 소스코드 부분에 대해서는 소스코드를 공개해야한다.

• -> MPL은 파일 단위로 적용되기 떄문에, 개발한 코드 파일이 MPL 코드를 포함하지 않으면 비공개로 유지할 수 있다.

CVS : 서버와 클라이언트로 구분된 시스템, 롤백 불가능

SVN : CVS의 제한적인 기능을 대체하기 위해 개발, 롤백 가능

Git : 분산형 버전 관리 시스템, 리눅스 토발즈가 리눅스 커널 개발 위해서 만듦. 원격서버 상태에 구애받지 않고 형상관리 가능

GitHub : 프로젝트 저장뿐만 아니라, 다른 사용자들과 함께 코드 공유, 및 협업 같이 할 수 있도록 함.

GitHub에서 사용하는 저장소 종류

1. 저장소 : 파일이나 디렉토리를 저장하는 장소

2. 로컬 저장소 : 본인 PC에 파일이 저장되는 개인 저장소

3. 원격 저장소 : 서버 등 네트워크에 있는저장소, GitHub에서 관리되고 있는 저장소.

-->> 로컬저장소에서 작업을 수행하고, 그 결과를 원격저장소에 저장함.

분산 버전 관리 시스템(DVCS)

DVCS

• 서버에 등록되어 있는 프로젝트의 버전 관리 정보를 전부 복제
• 서버에 문제가 생겨도, 복제물로 문제없이 협업 진행 가능
• 사용자가 가진 작업물을 서버에 저장할 수 있음

Git 개념

**Git 탄생 배경

• 리눅스 커널 개발을 위해 DVCS이 필요하여 Git이 탄생

• -> 리눅스 커널을 압축 파일을 이용하여 단순하게 관리

• Git 목표 : 빠른 속도, 단순한 구조, 비선형적 개발, 완벽한 분산.

**스냅샷이란

• 특정 시점의 파일 상태( Git은 스냅샷 방식으로 형상관리)
• 시간 순으로 프로젝트의 스냅샷을 생성
• 수정되지 않은 파일은 이전 스냅샷의 파일을 그대로 참조
• 파일 크기가 크고 변경점이 많은 프로젝트에서도 유용

** Git에서 사용하는 영역

• 작업 디렉터리 : 버전 관리가 필요한 파일이 저장되어 있는 디렉터리, .git 디렉터리에 반영

• 스테이징 영역 : 곧 커밋할 파일에 대한 정보를 담은 영역

• .git 디렉터리 : Git의 버전관리를 위한 데이터가 저장

1. 인터넷 접근의 불균형 문제

   • 인터넷은 전 세계적인 정보 교환을 가능하게 하지만, 농촌 지역은 인터넷 접근이 어려운 경우가 많음. 농촌지역 사람들은 휴대폰을 가지고 있지만 인터넷 연결이 어려움

2. 켄 뱅크스와 FrontlineSMS

   • 켄 뱅크스는 인터넷 없이 휴대폰으로 정보를 교환할 수 있는 무료 소프트웨어 FrontlineSMS를 개발.

• 이 소프트웨어는 컴퓨터와 휴대폰을 연결해 문자 메시지를 통해 양방향 소통을 가능하게 함.

• 활용 사례:

• • 말라위에서 의료 프로그램에 활용.
• • 나이지리아의 선거 모니터링.
• • 아이티의 재난 구호 지원.
• • 현재 190여 개국에서 사용 중.

3. 성공적인 아이디어 실현 방법

• 아이디어 검증: 철저히 조사하고, 커뮤니티와 소통하여 필요한지 확인.

• 홍보: 소셜 미디어(Facebook, Twitter 등)와 블로그로 아이디어 알리기. 같은 분야의 사람들과 네트워킹.

• 자금 조달: 소셜 네트워크를 활용. 기부자들에게 신뢰를 얻기 위해 준비된 모습을 보여야 함.

4. 전하고자 하는 메시지

• 혁신은 간단한 관찰에서 시작될 수 있으며, 아이디어와 열정만 있으면 세상을 바꿀 수 있음.

10-2 (Lessons In Business)

<가이 가와사키의 경력과 주요 교훈>

• 초기 경력

-- 1979년 UCLA에서 MBA 학위 취득 후 보석 회사에서 근무. -- 이때 사장 마틴 그루버에게 “특징이 아닌 혜택을 판매하라”는 교훈을 배움.

---> 제품이 어떤 기능을 가지고 있는지를 설명하기보다, 그 기능이 고객의 삶에 어떤 도움을 주는지를 강조하라 라는 뜻임.

-- 이후 Apple에서 이 교훈을 활용하여 큰 성공을 거둠.

• Apple에서의 경험

-- “수석 전도사” 역할로 Apple 제품의 가치를 홍보하고 열정을 전파. -- Apple의 법률 고문 알 아이젠스타트에게 기업 정치의 기술을 배워, 권력 투쟁 속에서도 갈등을 피함. -- Apple의 공동 창립자 스티브 잡스에게서 큰 영향을 받음.

<스티브 잡스에게 배운 네 가지 교훈>

• 고객의 진짜 필요를 이해하라

----> 고객은 보기 전까지 자신이 무엇을 원하는지 모름. ----> 기업가는 고객보다 먼저 문제를 발견하고 해결해야 함.

• 전문가를 맹신하지 말라

----> 전문가(컨설턴트, 애널리스트 등)는 소비자와 단절된 경우가 많음. ----> 직접 조사하고, 소비자와 소통하며 데이터를 얻어야 함.

• 디자인의 중요성

----> Apple의 성공 비결: 단순함, 우아함, 재미. ----> 아름다운 디자인은 높은 품질과 가치감을 전달하며, 소비자의 구매 결정을 유도.

• 직원들에게 큰 목표를 제시하라

----> 단순화하지 않고 도전적인 목표를 설정하여 최고 성과를 유도. ----> 스는 디테일과 높은 기준을 중시하여 혁신을 이루어냄.

<<소셜 미디어를 활용한 제품 판매 팁 (가와사키의 조언)>>

• 자주 게시

---> 지속적인 게시물로 고객과 소통 유지.

• 삶을 개선하는 콘텐츠

---> 고객에게 실질적인 가치를 제공하는 글을 올림.

• 멀티미디어 활용

---> 모든 게시물에 사진 또는 동영상을 포함해 시각적 관심을 유도.

• 게시물 반복

---> 시간대와 일정이 다른 사람들을 위해 동일한 콘텐츠를 반복 게시.

<핵심 메시지> 가이 가와사키는 Apple과의 경험에서 얻은 교훈을 바탕으로, 제품의 혜택을 강조하고 고객의 요구를 이해하며, 강력한 디자인과 혁신적인 사고로 성공을 거둔 기업가. 소셜 미디어를 활용해 제품을 효과적으로 홍보할 수 있는 실질적인 전략도 제안.

9-1 (What Are Feathers For?)

1. 깃털의 기원과 초기 구조

• 수각류 공룡: 약 1억 2,500만 년 전의 공룡 화석에서 발견된 원시적인 깃털은 얇은 털층으로 덮여 있었음.
• 이 초기 깃털은 이후 깃털의 진화와 역할을 이해하는 데 중요한 단서를 제공함.

2. 깃털 진화의 세 가지 주요 이유

• 단열(보온)

  --> 깃털은 초기 공룡이 체온을 유지하고 어린 개체를 보호하는 역할을 했을 가능성이 큼. --> 둥지 위에 팔을 펼친 화석과 현대 새의 부드러운 깃털이 이 이론을 뒷받침함.

  • 시각적 매력(이성 유인)

  --> 다양한 색상과 패턴은 짝을 유인하는 데 사용됨. --> 예: 공작새의 화려한 꼬리는 짝을 유인하는 데 중요. --> 깃털 내부에서 발견된 멜라노좀은 색깔을 만들어 내며, 이는 현대 새와 유사한 특징임.

  • 비행

  --> 현대 새의 비행 깃털은 비대칭 구조_(한쪽은 얇고 단단하며, 다른 쪽은 길고 유연함)_로 되어 있어 비행에 최적화.

  --> 깃털을 사용한 비행은 달리면서 팔을 위아래로 움직이거나, 나무에서 뛰어내리며 시작되었을 가능성이 높음.

3. 안키오르니스: 중요한 연결고리

• 약 1억 5천만 년 전의 공룡으로, 닭 크기의 몸에 흑백 깃털을 가짐.
• -> 깃털은 현대 새와 비슷했지만 _대칭적_이어서 날지는 못했음.
• -> 화석에서 발견된 팔의 움직일 수 있는 뼈는 깃털이 나무 사이를 뛰거나 활공하며 비행을 진화시켰음을 시사.

4. 깃털의 진화 과정 --> 체온 유지, 짝 유인, 비행과 같은 다양한 목적에 맞게 발전. --> 디자인, 색상, 구조의 변화는 공룡과 새의 생존과 번성에 크게 기여. --> 초기 깃털은 공룡의 생존에 필수적이었고, 이후 새들이 하늘로 날아오를 수 있는 토대가 됨.

<결론>

깃털은 다양한 생존과 적응적 이점을 제공하며, 보온, 짝 유인, 비행을 가능하게 한 혁신적인 진화의 산물임.

9-2 (Design By Nature)

<1. 투칸의 부리>

1. 부리의 특징

   • 투칸, 특히 토코투칸은 새 전체 길이의 약 1/3(15~23cm) 길이의 커다란 주황색-노란색 부리를 가짐.
   • 부리는 가볍지만 튼튼하게 설계되었으며, 케라틴(사람의 손톱과 머리카락의 주성분)으로 만들어짐.
   • 내부는 공기가 많이 포함된 거품 같은 구조와 얇은 뼈 네트워크로 이루어져 있어 단단하지만 가벼움.

2. 부리의 역할

   • 짝 유인: 찰스 다윈은 부리가 짝을 끌어들이는 역할을 한다고 이론화.

   • 다양한 기능: 과일 자르기, 싸움에서 방어, 포식자에 대한 경고.

   • 체온 조절: 부리에 혈액이 유입되면 열을 방출해 투칸의 몸을 식히는 데 도움.

3. 부리의 응용

• 투칸 부리의 구조는 자동차와 항공기 설계에 영감을 제공.
• 연구에 따르면 이 구조는 고에너지 충격을 잘 흡수하여 충돌 시 탑승자를 더 안전하게 보호할 수 있음.

<2. 상어 비늘>

1. 비늘의 구조와 역할

• 상어 피부는 매끄러워 보이지만 실제로는 이빨과 같은 재질로 된 작은 비늘로 덮여 있음.
• 비늘의 유연성: 물의 흐름에 따라 위로 올라가거나 평평해질 수 있음.
• 항력 감소: 비늘이 상어 주변 물의 흐름에 적응하여 속도를 높이고 효율적으로 헤엄칠 수 있도록 도움.

2. 짧은지느러미 마코 상어의 비늘 연구

• 비늘의 크기와 유연성이 상어 몸 전체에서 다름.
• 예: 몸 양쪽 비늘은 가늘고 잘 움직여 항력을 줄이는 데 적합.

3. 비늘의 응용

• 비행기: 상어 비늘 구조를 모방하면 항력을 줄여 속도를 높이는 데 사용 가능.
• 수영복과 선박 코팅: 상어 비늘의 특성을 활용해 더 빠르고 효율적인 디자인을 개발.

_**<설명> 투칸의 부리는 생존과 적응을 위한 다목적 도구입니다. 단단하면서도 가벼운 설계는 자연의 혁신적인 구조로, 이를 통해 열 조절과 다양한 활동이 가능해졌습니다. 상어의 비늘은 물 속에서의 항력을 최소화하는 데 최적화된 구조로, 이는 속도와 민첩성을 높이는 데 기여합니다.

이러한 자연의 설계는 자동차, 항공기, 수영복 등 다양한 현대 기술에 영감을 주며, 효율성과 안전성을 높이는 데 활용되고 있습니다.**_

버블정렬은 배열에서 2개의 인덱스를 선택하고 비교한다.(오름차순 가정)

왼쪽이 오른쪽보다 크면 교환한다.

오른쪽으로 한칸 이동해서 프로세스를 반복한다.

아래 예시로 이해해보자.

5는 2보다 크므로 서로 swap

이번에는 한칸 오른쪽으로 이동해서 5와 6을 비교한다. 왼<오 이므로 swap 하지 않는다.

다시 오른쪽으로 한 칸 이동해서 6과 3을 비교한다. 6>3 이므로 swap한다.

똑같은 방식으로 6과 1을 비교하고 swap, 6과 4를 비교하여 swap 하면 아래와 같이 버블 사이클 1회가 완료된다.

나머지를 정렬하려면 다시 처음부터 비교해서 버블정렬을 해주어야한다.

• 버블정렬은 배열의 N-1 의 원소들을 하나하나 비교해야하고 사이클마다 계속 비교하고 반복하므로 비효율적인 알고리즘이다.
• 최악의 경우 모든 원소를 교환해야하므로 시간 복잡도가 O(n^2)이다.

Selection Sort(선택 정렬)

선택 정렬은 전체 원소 중 가장 작은 원소의 위치를 "변수"에 저장한다.

가장 작은 원소 변수를 Min이라고 하자.

배열의 첫번째 원소의 위치를 Min에 저장한다.

*만약 배열을 돌때 첫번째 원소 즉 Min보다 작은 값이 있다면 그 값의 위치를 다시 Min 변수에 저장한다. *

이 과정을 계속 반복해 배열 내에서 가장 작은 숫자가 어디에 있는지 알아냈다. 이제 가장 작은 값을 배열의 맨 앞으로 swap 해준다.

1은 배열 내에서 가장 작은 값이므로 이미 정렬이 완료된 상태이다. 즉 다음 사이클을 시작할 때는 두번째 원소부터 시작한다. 이 과정을 계속 반복한다.

• 선택 정렬의 시간 복잡도: 버블 정렬과 비슷하게 교환, 비교하지만 사이클을 반복할 때마다 한번의 교환만 하면 돼서 버블정렬보단 효율적이다.

• 하지만 버블정렬과 같은 O(n^2) 복잡도를 가지고 있다.

<선택 정렬 구현 코드 c++>

#include<iostream>
#include<vector>
#include<queue>
#include <stack>
#include<algorithm>
#include<limits.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    int i,j,min,index,temp;
    vector<int> v={1,10,5,8,7,6,4,3,2,9};

    for(int i=0;i<10;i++){
        min=i;
        for(j=i+1;j<10;j++){
            if(v[min]>v[j]){
                min=j;
            }
            temp=v[i];
            v[i]=v[min];
            v[min]=temp;
        }
    }

    for(int i=0; i<v.size();i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;

    return 0;
}

https://velog.io/@minji0801/%EB%B2%84%EB%B8%94%EC%A0%95%EB%A0%AC-vs-%EC%84%A0%ED%83%9D%EC%A0%95%EB%A0%AC-vs-%EC%82%BD%EC%9E%85%EC%A0%95%EB%A0%AC-%EC%B0%A8%EC%9D%B4-%EC%A0%9C%EB%8C%80%EB%A1%9C-%EC%95%8C%EA%B3%A0%EA%B0%80%EC%9E%90 이분꺼 이미지 참고함~

1. 약수 판정

#include <stdio.h>
void print_divisor(int value); // 약수 구하는 함수 
int main(void) {
    int number;
    while (1) // 무한 반복
    {
        printf("약수를 구할 정수 입력(1 이하 종료) : ");
        scanf("%d", &number); // 데이터 입력
        if (number >= 2) { // 약수를 구할 수 있다면
            print_divisor(number);
        }
        else { // 약수를 구할 수 없다면
            printf("%d에 대한 약수를 구할 수 없습니다.\n", number);
            printf("프로그램을 종료합니다.\n");
            break;
        }
        printf("\n");
    }
    return 0;
}

void print_divisor(int value) {
    printf("%d의 약수 : ", value);
    for (int i = 2; i <= value; i++) {
        if (value % i == 0) {
            printf("%d ", i);
        }
    }
}

2. 완전수 출력하기

#include <stdio.h>
int perfect_number(int number); // 완전수 여부 판별 함수 (반환형 void으로 변경가능) 
int main(void) {
    int number=0;
    printf("1000 이하의 완전수: \n");
    perfect_number(number);
    // 반복문 수행 및 perfect_number() 호출하여 완전 수 계산 및 출력 
    for (number = 1; number <= 1000; number++) {
        if (perfect_number(number) == 1) {
            printf("%d\n", number);
        }

    }
    return 0;
}
//약수의 합이 자기 자신과 같아져야함.
int perfect_number(int number) {
    int sum = 0;
    for (int i = 1; i < number; i++) {
        if (number % i == 0) {
            sum += i;
        }
    }
    if (sum == number) return 1;

    else return 0;

}

3. 공 바꾸기

#include <stdio.h>
int store[101] = { 0, };
int i, j;
void swap(int a, int b);
int main(void) {
    int N, M;//M은 바꿀 횟수
    scanf("%d %d", &N, &M);
    for (int q = 1; q <= N; q++) {
        store[q] = q;
    }
    for (int k = 1; k <= M; k++) {
        scanf("%d %d", &i, &j);
        swap(i, j);

    }

    for (int u = 1; u <= N; u++) {
        printf("%d ", store[u]);
    }


    return 0;
}
void swap(int a, int b) {//값 바꾸는 알고리즘 중요
    int temp;
    temp = store[i];
    store[i] = store[j];
    store[j] = temp;


}

4. 신문 헤드라인

#include <stdio.h>
#include <ctype.h>
int main(void) {
    char str[100];

    scanf("%s", &str);

    for (int i = 0; str[i] != '\0'; i++) {//널문자를 만날때 까지 반복
        str[i] = toupper(str[i]);
    }//toupper은 문자열 소문자를 대문자로 바꿔줌줌

    printf("%s", str);


    return 0;
}

tolower() 함수는 대문자 C를 대응하는 소문자 c로 변환합니다.

toupper() 함수는 소문자 c를 대응하는 대문자 C로 변환합니다.

리턴값

두 함수는 변환된 문자를 리턴합니다. 문자 c에 대응하는 소문자 또는 대문자가 없으면 함수는 c를 변경하지 않고 리턴합니다.

로또 게임 만들기, 빙고게임 만들기

1. 로또 게임 만들기

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 45
void user_chek(int* arr_user); //사용자가 입력한 숫자 배열에 저장.

void generate_lotto_number(int* arr_lotto); 
//컴퓨터 로또번호 생성(랜덤함수 사용)

int mapping_number(int* arr_user, int* arr_lotto);
//사용자 입력 숫자와 컴퓨터가 생성한 로또번호 중 일치하는 번호 수 카운트

int arr_lotto[6] = { 0 }; //컴퓨터가 임의로 생성하는 번호 6개 저장.
int arr_user[6] = { 0 }; //사용자가 입력하는 6개 번호 저장.
void print_arr(int* arr1, int *arr2); //숫자 출력 
int main(void) {
    int cnt;
    srand((unsigned)time(NULL));
    generate_lotto_number(arr_lotto); //컴퓨터 로또 번호 생성
    user_chek(arr_user); //사용자 숫자 입력 
    print_arr(arr_user,arr_lotto);
    cnt = mapping_number(arr_lotto, arr_user);
    printf("\n 당첨 번호는 %d개 입니다.\n", cnt);
    return 0;
}
void user_chek(int* arr_user) {
    for (int i = 0; i < 6; i++) {
        scanf("%d", &arr_user[i]);
    }
}
void generate_lotto_number(int* arr_lotto) {
    int existed[46] = { 0, };//중복체크 해주기
    for (int i = 0; i < 6; i++) {
        int num = 0;
        while (existed[num]==1) {//숫자가 존재할 때까지
            num = (rand() % 45) + 1;//이 부분 정말 중요함
        }
        arr_lotto[i] = num;
        existed[num] = 1;//이미 나온 숫자이면 다시 while문으로 돌아가 난수설정 
    }    
}
int mapping_number(int* arr_user, int* arr_lotto) {
    int count = 0;
    for (int i = 0; i < 6; i++) {
        for(int j=0;j<6;j++)//이중 반복문 사용하여 두 배열의 공통인 원소 찾기
        if (arr_user[i] == arr_lotto[j]) {
            count++;
        }
    }
    return count;
}
void print_arr(int* arr1,int *arr2) {
    printf("사용자 입력: ");
    for (int i = 0; i < 6; i++) {
        printf("%d ", arr_user[i]);
    }
    printf("\n");

    printf("당첨번호(컴퓨터생성): ");
    for (int i = 0; i < 6; i++) {
        printf("%d ", arr_lotto[i]);
    }
}

<stdlib.h> : srand() 와 rand()함수를 사용하기 위해 사용 <time.h> : 함수에 현재 시간을 시드로 설정하여 난수를 더 무작위로 생성하기 위해 사용

int *arr의 뜻 : 정수형 배열을 가리키는 포인터를 나타냄. 이 코드에서는 배열의 시작 주소를 가리키는 역할을 하며 포인터를 사용함으로써 함수 내에서 배열의 값을 직접 수정할 수 있음 ~

srand((unsigned)time(NULL)): 난수 생성기를 초기화하는 코드. time(NULL)을 사용하여 현재 시간을 시드 값으로 전달하여 매번 다른 난수가 생성되도록 합니다._ generate_lotto_number(arr_lotto): 로또 번호를 생성하는 함수 호출. user_chek(arr_user): 사용자로부터 6개의 로또 번호를 입력받습니다. print_arr(arr_user, arr_lotto): 입력한 번호와 컴퓨터가 생성한 로또 번호를 출력. mapping_number(arr_lotto, arr_user): 사용자가 입력한 번호와 컴퓨터가 생성한 번호를 비교해 일치하는 개수를 cnt에 저장. 최종적으로 일치하는 번호의 개수를 출력.

generate_lotto_number 함수

> void generate_lotto_number(int* arr_lotto) {
    int existed[46] = { 0, };
    for (int i = 0; i < 6; i++) {
        int num = 0;
        while (existed[num] == 1) {
            num = (rand() % 45) + 1;
        }
        arr_lotto[i] = num;
        existed[num] = 1;
    }    
}

이 함수는 컴퓨터가 1부터 45 사이의 숫자 중에서 중복되지 않는 6개의 난수를 생성하여 arr_lotto 배열에 저장합니다.

existed[46] 배열은 난수 중복 체크를 위한 배열이다.

만약 중복 숫자가 나오면 다시 while문으로 가서 num난수를 생성해 중복 숫자가 나오지 않도록 한다.

(rand() % 45 + 1): 1에서 45 사이의 난수를 생성합니다. existed[num]이 1이면 이미 선택된 숫자이므로 다시 난수를 생성합니다.

mapping_number 함수

int mapping_number(int* arr_user, int* arr_lotto) {
    int count = 0;
    for (int i = 0; i < 6; i++) {
        for(int j = 0; j < 6; j++)
            if (arr_user[i] == arr_lotto[j]) {
                count++;
            }
    }
    return count;
}

사용자가 입력한 숫자와 컴퓨터가 생성한 숫자를 비교하여 일치하는 개수를 계산한다.

두 개의 배열을 비교하는 이중 루프를 사용하여, arr_user와 arr_lotto에서 일치하는 숫자가 있을 경우 count를 증가시킨다.

문제를 보고 어떻게 하면 문자열을 각각의 인덱스로 나누어 숫자로 저장할지에 대해 고민했다. c++의 #include string 라이브러리에 있는 stoi 함수를 써보려고 했지만 이 함수를 쓰면 각각의 인덱스에 접근이 어려워져 문자열 자체를 바로 숫자로 바꾸는 방법을 생각해냈다.

문자열을 숫자로 바꾸는 방법(아스키 코드 사용)

문자 '0'은 아스키 코드 즉 십진수로 48이므로 1~9의 문자에 대한 십진수의 값-'0'을 하면 실제 숫자가 나온다.

만약 문자 4를 숫자 4로 바꾸려면 문자 4의 10진수 값인 52-'0'==4가 되는것을 볼 수 있다.

#최종코드

 #include<iostream>
 #include<vector>
 #include<queue>
 #include <stack>
 #include<algorithm>
 #include<limits.h>
 #include <string>
 using namespace std;

 int main(){
     ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
     string A;
     string B;
     long long sum=0;
     cin>>A>>B;
    for(long long i=0;i<A.length();i++){
        for(long long k=0;k<B.length();k++){
            sum+=(A[i]-'0')*(B[k]-'0');
        }
     }
    cout<<sum;
     return 0;
 }

일단 1은 소수가 아니기 때문에 제외하고 2부터 (입력받은 값-1)까지 i를 증가시키면서 입력받은 값을 i로 나눈 나머지가 0이면 소수가 아니고, 나머지가 0이 아니면 소수이므로 이를 표현하려고 함.

알고리즘

1. is_prime을 처음에 1로 고정.
2. i로 나눈 나머지가 0이면 소수가 아니므로 is_prime=0 이고 반복문은 빠져나올 break;를 선언해줌.
3. 나머지가 0이 아니라면 소수이므로 is_prime=1일것이고, if(1)을 통해 count_number을 증가시켜줌.```

   #include <stdio.h>
   

int main(void) { int arr[1000] = { 0 }; int N; int count_number = 0; scanf("%d", &N);

for (int i = 0; i < N; i++) {
    scanf("%d", &arr[i]);
    //소수의 규칙을 먼저 찾기

}
for (int i = 0; i < N; i++) {
    int is_prime = 1;

    if (arr[i] < 2) {
        is_prime = 0;
    }

    for (int k = 2; k < arr[i]; k++) {
        if (arr[i] % k == 0) {
            is_prime = 0;
            break;
        }

    }
    if (is_prime) {
        count_number++;
    }


}

printf("%d", count_number );

return 0;

}

### 에라토스테네스의 체(백준 2960번)

에라토스테네스의 체 알고리즘은 여러 개의 수가 소수인지 아닌지를 판별할 때 사용하는 대표적인 알고리즘입니다. 에라토스테네스의 체는 N보다 작거나 같은 모든 소수를 찾을 때 사용할 수 있습니다. 알고리즘을 먼저 살펴보겠습니다

**1. 2부터 N까지의 모든 자연수를 나열한다.**

**2. 나열한 수 중에서 가장 작은수 i를 찾는다.**

**3. 나열한 수에서 i를 제외한 i의 배수를 모두 제거한다.**

_**4. 더 이상 반복할 수 없을 때까지 2번과 3번과정 반복한다
**_
이를 계속 반복하게 되면 결국 소수밖에 안남을 것입니다.

**고민했던것 : 배수들을 찾는 반복문을 어떻게 작성해야할지 막막했다.
--> i를 2부터 하나하나 증가시키고 j=i부터 j=n까지 j에 j를 계속 더하면서 (j=j+i) 배수들을 찾아나갔다.**

_예를 들어 j=2 라면 2+2, 2+2+2, 2+2+2+2, .... 등등 으로 배수를 구할 수 있다._



<코드구현>
```c
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    int n, k;
    int count=0;
    cin >> n >> k;
    vector<int> prime(n + 1);

    for (int i=2;i<=n;i++)
    {
        prime[i]=i;
    }

    for (int i=2; i<=n;i++)
    {
        for (int j=i; j<=n;j+=i)
        {
            if (prime[j]!=0)
            {
                prime[j] = 0;
                count++;
                if (count==k)
                {
                    cout << j << '\n';
                    return 0;
                }
            }
        }
    }
    return 0;
}

학교 실습 과제 에라토스테네스 체 구현

#include<stdio.h>
#include<stdlib.h> //calloc(), free() 함수 선언
#include<math.h> //sqrt() 
void eratos(int number, int array[]) { //에라토스테세스의 체 알고리즘 사용하여 소수 구하기
    int n, m, to, last, index;
    to = (int)sqrt((double)number); // 마지막 나눌 값
    for (n = 2; n <= to; n++) { // 바깥쪽 루프
        last = number / n; // 마지막 조사 값
        for (m = 2; m <= last; m++) { // 안쪽 루프
            index = n * m; // 배열의 인덱스
            array[index] = 1; // 소수가 아님을 표시한다.
        }
    } // 이중 반복문이 끝났을 때까지 값이 0인 원소의 인덱스가 소수이다.
}
void print_primes(int value, int* array) {    //출력하기 
    int n;
    int count = 0;
    printf("%d의 소수 : \n", value);
    for (n = 2; n <= value; n++) {

        if (array[n] == 0) { // 소수인 것만
            printf("%9d", n); // 소수를 9 칸의 공간에 출력한다.
            count += 1; // 한 줄에 출력한 소수의 수
            if ((count % 8) == 0) // 한 줄에 8 개를 출력하였다면,
                printf("\n"); // 다음 줄로 이동한다. }
        }
    }
    printf("\n");
}

int main() {
    int number;
    int* array; // 문자형 포인터
    printf("정수를 입력하세요: "); // 정수 입력
    scanf("%d", &number);
    if (number > 2) {
        array = (int*)calloc(number, sizeof(int)); // 배열 동적 할당
        if (array != NULL) {
            eratos(number, array); //eratos() 함수 호출 
            print_primes(number, array); //print_primes()함수 호출 
            free(array); //동적할당 해제 
        }
    }
    return 0;
}

#동적할당

• #include <stdlib.h>에 calloc(), malloc() 함수가 들어있다.
• malloc에는 초기화되지 않은 값이 있어서 배열에 쓰레기 값이 저장되어 있다.
• calloc에는 할당 후 해당 메모리공간을 0으로 초기화한다.
• 메모리누수를 막기 위해 동적할당을 해주었으면 해제를 해야함 --> free(void ~~ )

동적할당의 장점?

1. 상황에 따라 원하는 크기 만큼의 메모리가 할당되므로 경제적이다.(malloc or calloc)
2. 이미 할당된 메모리라도 언제든 크기를 조정할 수 있다(realloc)

동적할당의 단점?

할당 후 free를 통해 해제해주지 않으면 메모리 누수가 나타나고 이는 디버깅에 영향을 미친다.

동적할당의 예시

int *arr=(int *)malloc(10*sizeof(int));
int *arr=(int *)calloc(10,sizeof(int));

malloc 은 매개변수로 입력된 크기 만큼을 그대로 할당하는 것이고 calloc은 두번째 매개변수의 크기를 첫번째 매개변수 갯수 만큼을 할당하는 것이다. 위 두 명령어 모두 똑같은 크기의 공간을 확보한다. 단지 calloc은 메모리를 초기화해주지만 malloc에는 쓰레기값이 저장되어있다는 차이가 있다.