자기계발 캠퍼스

[데보션 영 3기] 모던 리액트 Deep Dive 도서 스터디 후기

공대생철이 — Sun, 1 Dec 2024 20:45:28 +0900

안녕하세요. 데보션 영 3기 여행가조✈️ 박성철입니다!

데보션 영의 활동으로 진행한 도서 스터디!

7월부터 9월말까지 3달에 걸친 그 대장정에 대한 후기를 작성해보려 합니다.

우선 스터디 도서를 신청 받았었는데 운이 좋게 제가 제안안 모던 리액트 Deep Dive가 채택이 되어서 저를 제외한 3명의 데보션 영 구성원과 함께 스터디를 진행했습니다.

저희 팀의 스터디 방식은 다음과 같았습니다.

1. 스터디는 일요일 격주로 오후 3시에 SKT 타워에서 진행 (오프라인)

2. 스터디 전에 노션에 챕터별 내용 정리

3. 2명씩 돌아가면서 발표 및 내용 깃허브에 정리

일단 책이 매우 두껍고 내용도 정말 방대하기 때문에 서로에 대한 동기부여가 필요했기에 발표에 대한 약간의 강제성을 가지고 진행을 했더니 다행히 모두 열정적으로 임해주어 무사히 완주할 수 있었습니다!

(내용이 진짜 개개개많아서 사실 1회독 하긴 했는데 앞에 내용 다시 봐야되는...ㅎㅎ)

01장: 리액트 개발을 위해 꼭 알아야 할 자바스크립트

1장은 자바스크립트 핵심에 대한 내용을 다뤘습니다.

자바스크립트의 자료형, 메소드 등에 대해서 다뤄보는 챕터였는데 아무래도 책 뒤에 나오는 웬만한 자바스크립트 문법을 커버치기 때문에 양이 상당히 많았습니다....

(이 때 발표 담당이 저였는데 진짜 양 보고 깜짝 놀랐다는...)

기존에 알고 있던 개념들도 많았지만 배열 또는 객체의 내장 메소드들의 작동원리까지 설명해주어 놓치고 사용했던 부분들에 대해서 점검해볼 수 있었고, symbol과 같이 많이 접하지 못한 내용에 대해서도 공부해볼 수 있는 계기가 되었던 챕터였다.

02장: 리액트 핵심 요소 깊게 살펴보기

2장은 제목 그대로 리액트의 기반이 되는 핵심 요소들을 뜯어보는 챕터였습니다.

여기서부터 조금씩 헤데이크가 오기 시작한다. 사실 리액트를 사용해본 개발자 중에 리액트의 내부 구조까지 살펴본 사람은 몇이나 될까?

제가 그렇지 못한 사람이었기에 정말 배울게 많았던 챕터였습니다.

리액트 렌더링 원리에 대해서는 볼 때마다 헷갈렸던 것 같습니다. 브라우저의 렌더링 과정과 함께 리액트에서 컴포넌트를 업데이트하는 원리에 대해서 스터디원들과 정리해가면서 지금은 그나마 조금 이해도가 올라간 것 같습니다.

그럼에도 아직 완벽히 이해한 것이 아니기에 다시 꼭 봐야지...

그 뿐만 아니라 react fiber, reconcilation 등 익숙하지 않은 키워드들이 등장했는데 사실 처음 봐서 그런지 '이런게 있구나'하고 넘어갔던 것 같습니다. 개인적으로 이런 내부 원리가 가장 어려운 것 같습니다.

03장: 리액트 훅 깊게 살펴보기

3장은 리액트에서 중요한 개념 중 하나인 hook에 대해 자세한 소개가 나와 있는 챕터였습니다.

자주 쓰는 hook부터 생전 한 번도 사용해 본 적 없는 이름조차 생소한 hook들까지 어떤 기능을 하고, 어떻게 사용하는지 자세히 설명되어 있었습니다. 그래도 조금 익숙한 내용들도 있었어서 흥미롭게 배웠던 챕터였습니다.

최근에 기술면접에서 리액트 훅에 대한 질문을 받았는데 이 때 배웠던 지식이 진짜 많은 도움이 됐습니다ㅠㅠ

04장: 서버 사이드 렌더링

4장은 제목 그대로 서버 사이드 렌더링(SSR), 그리고 Next.js에 대한 내용이 담겨 있었습니다.

CSR과 SSR, SPA에 대한 내용이 주가 되는데 특히 SSR에 대해서 뒤에 나오는 React의 서버 컴포넌트와 아주 헷갈려서 스터디원들이랑 화이트 보드에 그림 그려가며 열띤 토론을 했었네요.

어쨌든 프론트엔드에서 가장 화두가 되고 있는 주제이기에 이 부분도 꼭 다시 챙겨봐야겠습니다.

05장: 리액트와 상태 관리 라이브러리

5장에서는 상태 관리를 왜 해야 하는지, 상태 관리는 어떤 식으로 발전되어 왔는지, 그리고 상태 관리를 위한 도구들을 어떤 것들이 있는지 알아보는 챕터였습니다.

이 부분은 제가 발표를 맡았었는데 개인적으로 가장 재밌었던 챕터였습니다. 아무래도 공돌이라 그런지 이것저것 만져보면서 직접 해보는 게 확실히 재밌었던 것 같습니다. 책에는 recoil, zustand, zotai에 대해서 설명이 나왔는데 zotai는 책을 공부하면서 처음 써봤던 라이브러리라 서로 차이점을 비교해보면서 재밌게 설명했던 챕터였네요ㅎㅎ

06장: 리액트 개발 도구로 디버깅하기

'리액트 개발 도구'란 무엇이며, 어떻게 활용해야 하는지에 대한 내용이었습니다.

컴포넌트와 프로파일러 탭에서 각각 어떤 내용을 제공하는지에 대한 설명이 나와 있었는데 이 부분은 책으로만 보기보다는 실제로 이런저런 웹사이트에서 많이 적용시켜보면서 어떻게 툴을 잘 활용할지 고민이 많이 필요했던 부분이라고 생각합니다.

07장: 크롬 개발자 도구를 활용한 애플리케이션 분석

크롬 개발자 도구의 각 탭에 어떤 내용이 담겨 있고, 그러한 내용들을 어떤 방식으로 해석해야 하는지에 대한 내용이었습니다.

크롬 개발자 도구에서 보통 요소, 콘솔, 네트워크, 애플리케이션 정도 많이 썼던 거 같은데 제가 알고 있는 것은 새발의 피도 아니라 새발에 붙어있는 바이러스의 피 정도 될 것 같습니다. 크롬이 가진 힘에 대해서 정말 여실히 느꼈던 챕터였습니다.

특별히 Next.js 환경을 어떻게 디버깅 해야 할지에 대한 내용도 담겨 있어서 좋았습니다.

08장: 좋은 리액트 코드 작성을 위한 환경 구축하기

8장은 쉽게 말해 '테스트'에 관한 장이었다. ESLint를 활용한 정적 코드 분석과 테스팅 라이브러리를 활용한 테스트 방법에 대해 대략적인 소개를 하는 챕터였습니다. 이론적인 내용들이 이어지고 이것을 활용하는 패키지들에 대해서 설명하니 되게 신기했고 한국의 트리플에서 만든 라이브러리도 소개해서 되게 신기했습니다.

09장: 모던 리액트 개발 도구로 개발 및 배포 환경 구축하기

리액트 애플리케이션을 배포, 도커라이즈 하는 방법에 대한 내용이 나와 있는 장이었습니다. 도커에 대한 내용이 특히 깊게 나와 있어서 다들 많이 어려워 했던 챕터였던 것 같습니다. 이 때 제가 마침 인턴하면서 도커에 대해서 맛을 보고 있었는데 제가 회사에서 배웠던 아주 얄팍한 지식을 활용하여 스터디원들과 함께 공유해서 되게 기억에 남는 장이었습니다. 하지만 아직도 도커는 별로 안 친해졌네요ㅠㅠ

10장: 리액트 17과 18의 변경 사항 살펴보기

이 챕터 진도를 나가고 있을 때 이미 리액트 19 버전이 experimental로 나왔었습니다.

하지만 리액트 17, 18의 대격변이 말도 안되게 크게 일어났기 때문에 어떤 차이점이 있고 앞으로 리액트 팀이 어떤 방향성을 가지고 업데이트를 해나가는지 살짝은 이해할 수 있었던 그런 챕터였습니다.

단순히 리액트에 있는 내가 모르는 기능들을 배우는 것을 넘어, 새로운 기능이 어떤 배경에서 나왔는지를 알아야 해당 기능을 적절한 용도로 사용할 수 있다는 점을 새롭게 깨닫게 해주는 챕터였습니다.

11장: Next.js 13과 리액트 18

11장은 제목 그대로 Next.js 13과 리액트 18 버전에 대한 내용이었습니다.

리액트 18에서 처음 등장한 리액트 서버 컴포넌트와 Next.js가 제공하는 SSR에 대해 비교·분석하는 내용을 주로 다루고 있는데, 이 때 스터디원들끼리 다시 CSR 복기해보고 SSR이랑 서버 컴포넌트가 어떻게 다른지 이해하는데 애를 좀 먹었던 기억이 나네요ㅎㅎ

12장: 모든 웹 개발자가 관심을 가져야 할 핵심 웹 지표

웹 사이트에서의 '성능'과 구글에서 요약한 핵심 웹 지표인 Core Web Vital의 각 항목에 대해 자세히 알아보는 장이었슷비낟.

핵심 웹 지표인 LCP, FID, CLS와 핵심까지는 아니지만 특정 문제를 진단할 때 사용하는 유용한 지표인 TTFB, FCP에 대한 설명이 나와있었습니다. 지표에 대한 용어와 좀 친해지는 그러한 챕터였습니다.

13장: 웹페이지의 성능을 측정하는 다양한 방법

12장에 이어 웹 페이지의 '성능'에 대한 내용이었고, 성능을 측정하기 위해 사용할 수 있는 여러 가지 방법이나 사이트를 소개하는 장이었습니다. 구글 라이트하우스와 같은 다양한 툴에 대해서 다루면서 이런 게 있구나 하면서 되게 신기했던 챕터였습니다.

프론트엔드의 세계는 어디까지인가...

14장: 웹사이트 보안을 위한 리액트와 웹페이지 보안 이슈

다같이 어려워 했던 보안 관련 챕터였습니다. 웹페이지에서의 보안 이슈에는 어떤 것들이 있고, 어떤 방법으로 해결할 수 있는지에 대한 내용이 나와있는데 아무래도 보안에 대해서 다들 지식이 없어서 이 챕터에 대해서는 깊게 이해해서 얘기를 나눠보지 못했던 것이 개인적으로는 좀 아쉬웠던 것 같습니다.

15장: 마치며

리액트 프로젝트를 시작할 때 고려해야 하는 사항과 향후 프론트엔드 트렌드 속에서 리액트는 어떻게 변화할지에 대한 내용이었습니다.

이 장에서는 특히 지금까지 배운 내용을 점검해 볼 수 있는 문제들이 존재했는데 스터디원분들과 같이 풀어보는 시간을 가졌네요ㅎㅎ

이렇게 해서 952페이지에 달하는 모던 리액트 Deep Dive 책을 완독했습니다.

3달 동안 격주로 일요일 3시에 항상 모여서 스터디원들 모두 열심히 참여해준 덕분에 정말 중간에 아무런 난관 없이 무사히 스터디가 마무리되었습니다. 진짜 열정 있는 스터디원들이 딱 모여서 한 번의 갈등 없이 마무리할 수 있었던 게 너무 신기하고 뿌듯하네요ㅎㅎ

스터디 내용을 깃헙에 정리하는 걸 저는 이 스터디에서 처음 해보았는데 다들 PR 날리고 저도 마크다운에 대해서 점점 익숙해지면서 되게 효율적인 방법이라고 생각이 들었습니다. 다음에 또 개발 내용에 대한 스터디를 하면 깃헙을 잘 활용해본 것을 적극 고려해봐야겠습니다!

정말 긴 책이기에 사실 1회독 하는 걸로 이 책을 다 이해하는 건 불가능에 가깝습니다. 그럼에도 이 책은 제가 기술 면접을 준비할 때 또는 면접 본 후에 복기하면서 다시 내용을 찾아보는 사전과 같은 책이었습니다.

이 책은 꼭 다시 한 번 (혼자서라도) 2회독, 3회독 해봐야될 것 같습니다!!

[데보션 영 3기] 실용주의 글쓰기 세미나 후기

공대생철이 — Fri, 29 Nov 2024 16:46:56 +0900

안녕하세요. 데보션 영 3기 여행가조✈️ 박성철입니다!

데보션에서 5월에 진행한 글쓰기 세미나 들으면서 정리한 내용이 있어서 지금 제 상태를 점검해보면서 세미나 후기도 한 번 작성해보려 합니다ㅎㅎ

저는 블로그 자체를 운영한지는 한 3,4년 정도 되었고

기술 블로그는 중간 블테기를 제외하면 한 1년 정도 운영했었습니다.

주제도 딱히 하나로 정해져있지 않고

책 리뷰도 썼다가,

주식 공부한 것도 썼다가,

면접이나 코테 후기도 썼다가

마구잡이로 썼었네요...

제가 세미나를 들으면서 와닿았다는 점은 2가지였습니다.

1. 제 1독자 = "나"

세미나 당시 반응도 그랬고 다른 분들의 세미나 후기도 보면 제 1독자가 "나"라는 관점에서 많이들 감명 깊었던 것 같습니다.

저 또한 마찬가지였습니다. 블로그를 작성하는 목적이 다양하겠지만 인간의 본성 아닌 본성(?)인 남에게 인정받고자 하는 욕구는 블로그와 같이 모든 사람들에게 24시간 오픈되어있는 공간에서는 분명 배제할 수 없는 요소죠.

그렇게 고려해야될 요소가 많아지니 시작하는 것을 망설이게 되고 겨우겨우 저항에 저항해서 글을 썼더라도 다시 읽어보면 이게 올려도 되는 글인가 싶었던 순간들을 마주하게 됩니다.

블로그에 글 하나 쓰는데 생기는 고민거리만 벌써 2,3개는 떠오르네요.

(사실 이 글 쓰고 있는데도 지금 맞게 쓰고 있는건지...ㅋㅋㅋㅋ)

Simple is the Best

이 격언은 글쓰기에서도 적용된다고 생각합니다. 글 하나를 쓰기 위한 고려사항을 줄이고 "나"라는 독자가 먼저 읽는다는 단순한 생각으로 출발하면 장벽의 높이는 급격하게 낮아질 거라고 생각되었습니다.

그리고 어차피 저의 ST적인 면모 중 하나인 '남 시선은 별로 신경 안 쓴다'도 이러한 글쓰기 방식에 큰 도움이 될 거라 생각해서 제가 내면에 가지고 있던 두려움을 날려보낼 수 있는 시간이 되었습니다.

2. 사람들의 고민은 다 똑같구나

세미나에서 커뮤니티 운영하시면서 나왔던 질문 리스트들, 세미나 진행 중 볼 수 있었던 질문들, 반응들을 보면 결국 사람들의 고민은 다 비슷비슷했습니다. 이런 모습을 보면서 글쓰기도 다이어트와 비슷하다는 생각들기도 했습니다.

솔직히 다이어트 방법을 모르는 사람은 없습니다. 건강한 음식과 물 잘 챙겨먹고, 운동 꾸준히 하고, 잘 자면 다이어트는 끝입니다.

하지만 실제로 이를 이뤄내는 사람은 별로 없죠. 보통은 의지력의 문제로 돈을 내가면서 헬스장이나 필라테스를 가지만 이마저도 작심삼일로 끝나는 경우가 대다수죠. 글쓰기도 많이 써보고 많이 읽어보고 많이 고쳐보면 사실 자연스레 실력이 향상될 수 있을 겁니다.

하지만 일상의 귀찮음, 글을 쓰면서 생기는 걱정, 쓰고 나서의 걱정 등등 온갖 것들이 나의 글쓰기에 저항을 하기 시작하죠. 그래서 세미나에서도 언급해주셨듯이 "저항에 저항하라", "일단 써보자" 등의 말이 나왔습니다.

그래서 저는 생각했습니다. 반대로 돌이켜보면 대다수는 이 저항을 뚫어내지 못하지만 저항을 한 번이라도 뚫어보면 나는 최소 50% 이상의 인간이지 않을까. 그거를 반복적으로 한다면 점점 더 소수의 특별한 인간이 되지 않을까. 그리고 저항을 한 번 뚫어내고 두 번 뚫어내보면 저항의 역치는 점점 더 낮아지지 않을까.

많은 사람들이 곧 실패한다는 것은 곧 소수의 사람들이 성공하는 것이고 그것을 좌우하는 요소가 외적인 요소가 아니라 나의 내적인 요소라면 충분히 시도해볼 가치가 있는 것이죠.

세미나를 듣기 위해서 6시에 퇴근해서 집 오자마자 후다닥 노트북 키고 저녁 먹으면서 세미나를 들었는데 너무나 만족스러웠습니다. 새로운 관점이나 방법론에 대해서 배운 것도 있지만 무엇보다 스스로 용기를 가지고 다짐을 하게 되는 그런 시간이 되었다는 점에서 더더욱 만족도가 높았던 것 같습니다.

지금의 저를 생각해보면 정신 없다는 이유로 많이 못 쓰고 있었던 스스로를 반성하게 되는 것 같습니다. 오히려 정신 없던 와중에 스토리들이 엄청 많이 쌓여서 글 에피소드에 대한 걱정은 안해도 되고 이제 행동만 남았다는 게 제일 먼저 생각나네요ㅎㅎ

[데보션 영 3기] 데보션 프로 인터뷰 후기

공대생철이 — Thu, 28 Nov 2024 23:31:39 +0900

안녕하세요! 데보션 영 3기 여행가조✈️ 조장 겸 프론트엔드 개발자 겸 취준생 (이제는 취뽀한) 철이입니다~~

데보션 영 활동이 이제 거의 끝나가는데 마지막으로 데보션 프로님과의 인터뷰가 있어서

끝난지 2시간 만에 따끈따끈한 인터뷰 후기를 남겨보려 합니다ㅎㅎ

저는 데보션 프로이자 현재 SKT에 계신 현수환 프로님과 인터뷰를 진행했습니다.

현수환 프로님은 현재 SK텔레콤 Multimodal 인식팀에서 영상인식 관련된 AI 서비스 개발/아키텍터로서 활동하고 계셨습니다!

AI 서비스 개발을 하고 계신다는 거에 바로 혹해서 인터뷰 신청했었네요ㅎㅎ

저를 포함해서 다른 영 분들 4분과 함께 진행했고 어제 영끼리 사전 질문을 작성해서 미리 프로님께 전달드렸었습니다!

질문지를 받고 어떻게 대답해줘야할지 되게 막막해하셨다는 프로님...ㅎㅎ

(근데 내용이 너무 알찼어요...!)

제가 개인적으로 남겼던 질문 중에 가장 인상 깊었던 답변이 2개가 있어서 그 부분들을 중점적으로 후기로 작성해보려 합니다.

Q1. 신입으로 돌아가신다면 어떤 분야를 다루실 것인지 궁금합니다!

A1. 신입은 선택지가 없다...

정말 현실적인 조언이어서 사실 더 와닿았습니다. 특히 저 같은 경우는 이제 금융권으로 취업을 해서 금융권에 대한 안 좋은(?) 소문들에 대해서 걱정이 있었는데 걱정을 훨씬 덜어주는 조언을 하셨습니다. 신입의 경우 회사 사정에 맞추어 업무가 할당되는 경우가 많기 때문에 제가 원하는 업무를 진행하지 못할 확률이 훨씬 높다고 현실적으로 말씀해주셨습니다.

그래서 덧붙여서 말씀해주신게 소속되어있는 부서나 주변 사람들과 몰두하는 것도 중요하지만 다른 부서에서도 일이 어떻게 돌아가는지 전체적으로 파악하면 훨씬 더 도움될 거라고 조언해주셨습니다.

그리고 신입이 선택할 수 있다면 새롭게 만들 수 있는 기회가 주어지는 것으로 가는 것이 좋다고 말씀해주셨습니다. 예를 들어, 금융은 이미 구축되어있는 시스템이고 절대 에러가 나면 안되는 시스템이기에 설계를 건드는 것과 같은 작업은 사실상 불가능에 가깝다고 해주셨습니다. 그래서 코드를 많이 읽어볼 수는 있겠지만 직접 A to Z로 작업할 수는 없기에 배울 수 있는 것에 한계가 있어 금융권에 대한 그런 얘기들이 오가는 것 같다고 해주셨습니다. 그래서 어떤 분야던지 새롭게 만드는 기회가 있다면 설계부터 개발, 운영까지 일련의 과정을 모두 필드에서 경험할 수 있기에 그런 기회는 절대 놓치지 말고 꼭 잡아보는 게 좋을 것 같다고 조언해주셨습니다!

Q2. 회사를 선택하는 기준이 어떻게 되시는지 궁금합니다!

A2. 매출액이 잘 나오는 회사를 선호했지만 다른 관점들도 분명히 있다.

프로님께서는 현재 SKT가 2번째 회사라고 언급해주셨는데 이전 직장은 대기업이었지만 큰 적자를 보면서 회사가 휘청하면서 몇십년만에 사람들 해고하는 등의 일이 벌어지는 것을 직접 피부로 느끼셨습니다. 그래서 석사에서 연구하신 것을 바탕으로 입사하셨으나 매출액의 안정성에 대해서 생각해보게 되었고 SKT에 입사할 기회가 생기셔서 이직하셨다고 하셨습니다.

저도 사실 최종 면접을 앞둔 곳이 하나 더 있는데 일단 다 합격하고 보자는 마인드이긴 하나 만약 선택의 기로에 서게 된다면 어떻게 해야할지 고민이 많이 되고 있습니다. 고민 중인 두 곳이 모두 대기업인데 산업군의 결이 아예 달라서 고민이 됐습니다. 회사 선택의 기준은 사람마다 다 다르겠지만 매출액에 대한 부분에 대해서는 메이저하게 생각해보진 않았어서 새로운 관점을 배워갔던 것 같습니다!

이외에도 AI 서비스 개발이 진행되는 과정, 개발하고 났더니 고객들이 기상천외한 방법으로 사용해서 수정했던 경험들을 말씀해주시면서 너무 재밌는 인터뷰 시간을 보낼 수 있었습니다. 현직자 선배 분과 대화하는 거는 언제나 주니어의 입장에서 재밌는 것 같습니다

인터뷰에 응해주신 현수환 프로님께 다시 한 번 감사의 말씀 드립니다

[데보션 영 3기] 8,9월 영 전용 세미나 통합 후기 + 나의 취준 근황

공대생철이 — Wed, 30 Oct 2024 17:16:04 +0900

안녕하세요! 데보션 영 3기 여행가조✈️ 조장 겸 프론트엔드 개발자 겸 취준생 철이입니다~~

8,9월 모두 사회로 진출을 앞두고 있는 데보션 영을 위한 취준 관련 세미나가 열렸습니다.

취준생의 입장에서 해당 세미나들의 후기 그리고 저의 취준은 어떻게 진행되고 있는지 말씀 드려보려 합니다!

8월 밋업에서는 다음과 같은 주제들로 세미나가 진행되었습니다!

1. 인턴 4번하고 취업한 자의 지독한 취업 스토리 - SK 하이닉스 정해웅님

2. 취업, 인생의 중요한 기로에서 나누고 싶은 이야기 (feat. 때로는 면접관으로.. 때로는 멘토로..) - SK C&C 박병선님

3. 버그 잡다 회사 잡(job)은 사연들 - SK 텔레콤 김한범님

특히 병선님께서 발표는 되게 담백하게 해주셨는데 내용들이 취준생인 저의 입장에서 너무 도움되는 얘기가 많았습니다.

대기업 vs 중소기업 vs 스타트업

개발자로 취업을 원한다면 다들 한 번쯤은 고민해봤을 겁니다. 저 역시도 사실 이 고민은 계속하고 있는 상황이고 잠정적인 결론은 내렸지만 확정은 아닙니다. 대기업/유니콘, 중견기업/스타트업에서 어떤 시스템을 배울 수 있고 어떠한 경험을 할 수 있는지 각각 설명해주셔서 저의 결정에 도움이 되었던 것 같습니다. 하지만 모두에게 상황은 다 다르고, 절대적인 정답은 없기에 옳다 그르다로 판단하지 않고 내 판단에 대한 믿음을 가지고 계속 밀고 가야겠습니다!

자소서 시즌은 많이 지났는데 자소서 작성할 때 면접관의 입장에서의 팁도 전수해주셨습니다.

Fact랑 키 메시지를 잘 전달하고 있는 것이 핵심이다.

결국 이 한 문단으로 귀결을 지을 수 있었고 자소서 작성할 때 이러한 면을 집중적으로 피드백하면서 작성했습니다. 덕분에 서류에서 꽤나 높은 합격률을 나타낼 수 있었네요ㅎㅎ

그리고 세 분이 공통적으로 말씀해주신 경험의 가치에 대해서 적극 공감하고 가리지 않고 여러 방면으로 도전을 망설이지 않고 있습니다ㅎㅎ

도메인을 떠나 서류도 일단 써보자는 마인드로 지원했었습니다.

그래도 도전했기에 코딩테스트도 봐보고 면접도 경험해볼 수 있어서 결과와 상관없이 모두 다 가치 있는 경험이 되었네요ㅎㅎ

9월 밋업에서는 아래와 같이 진행되었습니다!

1. 취준생들이 가장 많이 하는 질문 Top5 - SK 텔레콤 김한성님

2. 나의 작은 취준 이야기 - 데보션 영 2기 N사 정경륜님

3. 내 아이패드에서만 작동하던 나만의 네컷, 지금은 전세계로? - 데보션 영 2기 서희찬님

9월 밋업은 데보션 영 2기 분께서 와주셔서 세미나보다는 오히려 선후배간의 대화? 느낌이 강했습니다. 한성님이 진행해주신 내용도 취준생들의 눈높이에 정말 딱 맞게 진행해주셔서 1시간이 넘는 시간 동안 호로록 들었던 기억이 아직도 생생하네요!

한성님께서 말씀해주신 팁들이 8월 밋업과 일맥상통하는 부분이 있었고 그 외에도 추가적인 팁을 얻을 수 있었습니다.

특히, 가장 도움이 되었던 말씀은 "의미없는 Github/Notion 제출은 권장하지 않는다' 였습니다.

실제로 대학생들이 깃헙이나 노션을 많이 활용은 하지만 그게 의미있는 결과물이 아닐 때가 훨씬 많습니다. 저 또한 마찬가지고요. 기업들도 이를 의무화하는게 아니라 선택사항으로 두고 있어서 저는 과감하게 제출하지 않고 자소서 내용에만 충실해서 제출했습니다. 결과를 까보니 오히려 이 전략이 더 성공적으로 먹히지 않았나 싶습니다.

저는 8월 밋업에서 회사 선택 기준에서 대기업을 가기로 마음을 먹었었습니다. 아니나 다를까 한성님도 이 가려운 부분에 대해서 긁어주셨습니다. 그리고 제가 생각했던 이유와 비슷했어서 확신(?)을 얻을 수 있었던 것 같습니다.

첫 회사로는 대기업이 좋다 !
대기업의 문제, 스타트업의 문제를 잘 생각해봐야한다
이직할 때 첫 연봉을 베이스로 상승되기 때문에 첫 회사가 중요하다

이 3가지 항목에 대해서 모두 적극공감하였기 때문에 일단 되든 안되는 대기업을 1순위로 놓고 취준을 하고 있습니다.

자 그러면 영 세미나를 들은 취준생 박성철의 현재 상황은 어떠할까요?

오늘자(10/30) 기준

지원한 곳 : 19개

자소서 합격한 곳 : 11개

취준 세미나 2번의 가르침 덕분에 첫 취준임에도 불구하고 서류는 꽤나 좋은 합격률을 나타내고 있습니다...!

다 대기업만 쓰고 있는데 서합이 제가 본격적으로 취준하기 전에 들었던 것보다 잘 나와서 놀랍기도 하면서 기쁘네요...오히려 자소서 경험도 쌓이고 합격하는 걸 보다보니 가성비(?)있는 노력으로 자소서 작성하고 코테 준비에 몰두하고 있습니다. (사실 코테가 진짜 자신이 없어서...)

10월이 저에겐 코테 + 인적성 + 면접 + 학교 시험으로 정신없는 한 달이 된 것 같습니다. (학교 공부는 살짝 뒷전...ㅋㅋㅋㅋ)

첫 취준이면서 힘든 점도 있긴 하지만 하면서 또 제 자신이 해왔던 걸 복기해보기도 하고 그 전에는 조금 설렁설렁 했던 코테 공부가 이제는 발등에 불 떨어져서 진심으로 공부하면서 하루하루 배움의 연속이네요ㅎㅎ

여기까지 저의 세미나 통합 후기 + 취준 근황이였습니다! 읽어주셔서 감사합니다

고려대 현장실습 - 선발 과정부터 FAQ까지

공대생철이 — Tue, 1 Oct 2024 20:40:18 +0900

안녕하세요!

막학기와 취준을 병행하며 살아가는 공대생 철이입니다ㅎㅎ

최근 취준을 하면서 이걸 진짜 많이 느끼고 있습니다.

"경력사항에 한 줄 쓸 수 있는게 진짜 크구나...."

신입임에도 불구하고 인턴 경험이 있다는 것은 당연히 취업에서 매력적일 수 밖에 없는 요소겠죠!

저도 그 덕분인지 최근에 넣은 대기업들 서류는 거의 다 붙고 있습니다...ㅎㅎ

하지만 인턴 자리 구하는게 너무 어렵죠ㅠㅠ

오히려 신입사원 입사보다 인턴 자리 구하는 게 어렵다고 말이 나오니까요

BUT!!

고려대 학우분들이라면 학교 연계로 인턴 경험도 쌓을 수 있고 전공 학점도 채울 수 있습니다!

바로 "현장실습"이라는 제도를 활용하시면 됩니다!

고려대학교 현장실습 온라인 시스템

http://internship1.korea.ac.kr

고려대학교 현장실습 온라인 시스템

internship1.korea.ac.kr

해당 사이트에서 공고 확인하고 신청까지 다 진행하시면 됩니다!

이 블로그를 쓰고 있는 시점에는 아직 참여 기업들이 확정되지 않아서 어떤 기업들이 있는지 나오지 않는데

해당 기업은 아래의 일정에 맞춰서 확인해보시면 됩니다!

제가 현장실습을 진행했던 엔씨소프트의 예로 들면

이력서 작성 -> 면접 -> 합격

이렇게 진행되었습니다!

이력서는 현장실습에서 작성한 이력서 외에 기업에서 따로 요구한 사항에 맞춰서 이력서를 작성해서 제출했었습니다.

서류를 작성해서 제출해서 패스하면 이렇게 합격 메일을 받고 면접에 관련한 안내 사항을 받게 됩니다!

그리고 면접을 진행하게 되고

(자세한 면접 후기는 아래 링크에)

https://blog.naver.com/jasonsc/223347483414

태어나서 처음 보는 개발자 인턴 면접 후기

저번 학기에 어느 모 대기업의 인턴을 지원하고 서류는 합격했으나 코딩테스트에서 개같이 멸망하면서 끝났...

blog.naver.com

이렇게 최종 합격을 하게 됩니다!

당연히 기업별 세부 채용 프로세스는 다를 수 있으니 그건 해당하는 기업의 공고를 잘 확인하셔서 지원하시면 될 것 같습니다!

9월 초에 고려대학교 SK미래관에서 채용박람회를 진행함과 동시에 현장실습센터에 대한 부스도 운영이 되었는데요

거기서 이틀동안 멘토로 있으면서 상담을 진행했었습니다.

상담기간 중 자주 나왔던 질문들에 대해서 답변을 드리려 합니다!

1. 2학년도 지원이 가능한가요?

네. 2학년 2학기를 마치셨다면 3학년으로 진학하기 전 겨울계절학기 현장실습에 지원 가능합니다!

2. 제가 스펙이 없는데 지원해도 괜찮을까요?

사실 이게 가장 많이 받았던 질문입니다. 일단 현장실습에 지원하는 학생풀을 생각해보면 대부분 3,4학년 학생들입니다. 면접관의 입장에서 생각해보면 학부 3,4학년한테 기대하는 바가 크지 않습니다. 스펙이 없어도 학교 수업 관련된 내용이나 관련 동아리해서 활동했던 내용들 써도 충분합니다. 저도 서류 왜 붙었는지 모르겠고 면접 때 답변 틀리게 했었는데 붙었습니다. 오히려 인턴십에 대한 적극성이나 해당 기업에 대한 관심도, 적극적으로 배우려는 자세 등을 어필하면 좋을 결과 얻을 수 있으리라 생각합니다.

3. 면접 준비는 어떻게 하셨나요?

개발 직군 기준으로 설명 드리면, 코딩테스트가 진행된다면 기본적인 알고리즘들만 제대로 알면 충분합니다. 전공 지식에 대해서도 기대치가 높지 않기 때문에 코딩을 할 줄 아는가 정도로만 확인하고 오히려 적극적으로 역질문하는 태도를 갖추는 게 중요합니다. 또한 면접이 끝났을 때 꼭 추가 질문하세요! 입사하면 어떤 팀에 배치되는지, 어떤 프로젝트를 수행하게 되는지 등등에 대해서 적극 어필하는 게 정말 중요합니다.

4. 전공 학점은 얼마나 인정받을 수 있나요?

이거는 과마다 다릅니다. 저희 과(전기전자공학부)의 경우에는 전공으로 최대 9학점을 인정 받았습니다. 다른 학과의 경우 대부분 12학점인데 이거는 과마다 다를 수 있으니 꼭 소속된 과 행정실이나 현장실습센터에 문의해보세요.

5. 지원하고 싶은 기업이 있는데 저희 과는 안 받아주시더라고요. 이런 경우에는 아예 지원이 불가능한 걸까요?

아니요. 제가 저희 과 포지션 새롭게 열어서 합격했었습니다. 학우분의 전공이 해당 직무와 연관성이 조금이라도 있다면 현장실습센터 측에 문의해보세요. 제가 지원하려던 포지션도 원래는 컴퓨터학과만 받았었는데 제가 따로 문의해서 저희 과도 지원 가능하도록 했습니다. 이거는 꼭 문의해보시는 걸 강력하게 권장드립니다.

여기까지 현장실습 선발과정부터 FAQ였습니다!

학우분들이 꼭 학교 제도를 적극 활용하셔서 유익한 경험 많이 쌓으시길 응원하겠습니다ㅎㅎ

[취준 일기] 풀 데가 없어서 여기에 소리 질러본다

공대생철이 — Thu, 26 Sep 2024 21:31:03 +0900

대학교 4학년 2학기...

취준을 위해 열심히 달리고 있는 하루하루...

추석 주까지 해서 많은 기업들의 서류 접수가 끝이 나고 조금씩 발표가 나는 것 같다.

오늘 오후에만 2곳에서 메일을 받았다.

한 곳은 이메일로 결과가 나왔으니 확인해보라는 메일이였다.

결과를 확인해보니

서류 합격하고 인적성 시험을 봤는데 합격했다ㅠㅠㅠㅠ

물론 아직 제일 중요한 코테랑 면접이 남았지만 그래도 "통과"라는 두 글자가 주는 기쁨은 취준생한테 정말 큰 것 같다.

SK에서 처음으로 인적성 테스트를 봤을 때 떨어져서 인적성에 대해서 약간 자신이 없는 상태였는데

이렇게 인적성을 패스해보니 감회가 남달랐다ㅠㅠ

코테는 다음주에 칠 예정...!

아직 실력이 많이 부족하지만 그래도 소중하게 얻은 기회인만큼 벼락치기 최선을 다해서 임해야겠다

코테를 칠 기회를 얻었다는 것에 기뻐하며 학교 수업을 듣고 집에 가는 길에

메일함을 확인해보았는데 낯선 주소의 메일이 하나 와있었다.

미리보기로 내 이름과 영입담당자가 보여서 심장이 쿠궁...

메일함을 열어보니

옴멤메...

제가 서류를 붙었다고요...?

서류로 얼마나 거르는지는 모르겠지만 일단 합격이니깐...

너무 기쁘다...ㅋㅋㅋㅋㅋㅋㅋㅋ

카카오는 포트폴리오가 자유양식이라 사실상 기대 못했는데

이렇게 서류를 패스하고 코테를 볼 기회를 얻었다는 것에 너무 기뻤다...!

아직 최종합격까지는 여러 관문이 남았지만

그래도 "통과", "합격" 두 글자가 나에게 주는 기쁨은 상상 이상으로 큰 것 같다.

다음주에 볼 코테 열심히 준비해보고 후회 없이 한 번 부딪혀보자.

[엔씨소프트] 고려대학교 현장실습 개발 직무 | 나의 첫 인턴 후기

공대생철이 — Sat, 31 Aug 2024 01:36:41 +0900

저의 첫 인턴 경험이 드디어 끝이 났습니다..!

현생을 사느라 정신이 없었네요ㅎㅎ

사실은 저번학기에 인턴을 할 생각은 없었습니다. 졸업 논문을 1학기 때 미리 쓰고 2학기 때 인턴이나 취준을 준비하려 했었죠.

요즘 인턴 자리 구하기가 매애애애애애우 어렵기에 (특히 개발자 쪽은 요즘ㅠㅠㅠㅠ)

인턴을 하게 되면 학교 현장실습 통해서 경험을 쌓아볼려고 했습니다.

일단 학교 현장실습이 뭔지 간단하게 설명하자면,

학교랑 기업이 연계해서 학부생들에게 실무 경험을 제공해주고 월급도 받고 학점도 인정받을 수 있는 제도입니다.

채용연계형 인턴도 상당히 많이 열리니 사실 현장실습을 통해서 잘하면 별도의 취준 없이 바로 취업까지 이어질 수도 있습니다.

안하면 오히려 개손해...

(저는 체험형 인턴이였습니다.)

이렇게 채용과 직접적으로 연관되어있기에 실제 선발 절차도 채용 절차랑 거의 흡사합니다.

제가 지원한 엔씨소프트의 경우에는

1차 서류

2차 면접

순서로 절차가 진행됐습니다.

면접은 실무 면접이고 이건 지원하는 부서에 따라 달랐지만 저 같은 경우는 포트폴리오 발표 + 라이브 코딩으로 면접을 봤습니다.

포트폴리오는 그 전에 했던 프로젝트나 동아리 활동 경험들에 대해서 자유 형식으로 발표하면 되는 거였고,

라이브 코딩은 말 그대로 면접 자리에서 코딩을 하면 됩니다.

자세한 나의 면접 후기는 아래 글에 있으니 한 번 봐주시면 감사하겠습니다.(꾸벅)

태어나서 처음 보는 개발자 인턴 면접 후기

저번 학기에 어느 모 대기업의 인턴을 지원하고 서류는 합격했으나 코딩테스트에서 개같이 멸망하면서 끝났...

blog.naver.com

어찌저찌 합격을 하게 되어서 엔씨소프트에서 3월부터 8월까지 약 6개월 동안 인턴십을 수행하게 되었습니다.

면접 후기 쓸 때는 기업명을 함부로 공개해도 되는지 몰라서 모자이크 처리하고 그랬는데

지금은 어차피 공개 이력서에도 써야되고 퇴사했기 때문에 그냥 써야지ㅎㅎ

사실 엔씨소프트에서 일해볼 수 있다는 거 자체가 현장실습 제도의 또 다른 장점을 나타내는 거라고 생각합니다.

엔씨소프트 현재 공고 상황 보면 개발 직무에서 신입은 아예 없는데

현장실습을 활용하면 대기업에서 개발 직무 인턴을 해볼 수 있다는 게 가장 개꿀 포인트이지 않을까 생각합니다.

그렇게 저는 3월에 첫 출근을 하게 됩니다...

첫 출근하면서 이 웅장한 건물에 입성하는 건 진짜 상상도 못했던 일인데 너무나 설렜던 순간입니다

이렇게 사원증도 받고 신규 입사했다고 회사 엘리베이터 출연(?)도 했습니다...ㅋㅋㅋㅋ

사원증 사진이 잘 나와서 마음에 드네요ㅎㅎ

저의 출근 루틴은 이러했습니다.

아침에 8시 전에 회사로 출근 해서 운동 딱 해주고

개운하게 샤워하고 사우나에 몸 좀 지져주고 사무실로 출근했습니다.

저희 회사는 유연 근무제를 적용하고 있었기에 자유롭게 출퇴근 시간을 정할 수 있고 알아서 근로시간에 맞춰서 일을 하면 됩니다.

팀마다 분위기는 다르지만 우리는 오전 10시반에 항상 데일리 회의를 했기 때문에 그 전에만 출근하면 됐습니다.

그렇게 오전 업무 마치면 회사 구내식당에서 점심을 먹습니다.

아마 저희 회사 최고의 자랑거리 중 하나이지 않을까 싶은데 밥이 진짜진짜진짜진짜진짜진짜 맛있습니다.

한식, 면류, 샐러드, 버거 등 6개 중에 선택해서 먹으면 되고 도시락, 죽, 빵과 같은 테이크 아웃 메뉴도 따로 제공을 해줍니다.

선택지도 많고 지이이인짜 맛있어서 점심 먹을 때 항상 행복했던 기억이...

이렇게 맛난 밥을 먹고 오후에 업무 보고 회사에서 6시쯤에 저녁 먹고 퇴근하는 게 저의 근무 루틴이었습니다 .

휴가 내고 AWS 행사도 참여했었고

회사 복지로 휴양소에 당첨이 되서 부산 기장에 있는 빌라쥬드 아난티도 여자친구랑 가볼 수 있었습니다.

여기까지 회사의 일상적인 모습이나 누렸던 복지들이었고

업무적으로는 개발자니깐 당연하게도 개발 열심히 했습니다.

6개월 동안 총 2개의 프로젝트를 진행했습니다.

어차피 대외비인 게 많기 때문에 어떤 프로젝트를 했는지에 대해서는 자세히 말하지 않고 인턴하면서 배웠던 점들을 말해볼려고 합니다.

1. 생각보다 코드를 작성하는 시간은 많지 않다.

물론 코드를 작성한 결과가 소프트웨어로서 동작하는 건 맞습니다.

하지만 개발자는 단순 코딩하는 사람이 아니라는 걸 피부로 느꼈습니다.

어떤 특정 기능을 구현하기 위해서 어떤 툴을 사용할 것인지 어떤 기술스택을 사용할 것인지

아키텍처는 어떻게 만들 것이며 왜 이들은 이런 식으로 설계가 되었고 데이터 플로우는 이게 맞는지

코드를 작성하는 시간보다 이런 고민을 하는 시간이 생각보다 훨씬 길었습니다.

예를 들어, 프로젝트를 한 달 안에 마무리하려고 하면

5~60퍼가 저렇게 다같이 고민을 하는 시간이었고

2~30퍼가 코드를 작성하는 시간

나머지가 테스트를 진행하는 시간

이런 식으로 프로젝트가 진행됐습니다.

모든 방향성이 결정되고 난 다음에 코드 작성을 하게 되니 불필요한 작업이 없어지고 필요한 부분에 대해서만 효율적으로 코드를 작성하게 되니

전체적으로 보면 개발 속도도 훨씬 빨랐고 안정성도 훨씬 높아지게 되는 거 같습니다.

코드부터 작성하던 과거의 저의 미천한 모습들이 겹쳐지면서 실제 현업에서 프로젝트가 어떻게 진행되는지 배웠습니다.

2. 소프트 스킬은 개발자의 역량에서 생각보다 훨씬 더 큰 부분을 차지한다.

저를 포함해서 많은 대학생 개발자들이 많이 착각하는게 기술을 많이 알아야 좋은 개발자라고 생각합니다.

그래서 이것도 알아야되고 저것도 알아야되고 이러면서 지식을 계속 쌓아나갑니다.

물론 당연히 많이 알면 알수록 좋습니다. 그리고 가장 중요한 능력입니다.

하지만 기술적 역량 = 개발자의 역량은 아닙니다.

문서화 능력, 팀원들과와 커뮤니케이션 능력 등에 대해서 절대 등한시해서는 안된다는 것을 배웠습니다.

팀원분들이 저에 대한 평가나 조언을 해주실 때를 보면

"성철님은 성격이 좋으셔서 어딜 가나 다 잘 어울려서 협업 잘 할 거에요"

"운동도 꾸준히 하고 맡은 업무도 책임감 있게 하는 모습이 성실해보여서 정말 좋았어요."

이렇게 피드백을 주셨습니다.

사실 인턴 레벨이라 기술적인 부분에 대해서는 기대치가 높지 않기에 피드백이 많지 않았던 거일 수 있겠지만

결국 사람들이 기억하는 건 제가 얼마나 많이 알고 있냐보다는 제가 어떤 사람이었는지라고 생각이 들었습니다.

기술적인 부분은 모르면 공부하면 됩니다.

근데 커뮤니케이션 능력은 공부한다고 착실하게 쌓이는 지식이 아니기 때문에 말하는 연습, 글 잘 쓰는 연습 등에 대한 필요성을 매우 크게 느꼈습니다.

그렇게 무사히 프로젝트들 마무리하고 인턴십 성과 발표까지 완료했습니다.

팀원들 모두 서로 성격도 너무 잘 맞고 유쾌해서 이렇게 떠난다는 게 마음 한 켠에 아쉬움이 계속 남네요.

퇴사하기 한 2주 전부터 팀원분들께서

"졸업하고 다시 오시는 거죠?"

"설마 재입사 안 하고 통수 치시는 건 아니죠?"

이런 식으로 장난 섞인 말씀도 많이 해주셔서 그래도 제가 이 팀에 잘 녹아들었다는 느낌이 들어서 아쉽지만 너무나 만족스러운 시간이었습니다.

팀원분들뿐만 아니라 제가 참여했던 사내 스터디원분들도 너무 아쉽다고 꼭 다시 돌아오셔야된다고 하시면서 번호 교환도 했었네요.

이런 거 보면 그래도 사회생활 꽤나 괜찮게 한 거 같습니다ㅎㅎ

엔씨소프트는 개발자들 사이에서는 최상위 티어에 있는 기업입니다.

특히 개발자 채용문이 다 닫힌 상황에서 이렇게 휴학 없이 대기업에서 인턴해볼 수 있다는 거는 정말 특별한 기회였습니다.

이런 기회를 제공해준 학교 그리고 이런 포지션을 만들어준 엔씨한테도 감사의 마음이 되게 많이 들었습니다.

덕분에 제 개인적인 역량뿐만 아니라 경력사항에 쓸 말이 훨씬 많아져서 하길 정말 잘했다고 생각합니다.

이런 기회를 제공해준 고려대학교 현장실습지원센터, 엔씨소프트

많이 부족한 인턴 잘 챙겨준 저희 개발실 실장님, 팀장님, 팀원분들(특히 제 멘토님)

사회 경험이 많이 부족한데도 같이 스터디 너무 재밌게 한 사내 스터디원분들

모두 너무너무 감사합니다.

[프로그래머스 python] 가장 많이 받은 선물

공대생철이 — Sun, 18 Aug 2024 22:36:34 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/258712

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

처음 든 생각

- 일단 주어진 입출력의 풀이를 보면 두 개의 표가 등장한다. 이걸 어떻게 활용할 수 있을까?

- 첫번째 표는 유저의 수만큼의 정사각 행렬이다. -> 이차원 행렬로 나타내야겠다

- 두번째 표는 선물지수를 구하는 건데 준 선물의 총합과 받은 선물의 총합은 위의 이차원 행렬의 가로합과 세로합으로 구하면 된다.

- 비교의 순서는 주고받은 선물의 개수 확인 -> 똑같다면 선물 지수 확인

나의 답

def solution(friends, gifts):
	// 행렬에서 인덱스를 맞춰주기 위해 dict 선언
    friendsId = {}
    for i in range(len(friends)):
        friendsId[friends[i]] = i
        
    // 얘가 모든 계산의 본체
    tArray = [[0 for _ in range(len(friends))] for _ in range(len(friends))]
    
    // 이차원 행렬의 선물 개수 채워주기
    for gift in gifts:
        giver = gift.split(" ")[0]
        receiver = gift.split(" ")[1]
        giverId = friendsId[giver]
        receiverId = friendsId[receiver]
        tArray[giverId][receiverId] += 1
        
    // 선물 지수 계산 - friend의 인덱스와 sync 되게    
    giftIndexArray = []
    for i in range(len(friends)):
        tmp = 0
        for j in tArray:
            tmp += j[i]
        giftIndexArray.append(sum(tArray[i]) - tmp)
    
    nextMonthGiftArr = []
    
    // 순서대로 비교해가면서 다음달 선물 계산
    for i in range(len(friends)):
        nextMonthGift = 0
        for j in range(len(friends)):
            gived = tArray[i][j]
            received = tArray[j][i]
            if gived > received:
                nextMonthGift += 1
            elif gived == received:
                if giftIndexArray[i] > giftIndexArray[j]:
                    nextMonthGift += 1
        nextMonthGiftArr.append(nextMonthGift)
            
    
    return max(nextMonthGiftArr)

먼저 첫번째 목표는 예시 풀이처럼 이차원 행렬을 그리는 것이다.

이차원 행렬의 index를 맞춰주기 위해 딕셔너리를 하나 만들어서 조회하는 방식으로 하였다. index 메소드를 쓰면 O(n)이 추가되는 거라서 딕셔너리로 설정해주는 방식을 사용하였다.

그 다음 0으로 채워진 이차 정사각 행렬을 만들어주고 선물 내역들을 반복문으로 돌면서 누가 누구에게 선물을 줬는지 하나씩 확인해서 반영해주면 된다.

선물지수를 계산하는 과정은 행의 합과 열의 합을 빼주면 되는 간단한 과정이다.

이제 다음달 받을 선물을 계산하면 된다.

한 사람을 기준으로 나머지 모든 사람들과 비교를 하면서 선물을 받을지 말지 결정을 하면 된다.

이차원 행렬에서 대각선에 있는 항들은 모두 자기 자신을 가리키는데 준 선물과 받은 선물이 동일하고 선물 지수도 같다면 선물을 주고받지 않는다는 것을 활용해 선물 개수 비교 -> 선물 지수 비교의 논리에서 같이 동작할 수 있게 된다.

그래서 본격적으로 계산을 해보자.

준 선물과 받은 선물을 비교하는 것은 행렬 원소의 대각선 반대 방향의 원소끼리 비교하면 된다. 그래서 준 선물이 더 많다면 하나를 더 받게 되고, 선물 개수가 같을 경우 선물 지수를 비교하면 된다. 선물 개수가 적다면 아무런 영향이 가지 않기 때문에 애초에 조건문 자체에서 확인해줄 필요가 없다.

선물 개수가 같은 경우 선물 개수가 같거나 그 이하면 받지 않기 때문에 큰 경우에만 선물을 하나 추가한다.

그렇게 순서대로 구한 결과를 하나씩 append해주면 인덱스가 friends의 순서와 sync가 맞기 때문에 각각의 다음달 선물을 구할 수 있다.

여기서 최대값을 리턴해주면 끝이다.

이 화면을 언제나 짜릿한 거 같다.

문제 푸는데 생각보다 오래 걸리기는 했지만 문제 자체를 완벽하게 이해한 후 순서대로 코드를 작성하면 무탈한 문제였다.

머리풀기로 풀어보기에는 아주 좋은 문제라고 생각된다.

SKT 티움투어 후기 - 서울에서 신기술을 무료관람...?

공대생철이 — Tue, 13 Aug 2024 21:51:48 +0900

안녕하세요 SKT 데보션 영 3기로 활동하고 있는 철이입니다!

SKT의 개발 문화와 신기술을 널리널리 알리고 있는 입장에서 너무나 재미났던 티움 투어를 하고 왔습니다.

(제일 중요한 거...모두에게 무료...!)

예약링크

https://tum.sktelecom.com/reservation/registReservation.do

미래기술 체험관 T.um(티움)

SK텔레콤 미래기술 체험관, 시설 안내, 방문예약, 전시관 정보, 체험 서비스 등 제공.

tum.sktelecom.com

저는 데보션 영 활동을 같이 하고 있는 동기들 10명과 함께 해당 투어를 진행하였습니다.

이렇게 웅장한 스크린이 로봇 팔과 함께 위잉위잉하면서 움직이는데 완전 신기방기합니다...

환영 영상을 보고 나면 차세대 이동수단인 "하이퍼루프"를 타고 이동합니다.

4d 영화처럼 화면이 움직이고 좌석이 막 흔들흔들하면서 움직이는데 재밌었습니당ㅎㅎ

그러고 나서 우주 세상으로 넘어가는데

이런 투명 스크린에 아이언맨 영화에 나오는 거처럼 촤라락 영상 나오고 홀로그램 나오는데 진짜 감탄밖에 안 나옵니다...

뭔가 이걸 보면서 미국에는 이미 손으로도 움직일 수 있는 기술이 있지 않을까 싶긴 합니다.

미래의 세상에서는 우주도 분명 인간 의식주의 일부가 될 거기 때문에 우주 세상을 중심으로 여러가지 상황들이 디스플레이에 나옵니다.

이게 제일 신기했던 거...!

저 원통 안에 들어가서 VR 안경을 끼고 그 메타버스 세상으로 들어가는데

메타버스에서 온도가 바뀌는 상황에서 실제 손잡이의 온도가 막 뜨거워졌다가 차가워졌다가 하는데 너어어어어어어어어무 신기했습니다...

공학도로써 이런 건 진짜 참을 수 없는 신기함과 희열ㅋㅋㅋㅋㅋㅋ

이건 원격 의료하는 건데 3d 프린팅 + 로봇 조작으로 막 하는데

그냥 보면서 우와 소리 밖에 안 나오는...ㅋㅋㅋㅋㅋㅋ

결론부터 말하자면

진짜 신세계...

뉴스에서만 보던 신기술들이 눈 앞에 펼쳐지니깐 진짜 세상이 변하는 속도를 몸소 느꼈던 거 같습니다.

아마 저희보다 더 어린 초등학생이나 중학생들 오면 난리날 거 같은...

막 게임하는 느낌도 들고 그래서 가족끼리 방문해봐도 되게 재밌을 거 같습니다!

여기까지 티움투어 후기였습니다

AWS IAM이란?

공대생철이 — Sun, 5 May 2024 15:32:17 +0900

AWS는 저번에 살펴봤다시피 인터넷을 통해서 리소스를 제공하고 있습니다. 그만큼 편리하게 접근할 수 있기에 아무나 접근 권한을 줘버리면 안되겠죠. 그래서 AWS에서는 IAM이라는 것이 있습니다. IAM은 Identity and Access Management의 약자로 별도의 접근 권한을 계정을 운영 및 관리하는 것입니다. 실제로 AWS에 처음 로그인을 할 때 아래와 같은 화면을 맞닥뜨리게 됩니다.

루트는 말 그대로 모든 권한을 가지고 있는 계정이고 회원가입을 하면 자동으로 생성됩니다. 그리고 IAM 사용자로 별도의 권한을 가진 계정으로도 로그인이 가능합니다.

IAM은 위와 같이 관리가 가능합니다. Alice, Bob, Charles가 개발자로서의 역할을 가지고 있는 팀원들일 때 이들은 Developers라는 별도의 그룹으로 관리하여 접근 권한을 부여할 수 있습니다. Charles가 또 Audit Team에도 속해있을 경우 Audit Team에 해당하는 권한도 가질 수 있습니다. 이처럼 조직 내의 별도의 유저들을 그룹으로 관리할 수 있 수 있습니다. 물론 Fred처럼 유저가 반드시 그룹에 속해 있을 필요는 없습니다.

각각의 유저 또는 그룹은 정책 JSON 문서로 정의될 수 있습니다. 이 정책 문서는 유저별로 접근 권한을 나타내게 됩니다. 아래의 예시를 한 번 살펴보죠.

Statement 항목을 보면 ec2의 describe가 허용되어있고, elasticcloudbalancing의 describe가 허용되는 등 접근 가능한 기능들이 JSON 문서에 나와있습니다. 이렇게 유저별로 접근 권한을 부여할 수 있는데 이에 대해서는 한 가지 원칙이 있습니다. 사실 되게 당연한 거긴 한데 유저가 딱 필요한 서비스들에만 접근 권한을 부여하는 것입니다. 그 이상 그 이하도 아닌 딱 필요한 서비스들에만 접근 권한을 부여해주는 게 가장 좋습니다.

이 정책 JSON 문서에 대해서 좀 더 자세하게 살펴보죠.

문서는 일단 3개의 항목으로 구성되어있습니다.

Version : IAM 정책 문서의 문법 체계가 정해진 날짜로 현재는 2012-10-17이고 항상 포함되어있습니다.

Id (선택) : 정책의 구분자

Statement (필수) : 최소 한 개 이상 필수 - 아래 구성요소 참고

Statement 구성요소

- Sid (선택) : statement의 구분자

- Effect (Allow 또는 Deny) : statement의 접근을 허용하는지 거부하는지

- Principal : 해당 정책이 적용받는 대상 (계정, 유저, 역할 등등)

- Action : 해당 정책이 접근 허용 또는 거부하는 action들의 리스트

- Resource : action들이 적용되는 리소드들의 리스트

- Condition (선택) : 해당 정책이 발효하는 조건

(예시)

해당 클라우드의 접근 권한을 어떻게 설정할 수 있는지 정책에는 어떤 것들이 있는지 살펴보았습니다. IAM을 통해서 클라우드 접근에 대한 정책 이외에도 비밀번호에 대한 정책도 설정이 가능합니다. 그럼 어떤 비밀번호 정책들이 있는지 한 번 살펴보죠.

비밀번호는 사실 강력하면 강력할수록 무조건 보안상 좋습니다. 그래서 AWS는 비밀번호에 대한 다양한 규칙들을 사전에 만들어놓고 이에 대해 root가 선택적으로 적용이 가능합니다. 비밀번호 최소 길이, 대소문자나 특수문자 등에 대한 최소 포함 조건, 비밀번호 만료 기간, 매번 새롭게 만들어야하는지 등등 다양한 규칙들이 있습니다.

이러한 비밀번호 규칙 외에도 이중으로 보안을 강화하는 방법도 있습니다. MFA (Multi Factor Authentication)이라는 방법도 있습니다. 사실 아무리 비밀번호 규칙이 강하다고 한들 비밀번호는 한 번 유출되면 끝이죠. 이거를 이중으로 하면 당연히 보안이 훨씬 더 강합니다.

MFA는 기존 비밀번호 + 나만의 장치의 구조로 되어있는 인증 방식입니다.

그래서 MFA의 장점은 매우 단순합니다. 비밀번호가 유출되어도 나의 AWS 계정이 도용될 일이 없는 거죠.

MFA도 다양한 선택지가 있습니다.

1. Virtual MFA device

Google Authenticator, Authy 등 스마트폰에서 앱을 활용한 인증이 가능합니다. 아래와 같은 앱들을 지원하고 있으니 편한 걸로 사용하면 됩니다.

2. Universal 2nd Factor (U2F) Factor Key

Yubico사에서 만들 별도의 장치가 있습니다. 이를 사용해서 usb처럼 휴대하면서 보안 장치로 활용이 가능합니다. 본인의 스마트폰이 분실되어도 보안에서는 지장이 없을 정도로 강력한 보안장치이지만 분실의 우려 + 장치 추가 구입 비용이라는 단점이 있습니다.

3. 그 외의 장치들

서드파티 제조사가 만든 장치를 따로 사용해서 MFA를 사용할 수도 있습니다.

이렇게 AWS의 인증 수단들에 대해서 살펴봤습니다. 인증을 하고 나면 이제 직접 AWS를 조작할 수 있어야겠죠. 유저는 AWS 조작에 어떻게 접근할 수 있을까요? 총 3가지 방법이 있습니다.

(1) AWS Management Console - 비밀번호 + MFA 로 인증

(2) AWS Command Line Tools (CLI) - Access Key로 인증

(3) AWS Software Developer Kit (SDK) - 코드로 Access Key 인증

AWS Managament Console은 AWS 웹사이트에서 관리하는 것을 의미합니다. Access Key는 Management Console에서 발급받을 수 있으면 이에 대한 관리는 사용자가 직접 수행해야합니다. 위에서 직접적인 인증수단으로 활용되기 때문에 비밀번호처럼 절대 유출되면 안됩니다.

AWS CLI는 Command Line 명령어로 AWS를 조작할 수 있도록 하는 것입니다. 퍼블릭 API로 AWS에 바로 접근해서 조작이 가능하고 Management Console에 들어가서 웹사이트를 조작하지 않고 명령어로 AWS를 조작할 수 있습니다.

AWS SDK는 AWS를 사용하는 애플리케이션 안에 사용하는 언어에 맞게 SDK를 설치한 후 프로그래밍 언어를 통해 AWS를 조작하는 것입니다. Javascript, Python, Java, Go 등등 웬만한 모든 언어에 적용이 가능하고 안드로이드, IOS와 같은 모바일 SDK 뿐만 아니라 임베디드, IoT에 대해서도 지원하고 있습니다.

IAM 보안을 관리하기 위한 도구로는 2가지가 있습니다.

- IAM Credentials Report : 계정의 모든 유저들에 대한 자격 증명 리스트

- IAM Access Advisor : 유저에게 어떤 서비스에 대한 접근 권한을 가지고 있고 언제 서비스에 마지막으로 접근했는지 표시해주는 리스트

IAM 역시 AWS의 공동 책임 모델이 적용됩니다. AWS의 네트워크 보안 등 인프라에 관련된 부분은 AWS가 책임을 지지만, MFA 설정, 계정/유저 관리, 적절한 권한 부여 등에 대한 부분은 유저가 책임을 져야 합니다.

IAM에 대한 내용이 많았는데 관련해서 간단하게 정리한 후 글을 마무리해보겠습니다.

Users : 실질적인 유저로서 AWS Console에 비밀번호를 가진 사람

Group : 유저들의 집합

Policies : 유저나 그룹의 접근 권한을 나타낸 JSON 문서

Security : 비밀번호 정책 + MFA

AWS CLI : Command Line을 통해서 AWS를 조작

AWS SDK : 프로그래밍 언어를 통해서 AWS를 조작

Access Keys : AWS를 CLI나 SDK로 조작하기 위한 키이고 console에서 발급 가능

Audit : IAM Credentials Report + IAM Access Advisor

여기까지 AWS IAM에 대한 내용이었습니다. 감사합니다.

AWS 클라우드란?

공대생철이 — Thu, 2 May 2024 21:58:46 +0900

개발자라면 AWS, 클라우드 이 두 단어를 못 들어봤을리는 없을 겁니다. 하지만 저를 포함해서 단어만 알고 막상 활용을 잘 못한다거나 지식이 부족한 경우도 많이 있는 것 같아 저도 기초부터 차근차근 공부해나가면서 관련 지식을 블로그에 기록하려 합니다.

먼저 클라우드라는 게 뭔지 한 번 살펴보죠.

클라우드 이전의 방식에서 인프라를 구축한다고 하면 서버 장비를 직접 사와서 서버를 구축하는 것이었습니다. 데이터 센터라는 시설을 빌리거나 직접 데이터 센터를 운영할 경우 전력, 냉각, 유지보수 등 모든 사항들에 대해서 직접 관리했어야 했죠. 뿐만 아니라, 24시간 동안 시설의 동작을 감시할 인력도 고용을 해야하고 증설을 하고 싶으면 필요한 만큼 또 장비를 구매해서 직접 설치해야하죠. 최악의 경우, 지진, 정전, 화재가 일어날 경우 데이터 손실은 물론이고 장비들의 재산적 손실까지 발생할 수 있습니다. 진입장벽도 너무나 높고 위험부담도 크기 때문에 이 관리를 외부화하려고 했고 이 때 "클라우드"라는 개념이 등장하게 됩니다.

그렇다면 클라우드 컴퓨팅이라는 것은 무엇일까요?

클라우드 컴퓨팅은 온디맨드 즉, 필요한 만큼의 파워, 데이터 저장공간 등의 리소스들을 그때그때 사용하는 방식입니다. 그래서 사용자는 사용한 만큼의 비용을 지불하면 되고 추가적으로 리소스가 더 필요하다면 즉각 가져와서 쓸 수 있습니다. 서버, 스토리지, 데이터베이스 등에 굉장히 쉽게 접근할 수 있는 것이죠. 그래서 사무실과 데이터 센터를 모두 직접 운영했어야 하는 기업들은 클라우드를 활용하여 관리의 주체를 외부화 시킬 수 있었고 개인/기업의 니즈에 따라 필요한 만큼만 서버를 운영할 수 있게 되었습니다.

클라우드에는 크게 3가지 방식이 있습니다.

1. 프라이빗 클라우드

외부에는 노출되지 않는 하나의 조직만을 위한 클라우드 서비스를 제공하는 것이죠. 모든 제어 권한을 가질 수 있고 민감한 애플리케이션의 경우 보안의 이유로 활용이 가능합니다. 이러한 형태의 대표적인 서비스로는 rackspace가 있습니다.

2. 퍼블릭 클라우드

우리가 흔히 보는 클라우드 형태입니다. 클라우드 서비스 사업자들이 보유하고 있는 리소스들을 인터넷을 통해 제공받아 사용하는 것입니다. 이들의 수많은 장점들은 뒤에서 더 자세히 살펴보도록 하겠습니다. 이러한 형태의 대표적인 서비스로는 Microsoft Azure, Google Cloud, AWS가 있습니다.

3. 하이브리드 클라우드

일부 서버는 직접 설치하여 관리하고 일부는 클라우드를 활용하여 구축하는 형태입니다. 사용자의 개인적인 인프라에 민감한 정보들을 저장할 수 있고 또한 클라우드를 활용하여 확장의 유연성도 챙겨갈 수 있습니다.

클라우드 컴퓨팅의 5가지 특징

1. On-demand self service

유저는 서비스 관리자의 개입 없이 원하는 시점에 바로 사용 가능합니다.

2. Broad network access

네트워크를 기반으로 리소스에 접근 가능하고 다양한 클라이언트가 접근 가능합니다.

3. Multi-tenancy and resource pooling

다양한 사용자들이 같은 인프라와 서비스를 사용합니다.

4. Rapid elasticity and scalability

리소스들을 필요할 때 빠르게 취득할 수 있습니다.

5. Measured service

사용량이 측정 가능하고 사용자는 사용한 만큼 비용을 지불합니다.

클라우드 컴퓨팅의 6가지 장점

1. Trade capital expense(CAPEX) for operational expense(OPEX)

하드웨어, 에너지 비용 등에 대한 자본 비용과 이에 대한 운용 비용을 낮출 수 있습니다. 하드웨어를 직접 소유하지 않아도 되고 사용한 만큼만 지불하면 되기 때문이죠.

2. Benefit from massive economies of scale

서비스의 규모가 커질수록 클라우드 컴퓨팅을 활용하여 비용을 낮출 수 있습니다.

3. Stop guessing capacity

이전에는 사용량을 예측해서 그에 맞게 장비를 구매해야 했지만 측정된 실제 사용량에 맞춰서 서버의 크기를 조절할 수 있습니다.

4. Increase speed and agility

서버에 대한 진입장벽이 낮아져 빠르게 서비스나 애플리케이션을 개발할 수 있게 되었습니다.

5. Stop spending money running and maintaining data centers

데이터 센터의 운영, 유지 비용이 더이상 들지 않게 되었습니다.

6. Go global in minutes

AWS와 같은 글로벌 인프라 사업자들을 통해 서비스나 애플리케이션이 국경을 넘어 어디서든지 접근 가능할 수 있게 되었습니다.

이러한 장점들 덕분에 클라우드 컴퓨팅은 더 쉽고 빠르게 고성능의 서비스나 애플리케이션을 개발할 수 있게 되었고 물리적 장비에 대한 걱정 없이 온전히 개발에만 집중할 수 있게 되었습니다.

그럼 이제 전세계에서 가장 많이 사용되는 AWS에 대해서 살펴보죠.

AWS는 리전(Region) 단위로 전세계에 서비스를 공급하고 있습니다. 버지니아, 파리, 로마, 도쿄 등등 전세계 곳곳에 리전이 있습니다. 참고로 서울도 있습니다. 이 리전이 의미하는 것은 데이터 센터들의 클러스터, 쉽게 말하면 데이터 센터 집합입니다. 위의 도시들에 데이터 센터들이 여러개 모여있다는 것이죠.

그럼 그 많은 리전 중에 어떤 리전을 선택하는 것이 좋을까요?

크게 4가지 고려사항이 있습니다.

1. 데이터 주권 등의 법률을 준수해야 합니다.

2. 유저들에게 근접성을 높여 지연 시간을 줄여야 합니다.

3. 리전 별로 제공되는 서비스의 차이가 있기에 원하는 서비스가 해당 리전에 있는지 확인해야 합니다.

4. 리전 별로 가격이 다르고 이는 모두 투명하게 공개되어있기에 비용을 고려해서 선택하면 됩니다.

AWS 리전 안에는 여러개의 AWS Availabilty Zones 줄여서 AZ가 있습니다. 통상적으로 3개 많게는 6개까지 있습니다. 예를 들어 시드니 리전(ap-southeast-2)에는 ap-southeast-2a, ap-southeast-2b, ap-southeast-2c 이렇게 3개의 AZ가 있습니다.

각각의 AZ는 한 개 또는 그 이상의 구분된 데이터 센터들을 가집니다. 그리고 그 데이터 센터들은 다른 AZ와는 독립적으로 동작합니다. ap-southeast-2a에 있는 데이터 센터에 화재가 나더라도 나머지 2개의 AZ가 서비스를 계속해서 제공할 수 있도록 구성되어있습니다. 그렇기에 재난 상황에 대해서는 크게 걱정할 필요가 없게 됩니다.

여기까지 AWS의 하드웨어적인 부분에 대한 간단한 설명이었습니다.

그렇다면 AWS는 보안에 대해서는 어떠한 운영 정책을 유지하고 있을까요?

AWS는 공동 책임 모델을 준수하고 있습니다.

간단하게 말하면,

클라우드 내에서의 보안 -> 고객 책임

클라우드의 보안 -> AWS의 책임

고객 데이터 관리, 권한 부여 등에 대해서는 AWS 사용자가 책임을 져야하는 부분이고 AWS의 하드웨어, 네트워킹 등의 인프라에 대해서는 AWS가 책임을 지는 것이죠.

또한 AWS는 이용 목적 제한 방침을 살펴보면 불법 또는 사기 행위, 테러나 네트워크의 남용, 이메일이나 메시지 남용 등의 콘텐츠 또는 리소스가 발견되면 사용자의 허가 없이 액세스를 자체적으로 중지시킬 수 있다는 점도 참고하면 좋을 것 같습니다.

우리 조직의 개발 문화는 어느 정도일까? - DORA metric

공대생철이 — Sat, 13 Apr 2024 18:22:32 +0900

프론트엔드 개발을 위주로 하는 입장에서 DevOps는 사실 단어는 너무나도 많이 들리지만 막상 아는 건 하나도 없는 가깝고도 먼 단어입니다.

최근 팀에서 DevOps 관련된 주제를 가지고 토론을 빙자한 수다를 좀 떨었는데 아주 흥미로운 내용이었습니다.

팀의 개발 문화를 측정하는 지표에 대한 이야기였죠.

DORA란?

DORA (DevOps Research and Assessment)

구글에서 개발한 DORA (DevOps Research and Assessment)는 제품 개발을 보다 효율적인 운영할 수 있도록 도와주는 지표입니다. 특히 요즘 개발 프로세스 중에서 가장 핫한 키워드인 "애자일(Agile)"과 아주 밀접한 관계를 가진 지표이기도 해서 실제 많은 기업들이 이 지표를 사용하고 있습니다.

DORA의 핵심 지표는 4가지입니다.

1. 배포 빈도 (Development frequency)

2. 리드 타임 (Lead time for changes)

3. 변경 실패율 (Change failure rate)

4. 서비스 복구 시간 (Time to restore sevice)

1. 배포 빈도 (Development frequency)

아주 직관적이죠. 배포를 얼마나 많이 하느냐 측정하는 것입니다. 이를 통해 개발팀의 속도와 역량, 자동화 수준을 측정하게 됩니다. 배포 빈도가 높을수록 팀은 피드백을 더 빨리 수집할 수 있고 그에 따른 기능 개선의 가능성이 더 높아지기 때문에 전반적인 효율성을 체크할 수 있습니다. 특히 요즘 같이 마이크로서비스 아키텍처(Micro Service Architecture)가 유행하는 시점에서는 다른 서비스의 영향을 받지 않고 독립적으로 배포가 가능하기에 배포 크기도 줄어들어 배포가 용이해진 만큼 배포 빈도는 단순하면서도 강력한 지표라고 할 수 있습니다.

2. 리드 타임 (Lead time for changes)

리드 타임은 팀이 기능 개발을 하겠다고 한 시점부터 실제 사용자에게 해당 기능이 제공되기까지 걸리는 속도를 측정합니다. 팀의 개발 역량, 코드의 복잡성, 환경 변화 등 다양한 변수에 대해 종합적으로 산출되는 결과의 지표이기에 팀 DevOps의 전반적인 능력을 나타냅니다.

3. 변경 실패율 (Change failure rate)

변경 실패율은 실제 프로덕션까지 진행했을 때 실패한 배포 또는 코드의 비율을 의미합니다. 배포 빈도와 리드 타임의 경우 해당 배포의 성공 여부와 상관없이 측정하게 됩니다. 이에 대한 견제 기능을 하는 것이 바로 변경 실패율 지표입니다. 속도도 중요하지만 이것이 얼마나 정확하게 배포가 진행되었고 안정적으로 동작하는지 속도 대비 안정성을 측정하는 항목입니다.

4. 서비스 복구 시간 (Time to restore sevice)

문제가 발생한 후 해결하는데 걸리는 평균 시간을 나타냅니다. 실제 프로덕션 중인 환경에서 문제가 발생하면 이에 대해 얼마나 빠르게 대처하는지는 정말 중요합니다. 문제가 빠르게 대처되지 않을 경우 유저 이탈 즉, 서비스의 매출 저하와 직결되기 때문이죠. 외부의 공격이든 코드의 버그든 이에 대해서 신속하게 대응할 수 있어야 합니다.

위의 지표들을 가볍게 테스트할 수 있도록 DORA 측은 Quick Check 서비스를 제공하고 있습니다.

위의 결과처럼 산업군의 평균, 표준편차와 나의 위치를 함께 보여줘서 간단하게 판단해 보기 아주 좋은 것 같습니다.

DORA 지표를 사용하지 않을 이유

하지만 해당 지표는 과연 절대적일까요? 당연히 아닙니다.

Goodhart's law라고 들어보셨나요? 영국의 경제학자 Goodhart의 격언이 있습니다.

"측정값이 목표가 되면 더 이상 좋은 측정값이 아니다."

단순히 DORA 지표 개선을 위한 개발이 되는 순간 DORA는 유의미한 결과를 불러일으키지 못합니다. 각각의 지표에 대해서 어떤 상황이 발생할 수 있는지 살펴보죠.

1. 배포 빈도 (Development frequency)

배포를 많이 하는 것은 팀이 기능 개발을 지속적으로 한다는 점에서 좋지만 실제 개선이 어떻게 달성되는지도 중요합니다. 결국 개발팀이 배포를 얼마나 많이 했는지보다 중요한 것은 사용자가 더 빈번한 배포로 인한 이점을 보고 있는지입니다. 특히 해당 개발 팀의 역량이 낮을 경우 단순히 더 열심히 개발해서 배포 빈도만을 높이게 되면 안정성에 큰 타격이 갈 것입니다.

2. 리드 타임 (Lead time for changes)

리드 타임을 단축시킨다는 것은 더 빠르게 기능 개발을 하는 것이고 릴리스를 자주 수행하기에 제품 개발 또는 완성 속도가 빨라지기에 좋다고 볼 수 있죠. 하지만 이 속도에 너무 몰두한 나머지 테스트를 안 하거나 대충 하는 등의 지름길을 택하여 개발을 진행시킬 수도 있습니다. 또는 코드 작성 시 무조건적으로 빠르게 기능"만" 완성시켜 보안에 대한 약점을 유발할 수도 있죠.

3. 변경 실패율 (Change failure rate)

변경 실패율의 통계 산출 방식을 통한 왜곡이 가능할 수도 있습니다. 변경 실패율은 통상적으로 배포 수 대비 버그 / 오류 발생 비율을 측정합니다. 기존에 10번 배포해서 1번 버그가 일어났던 것이 100번 배포해서 9번 버그가 일어나게 되면 팀의 변경 실패율 지표는 향상한 것으로 측정됩니다. 하지만 버그의 절대적인 횟수에서 차이가 나게 되죠. 수정해야 되는 기능의 크기가 어느 정도인지는 차이가 나겠지만 1번 버그가 일어나면 하나의 기능만 고치면 되지만 9번 버그는 결국 9개의 기능을 수정해야 한다는 뜻이 됩니다. 즉, 인위적으로 배포 횟수를 늘려 지표를 향상한 것처럼 눈속임이 가능할 수 있습니다.

4. 서비스 복구 시간 (Time to restore sevice)

서비스를 복구하는 가장 빠른 방법이 뭘까요? 가장 빠르면서 단순하게 이전에 안정적으로 동작했던 코드로 롤백을 시키는 것일 겁니다. 하지만 서비스 복구 전략이 롤백이 대부분인 경우 사용자 입장에서 문제가 발생하지 않으니깐 괜찮은 것이 아니라 오히려 최신 기능들에 대한 가치를 사용자로부터 빼앗는 꼴이 됩니다. 이렇게 되면 평균 복구 시간은 매우 짧지만 제품은 계속 그대로인 상태의 잘못된 민첩함을 가지게 되는 것이죠.

또 모니터링과 관련하여 통계의 왜곡이 일어날 수 있습니다. 문제 감지를 위한 모니터링이 부족하여 평균 복구 시간이 짧을 수도 있을 것입니다. 에러 발견 후 수정까지 1시간도 안 걸렸지만 그 에러를 발견한 시점이 이미 첫 발생부터 일주일이 지난 시점이라면 그 사이에 유저들은 이미 떠나가있겠죠.

결론

DORA 지표는 팀 개발 문화를 측정하는데 도움이 되는 도구인 것은 분명 사실입니다. 하지만 이 지표가 목표가 되는 순간 프로젝트 진행 상황에 대해서 오해가 커질 우려도 있다는 것 또한 부정할 수 없는 사실입니다. 특히, 저의 포함한 대다수의 한국인들이 겪어온 상황을 고려해 봤을 때 성적을 위한 공부를 했던 경험이 다들 있던 만큼 지표가 목표가 될 가능성이 결코 적지 않다고 보입니다.

또한 많은 공학이 그러하듯이 한 가지를 선택하면 한 가지를 포기해야 하는 경우가 있는 지표입니다. 배포를 자주 하다 보면 사람이기에 놓칠 수 있는 부분들이 더 많아지는 것은 어찌 보면 당연한 일일 수도 있습니다. 이에 따라 본질적인 문제해결이 아닌 어떤 수치적 이득을 취하는 것이 효과적일지 고민하게 되는 상황도 펼쳐질 수도 있을 거라 생각합니다.

물론 적절하게 사용할 경우 DORA 지표는 팀의 진행 상황을 보여주는 훌륭한 방법이고 비즈니스 가치를 설명하는 데도 아주 좋은 근거가 될 수 있을 것입니다. 개발자, 기획자뿐만 아니라 기타 이해관계자들도 개발 상황을 함께 개선시켜 나갈 수 있도록 판단하는 데 활용될 수 있죠. 해당 지표를 도입하게 된다면 개발의 목적이 "어떻게 좋은 수치를 내야지?"가 아니라 "어떻게 이 문제를 해결할까?" 임을 지속적으로 돌이켜볼 필요가 있을 것 같습니다.

참고

https://dora.dev/

https://www.atlassian.com/devops/frameworks/dora-metrics - DORA metrics: How to measure Open DevOps success

https://www.infoq.com/articles/dora-metrics-anti-patterns/ - How Not to Use the DORA Metrics to Measure DevOps Performance

스크롤바 CSS로 커스텀 스타일링(디자인) 하는 법

공대생철이 — Fri, 5 Apr 2024 17:10:53 +0900

글을 시작하기에 앞서 먼저 주의사항 하나 짚고 넘어가자.

Mdn에서 스크롤바를 조작하는 ::webkit-scrollbar는 표준이 아니기에 제품 출시에는 사용하지 않기를 권고한다. 실제 호환성을 살펴보면 보는 모든 브라우저를 지원하지는 않는다.

그렇다면 지원하는 브라우저가 뭔데??

바로 webkit 계열의 브라우저들이다. Webkit 계열에 해당하는 브라우저들에는 뭐가 있을까?

- 크롬 (Android 웹뷰 포함)

- 엣지

- 사파리

- 삼성 인터넷

- 오페라

- 네이버 웨일

그렇다. 사실상 대부분의 브라우저들이다. 그렇기에 ::webkit-scrollbar는 웬만하면 모든 브라우저에서는 된다. 하지만 파이어폭스 유저들을 위한 서비스라면 호환이 안 되니 이 점은 참고하자.

먼저 스크롤바를 스타일링하기 위해서 스크롤바로 어떻게 구성되어 있는지 살펴보자.

위와 같은 스크롤바를 브라우저 오른쪽에서 본 적이 있을 것이다.

::-webkit-scrollbar	전체 스크롤바입니다.
::-webkit-scrollbar-track	스크롤바의 트랙(진행률 표시 바)으로, 흰색 바 위에 회색 바가 있는 부분입니다.
::-webkit-scrollbar-thumb	드래그 가능한 스크롤 핸들입니다.
::-webkit-scrollbar-button	스크롤바의 화살표 모양의 버튼입니다.

스크롤바의 구성요소는 위와 같이 크게 4개이다.

사실 이 구성요소만 잘 이해했다면 어떻게 스타일링할지 금방 감이 올 것이다. 어디에 색을 입힐지 어디에 border-radius와 같은 속성을 적용시킬지 말이다.

이제 코드로 살펴보자.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Scrollbar demo</title>
  </head>
  <style>
    .container {
      width: 500px;
      height: 100px;
      overflow: scroll;
    }
  </style>
  <body>
    <div class="container">
      Lorem ipsum dolor sit amet consectetur adipisicing elit. Doloribus odit illo repellendus
      voluptate saepe aliquid in nesciunt error, quas totam minus! Et maiores inventore animi
      molestiae eaque mollitia tempora nam? Lorem ipsum dolor sit amet consectetur adipisicing elit.
      Doloribus odit illo repellendus voluptate saepe aliquid in nesciunt error, quas totam minus!
      Et maiores inventore animi molestiae eaque mollitia tempora nam? Lorem ipsum dolor sit amet
      consectetur adipisicing elit. Doloribus odit illo repellendus voluptate saepe aliquid in
      nesciunt error, quas totam minus! Et maiores inventore animi molestiae eaque mollitia tempora
      nam?
    </div>
  </body>
</html>

겁나 긴 줄 글이 있고 container의 영역을 벗어나면 scroll을 할 수 있도록 수정하였다. 그러면 아래와 같이 매우 못생긴 스크롤바를 마주칠 수 있다.

이제 스타일링을 해보자.

    .container::-webkit-scrollbar {
      width: 20px;
    }
    .container::-webkit-scrollbar-track {
      background-color: gray;
    }
    .container::-webkit-scrollbar-thumb {
      background-color: skyblue;
    }
    .container::-webkit-scrollbar-button {
      display: none;
    }

스크롤바의 4가지 요소에 각각 CSS를 적용시킨 것이고 먼저 어떻게 될지 상상을 해본 뒤 결과를 확인해보자.

그렇다. 이렇게 나왔다.

스크롤바의 구성요소만 잘 이해한다면 위와 같은 CSS가 적용된 게 바로 이해가 된다.

    .container::-webkit-scrollbar-thumb {
      background-color: red;
      border-radius: 10px;
    }

색깔뿐만 아니라 다른 CSS 속성들도 적용 가능하다.

결국 스타일링을 결정 짓는 것은 "어떤 요소"에 "어떤 속성을 적용시키느냐"가 관건이기에 스크롤바 자체의 구성 요소만 알고 있다면 그 다음 스타일링은 매우 자유롭게 가능하다.

참고

https://developer.chrome.com/docs/css-ui/scrollbar-styling?hl=ko

https://codingeverybody.kr/css-scrollbar-custom-styling/

2024 팀 네이버 신입공채 코딩테스트 후기

공대생철이 — Sat, 23 Mar 2024 13:38:21 +0900

웹 개발자라면 그것도 프론트엔드 개발자라면 네이버는 정말 가고 싶은 회사 중 하나다.

이번 채용공고에서 25년도 2월 졸업자까지 지원이 가능했기에 지원자격에 딱 맞기도 했고 올해 하반기는 채용이 없을 확률이 매우 높기에 일단 되든말든 코테라도 봐보자해서 지원하게 되었다.

3월 18일까지가 지원서 접수였고 오늘 23일 아침 10시~12시에 코딩테스트가 진행되었다.

진행시간 : 10시 ~ 12시

문제수 : 3문제

진행 환경 : 프로그래머스

이전에 프로그래머스에서 문제를 푼 경험도 있었고 코딩테스트를 봐본 경험도 있어서 IDE가 어색하지는 않았다. 그저 내가 코테 공부를 많이 안 했을 뿐...지금 인턴도 하고 있고 출퇴근하면서 정신 없는 건 사실이지만 어쨌거나 공부를 안한 건 사실이다ㅋㅋㅋㅋ

일단 3문제를 다 읽기는(?) 읽었다.

나의 코테 문제풀이 실력이 낮아서 그런지는 모르겠지만 3문제 다 구현 문제로 보였다.

뭔가 특수한 알고리즘을 사용하는 것은 전혀 눈에 띄지 않았고 상황에 대한 이해 + 디테일 캐치와 같은 형식의 문제로 보였다.

(다시 한 번 말하지만 나는 코테 고수가 아니기 때문에 문제 유형 판별을 못한 것일 수 있다.)

A4 용지 한 장은 사용이 가능해서 종이에 먼저 시나리오를 좀 써보고 그 안의 과정들에 대해 간단하게 기술해본 후에 문제를 풀었다.

1번 문제 난이도는 그렇게 높지 않았다고 생각한다. 하지만 개인적으로는 풀었다고 당당하게 말하기는 어려울 것 같다.

문제 상황 자체가 어렵지는 않았는데 시간 복잡도에서 나의 풀이에 대한 의구심이 들었다.

그래서 테스트 케이스는 통과했으나 막상 더 많은 케이스를 돌렸을 때는 어떻게 될지 자신이 없다.

2번 문제 난이도도 높지 않았다고 생각했으나 막상 해보니깐 시간이 꽤나 걸렸다.

처음에 2번 문제를 풀 때 순간 어? 하면서 코드로 구현하는 과정에서 막혀가지고 3번 문제를 읽고 다시 돌아와서 풀었다.

결과적으로 테스트 케이스는 다 맞았지만 내가 봐도 시간 복잡도가 좀 말이 안되는 풀이다.

그래서 이 역시 완전히 풀었다고는 자신있게 말 못하겠다.

3번 문제는 2번 문제 풀이 중 막혔을 때 잠깐 다녀와서 읽었지만 풀이에 시간이 걸릴 것 같아 잠시 보류하고 다시 2번으로 넘어갔었다.

근데 2번 문제 다 풀고 제출하니 시간이 5분 남았다. 시간 내로는 절대 풀지 못하겠지만 그래도 소중한 실전 코테 경험이기에 아이디어라도 머릿속으로 떠올려보자하면서 짱돌만 굴리다가 끝이 났다. 사실 아이디어도 완벽하게 떠오르지는 않았다.

이렇게 나의 첫 네이버 코테가 끝이 났다.

엄청난 건방짐이지만 네이버의 코테 수준이 "와 손도 못 대겠다" 이 정도까지는 아니였던 것 같다. 다만 아이디어나 예외 처리의 디테일을 요구하는 부분이 있는 것 같고 자소서와 인적성과 함께 평가하기에 논리적 사고 능력을 체크하는 느낌의 코테였다.

그럼에도 불구하고 공부 안 하면 안 풀리는 건 똑같다.

이전에 LG CNS, 카카오 인턴에 이어 3번째 코테인데 아직 그다지 발전한 것 같지는 않다ㅋㅋㅋㅋ

결과는 솔직히 기대 안되고 그냥 자기반성의 계기를 마련했다고 생각한다.

정신 차리고 코테 공부 이제 진짜 제대로 좀 해야겠다.

백준 2839 - 설탕 배달

공대생철이 — Wed, 31 Jan 2024 14:28:41 +0900

처음 든 생각

- 브루트 포스해도 시간 복잡도가 괜찮을까? -> 최대 50000이니깐 O(N)으로 한쪽으로만 탐색을 다 하면 충분하겠네

나의 답

import sys
input = sys.stdin.readline

N = int(input())

three = N // 3
five = 0
isPossible = False
result = 10000000

while three >=0:
    if (N - (three * 3)) % 5 == 0:
        five = (N - (three * 3)) // 5
        result = min(result, three + five)
        isPossible = True
    three -= 1

if isPossible:
    print(result)
else:
    print(-1)

사용될 3의 개수의 최댓값이 더 크므로 3의 개수를 기준으로 하나씩 줄여가면서 5의 개수를 판단해보기로 하였다.

3의 개수 * 3 만큼 값을 빼준 값이 5로 나누어떨어지면 그 때만 5의 개수를 계산하면 된다.

그 다음 연산은 코드를 보면 이해가 어렵지 않을 거라 생각한다.

백준 1018 - 체스판 다시 칠하기

공대생철이 — Wed, 31 Jan 2024 14:24:36 +0900

처음 든 생각

- 8*8 이라는 체스판의 크기를 일정하므로 시작점에 대한 좌표를 기준으로 가로 8개, 세로 8개를 세면 되겠다.

- 다시 칠해야하는 개수는 정답 후보군이 2개 밖에 없으므로 정답을 하드코딩하여 비교해준다.

나의 답

import sys
input=  sys.stdin.readline
N, M = map(int,input().split())

ans1 = [
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
]
ans2 = [
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
    ['W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'],
    ['B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'],
]
arr = [ list(input()) for _ in range(N) ]

def checkChess(x,y):
    cnt1 = 0
    cnt2 = 0
    for i in range(8):
        for j in range(8):
            if arr[x+i][y+j] != ans1[i][j]:
                cnt1 += 1
            if arr[x+i][y+j] != ans2[i][j]:
                cnt2 += 1
    return min(cnt1,cnt2)

result = 1000000000
for i in range(N-7):
    for j in range(M-7):
        result = min(result,checkChess(i,j))

print(result)

두 개의 정답 체스판을 2차원 행렬로 선언해주었다.

다시 칠해야하는 정사각형의 개수를 구하기 위한 함수를 따로 만들었다.

1번 정답, 2번 정답과 비교하여 각각의 수정 개수를 비교하여 최소값을 리턴하게 된다.

그 다음 모든 가능 시작 꼭지점에 대하여 결과를 확인하여 최솟값을 도출하면 된다.

시간 복잡도가 괜찮을지 고민이 잠깐 됐는데 50보다 작거나 같은 자연수 이기에 어림잡아 최대 연산 횟수가 50^2 * 8^2 = 160,000이므로 무리 없다고 생각하였다.

백준 19532 - 수학은 비대면강의입니다

공대생철이 — Tue, 30 Jan 2024 17:16:58 +0900

처음 든 생각

- 연립 방정식을 해결했던 과정을 하나씩 복기해보자

1. x또는 y의 계수를 최소공배수로 맞춰준다

2. 두 개의 식을 빼서 x 또는 y를 구한다

3. 구한 하나의 변수를 기준으로 계산하여 나머지 변수의 값을 찾는다.

- 최소공배수는 (두 수의 곱) / (두 수의 최대 공약수) 로 구할 수 있다. math.gcd를 사용하자.

나의 답

import sys, math
input=  sys.stdin.readline
a,b,c,d,e,f = map(int,input().split())

if a == 0:
    y = c // b
    x = (f-e*y) // d
    print(x,y,sep=' ')
    
elif d == 0:
    y = f // e
    x = (c-b*y) // a
    print(x,y,sep=' ')
elif b== 0:
    x = c // a
    y = (f-d*x) // e
    print(x,y,sep=' ')
elif e==0:
    x = f // d
    y = (c-a*x) // b
    print(x,y,sep=' ')
else:
    x_lcm = a*d // math.gcd(a,d)
    y_lcm = b*e // math.gcd(b,e)

    times_1 = x_lcm // a 
    times_2 = x_lcm // d

    b *= times_1
    c *= times_1
    e *= times_2
    f *= times_2

    y = (c-f) // (b-e)
    x = (c-b*y) // x_lcm

    print(x,y,sep=' ')

먼저 앞선 4개의 경우 a,b,d,e가 0일 때를 예외로 처리해준 것이다. 이 상황에서는 바로 x 또는 y를 찾을 수 있기 때문에 바로 값을 찾은 후 나머지 문자에 대한 연산만 수행해주면 끝이다.

이게 아니라면 이제 위에서 살펴본 연립방정식의 과정을 따라가면 된다.

사칙연산 과정을 파이썬 코드로 구현한 것이기에 따로 설명은 안해도 될 것 같다.

처음에 이 문제를 풀었을 때 계수가 0인 것에 대한 예외를 떠올리지 못했다.

수학 문제 풀 때 0이라는 특이 상황이 있다는 것을 한 번 더 마음에 새기고 가자.

또한 최대공약수를 구하는 알고리즘을 따로 구현해서 사용할 수 있겠지만

math 라이브러리 안에 gcd 메소드가 내장되어있다는 것도 까먹지 말자.

최대공배수를 구하는 lcm 메소드도 있다는데

파이썬 버전 3.9 이상에서만 지원한다고 하여 코테에 사용하기에는 조금 리스크가 있을 것 같다.

백준 14889 - 스타트와 링크

공대생철이 — Mon, 29 Jan 2024 14:54:24 +0900

처음 든 생각

- 조합을 백트래킹으로 구현해서 팀을 만든 다음, 나머지 팀도 구해서 각각의 능력치를 비교해주면 되겠다.

나의 답

import sys
input = sys.stdin.readline

N = int(input())
arr = []
for _ in range(N):
    arr.append(list(map(int, input().split())))

result= 10000
t1 = []
def f(p):
    if len(t1) == N//2:
        global result    
        t2 = [j for j in range(N) if j not in t1]
        sum1 = 0
        for k in t1:
            for l in t1:
                sum1 += arr[k][l]
        for m in t2:
            for n in t2:
                sum1 -= arr[m][n]
        result = min(result, abs(sum1))
        return
    else:
        t1.append(p)
        for i in range(p,N):  
            f(i+1)
        t1.pop()
f(0)    
print(result)

팀 하나를 결정 지으면 나머지는 알아서 결정되므로, N//2명의 팀을 구하는 게 우선이다.

인덱스를 기준으로 팀을 구성하게 된다.

아직 팀이 결정되지 않으면, 해당 인덱스를 추가하고 반복문으로 그 뒤의 인덱스에 대해 탐색을 한다.

N=6일 때를 예시로 한 번 살펴보자.

(순서대로)

f(0), t1 = [0]

f(1), t1 = [0,1] ---- (a)

f(2), t1 = [0,1,2]

f(3),f(4), f(5), f(6) 3개 채워졌으므로 결과 계산

f(2)에 대한 pop 수행 t1 = [0,1]

(a)에 있던 반복문에서 f(2) 끝났으니깐 f(3) 수행, t1=[0,1,3]

f(4),f(5),f(6) 3개 채워졌으므로 결과 계산

....

이런 식으로 수행해나가는 매커니즘의 백트래킹이였다.

처음에 이 문제를 풀 때 메모리 초과가 났었는데, 3개짜리 조합을 다 구해놓고 구하는 방식으로 알고리즘을 구현했었다. 조합의 경우 공간복잡도가 N! / (N//2)!(N//2)! 이므로 어쨌든 팩토리얼 단위로 나오게 된다. 20!의 경우 19자리 수이므로 공간복잡도가 클 수 밖에 없었다.

해당하는 조합을 찾을 때마다 바로바로 연산처리를 하는 과정으로 수정해서 문제를 해결할 수 있었다.

백준 14888 - 연산자 끼워넣기

공대생철이 — Sun, 28 Jan 2024 20:36:07 +0900

처음 든 생각

- 연산자를 하나씩 다 끼워넣어서 확인해도 될까?

-> 피연산자가 최대 11개 이므로 연산자는 10개 사용 가능 즉, 10! 가지의 경우의 수가 최대이므로 완전 탐색해도 되겠다.

- 그 다음은 백트래킹해가면서 모든 연산을 재귀적으로 수행하면 되겠다

나의 답

import sys
input = sys.stdin.readline

N = int(input())
arr = list(map(int, input().split()))
operators_list = list(map(int,input().split()))

max_value = -10000000000
min_value = 10000000000

def search(idx, operators,result):
    if idx == N:
        global max_value,min_value
        max_value = max(max_value,result)
        min_value = min(min_value,result)
        return
    else:
        for i in range(4):
            if i == 0 and operators[i]>0:
                operators[i] -= 1
                result = result + arr[idx]
                search(idx+1, operators,result)
                result = result - arr[idx]
                operators[i] += 1
            elif i == 1 and operators[i]>0:
                operators[i] -= 1
                result = result - arr[idx]
                search(idx+1, operators,result)
                result = result + arr[idx]
                operators[i] += 1
            elif i == 2 and operators[i]>0:
                operators[i] -= 1
                result = result * arr[idx]
                search(idx+1, operators,result)
                result = result // arr[idx]
                operators[i] += 1
            elif i == 3 and operators[i]>0:
                operators[i] -= 1
                if result < 0:
                    result = -result
                    result = result // arr[idx]
                    result = -result
                else:
                    result = result // arr[idx]
                search(idx+1, operators,result)
                if result < 0:
                    result = -result
                    result = result * arr[idx]
                    result = -result
                else:
                    result = result * arr[idx]
                operators[i] += 1

search(1,operators_list,arr[0])
print(max_value)
print(min_value)

코드가 길어보이지만 연산자에 대한 계산을 개별적으로 수행해서 길어진 것이다.

먼저 함수는 몇번재 연산인지 체크할 인덱스, 계산 후 남은 연산자들, 그리고 결과값을 매개변수로 받는다.

백트래킹할 때마다 다시 돌아오거나 그 다음 연산을 수행하기 위해서 남은 연산자와 결과값이 필요하다.

그 다음은 각각의 연산자에 대한 코드이다.

+ 연산자가 있으면 결과값에 대해서 + 연산을 수행하고 또 이어서 탐색한다.

이 때 + 연산자의 개수는 1개 감소시키고, 결과값도 + 연산을 수행한 결과값을 매개변수로 전달한다.

그렇게 재귀적으로 계속해서 수행해나간 후 마지막 피연산자에 대한 연산까지 수행하면 최댓값, 최솟값을 할당해주는 처리를 해주면 된다.

만약 마지막 연산까지 수행하면 백트래킹을 위해서 단계별 복원을 해줘야한다.

그 부분이 search 재귀함수 실행 이후에 필요한 부분이다.

백트래킹의 큰 맥락을 따지면 이렇다.

1. 시작점을 설정한 후 탐색을 시작한다.

2. 마지막에 도달했을 때의 상황(재귀 탈출 조건)에 대해서 설정해준다.

3. 계속해서 탐색을 해야하는 상황이면 재귀적으로 탐색을 진행하고

4. 한 단계의 탐색이 완료될 경우 다시 원상복구시키는 과정을 통해 백트래킹이 가능하도록 한다.

추가) 결과값은 그 때 그 때 계속 바뀌므로 매개변수로 전달하여 임시적으로 저장해서 써야될 것 같다.

백준 1629 - 곱셈

공대생철이 — Thu, 25 Jan 2024 16:11:46 +0900

처음 든 생각

- 일단 A, B, C 범위가 심상치가 않네 이건 뭔가가 숨겨져 있다.

그래서 구글링을 좀 해서 풀었다.

나의 답

import sys
input = sys.stdin.readline
A,B,C = map(int,input().split())

def p(n):
    if n==1:
        return A % C
    else:
        tmp = p(n//2)
        if n%2 == 0:
            return tmp*tmp % C
        else:
            return tmp* tmp * A % C

print(p(B))

먼저 코드 설명에 분할 정복을 이용한 거듭제곱 알고리즘 부터 살펴보자.

https://hbj0209.tistory.com/43

[Algorithm] 분할정복을 이용한 거듭제곱

# 분할정복을 이용한 거듭제곱 - C**n연산은 x를 n번 곱하므로 O(N)이지만, 이 방법을 사용하면 O(logN)에 거듭제곱 값을 구할 수 있다. - 아래 코드에서 fpow함수가 그 방법이다. - n이 1이면 그냥 C의 1

hbj0209.tistory.com

지수법칙을 활용해서 지수를 계속해서 2로 나눈 후 곱해가는 방식으로 N번 곱하는 것이 아니라 logN번 만큼 곱해나가는 알고리즘임을 알 수 있다.

이걸 코드로 가져와서 좀 더 자세히 살펴보자.

먼저 나머지 연산에 대해서 살펴보면 (a * b) % n = (a의 나머지) * (b의 나머지) % n 이다.

power 함수는 n (차수)를 매개변수로 사용한다.

만약 1차일 경우 그 때의 나머지 값을 리턴한다.

그게 아니라면 차수를 반으로 나눠서 다시 연산을 수행한다.

해당 재귀함수의 동작 과정을 손으로 써본 것이다.

즉 12 -> 6 -> 3 -> 1의 나머지 연산만 수행하여 전체의 나머지 계산을 할 수 있기에 시간 복잡도가 O(logN) 이다.

문제에서 O(N)만 되도 20억번이 넘는 연산을 수행해야하기 때문에 시간 초과가 날 수 밖에 없다.

새로운 거듭제곱을 분할해서 계산하는 알고리즘은 처음 배웠다. 그래도 논리 자체가 어려운 편은 아니라서 이해는 금방 되었다. 다만 손으로 써보는 건 또 다른 얘기니 복습을 통한 반복이 필요할 것 같다.

백준 1780 - 종이의 개수

공대생철이 — Thu, 25 Jan 2024 15:29:57 +0900

처음 든 생각

- 어제 한 쿼드트리랑 구조가 아예 똑같고 나누는 숫자만 다르네

- 0,1,-1로 다 차있는지 아닌지 비교해서 아니면 분할해서 다시 검색하는 방식으로 재귀를 구성하면 되겠다.

나의 답

import sys
input = sys.stdin.readline
N = int(input())

arr = [list(input().split()) for _ in range(N) ]

zero = 0
one = 0 
minus = 0

def nine_tree(x,y,n):
    global zero, one, minus

    total = 0
    start = arr[x][y]
    for i in range(x,x+n):
        for j in range(y,y+n):
            if start != arr[i][j]:
                total = float("inf")
                break
            elif arr[i][j] == "0":
                continue
            elif arr[i][j] == "1":
                total += 1
            elif arr[i][j] == "-1":
                total -= 1
    
    if total == 0:
        zero += 1
        return
    elif total == n**2:
        one += 1
        return
    elif total == n**2 * -1:
        minus += 1
        return
    else:
        n = n//3
        nine_tree(x,y,n)
        nine_tree(x,y+n,n)
        nine_tree(x, y+ n*2,n)
        nine_tree(x+n,y,n)
        nine_tree(x+n,y+n,n)
        nine_tree(x+n,y+n*2,n)
        nine_tree(x+n*2,y,n)
        nine_tree(x+n*2,y+n,n)
        nine_tree(x+n*2,y+n*2,n)

nine_tree(0,0,N)
print(minus)
print(zero)
print(one)

쿼드트리와 같이 시작 좌표와 정사각형의 크기를 매개변수로 받는다.

그 다음 해당 정사각형에서 -1,0,1 셋 중에 하나로 가득차있는지 아닌지 비교한 후에 아닐 경우 9개의 정사각형으로 다시 분할해서 재귀적으로 탐색을 한다.

문제 구성 자체가 이전에 풀었던 색종이 만들기, 쿼드트리와 아예 똑같아서 더 이상 풀이할 건 없을 것 같다.

다만 짚고 넘어가야할 점이 있다.

import sys
input = sys.stdin.readline
N = int(input())

arr = [list(input().split()) for _ in range(N) ]

zero = 0
one = 0 
minus = 0

def nine_tree(x,y,n):
    global zero, one, minus

    count_zero = 0
    count_one = 0 
    count_minus = 0
    for i in range(x,x+n):
        for j in range(y,y+n):
            if arr[i][j] == "0":
                count_zero += 1
            elif arr[i][j] == "1":
                count_one += 1
            elif arr[i][j] == "-1":
                count_minus += 1
    
    if count_zero == n**2:
        zero += 1
        return
    elif count_one == n**2:
        one += 1
        return
    elif count_minus == n**2:
        minus += 1
        return
    else:
        n = n//3
        nine_tree(x,y,n)
        nine_tree(x,y+n,n)
        nine_tree(x, y+ n*2,n)
        nine_tree(x+n,y,n)
        nine_tree(x+n,y+n,n)
        nine_tree(x+n,y+n*2,n)
        nine_tree(x+n*2,y,n)
        nine_tree(x+n*2,y+n,n)
        nine_tree(x+n*2,y+n*2,n)

nine_tree(0,0,N)
print(minus)
print(zero)
print(one)

처음에 풀었던 방식이었고 이렇게 풀어서 시간 초과가 떴었다. 그리고 다시 수정한 코드가 "나의 답"에 작성되어있는 코드이다.

-1,0,1로 다 구성되어있는지 아닌지 비교하는 로직에서 가장 큰 차이가 있다.

시작점을 기준으로 n^2 개 만큼의 정사각형을 탐색하는데 만약 다른 원소가 하나라도 발견되면 걔는 애초에 성립할 수 없는 정사각형이기에 뒤에 원소들을 살펴볼 필요가 없다. 하지만 처음 코드는 그럼에도 불구하고 하나씩 다 완전 탐색으로 찾는 것이기에 시간 손해가 발생할 수 없었던 코드였다.

재귀의 큰 구성뿐만 아니라 그 내부의 탈출 조건을 구성할 때의 시간 복잡도도 고려하여 알고리즘을 작성하는 것의 필요성을 배운 문제였다.

백준 1992 - 쿼드트리

공대생철이 — Wed, 24 Jan 2024 17:07:21 +0900

처음 든 생각

- 아까 복습한 색종이 만들기 문제랑 완전 판박이네

- 4개로 분할할 때에 추가적으로 괄호가 들어가야하네

- 모두 0/1일 때 결과를 리턴함으로서 재귀 리턴 조건을 맞춰주고

- 4개로 분할할 경우 괄호를 포함한 재귀함수를 리턴해야겠다.

나의 답

import sys
input = sys.stdin.readline
N = int(input())

arr = [list(input()) for _ in range(N) ]
def search(x,y,n):
    zero_count = 0
    for i in range(n):
        for j in range(n):
            
            if arr[x+i][y+j] == "0":
                zero_count += 1

    if zero_count == n*n:
        return "0"
    elif zero_count == 0:
        return "1"
    else:
        return f"({search(x,y,n//2)}{search(x,y+n//2,n//2)}{search(x+n//2,y,n//2)}{search(x+n//2,y+n//2,n//2)})"
    
print(search(0,0,N))

https://selfdevelopcampus.tistory.com/164

백준 2630 - 색종이 만들기

처음 든 생각 - 정사각형이 성립하는지 안하는지 판단한 다음 - 정사각형이 만들어지지 않는다면 다시 4개로 쪼개서 확인한다. - 크기가 1인 정사각형일 때가 재귀 탈출 조건일 것이다. 나의 답 im

selfdevelopcampus.tistory.com

위의 풀이를 참고하면 사실상 구조는 거의 똑같다.

안에 0의 개수를 세서 0의 개수가 탐색하고자하는 정사각형에 가득 차있으면 0을 리턴하고 0개일 경우 모두 1이라는 뜻이므로 1을 리턴한다. 나중에 괄호까지 포함해서 리턴해야하므로 문자열 자료형의 0과 1을 리턴하도록 했다.

그 다음 만약 모두 0이나 1이 아니면 4개로 분할을 해야한다. 이 역시 위의 "색종이 만들기" 문제와 거의 똑같다.

분할하는 정사각형의 시작점을 매개변수로 받는 함수로 구성하여 시작점을 조절하는 방식으로 정사각형을 분할한다. 그리고 각각의 정사각형의 탐색결과를 모두 합쳐서 괄호 안에 넣어주면 된다.

색종이 만들기를 제대로 복습했는지 스스로 점검할 수 있었던 좋은 문제였다. 정사각형의 4분할 과정 한 번 더 점검하고 넘어가자.

백준 2630 - 색종이 만들기

공대생철이 — Wed, 24 Jan 2024 13:41:03 +0900

처음 든 생각

- 정사각형이 성립하는지 안하는지 판단한 다음

- 정사각형이 만들어지지 않는다면 다시 4개로 쪼개서 확인한다.

- 크기가 1인 정사각형일 때가 재귀 탈출 조건일 것이다.

나의 답

import sys
input = sys.stdin.readline
N = int(input())

arr = []
for _ in range(N):
    arr.append(list(map(int,input().split())))

blue = 0
white = 0

# 사각형 별 시작 좌표 + 크기 를 받아서
def search(sr, sc, n):
    global blue, white
    # 1의 갯수를 센다
    blue_count = 0
    for i in range(sr,sr + n):
        for j in range(sc,sc+n):
            if arr[i][j] == 1:
                blue_count += 1
    # 모두 1이면 파란 정사각형 성립            
    if blue_count == n**2:
        blue += 1
        return
    # 모두 0이면 하얀 정사각형 성립
    elif blue_count == 0:
        white += 1
        return
    # 정사각형이 만들어지지 않았다면 네개로 나눠서 다시 검색
    else:
        search(sr,sc,n//2)
        search(sr+n//2,sc,n//2)
        search(sr,sc+n//2,n//2)
        search(sr+n//2,sc+n//2,n//2)

search(0,0,N)
print(white)
print(blue)

정사각형이 성립하는지를 먼저 판단한다. 그러기 위해서 1의 개수를 세는 방법으로 확인하기로 했다. 1의 개수가 N^2 개라면 모두 1이라는 뜻이므로 파란색 정사각형이 만들어진 것이다. 만약 0개라면 하얀색 정사각형이 만들어진 것이다. 그러면 더이상 쪼개서 검색할 필요가 없으므로 리턴함으로써 함수를 종료한다.

만약 정사각형이 만들어지지 않았다면 다시 4개로 나눠서 검색한다. search 함수는 탐색할 정사각형의 가장 좌측 상단의 좌표를 매개변수로 받는다. 시작 좌표 값을 기준으로 4개로 나누는 것은 위의 코드대로 n//2 를 추가해주는 방식으로 조절하면 된다.

사실 아이디어는 그렇게 어렵지 않게 떠올랐으나 구현에서 꽤나 애를 먹었다. 아직 재귀에 대한 그림이 머릿 속에서 빠릿빠릿하게 그려지지 않는 것 같다. 리턴하는 순서도 아직 하나하나씩 써가면서 확인하고 있어서 재귀에 대한 문제풀이가 좀 많이 필요할 것 같다.

백준 24511 - queuestack

공대생철이 — Mon, 22 Jan 2024 14:15:14 +0900

처음 든 생각

- 흠 이게 뭔 소리지 -> 종이에 하나씩 차근차근 써가면서 읽어보니 이해됐다.

- 아 결국 큐에 있는 애들만 원소를 바꿔치기 하면 되겠구나

나의 답

import sys
from collections import deque
input = sys.stdin.readline

N = int(input())
isStack = list(map(int, input().split()))
arr = list(map(int, input().split()))
M = int(input())
new = list(map(int, input().split()))

q = deque()
for i in range(N):
    if isStack[i] == 0:
        q.append(arr[i])
q.reverse()
result= []
for i in new:
    q.append(i)
    result.append(q.popleft())

print(" ".join(map(str, result)))

자료구조가 스택인 놈들은 어차피 원소의 값이 바뀌지 않고 처리해줘야할 게 없기 때문에 넘어가면 된다. 결국 자료구조가 큐인 애들만 싹 모아주고 별도의 큐를 만들어준 다음 거기서 하나씩 append하고 popleft 하는 거나 마찬가지다.

1번 예제를 통해서 간단하게 살펴보면

[1,4]라는 큐에서 2 4 7이 차례대로 들어오는 것이다.

1 4에서 2라는 애를 새로 추가해서 [ 2 1 4] 로 만들어준 다음 4는 맨 마지막에 pop해서 리턴되는 놈이다. 그래서 1차 결과는 [2 2 3 1]

큐 자료구조에서 하나씩 추가하면서 밀어내는 것이 결국 처리될 하나의 공통 로직이다.

그래서 for문 한 번만 돌면서 append, popleft만 반복해주면 된다.

나의 틀린 답

import sys
input = sys.stdin.readline

N = int(input())
isStack = list(map(int, input().split()))
arr = list(map(int, input().split()))
M = int(input())
new = list(map(int, input().split()))

result = []

for i in new:
    idx = 0
    tmp = i
    while idx<N:
        if isStack[idx] == 0:
            tmp2 = arr[idx]
            arr[idx] = tmp
            tmp = tmp2
        idx += 1
    result.append(tmp)

print(" ".join(map(str, result)))

처음에 생각했던 알고리즘은 new에 대해서 하나씩 다 확인해가면서 리턴값을 확인하는 것이었다. 결과는 '시간 초과'였는데 이유는 간단했다. 위의 알고리즘은 최악의 경우 100억번의 연산을 수행해야하기 때문이다. 시간 복잡도 측면을 고려하지 않고 그냥 문제 흐름대로 바로 구현하다가 실패한 케이스였다.

조건에 따른 시간복잡도도 고려하면서 알고리즘을 구성하는 연습을 더더 많이 해보자.

백준 28279 - 덱 2

공대생철이 — Sun, 21 Jan 2024 17:51:28 +0900

처음 든 생각

- 그냥 큐의 메서드만 잘 활용하고 출력값만 실수하지 말자

- 아 input 말고 sys.stdin.readline 쓰자 -> 예전에 로직은 다 맞았는데 input 때문에 시간 초과 났던 문제가 있어서 ptsd가 왔다.

나의 답

import sys
from collections import deque

N = int(sys.stdin.readline())
q= deque()
for _ in range(N):
    cmd = list(map(int, sys.stdin.readline().split()))
    n = cmd[0]
    if n == 1:
        q.appendleft(cmd[1])
    elif n == 2:
        q.append(cmd[1])
    elif n==3:
        if len(q) == 0:
            print(-1)
        else:
            print(q.popleft())
    elif n ==4:
        if len(q) == 0:
            print(-1)
        else:
            print(q.pop())
    elif n == 5:
        print(len(q))
    elif n ==6:
        if len(q) == 0:
            print(1)
        else:
            print(0)
    elif n == 7:
        if len(q) == 0:
            print(-1)
        else:
            print(q[0])
    elif n == 8:
        if len(q) == 0:
            print(-1)
        else:
            print(q[-1])

딱히 해설할 건 없는 것 같다.

왼쪽 앞에 넣어주는 건 appendleft 빼는 건 popleft

오른쪽 끝에 넣어주는 건 append 빼는 건 pop

이 메서드들만 잘 숙지하고 있었으면 쉽게 풀 수 있는 문제였다.

백준 4779 - 칸토어 집합

공대생철이 — Wed, 17 Jan 2024 21:42:54 +0900

처음 든 생각

- 재귀로 3 그룹씩 쪼개가면서 풀면 되겠다.

- 근데 리턴 조건을 어떻게 설정해야 되지...?

나의 답

def cantor(n):
    if n == 1:
        return "-"
    else:
        left = cantor(n//3)
        center = " " * (n //3)
        return left + center + left

while True:
    try:
        N = int(input())
        result = cantor(3**N)
        print(result)
    except:
        break

3개의 그룹으로 쪼개고 왼쪽 오른쪽은 또 칸토어한 결과를 더해주는 것이다.

N = 2를 예시로 들면

cantor(3) | " " 3개 | cantor(3)

cantor(1) " " cantor(1) | " " 3개 | cantor(1) " " cantor(1)

이렇게 되는 구조다.

결국 1개만 남을 때 "-"를 리턴해주면 되는 거였다.

그 다음 입력에서 애를 먹었다.

조건을 보면 파일의 끝에서 입력을 멈춘다고 했다.

계속 숫자를 받으면서 칸토어를 출력하는데 끝에 다다르면 멈춰야 되는 것이다.

이건 외우자.

while True:
	try:
    	
	except:
		break

계속 시도하다가 끝나면 멈추는 try - except 구문이다.

솔직히 논리로는 바로 나왔는데 구현에서 시간을 너무 많이 썼다. 재귀에 대한 나의 구현 능력이 얼마나 부족한지를 깨닫는 문제였다.

SWEA 5177 - 이진 힙

공대생철이 — Wed, 17 Jan 2024 15:23:09 +0900

https://swexpertacademy.com/main/learn/course/subjectDetail.do?courseId=AVuPDN86AAXw5UW6&subjectId=AWOVJ-_6qfsDFAWg&&#

처음 든 생각

- 노드의 개수+1 개 만큼 담을 수 있는 힙을 불러와주고

- 하나씩 append하면서 부모 노드와 비교하면서 필요한 경우 스왑을 해줘야겠다.

나의 답

T = int(input())
from collections import deque
for test_case in range(1, T + 1):
    N = int(input())
    num_list = deque(list(map(int, input().split())))
    min_heap = [0]
    def check_parent(i):
        global min_heap
        if min_heap[i//2] > min_heap[i]:
            min_heap[i//2], min_heap[i] = min_heap[i], min_heap[i//2]
            check_parent(i//2)
    for i in range(1,N+1):
        min_heap.append(num_list.popleft())
        check_parent(i)
    result = -min_heap[len(min_heap)-1]
    while N >=1:
        result += min_heap[N]
        N = N // 2
    print(f"#{test_case} {result}")

받아온 숫자들을 왼쪽부터 하나씩 pop을 하기 위해서 큐를 사용했다.

작은 숫자가 가장 위에 오는 힙이기에 min_heap 으로 선언을 하였고 하나씩 popleft해주면서 append를 한다.

그리고 그 노드의 값과 부모 노드의 값을 비교해준다.

check_parent의 경우 부모노드와 비교해서 본인이 작으면 스왑을 하고 다시 부모노드와 비교할 수 있도록 재귀적으로 호출하였다.

그렇게 최소 힙을 완성한 다음 결과 처리만 해주면 끝이다.

힙 문제를 풀 때 1번 노드, 2번 노드 이런식으로 하기 때문에 맨 처음은 0으로 사용하지 않는 노드로 간주하고 항상 인덱스와 노드 번호가 일치하게 처리될 수 있도록 선언해야한다.

SWEA 5147 - Subtree

공대생철이 — Tue, 16 Jan 2024 11:43:54 +0900

https://swexpertacademy.com/main/learn/course/subjectDetail.do?courseId=AVuPDN86AAXw5UW6&subjectId=AWOVJ-_6qfsDFAWg&&#

처음 든 생각

- 부모와 자식 간의 관계임을 어떻게 나타낼까 -> [부모 , [자식들 노드] ] 형식으로 번호에 맞춰 매겨야겠다.

- subtree 노드 개수를 확인하기 위해 DFS를 해야겠네 -> DFS 코드 구현 어떻게 했더라...

나의 답

T = int(input())
for test_case in range(1, T + 1):
    E,N = map(int, input().split())
    tree =[ [0,[]] for _ in range(E+2)] 
    visited = [0 for _ in range(E+2)]
    a = list(map(int, input().split()))
    for i in range(0,len(a),2):
        tree[a[i]][1].append(a[i+1])
        tree[a[i+1]][0] = a[i]
        
    def dfs(v):
        global visited
        for i in tree[v][1]:
            if visited[i] == 0:
                visited[i] = 1
                dfs(i)          
    dfs(N)
    print(f"#{test_case} {sum(visited) + 1}")

노드의 숫자 번호를 그대로 사용하기 위해 E+2개의 노드와 방문 여부 리스트를 선언한다. 인덱스 0은 0번 노드가 없기 때문에 참조될 일이 없다.

간선은 2개씩 끊어서 비교해줘서 부모-자식 간의 관계를 할당해주면서 트리를 완성해주면 된다.

그 다음 기준 노드를 시작으로 DFS를 한다.

DFS는 연결된 자식 노드들을 끝까지 타고 들어가면서 방문 여부를 체크해준다.

다시 복습하면,

매개변수 = 시작 노드

연결된 노드들 반복문 돌면서

-> 방문 안했으면 그 노드 다시 DFS

-> 방문 했으면 패스

노드의 개수만 판단하면 되므로 visited의 총합을 출력하면 된다.

맨 처음 시작 노드를 빼먹어서 그냥 결과에 1을 더해주기로 했다.

트리구조 직접 만들어보고 DFS 복습하기 좋은 문제였다.

SWEA 5110 - 수열 합치기

공대생철이 — Tue, 16 Jan 2024 09:21:08 +0900

https://swexpertacademy.com/main/learn/course/subjectDetail.do?courseId=AVuPDN86AAXw5UW6&subjectId=AWOVJ1r6qfkDFAWg

처음 든 생각

- 반복문으로 새로운 수열의 첫째 원소랑 기존 배열의 원소들과 하나씩 비교해주면서 위치를 찾은 다음 합쳐주면 되겠다

나의 답

T = int(input())
for test_case in range(1, T + 1):
    N, M = map(int, input().split())
    arr = [float('inf')]
    cnt = 0
    for _ in range(M):
        a = list(map(int, input().split()))
        for i in range(N*cnt+1):
            if a[0] < arr[i]:
                arr[i:i] = a
                break
        cnt +=  1
    print(f'#{test_case}',end=' ')
    print(*arr[-11:-1][::-1])

무한대를 비교하여 기존 배열 안의 모든 원소들보다 첫째 항이 더 클 경우의 예외 처리를 간단하게 했다.

그 다음 기존의 배열들과 원소를 하나씩 비교해가면서 큰 놈을 발견하면 바로 수열을 합쳐준다.

처음 제출했던 답

T = int(input())
for test_case in range(1, T + 1):
    N,M = map(int,input().split())
    s =[float('inf')]
    for _ in range(M):
        new = list(map(int, input().split()))  
        for i in range(len(s)+1):
            if new[0] < s[i]:
                s= s[:i] + new + s[i:]
                break
    print(f"#{test_case}", end=" ")
    print(*s[-11:-1][::-1])

위의 답을 제출했더니 1개가 계속 시간 초과로 안되는 것이었다.

len(s)가 시간복잡도가 혹시 큰가 해서 수정했다.

-> 사실 찾아보니 len 함수의 시간 복잡도도 O(1)이라 지장없었다.

그리고 수열을 합쳐주는 부분을 구글링해서 다른 방법이 있나 찾아본건데...솔직히 뭔 차이인지 모르겠다.

아시는 분 있으면 댓글로 알려주세요ㅠㅠ

복습할 부분

1. 리스트를 합치는 방법

 list[i:i] = new_list

list의 i번째 인덱스부터 new_list의 원소들을 추가해준다.

2. 인덱스 슬라이싱 음수

-11이면 오른쪽 끝에서부터 11번째 원소이다. -11:-1 이라면 맨 오른쪽 원소를 제외하고 오른쪽에서부터 2번째 원소~11번째 원소를 가리키는 것이다.

3. 리스트 역순

슬라이싱 기법을 활용해서 [::-1]을 추가하면 리스트의 원소가 역순으로 배치된다.

백준 2580 - 스도쿠 python

공대생철이 — Mon, 15 Jan 2024 12:25:46 +0900

처음 든 생각

- 행, 열, 3*3 모두 고려를 해줘야겠네

- 무조건 1개만 남겨저서 풀 수 있는 놈이 있을테니 그걸 중심으로 풀어나가면 되겠다

-> 라고 생각한 것이 크나큰 오산이었다.

예를 들어 어떤 0은 열을 검사했을 때는 1,2가 가능하고 행을 검사했을 때 2,3,6이 가능하다고 했으면 이 녀석은 2로 확정지을 수 있다.

즉, 무조건 1개만 남겨져서 풀겠다는 어마어마한 경기도 오산이었고 오직 예제에서만 가능한 경우였다. 가능한 후보군에 대하여 하나하나씩 다 검사를 했어야 한다.

(답지 보고 푼) 나의 답

import sys
input = sys.stdin.readline

s = []
zero_q = []
for i in range(9):
    temp_list = list(map(int, input().split()))
    s.append(temp_list)
    for j in range(9):
        if temp_list[j] == 0:
            zero_q.append([i,j])

# 해당 행에 a가 있는지 없는지 확인
def checkRow(r,a):
    for i in range(9):
        if s[r][i] == a:
            return False
    return True

# 해당 열에 a가 있는지 없는지 확인
def checkCol(c,a):
    for i in range(9):
        if s[i][c] == a:
            return False
    return True

# 해당 3*3에 a가 있는지 없는지 확인
def checkSquare(r,c,a):
    nr = r//3 *3
    nc = c//3 *3
    for i in range(3):
        for j in range(3):
            if a == s[nr+i][nc+j]:
                return False
    return True

# 모든 0 좌표들에 대하여 dfs 수행
def dfs(idx):
    if idx == len(zero_q):
        for i in range(9):
            print(" ".join(map(str,s[i])))
        exit()
    for i in range(1,10):
        r = zero_q[idx][0]
        c = zero_q[idx][1]
        # 0인 좌표에 1~9까지 넣어보면서 가능한지 확인
        if checkRow(r,i) and checkCol(c,i) and checkSquare(r,c,i):
            s[r][c] = i
            dfs(idx+1)
            # 만약에 넣어봤다가 더이상 dfs 함수 스택이 쌓이지 않거나 exit가 안 된거면 다시 0으로 바꿔서 다음 수를 대입
            s[r][c] = 0
dfs(0)

행, 열, 작은 정사각형에 대하여 a가 있는지 없는지 확인하고 만약 a 값이 있다면 얘는 들어갈 수 없는 놈이기에 False를 리턴해준다.

그다음 노드 하나씩 DFS를 수행해나간다. 즉, 될 때까지 깊게 파는 거다.

0인 좌표들에 대해서 1~9까지 가능한 숫자를 찾은 후에 가능하다면 대입하고 그 다음 노드에 대하여 DFS를 수행한다. 만약 다음 DFS를 실행했을 때 1~9까지 가능한 숫자가 없다면 함수 스택이 쌓이지 않기에 다음 수를 대입해야 한다. 그렇게 0으로 초기화를 시켜준 후 새로운 i값을 대입하는 백트래킹 알고리즘이었다.

처음 구현한 알고리즘은 이거였다.

import sys
from collections import deque
input = sys.stdin.readline

s = []
row_zero = [0 for _ in range(9)]
col_zero = [0 for _ in range(9)]
square_zero = [ [0 for _ in range(3)] for _ in range(3)]
zero_q = deque([])


for i in range(9):
    temp_list = list(map(int, input().split()))
    s.append(temp_list)
    for j in range(9):
        if temp_list[j] == 0:
            row_zero[i] += 1
            col_zero[j] += 1
            square_zero[i//3][j//3] += 1
            zero_q.append([i,j])

while zero_q:
    temp = zero_q.popleft()
    if row_zero[temp[0]] == 1:
        s[temp[0]][temp[1]] = 45 - sum(s[temp[0]])
        row_zero[temp[0]] -= 1
        col_zero[temp[1]] -= 1
        square_zero[temp[0]//3][temp[1]//3] -= 1
        continue
    elif col_zero[temp[1]] == 1:
        sum_col = 0
        for k in range(9):
            sum_col += s[k][temp[1]]
        s[temp[0]][temp[1]] = 45 - sum_col
        row_zero[temp[0]] -= 1
        col_zero[temp[1]] -= 1
        square_zero[temp[0]//3][temp[1]//3] -= 1
        continue
    elif square_zero[temp[0]//3][temp[1]//3] == 1:
        sum_square = 0
        for m in range(temp[0]//3 * 3,temp[0]//3 * 3 + 3):
            for n in range(temp[1]//3 * 3 , temp[1]//3 * 3 + 3):
                sum_square+= s[m][n]
        s[temp[0]][temp[1]] = 45 - sum_square
        row_zero[temp[0]] -= 1
        col_zero[temp[1]] -= 1
        square_zero[temp[0]//3][temp[1]//3] -= 1
        continue
    zero_q.append(temp)
        
for r in s:
    print(" ".join(map(str, r)))

큐로 0의 좌표들을 관리한 다음 0의 개수가 1개인 놈이라면 확정을 지을 수 있기 때문에 찾아서 넘어가고 아니면 다시 뒤로 append해서 나중에 다른 좌표들 조사가 끝났을 때 다시 계산하는 방식으로 했다.

예제도 올바르게 나왔으나 애초에 스도쿠의 아이디어 자체가 잘못된 것이었다.

~~괜히 틀린 알고리즘 구경하다가 눈 버릴 수도 있으니 자세히 살펴보지 말고 그냥 이렇게 풀어서 틀린 놈도 있구나~하고 넘어가면 된다.~~

일단 DFS를 접목시켜서 백트래킹을 할 생각을 못한 것은 경험치가 정말 부족하다는 것을 방증하는 것이었다.

실제로 답안 코드를 처음 봤을 때도 한 번에 이해는 되지 않았다. 갑자기 DFS?? 이런 느낌이었다.

하지만 결국 한 놈을 죽도록 팬다는 DFS의 철학을 대입시켜보면 스도쿠와 정확히 통한다.

이 문제는 기필코 이번주에 다시 복습하면서 새로 풀어봐야겠다.

아마 다시 풀어보면 못 풀 확률이 높아보이지만...

SWEA 5102 - 노드의 거리

공대생철이 — Sat, 13 Jan 2024 21:45:26 +0900

https://swexpertacademy.com/main/learn/course/subjectDetail.do?courseId=AVuPDN86AAXw5UW6&subjectId=AWOVIoJqqfYDFAWg

처음 든 생각

- 이건 무조건 BFS다 -> 큐로 구현하고 방문 여부에 따라 반복문으로 노드를 하나씩 추가해주면서 확인하면 된다

- 이동한 거리를 측정하기 위해서 노드 번호와 거리를 같이 다뤄야겠다.

나의 답

T = int(input())
from collections import deque
for test_case in range(1, T + 1):
    V, E = map(int,input().split())
    g = [[] for _ in range(V+1) ]
    for _ in range(E):
        a,b = map(int, input().split())
        g[a].append(b)
        g[b].append(a)
    S,G = map(int,input().split())
    visited = [0 for _ in range(V+1)]
    q = deque([[S,0]])
    answer = []
    while q:
        t = q.popleft()
        if t[0] == G:
            answer = t
            break
        elif visited[t[0]] == 0:
            visited[t[0]] = 1
            for i in g[t[0]]:
                if visited[i] == 0:
                    q.append([i, t[1] + 1])
    if answer:
        print(f"#{test_case} {answer[1]}")
    else:
        print(f"#{test_case} 0")

먼저 각각의 노드가 연결된 그래프를 만들기 위해서 N+1 개의 빈 배열을 선언해준다. 인덱스로 변환하지 않고 노드의 번호를 그대로 사용하기 위해 맨 앞의 빈 배열도 추가했다. 그 다음 연결된 노드를 추가해줌으로써 그래프를 완성한다.

방문 여부를 확인하는 리스트와 방문 노드를 관리할 큐를 만들고 [ 노드 번호, 거리 ] 형식으로 큐 안에 데이터를 넣어준다.

다음 반복문을 돌면서 전형적인 BFS의 알고리즘을 따라가면 된다. popleft 한 후에 도착점에 도달했다면 정답을 찾은 것이므로 반복문을 나가고 아니라면 그 노드를 방문 처리해주고 연결된 노드를 방문한다.

가장 전형적인 BFS 문제였다. 처음에는 G를 찾았을 때 바로 print를 해주면서 break 하려고 했는데 그렇게 되니 못 찾을 경우의 처리가 바로 떠오르지 않아서 그냥 정답 변수 하나 더 선언해서 처리하였다.

BFS

- 큐

- 방문 여부 확인

- 연결된 노드 모두 추가

이 3가지 매커니즘에 대해서 한 번 더 복습하고 넘어갈 수 있었던 좋은 문제였다.

SWEA 5099 - 피자 굽기

공대생철이 — Sat, 13 Jan 2024 18:16:40 +0900

처음 든 생각

- 전체 피자를 관리하는 큐와 화덕의 큐 두 개를 생성해야겠다

- 화덕 큐에 피자가 없어질 때까지 반복문을 돌고 popleft, append를 조건에 따라 처리해주면 되겠다.

나의 답

T = int(input())
from collections import deque
for test_case in range(1, T + 1):
    N,M = map(int, input().split())
    every = list(map(int, input().split()))
    for i in range(len(every)):
        every[i] = [i+1, every[i]]
    q_pizza = deque(every)
    q_fire = deque([q_pizza.popleft()])
    result = []
    while q_fire:
        if len(q_pizza) == 0:
            temp = q_fire.popleft()
            if temp[1] // 2 == 0:
                result.append(temp)
            else:
                temp[1] = temp[1] // 2
                q_fire.append(temp)
        elif len(q_fire)<N:
            q_fire.append(q_pizza.popleft())
        else:
            temp = q_fire.popleft()
            if temp[1] // 2 == 0:
                result.append(temp)
                q_fire.append(q_pizza.popleft())
            else:
                temp[1] = temp[1] // 2
                q_fire.append(temp)
    print(f"#{test_case} {result[-1][0]}")

먼저 전체는 [인덱스, 치즈의 양] 이렇게 다루기로 했다. 그래야 나중에 결과 도출할 때 몇번째 피자인지 바로 알 수 있기 때문이다.

전체 피자를 담은 q_pizza 큐와 화덕에 있는 피자를 담은 q_fire 큐를 선언해준다. q_fire에는 디폴트로 첫번째 피자를 넣어주었다.

결과에는 순서대로 치즈가 다 녹은 피자들을 넣어줄 것이다.

이제 반복문을 돈다.

만약 q_pizza에 남아있는게 없다면 이미 모든 피자가 완성되었거나 화덕에서 조리 중이기에 남은 애들끼리만 연산을 해주면 된다.

그래서 popleft하고 치즈가 다 녹았으면 결과에 넣고 아니면 남은 치즈 양만 계산해주고 다시 후순위로 append 해준다.

만약 q_pizza가 남았는데 화덕에 아직 여유 공간이 있다면 화덕에 새로운 피자를 넣어준다.

화덕이 가득차있다면 하나씩 popleft를 하면서 다 녹았는지 확인한다. 만약 다 녹았다면 결과에 넣어주고 q_pizza에서 새로운 피자를 투입시킨다. 안 녹았다면 치즈 양만 계산해주고 다시 후순위로 append 해준다.

원형 큐인 것 같았지만 그냥 선형 큐 방식으로 처리해도 무방했다.

처음 풀 때 while문이 안 끝났었는데 q_pizza에 남은 게 없을 때 그 안에서만 순서대로 조리되는 것을 빼먹었다. 그거를 빼먹은 거 빼고는 나머지는 모두 연습장에 쓴 풀이과정을 구현했더니 올바르게 결과가 출력되었다. 상황 분류를 좀 더 디테일하게 하자.

SWEA 5105 - 미로의 거리

공대생철이 — Fri, 12 Jan 2024 13:36:24 +0900

처음 든 생각

- BFS로 거리에 따라 하나씩 탐색을 해야겠다.

- 3인 점을 처음 발견하면 그 때가 최소 거리가 될테니깐 함수를 중단하면 되겠다.

- 방문한 사실 확인 + 출발점에서의 거리를 한 번에 계산해야겠다.

나의 코드

T = int(input())
from collections import deque
for test_case in range(1, T + 1):
    N = int(input())
    a= [[] for _ in range(N)]

    starting =[0,0]
    for i in range(N):
        a[i] = list(map(int, list(input())))
        if 2 in a[i]:
            starting[0] = i
            starting[1] = a[i].index(2)
    q = deque()
    q.append(starting)
    a[starting[0]][starting[1]] = 4
    
    dx = [0,0,-1,1]
    dy = [-1,1,0,0]
    found = False
    result = 0
    while q and found != True:
        temp = q.popleft()
        for i in range(4):
            nx = temp[1] + dx[i]
            ny = temp[0] + dy[i]
            if nx<N and nx>=0 and ny<N and ny>=0:
                if a[ny][nx] == 3:
                    found = True
                    result = a[temp[0]][temp[1]] - a[starting[0]][starting[1]]
                    break
                elif a[ny][nx] == 0:
                    q.append([ny, nx])
                    a[ny][nx] = a[temp[0]][temp[1]] + 1 
    if found:
        print(f"#{test_case} {result}")
    else:
        print(f"#{test_case} 0")

먼저 전체 미로를 2차원 리스트로 표현하고 시작점을 구한다.

그 다음 BFS를 하기 위해 큐를 선언한다. 큐를 통해서 거리에 따라 노드를 계속 추가하는 방식으로 탐색을 할 예정이다.

ex 거리가 1인 노드들 먼저 큐 안에 다 넣고 그다음 popleft해서 탐색

시작점을 4라고 표시했다. 0,1,2,3은 이미 각각의 숫자가 의미를 가지고 있었기에 4부터 거리를 측정하기로 했다. 4 이상이면 이미 방문했다는 뜻이고 그에따라 거리를 하나씩 증가시켜주면서 계산을 하면 된다.

그 다음부터는 본격적인 BFS 알고리즘이다.

found라는 플래그와 큐를 동시에 고려하여 반복문을 돌도록 설계하였고, 하나씩 노드를 popleft하면서 상하좌우의 노드들을 탐색한다.

만약 노드의 값이 0이라면 아직 방문하지 않았다는 뜻이기에 큐에 해당 노드를 추가해주고 이전 노드보다 거리가 1 늘어난 것이므로 값을 변경해준다.

만약 노드의 값이 3이라면 목표하는 노드에 도달한 것이므로 플래그를 True로 바꿔주고 지금까지 지나간 노드의 개수를 계산해준다.

그 외의 경우 (1,2, 4,5...)는 이미 방문했거나 방문할 수 없는 노드이기 때문에 추가적으로 고려할 사항이 없다.

결과는 플래그에 따라 출력해주면 된다.

BFS를 거의 처음으로 혼자 풀었던 것 같다. 첫 제출에 바로 pass해서 기분이 진짜진짜 좋았다.

어떤 식으로 반복문을 설계해야할지 어떤 걸 검사해야할지 큐를 어떻게 활용해야할지 감을 잡기에 아주 좋은 문제였다.

SWEA 4881 - 배열 최소 합

공대생철이 — Wed, 10 Jan 2024 17:16:31 +0900

처음 든 생각

- 일단 백트래킹이고 (내가 더럽게 못하는 유형)

- n-queens 문제랑 비슷한데 대각선만 빠진 형태네

- 각 열에 대해서 하나씩 선택해가면서 모든 값을 비교해봐야겠다.

def search(i, s):
    global result
    if s > result:
        return
    elif i == N:
        result = min(result,s)
    else:
        for j in range(N):
            if col[j] == 0:
            	// 열 방문 찍고
                col[j] = 1
                // 그 다음 행으로 넘어가서 탐색
                search(i+1, s+a[i][j])
                // 다시 복귀 -> 백트래킹
                col[j] = 0


T = int(input())
for test_case in range(1, T + 1):
    N = int(input())
    a = []
    for _ in range(N):
        a.append(list(map(int, input().split())))
    result = 1000
    // 방문 여부 체크하는 리스트
    col = [0] * N   
    search(0,0)
    print(f"#{test_case} {result}")

방문 여부에 따라서 이미 방문한 열은 제외하고 탐색을 하는 방식이다.

일단 백트래킹에 대해서 아직 내가 구현능력이 좀 많이 부족하다고 느꼈던 문제였다. (실제로 정답률 처음에 50%)

백트래킹 다시 공부해야겠다.

끄적여보는 2023년 회고

공대생철이 — Mon, 8 Jan 2024 11:33:25 +0900

2023년도 끝났다. 2024년이 시작된지 일주일이 넘었지만 아직도 사람들을 만나면 "새해복 많이 받으세요"를 하기 때문에 뒷북까지는 아니라고 생각하는 회고를 작성해보려 한다.

~~한 번도 봐본 적 없는 원펀맨 ost를 들으면서 회고록을 끄적여본다.~~

1월

플러터에 대해서 갑자기 관심이 솟구쳤었다. 노마드 코더의 플러터 강의를 듣고 앱 개발 생각보다 할만하네? 라고 생각하여 실제 나만의 앱을 출시하기로 결심했었다. 강의에서는 웹툰 앱을 만들어보는 것이였는데 나는 간단한 뽀모도로 타이머 앱을 기획하고 개발하기로 했다.

생애 첫 앱 개발 기록 - Pomodoro 앱 기획

저번주부터 다트와 플러터를 시작해보면서 정말 재밌었다. 안드로이드 에뮬레이터 띄우는 것도 신기하고 구현하는 난이도도 높지 않아 자신감이 뿜뿜 올라왔다. 그래서 실제 앱을 플레이 스토

selfdevelopcampus.tistory.com

생애 첫 앱 개발 기록 - Pomodoro 앱 개발 (1)

저번에 했던 기획안에 맞추어 대강 화면을 어떻게 구성할지 손으로 그렸다. 피그마 같은 걸 쓰면 더 기깔나긴 하겠지만 당장 앱 만드는 게 우선이라 피그마를 배워서 쓰기보다는 일단 손으로 그

selfdevelopcampus.tistory.com

생애 첫 앱 개발 기록 - Pomodoro 앱 개발 (2)

https://selfdevelopcampus.tistory.com/entry/%EC%83%9D%EC%95%A0-%EC%B2%AB-%EC%95%B1-%EA%B0%9C%EB%B0%9C-%EA%B8%B0%EB%A1%9D-Pomodoro-%EC%95%B1-%EA%B0%9C%EB%B0%9C-1 생애 첫 앱 개발 기록 - Pomodoro 앱 개발 (1) 저번에 했던 기획안에 맞추어

selfdevelopcampus.tistory.com

당시에 개발 블로그도 시작한 지 얼마 안 된 시점이였는데 개발 기록을 남겨볼려고 했으나 중간에 무슨 이유인지는 모르겠으나 기록이 끊겼다. 역시 인간의 게으름은 정말 거스르기 어려운 것 같다. 그래도 기록은 중간에 끊겼으나 결과물을 만들어서 세상에 공개했다.

PPocus - 집중 타이머 - Google Play 앱

집중과 휴식을 한 번에 해결해야 합니다. (광고 없음)

play.google.com

참으로 조잡하지만 어쨌든 결과물은 나왔고 다운로드도 누가 했는지는 모르겠지만 5회 이상했다. 내가 테스트로 갤럭시에 설치해본 것 말고 누군가 또 다운로드를 해봤다는 것과 플레이스토어에 내 이름이 박혀있는 앱이 있다는 게 정말 신기했다.

이렇게 한 달간 플러터랑 같이 놀면서 시간을 보냈다.

2월

2월 내 생일 야호. 생일날 여자친구와 함께 부산여행을 했고 회 먹고 케익 먹고 와인 마시고 야무지게 놀았다.

이 기간 동안에는 작년 하반기에 같이 스타트업에서 일했던 백엔드 개발자 분과 같이 토이 프로젝트를 기획했는데 그 분도 다시 취업 준비하고 나도 개강 준비하느라고 흐지부지 됐다. 그 악명 높은 공대 3학년 1학기에 접어들어 걱정이 되게 많았던 것 같다. 반도체 과목을 어쩔 수 없이 들어야되는데 어떤 교수님 수업을 들어야 할까, 또 다른 전공 과목은 어떤 걸 수강하지 이런 고민이 좀 많았던 것 같다. 한마디로 개발은 안하고 걱정만 오지게 했다. 앞으로 다시는 이러지 말자. 걱정해봤자 해결되는 것 없다.

3월

개강을 했다. 2월 중에 동아리를 두 개 지원했다. 고려대 멋사랑 고려대학교 중앙 컴퓨터 동아리 KUCC에 지원했다. 멋사는 떨어졌고 KUCC는 붙어서 KUCC의 신입 부원으로 활동하게 되었다. 쿠씨씨에서 신입 부원이었지만 이전에 프론트엔드 개발자로 스타트업에서 일해본 경험, 해커톤 출전 경험 등을 살려 프론트엔드 세션을 열어보기로 했다. 8주 동안 내가 커리큘럼을 기획해서 부원들의 수강신청을 받아 가르치는 형식이다. 신입부원이기에 더 열심히 해야겠다는 패기도 조금 있었고 내 개인적으로도 부원들에게 많은 것들을 알려주고 싶은 욕심도 있어서 도서관에서 자바스크립트나 리액트 책도 대출해가면서 세션을 준비했다.

그리고 생활비 + 데이트 비용을 벌기 위해 과외 3개와 대치동 조교도 병행했다. 솔직히 이건 좀 투머치였다는 생각이 든다. 김과외에 이전에 했던 나의 대치동 조교와 과외 경력을 적어서 올렸더니 문의가 꽤나 많이 왔고 이전에 학원에서 가르쳤던 학생이 개인적으로 과외를 요청하기도 했고 친구 통해서 과외를 받기도 했다. 거기에 원래 하던 대치동 조교까지 사실 지금 보니 진짜 돈에 미친X이었던 것 같다. 수입은 풍족했으나 성적은 나락갈 수 밖에 없는 일정이었다. 지금은 모두 정리하고 과외만 2개하고 있다.

4월

동아리 활동도 시험기간이라 잠시 중단되었고 과외만 병행하며 하루하루를 보냈다. 이 때는 전공공부라는 명목하에 개발도 잠깐 멈췄지만 그건 그냥 핑계였다. 회로, 반도체 관련 과목이 많았었는데 하기 싫다는 나의 마음을 이겨내기에는 나의 성실함은 너무나도 약했다. 결국 중간고사 점수는 나락갔고 그래도 개발 관련 과목인 컴퓨터구조 과목도 공부도 제대로 안 했다. 한 마디로 총체적 난국.

요건 중간 끝나고 동아리원들이랑 채널톡 탐방 다녀온 사진

5월

중간이 끝나고 세션도 다시 재개되고 이 때 동아리 내 새로운 프로젝트에 참여하기도 했다. 이 달의 가장 빅 이벤트는 아무래도 SKYCC 해커톤 참여와 입실렌티이지 않았나 싶다.

SKYCC는 서울대학교, 고려대학교, 연세대학교 학생들이 모여 역삼 AWS에서 진행했던 연합 해커톤이다. 엄청난 뷰의 사옥에서 능력있는 사람들과 개발을 하면서 내가 진심으로 개발자가 되고 싶어한다는 것을 한 번 더 깨달았던 대회였다. 아쉽게 입상은 못했지만 팀원들과 협업하는 과정 자체가 엄청 재밌었고 내가 속한 동아리의 사람들이 대상, 금상을 수상하는 것을 보고 정말 능력자들이 많고 나는 아직 갈 길이 멀었구나 의지를 다졌던 것 같다.

마지막이 될 수도 있는 입실렌티...올해 4학년이 되면서 학교에서 보내는 마지막 년도가 될 것 같은데 1학기에 졸업논문을 쓰게 되어 입실렌티에 참여할 수 있을지 없을지 모르겠다. 그래도 올해로 6년째 같이 몰려다니는 동기들과 함께 또 한 편의 추억을 쌓아서 한 편으로는 다행으로 생각된다.

6월

5월 말의 입실이 끝났으니 이제 기말고사다. 사실 중간고사 상황을 고려하면 성적에 희망이 없었다는 것을 알았다. 보통은 이러면 '만회하기 위해 열심히 해야지' 라고 생각하고 더 열심히 할 생각하지만 나는 너무나도 약한 존재였다. 그냥 "시험 한 번 봐보자" 수준의 마인드로 공부를 했다. 이딴 마인드로 공부를 하니 당연히 좋은 성적이 나올리 만무하다. 모든 성적을 공개할 수는 없지만 C+가 3개인 것 정도로 얼마나 공부를 대충했는지 알 수 있다.

7월

1학기가 끝나고 반도체 관련 공부를 사실상 접기로 마음을 먹었고 개발 쪽 공부에 전념하기로 했다. 2024년에 본격적인 취준에 들어가기 때문에 자료구조와 알고리즘을 다시 공부하기로 했고 코딩테스트용 파이썬도 공부하고 자바스크립트에 대한 기초도 다시 다지고 노드도 한 번 다뤄보기로 결심했다. 자료구조와 알고리즘, 노드 강의를 유데미로 신청했고 자바스크립트에 대한 기초는 <모던 자바스크립트 딥 다이브> 책을 통해 공부하기로 했다. 파이썬은 <점프 투 파이썬> 책을 택했다. 이 중에서 끝까지 수행한 건 파이썬 책을 완독 뿐이다.

목표로 했던 4가지 항목 이외에 자꾸 다른 거에 눈길이 가기 시작했고 유튜브에서 html,css,js를 활용해서 소소한 기능들을 만들어보는 걸 따라쳐보고 리액트로 혼자 블로그 만들어보려고 하고 별의별 짓을 다했다. 자료구조와 알고리즘 강의는 80% 정도 들었고 딥 다이브 책과 노드는 사실상 다시 시작하는 게 나을 정도로 성취도가 처참했다.

여자친구와의 첫 해외여행(일본) 은 잊지 못할 추억이다.

저 참치는 진짜 개맛있었다. 또 먹으러 일본 가야지.

8월

동아리 활동한지 한 학기 만에 부회장이 되었다. 운영진 MT, 50주년 동문회 기획, 신입 회원 리크루팅 등으로 할 일이 갑자기 많아졌다. 거기에 학생들 여름방학으로 잠깐 쉬었던 과외를 재개하면서 개발 공부에 많이 소홀해졌다. 아주 깨작되는 수준으로만 해서 개발을 했다고 말하기도 좀 그렇다.

50주년 행사

9월

다시 2학기가 시작되었다. 1학기 때 거의 1학년 급 성적을 받아서 2학기는 절치부심하고 전공학점 챙기고 동아리 세션 활동 열심히 해보자고 다짐했다. 물리적 지식을 다루는 과목이 한과목 뿐이어서 수강신청은 나름 만족했다. 고연전 뒤풀이도 하고 KUCC 전체 MT 기획도 하고 재미나게 놀고 온 학기 초였다.

이 달 말에 재밌는 오퍼를 하나 받았다. 나의 SKYCC 후기를 보고 초기 스타트업 팀에서 합류 제의를 받았다. 부동산 관련 플랫폼을 기획 중인 스타트업인데 아이템이 꽤나 재밌었고 마침 진행중인 개발 프로젝트도 없었어서 참여하기로 했다. 9월 말부터 본격적인 개발을 시작했고 개발자가 프론트인 나 한 명뿐이었기에 11월까지 목업을 완성하는 것을 목표로 했다.

10월

동아리에서 프론트엔드 세션 3주차까지 진행한 후 중간고사 휴식기간을 맞이했다. 이번 중간고사는 저번 학기의 실수를 반복하지 않기 위해 중간고사 공부를 2~3주 전부터 하기로 계획했고 성적도 나름 괜찮았다. 확실히 하면 되는 것 같다는 느낌을 받았다.

이건 KUCC 2학기 운영진들끼리 10월 초에 찍었던 단체사진

다들 너무 고생 많았습니다ㅠ

11월

2023년 중 가장 바빴던 한 달이었다. 3-2였기 때문에 2024년 졸업 예정자를 요구하는 대부분의 인턴이나 신입 채용에는 지원 자체가 아예 불가했었는데 25년 2월 졸업 예정자도 포함되어있는 인턴이 떴었다. LG CNS 인턴이 떠서 곧바로 서류 작성을 하고 코딩테스트 준비를 했다. 결과는 불합격.

사실 코테는 2024년의 내가 본격적으로 준비해야되는 거라고 생각해서 별 생각없이 있다가 갑자기 봐야되는 상황이 펼쳐져서 서류가 열린 날부터 2주 동안 벼락치기를 했다. 세션에서 다루던 자바스크립트를 지원하지 않았기에 그나마 경험이 있는 파이썬으로 응시해야했고 어디서부터 공부해야할지 몰라서 학교 수업도 안 듣고 유튜브의 동빈나 님의 강의를 하루에 2,3개씩 보면서 프로그래머스에서 문제풀이를 했다. 2주 동안 코테 노베가 공부해서 대기업의 코테를 패스한다는 것 자체가 사실 말이 안 된다. 그래도 2주동안의 공부로 3문제 중 2문제를 풀어서 제출했다는 것에 희망을 봤던 시험이었다. 또한 대기업의 서류도 처음으로 통과하면서 취준의 희망을 갖게 되었다.

금토에 걸쳐 진행되는 1박2일 해커톤에도 참여를 했었다. 프론트엔드 개발자로 참여했고 4명이 1조로 참여했다. 기획을 대회가 시작되기 전에 거의 다 끝내놨었기에 우리 조는 대회 날 개발에만 몰두하기로 결정했다. 하지만...

내가 망쳤다...

나랑 백엔드 팀원이 실수를 좀 했다. 기획도 괜찮았고 개발 상황도 순조로웠는데 마지막 API 연결 과정에서 계속 안되는 것이었다. 이 해커톤의 중요 포인트는 완성도였기 때문에 이걸 완성시키지 못하면 시상은 당연히 꿈도 꿀 수 없었다. 시간에 쫓겨 이리저리 막 해봤는데 계속 안돼서 한 개의 (좀 많이 중요한) 페이지를 완성시키지 못한 상태로 제출했다. 나중에 살펴보니 API 자체에도 에러가 조금 있었고 나도 헤더를 잘못 설정했었다. 나의 실수로 인해 완성되지 못했다는 사실 때문에 큰 아쉬움이 남았던 대회였다. 그럼에도 같이 1박2일 동안 밤샘 코딩하면서 팀원들과 협업하고 멘토님들의 조언도 들을 수 있었던 소중한 시간이고 경험이었다.

그리고 코테를 한 번 더 봤다...

카카오의 대규모 인턴 공고가 떠서 바로 지원했다. 카카오의 경우 서류와 코딩테스트를 함께 보는 것이 1차였기 때문에 모든 사람들에게 코테 기회가 주어진다. 이전의 벼락치기 했던 것의 기억을 살려서 bfs, dfs 쪽 다시 살펴보고 구현 관련 문제들을 프로그래머스에서 계속 풀었다. 결과는 역시나 탈락. 사실 기대도 안하긴 했다. 전체 5문제 중에 2문제만 풀었기 때문이다. 오히려 만족스러웠다. 공부한 dfs를 실제로 시험장에서 적용시켜서 풀었기 때문이다. 나머지 3문제는 애초에 아이디어를 떠올리지 못했고 이건 순전히 나의 코테 실력부족이었기 때문에 아쉬움보다는 오히려 더 열심히 공부해야겠다는 다짐으로 남았다.

이렇게 1번의 해커톤과 2번의 코테로 정신없이 지나간 한달이었다. 그 와중에 스타트업의 MVP 개발도 매일매일 조금이라도 했으니 진짜 정신없이 지나간 하루였다. 채용 프로세스를 직접 경험해보면서 많은 것을 배웠던 한 달이었다.

요건 11월에 마지막 세션 끝나고 한 학기 동안 함께 고생한 세션원들 회식

부족한 세션장 끝까지 잘 따라와주고 회식 다 참석해줘서 고마원 세션원들

12월

이제 기말고사가 다가왔고 2023년도 끝이 보인다. 학교 공부는 학교 공부고 재미난 행사가 있어서 다녀왔다.

강남역에서 열린 삼성 개발자 컨퍼런스에 다녀왔다. 삼성전자라는 거대 조직의 개발 문화나 개발자분들을 보면서 '나는 정말 하염없이 작은 돼지감자에 불과하구나...'를 한 번 더 느꼈다. 배운 점도 정말 많았고 삼성전자라는 기업에 들어가고 싶다는 생각도 들었다. 그래서 삼성 채용 프로세스를 찾아봤더니 일단 영어성적이 필요해서 바로 오픽을 신청했다. 기말 끝나고 바로 볼 수 있게 신청했고 결과는 뒤에서 공개하겠다.

2학기 기말고사의 결과는 그다지 좋지 못했다. 일단 객관적으로 내가 봐도 공부량이 중간고사보다 적었고 흥미에 따른 공부 의지 편차가 너무나 극심했다. 특히 데이터 과학 과목은 해도해도 이해가 안되니깐 자연스럽게 흥미도 떨어지고 손에서 멀어지게 되었다. 그래도 결과적으로 받은 학점은 1학기 보다는 훨씬 나았다. 이제 전공필수는 다 채웠고 4학년 과목만 몇 개 들으면 사실상 졸업이다.

기말 시험 성적도 다 받았고 신청했던 오픽을 보러 갔다. 시험 유형은 시험 전전날 쯤에 처음 봤고 생각보다 무난할 것 같았다.

다행히 AL을 받았다. 2년동안 유효기간이니깐 2024년 취준할 때 유용하게 써먹을 수 있을 것 같다.

2023년을 돌아보니 뭔가 바쁘게 산 것 같으면서도 남는 게 뭐였을까 고민하게 되는 한 해였다. KUCC에 들어와서 개발도 많이 했지만 사실상 부원들과 프론트엔드 지식을 공유하는 것에 초점을 두었기에 나의 설명방식이나 커리큘럼 기획 등에 힘이 더 실어진 것 같다.

2023년은 나의 개발적 지식을 더 깊게 공부해보기보다는 해커톤과 스타트업을 통한 협업 경험 및 기존에 공부했던 기술 활용 경험에 초점이 맞춰져 있었다. 또한 과외도 1년 내내 했으니 남에게 지식을 전달하는 교육 활동에 초점을 많이 두었던 것 같다. 내가 가지고 있는 지식을 전달하는 과정에서 단어나 비유 선택 등 언어적 스킬이 많이 늘었다고 생각된다.

여기까지 의식의 흐름과 같은 회고였고 KPT 회고를 통해서 항목별로 좀 정리를 해보자.

Keep

해커톤 및 컨퍼런스 참여

방학 동안의 프로젝트 기획 및 실천

코딩테스트 공부

수학 과외

아침 독서 + 지하철 독서

헬스

Problem

전공공부 성취도(특히 CS 지식)

유튜브 시청

네이버 부동산 서핑

강의랑 개발 책 등 공부거리를 너무 많이 벌여놓음

Try

취업 준비에 대한 순차적 단계 밟아나가기

SWEA 강의 및 문제 풀이

코딩테스트 응시 기회가 있다면 주저하지 않고 나가기

코딩테스트 / 면접 스터디 참여 or 리드

부동산 사이트 차단 (크롬 익스텐션)

4학년 과목 잘 듣고 시험공부 좀 성실히 하자...

졸업을 앞둔 2024년도에 나에게 어떤 기회가 펼쳐질지는 모르겠지만 내가 얻고자 하는 결과에 대해 주저하지 말고 부딪히고 중간에 주저앉지 말자.

python 코딩테스트 - 프로그래머스 숫자의 표현

공대생철이 — Fri, 22 Dec 2023 17:13:07 +0900

출처 : 프로그래머스

처음 든 생각

- 자신은 디폴트로 무조건 가지고 있고 나머지 경우들을 탐색하면 된다.

- 반띵해서 완전탐색을 해줘야겠다.

나의 답

def solution(n):
    answer = 1
    for i in range(1,n//2+1):
        total = 0
        while total<n:
            total += i
            if total == n:
                answer +=1
                break
            i += 1
            
    return answer

정답의 초기값은 자기 자신을 무조건 포함하므로 1로 설정해준다.

그 다음 1부터 n//2 까지 반복문을 돌면서 연속된 숫자의 합을 계산한다. while 문으로 n보다 커질 때까지 더해준 후 내부에서 결과를 확인하는 로직을 구성한 후 목표값과 같은 경우 그게 해당하는 숫자로 시작하는 연속된 자연수 합의 조합의 유일한 경우의 수이므로 바로 while문을 탈출한다.

다른 사람의 답

# 문제가 개편되었습니다. 이로 인해 함수 구성이나 테스트케이스가 변경되어, 과거의 코드는 동작하지 않을 수 있습니다.
# 새로운 함수 구성을 적용하려면 [코드 초기화] 버튼을 누르세요. 단, [코드 초기화] 버튼을 누르면 작성 중인 코드는 사라집니다.
def expressions(num):
    answer = 0
    for i in range(1, num+1):
        summ = 0
        while (summ < num):
            summ += i
            i += 1
        if summ == num:
            answer += 1
    return answer


# 아래는 테스트로 출력해 보기 위한 코드입니다.
print(expressions(15));

똑같이 완전 탐색으로 풀었으나 범위가 1부터 num까지 모든 수를 가리킨다. 이후의 로직은 연속되게 숫자를 더하면서 num과 같은지 아닌지 확인하는 방식으로 내가 푼 방식과 똑같다.

python 코딩테스트 - 프로그래머스 다음 큰 숫자

공대생철이 — Tue, 5 Dec 2023 15:14:20 +0900

처음 든 생각

- 하나씩 키워가면서 일일이 탐색을 해야겠다

- 이진수로 바꾸는 것은 저번에 배운 bin 함수를 활용해서 해봐야지

나의 답

def solution(n):
    answer = 0
    bn = bin(n)
    cnt = bn[2:].count("1")
    while True:
        n+=1
        if bin(n)[2:].count("1") == cnt:
            return n

주어진 수가 가진 1의 개수를 cnt 변수에 담아놓고 반복문을 통해서 알맞은 수를 찾아가는 과정으로 구현한 것이다.

찾을 때까지 반복문을 돌게 하기 위하여 while True를 사용했고 찾으면 바로 리턴을 하면서 solution 함수를 끝내는 방식으로 구현하였다.

다른 사람들의 풀이도 변수명만 다를 뿐 사용한 함수도 똑같아서 따로 참고해볼 사항은 없었다.

python 코딩테스트 - 프로그래머스 이진 변환 반복하기

공대생철이 — Mon, 4 Dec 2023 17:26:22 +0900

처음 든 생각

- 문제에 나온 그대로 차근차근 단계를 밟아나가자

(1) 0 제거

(2) 남은 1의 개수만큼 이진수로 변환

(3) (1)~(2) 과정 반복

- 0을 제거할 때 하나씩 count하면 될 거고

- 이진수 변환하는 건 혹시 라이브러리나 내장함수가 있을까? -> 아니면 재귀로 해서 풀어야된다

나의 답

def solution(s):
    zeros = 0
    count = 0
    tmp = 0
    
    while len(s) > 1:
        for i in s:
            if i == "0":
                zeros+=1
            else:
                tmp += 1
        s = format(tmp,'b')
        tmp = 0
        count += 1
    
    return [count , zeros]

0의 개수, 이진변환 횟수, 1의 갯수를 담을 3개의 변수를 선언하였다.

반복문은 while로 구성했고 길이가 2 이상일 때는 무한 반복하도록 했다. 만약 길이가 1이라면 0 또는 1이기에 종료조건에 다다른 것이다.

문자열을 하나씩 탐색하며 0과 1의 개수를 세어주고 format을 활용하여 이진변환을 했다.

이 과정이 한 번 끝나면 count를 1 키워주고 다시 1의 개수는 초기화시켜준다.

format 파이썬 내장함수를 활용하여 진수 변환이 가능하다.

b = format(n,'b') #Binary format
o = format(n,'o') #Octal format
x = format(n,'x') #Hexadecimal format

format은 파이썬을 처음 공부할 때 문자열 내의 값 대입할 때 사용하는 것은 봤는데 진수 변환도 가능하다는 점은 이번에 처음 알게된 내용이다. 첫 번째 인자에 정수형 값, 두 번째 인자에 2진수, 8진수, 16진수를 가리키는 알파벳 1개 문자열을 대입하면 진수가 변환된다.

다른 사람의 답

def solution(s):
    a, b = 0, 0
    while s != '1':
        a += 1
        num = s.count('1')
        b += len(s) - num
        s = bin(num)[2:]
    return [a, b]

발상은 거의 같다.

반복문의 조건이 "1"이 아닌 것으로 조금 더 디테일하게 조건을 설정하였다.

1의 개수를 세는 방식도 for 문이 아니라 count 메서드를 통해 세었다.

여기서는 이진수 변환은 bin이라는 내장함수를 통해서 진행하였다.

>>> bin(10)
'0b1010'

bin 함수의 결과값은 0b를 포함한 문자열로 나오므로 인덱스 슬라이싱을 통해서 앞에 2개는 제거해주는 형태로 이진수 변환을 진행하였다.

format과 bin이라는 파이썬의 내장함수를 알게 되었다.

파이썬은 진짜 유용한 내장함수가 개많은 것 같다.

python 코딩테스트 - 프로그래머스 최솟값 만들기

공대생철이 — Mon, 4 Dec 2023 13:53:43 +0900

출처 : 프로그래머스

처음 든 생각

- 순차적으로 곱해주는데 곱하는 수들의 조합을 어떻게 해줘야될까

- 가장 큰 놈이랑 가장 작은 놈이랑 곱해주고 이런 식으로 큰 수 x 작은 수 조합으로 계속 곱해야겠네

나의 답

def solution(A,B):
    answer = 0
    A = sorted(A)
    B = sorted(B,reverse=True)
    for i in range(len(A)):
        answer += A[i] * B[i]

    return answer

하나의 배열은 내림차순, 다른 배열은 오름차순으로 정렬을 하였다.

그 다음 반복문을 돌면서 같은 인덱스를 참조하며 곱한 값을 더해준다.

그리디의 가장 일반적인 케이스라고 생각된다. 큰 수를 가장 적게 더해주는 방식으로 차근차근 나아가면 되는 방식으로 해결되는 문제였다.

다른 사람의 답

def getMinSum(A, B):
    return sum([a * b for a, b in zip(sorted(A), sorted(B, reverse=True))])

내가 푼 방식과 아이디어는 동일했으나 코드 구현을 한 줄로 완성시킬 수도 있었다.

길이가 같기 때문에 zip을 활용하면 순서대로 하나씩 묶인 튜플로 만든 다음 거기서 두 수의 곱을 리스트의 원소로 불러온 코드다.

그 다음 리스트의 sum으로 답을 낸 것이다.

길이가 같고 서로 연계된 작업을 진행할 때 zip을 쓸 수 있다는 점은 항상 염두에 둬야할 것 같다.

앞으로도 잘 떠올려보자.

React - 가로 스크롤바 간단하게 만들기 (feat. tailwindCSS)

공대생철이 — Mon, 4 Dec 2023 11:31:49 +0900

모바일에서 가로로 스크롤되는 메뉴 / 내비게이션 바는 흔히 볼 수 있다.

자주 보이는 컴포넌트이지만 구현은 전혀 어렵지 않다.

기본적인 논리는 이렇다.

- div라는 태그가 있는데 안에 내용물이 넘치는 상황

- 내용물이 overflow되면 가로로 스크롤 될 수 있게 설정을 해주면 된다

아래 예제는 tailwind를 사용하여 구성하였다.

<div className="whitespace-nowrap overflow-x-auto flex">
    {navItem.map((item) => {
          return (
    		// 내용물 알아서
          );
     })}
</div>

기본적으로 div는 block이기 때문에 width가 전체 가로 길이와 일치한다.

모바일 화면에서 가로길이를 넘어갔을 때 이를 화면 안으로 몰아서 넣으려고 하지 않게 해주기 위해 whitespace 속성을 사용한다.

왼쪽은 일반적인 div 태그 내에서 내용물이 넘칠 때의 상황이다.

굳이굳이 테두리 앞에 모든 걸 넣으려고 한다.

하지만 우리는 넘치게 둬야한다. 그래야 일자로 안에 content들이 나열되니깐.

whitespace : nowrap 속성으로 이를 적용시켜준다.

그 다음 넘치는 부분을 가릴지 스크롤하게 할지 등등의 속성을 결정지어줘야한다.

이는 overflow를 통해 가능하다.

우리는 가로 방향으로 스크롤이 되게 만들고 싶으니깐 overflow-x 를 사용했다.

세로 방향으로 스크롤하게 하고 싶으면 y축 방향으로 하면 된다.

그 다음 태그 안에 원하는 메뉴 / 내비게이션 아이템을 넣으면 된다.

예시로 메뉴 아이템을 몇 개 넣어서 구현해본 화면이다.

가로로 잘 넘어가고 있고 그 안에 아이템별 속성은 알아서 원하는대로 설정하면 된다.

LG CNS 2024 동계 DX Core 인턴 코딩테스트 후기

공대생철이 — Sun, 26 Nov 2023 17:00:06 +0900

아직 3학년 2학기라서 내년도 졸업 예정인 인턴 or 신입 채용 공고에 지원이 불가능한 걸로 생각하고 있던 와중 25년도 2월 졸업예정자도 지원 가능한 인턴이 열려서 지원하게 되었습니다.

LG CNS 2024 채용연계형 동계 인턴 포지션에 지원했고 이번 겨울방학 때 정말 좋은 경험이 될 것 같아서 바로 지원했습니다. 지원 가능하다는 사실을 알자마자 바로 자소서 쓰기에 돌입했고 그 이후에 볼 코딩 테스트 준비도 시작했습니다.

사실 코테는 올해 치를 계획이 없어서 아예 준비를 못하고 있었는데 갑자기 시작하게 되었습니다...ㅋㅋㅋㅋ

전공 수업도 거의 다 안 가고 학교 도서관에서 유튜브 코테 강의 보면서 벼락치기하고 그런 나날을 보내던 와중에...

서류를 합격했다는 메일을 받았고 코테 일정도 받게 되었습니다!

LG CNS 지원서 자체가 글자 제한수도 빡빡하고 질문도 많지 않아서 어떻게 간결하게 내용을 녹여낼까 고민을 엄청 많이 했는데 다행히 서류 합격이 되었습니다. 대기업 서류 합격은 처음이라 엄청 신났었네요ㅎㅎ

서류 합격 메일을 받고 한 3일? 뒤가 코테여서 마지막까지 프로그래머스로 벼락치기하면서 공부를 했었습니다.

그렇게 토요일이 되었고 3문제가 출제됐습니다.

3문제 전부 다 구현 문제였는데 1,2번은 비교적 간단하게 풀 수 있는 문제였고 3번이 어려운 문제였습니다.(제 기준)

약간 문제를 보자마자 어 이거 어떻게 해야되지...? 아예 감이 안 오는 느낌?

LG CNS 코테는 예시를 통해서만 확인이 가능하고 "제출하고 채점하기" 기능처럼 테스트 케이스 2,30개에 대한 통과여부를 가르쳐주지 않아서 제가 테스트 케이스 어떤 것들이 나올 수 있을지 다 때려박아보면서 검토하고 코드 수정하고 했습니다.

그렇게 1,2번은 완벽하게 풀었다고 생각했고 3번은 아예 문제 감을 못 잡아서 못 풀고 마무리했습니다.

그리고 또 한 3일 뒤에 메일이 띠링하고 왔는데...!

아쉽게도 떨어졌습니다ㅠㅠ

솔직히 코테 노베에서 열흘 동안 벼락치기해서 붙는다는 것 자체가 너무 말이 안 되는 스토리이기도 했고

제가 머리가 엄청 좋은 편도 아니라 노력이 많이 필요한 스타일인데 붙기를 바란 것 자체가 사실 욕심이지 않았나...

그래도 공부하면서 파이썬 공부할 수 있는 기회도 얻어서 너무 재밌었고

오랜만에 수능 수학 푸는 것처럼 문제 푸는 희열도 느낄 수 있어서 즐거웠던 시간이었습니다.

3문제 중 2문제 풀어서 솔직히 혹시...?하는 마음도 있긴 했으나 떨어져서 아쉽긴 하네요ㅠㅠ

하지만 공부하고 바로 시험도 보면서 문제 풀리는 광경을 보니 스스로 가능성을 확인하기도 한 시간이었어서 앞으로 코테를 더 열심히 공부할 의지가 불타오르는 계기가 된 것 같습니다.

어제 카카오 코테도 보고 왔는데 그 후기도 빠르게 적어보도록 하겠습니다.

python 코딩테스트 - 2022 카카오 인턴 기출 2번

공대생철이 — Fri, 24 Nov 2023 23:31:47 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/118667

프로그래머스

programmers.co.kr

처음 든 생각

- 대놓고 큐 쓰라고 줬고 popleft랑 append를 쓰면 되겠다. 이 함수들은 시간복잡도 O(1)이니깐

- 서로 대소 비교를 하면서 큰 놈에서 작은 놈으로 하나씩 옮겨가주면서 같은지 아닌지 계속 확인하면 되겠다.

나의 답

from collections import deque
def solution(queue1, queue2):
    q1 = deque(queue1)
    q2 = deque(queue2)
    s1 = sum(q1)
    s2 = sum(q2)
    if (s1 + s2) % 2 == 1:
        return -1
    
    for i in range(4 * len(q1)):    
        if s1 == s2:
            return i
        elif s1 > s2:
            tmp = q1.popleft()
            s1 -= tmp
            q2.append(tmp)
            s2 += tmp
        else:
            tmp = q2.popleft()
            s2 -= tmp
            q1.append(tmp)
            s1 += tmp
          
    return -1

먼저 deque을 불러와서 큐로 만들어준 다음, 처음 합을 구해준다.

만약 두 큐의 합이 홀수일 경우 반으로 나누면 소수가 되므로 절대 합을 같게 할 수 없어 -1을 리턴한다.

그 다음 반복문이 핵심인데 (여기서 틀렸었다)

전체 길이의 하나의 큐의 길이의 4배 만큼 반복문을 설정한다.

이렇게 하는 이유는 먼저 시간 복잡도를 O(n^2)을 넘어가지 않게 하기 위함이고 그렇다면 반복문의 최대횟수는 큐의 값들이 서로의 큐를 방문하고 다시 돌아오는 데까지 4n번이기 때문이다. 아래 그림을 보면 이해가 빠르다.

그 다음 반복문을 range로 돌게 된다. 원소가 pop, append가 되면 i는 자동으로 1씩 증가하기 때문에 굳이 다른 변수를 선언하지 않고 바로 처리가 가능하고 처음에 같은 답이 나와도 0으로 바로 처리가 가능할 수 있게 range를 사용하였다.

반복문을 돌면서 대소 비교를 하고 큰 놈은 popleft 후 합에서 그 크기만큼 감소하고 작은 놈은 append 하고 그 크기만큼 증가시키면 된다.

반복문을 다 돌았는데 답이 없으면 -1을 리턴한다.

이 문제는 단순한 큐 문제인 것 같았지만 의외의 난관 + 새로 배울 점이 많았던 문제였다.

1. sum의 시간 복잡도는 O(n)이다.

처음에 이 문제를 풀 때 반복문 안에서 합을 계속해서 또 계산하는 과정을 위해 sum을 활용했다. 하지만 시간 초과가 났었는데 그 이유는 알고보면 간단했다. 반복문을 도는데 그 안에서 O(n)인 함수가 또 실행되니 결국 O(n^2)형태였던 것이다. 문제의 조건에 나와있다시피 큐의 최대 길이는 300,000인데 O(n^2)가 되게 되면 10억회의 연산을 하므로 시간초과가 날 수 밖에 없었다. 원소의 개수가 크게 변동이 없을 때는 처음 합에서 단순 연산을 통해서 값을 계산해주는 것이 시간 복잡도 측면에서 훨씬 이득이다.

2. 반복문을 쓸 때 최대 범위를 알면 for문을 쓰자

이 문제를 처음 풀 때 while로 반복문을 구성했다. 전체의 절반 만큼 해당하는 합을 될 때까지 while문을 도는 방식이었다. 물론 이 방식이 틀린 건 아니지만 시간 복잡도에서 확신을 가지기 어려웠다. 최대 동작 횟수를 위와 같이 파악할 수 있는 문제에서는 반복문의 제약조건을 확실하게 걸어야 시간 복잡도가 훨씬 잘 보이고 더 나아가 for 문을 사용하기 때문에 인덱스나 값을 활용하기에 훨씬 용이했다.

python 코딩 테스트 - 카카오 2022 인턴 기출 1번

공대생철이 — Thu, 23 Nov 2023 17:04:00 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/118666

프로그래머스

programmers.co.kr

문제가 매우 길어 링크를 첨부했다.

처음 든 생각

- 성격 유형 점수랑 성격 유형이 4가지로 고정이니깐 같은 인덱스로 조작해야겠다.

- 앞에 오는 게 뭔지 관리를 해줘야겠다.

- 각 지표별 성격유형을 점수를 매긴 후 정렬을 해주고 합쳐줘야겠다.

- 같은 점수를 나타내더라도 알파벳 순서로 정렬 되므로 굳이 추가적인 작업은 필요 없겠다.

나의 답

def solution(survey, choices):
    answer = ''
    a = ["RT","TR","CF","FC","JM","MJ","AN","NA"]
    arr = [{"R":0, "T":0},{"C":0,"F":0},{"J":0,"M":0},{"A":0,"N":0}]
    
    for i in range(len(survey)):
        arrIdx =  a.index(survey[i]) // 2
        if choices[i] < 4:
            arr[arrIdx][survey[i][0]] += abs(choices[i]-4)
        elif choices[i] > 4:
            arr[arrIdx][survey[i][1]] += abs(choices[i]-4)
    tmp = []
    for j in arr:
        tmp.append(sorted(j.items(),key = lambda x:x[1], reverse=True))
    
    for k in tmp:
        answer+=k[0][0]
    
    return answer

가능한 문제 유형들과 각 지표별 성격 유형을 미리 선언해주었다.

survey를 반복문을 돌면서 해당하는 지표에 접근해서 점수를 수정하면 된다.

그렇게 모든 점수를 입력하면 점수 기준 내림차순으로 정렬을 해주고 앞에 있는 애들을 하나씩 답에 갖다붙이면 끝이다.

다른 풀이

def solution(survey, choices):
    result = {"R": 0, "T": 0, "C": 0, "F": 0, "J": 0, "M": 0, "A": 0, "N": 0}
    n = len(choices)
    for s, c in zip(survey, choices):
        c = c - 4
        if c < 0:
            result[s[0]] -= c
        elif c > 0:
            result[s[1]] += c
    answer = ""

    p_types = [("R", "T"), ("C", "F"), ("J", "M"), ("A", "N")]
    for type1, type2 in p_types:
        if result[type1] >= result[type2]:
            answer += type1
        else:
            answer += type2
    return answer

survey, choices 길이가 고정이므로 zip을 통해 튜플로 묶어준 후 반복문을 돌면서 해당하는 점수를 매겨주는 방식이다.

그 다음 지표별 성격 유형을 알파벳 순으로 미리 선언해준 후 그에 맞춰 정답에 추가하면 된다.

구현하는 방식은 달랐으나 큰 맥락을 비슷햇다.

- 점수 - 4가 양수인지 아닌지

- 알파벳 순으로 미리 해놓으면 점수가 같아도 상관 없다는 점

1번 문제에 레벨 1 문제라 실제 시험에서도 편안하게 머리 푸는 느낌으로 맞추고 넘어가야할 듯하다.

python 코딩테스트 - 프로그래머스 구명보트

공대생철이 — Fri, 17 Nov 2023 14:59:34 +0900

출처 : 프로그래머스

처음 든 생각

- 정렬을 한 뒤에 큐나 스택 자료구조를 사용하면 되겠다.

자료구조 선택 이후 그 다음 계산로직만 구현하면 된다고 판단해서 바로 코드를 작성했다.

나의 답

from collections import deque

def solution(people, limit):
    answer = 0
    q= deque(sorted(people))
    
    while q:
        if len(q) == 1:
            q.popleft()
            answer += 1
            break
        if q[0] + q[-1] > limit:
            q.pop()
            answer += 1
        else:
            q.popleft()
            q.pop()
            answer += 1

    return answer

큐 자료구조를 사용했고 길이가 1인 특수 케이스에 대해서 따로 처리를 한 후 최솟값과 최댓값을 짝을 지어 limit와 비교하도록 하였다.

로직 자체는 그렇게 어렵지 않으나 처음에 스택으로 풀었을 때 어마어마한 뻘짓을 했다.

구명 보트에 2명만 탑승 가능하다는 사실을 놓치고 limit에 될 때까지 더해주는 방식으로 코드를 작성했었다.

제발 문제를 잘 읽자.

python 코딩테스트 - 프로그래머스 전력망을 둘로 나누기

공대생철이 — Thu, 16 Nov 2023 21:41:56 +0900

출처 : 프로그래머스

처음 든 생각

- 이건 무조건 DFS를 써야된다.

- 하나가 끊어진 모든 경우를 탐색하면서 DFS를 해서 차이를 구하면 되겠다.

나의 답

def solution(n, wires):
    answer = n
    
    def dfs(g,v,s):
        v[s] = True
        for k in g[s]:
            if v[k] == False:
                dfs(g,v,k)
            
    for i in range(len(wires)):
        a,b = wires[i]
        wires[i] = [0,0]
        g = [[] for _ in range(n+1)]
        v = [False for _ in range(n+1)]
        for j in range(n-1):
            x,y = wires[j]
            if x > 0:
                if y not in g[x]:
                    g[x].append(y)
                if x not in g[y]:
                    g[y].append(x)
        wires[i] = [a,b]
        
        for i in range(n+1):
            if g[i]:
                dfs(g,v,i)
                break
                
        count = 0
        for i in v:
            if i == True:
                count += 1
        count2 = n - count
        diff = max(count-count2, count2-count)
        
        answer = min(answer,diff)
            
    return answer

DFS의 코드를 작성했지만 먼저 흐름을 파악하기 위해 아래의 반복문을 먼저 작성했다.

wires에서 하나씩 없애주는 과정을 하기 위한 반복문이다.

기존의 값을 임시로 저장하고 remove 하는 방식이 아니라 0,0으로 대치하는 방식을 택했다.

다음으로, 해당 문제는 각 노드별 연결 포인트를 그래프로 표시해주는 것이 아니기에 DFS를 하기 위해서 스스로 그래프를 구현해야했다.

g의 빈 배열을 노드 개수+1 만큼 펼쳤다. (인덱스가 아니라 노드 번호에 맞춰서 바로 참조할 수 있도록)

그 다음 wires를 다시 반복문으로 돌면서 연결된 노드 들을 g에 추가해준다. 0인 부분은 끊어진 연결이기 때문에 그 부분만 조건으로 걸어주면 된다. 그렇게 하나의 연결이 끊긴 그래프가 완성 되었으므로 wires는 다시 원상복구를 시켜준다.

이제 이 그래프를 가지고 DFS를 할 것이다.

DFS는 그래프, 방문 배열, 시작 노드 3개의 인자를 받게 한다.

그래프에 만약 연결된 노드가 없으면 DFS를 시작할 수 없기 때문에 그래프에서 하나라도 연결된 노드가 있다는 것을 확인하고 DFS를 할 수 있도록 구성했다.

DFS의 순서는 시작 노드를 방문하고 그 다음 그래프에서 그 노드에 연결된 노드들을 반복문으로 돌면서 재귀적으로 동작하는 것이다.

-> 이건 매우매우 중요하므로 암기해놓자.

DFS를 하게 되면 연결되어있는 하나의 덩어리가 구성하고 있는 노드들에 대해 v리스트에 True로 찍혀있을 것이다. 그래서 True인 노드들을 세주면 하나의 덩어리가 가지고 있는 노드 수가 되고 다른 덩어리는 전체에서 빼주면 되므로 (무조건 2 덩어리) 2개의 차이의 절댓값을 구하여 answer에 할당한다.

이 문제에서 조금 까다로웠던 점은 그래프를 직접 만들면서 인덱싱을 실수한 것, 그리고 DFS 함수에 인자를 어떤 것으로 줘야 하는지 고민이 되었고 반복문에 재귀까지 시간 복잡도가 조금 빡세보이지만 최대한 병렬적으로 처리하여 시간복잡도를 낮추어 테스트 케이스를 한 번에 통과할 수 있었다.

python 코딩테스트 - 프로그래머스 할인 행사

공대생철이 — Tue, 14 Nov 2023 21:58:48 +0900

출처 : 프로그래머스

처음 든 생각

- 먼저 want와 number를 통해서 원하는 품목과 개수를 딕셔너리를 만들고 나중에 비교해야겠다.

- discount 리스트를 한 칸씩 옮겨가면서 슬라이싱을 한다. 크기가 원하는 총 개수랑 똑같으니깐 sliding window라고 해도 되네.

- window 내에서 품목, 개수 딕셔너리를 만들고 원하는 품목 딕셔너리랑 비교하면 되겠다.

나의 답

def solution(want, number, discount):
    answer=0
    obj = {}
    total = 0
    for i in range(len(want)):
        if want[i] not in obj:
            total += number[i]
            obj[want[i]] = number[i]
    tmp = {}
    for i in range(len(discount)-total+1):

        sliced = discount[i:i+total]
        
        for k in range(len(sliced)):
            if sliced[k] not in tmp:
                tmp[sliced[k]] = 1
            else:
                tmp[sliced[k]] += 1
        
        key_list = list(tmp.keys())
        count = 0
        for j in key_list:
            if j in obj:
                if tmp[j] == obj[j]:
                    count +=1
                if count == len(key_list):
                    answer += 1
            else:
                 continue    

        tmp = {}
            
    
    return answer

반복문을 통해서 원하는 품목의 딕셔너리를 만들어준다.

그 다음 임시 딕셔너리를 만들고 반복문을 돈다. 이 때 범위는 가장 최대로 오른쪽으로 슬라이딩 된 window의 시작 인덱스까지 돌아야한다.

그래서 슬라이싱을 한 다음 딕셔너리로 정리하고 key의 리스트 만들어준 후 obj, tmp 딕셔너리의 값을 비교해서 같은지 확인한다. 다 맞으면 answer에 1을 추가한다. 비교한 후 tmp 딕셔너리는 다시 초기화시켜준다.

만약에 맞는게 없으면 answer가 추가될 일이 없어 초기값 0으로 출력될 것이기에 마지막에 리턴하는데는 지장이 없다.

헷갈렸던 지점은

window를 어디까지 슬라이딩 시킬지

순간적으로 까먹은 딕셔너리에서 key 값들만 불러오는 문법 -> list(dict.keys()), list(dict.values()) 절대 까먹지 말자

정도 였던 것 같다.

for 문이 많이 등장하긴 했으나 따지고 보면 O(KN)이라 시간 복잡도는 O(N)이다. 그래서 실제로 완성했을 때 시간 초과도 없이 통과할 수 있었다.

python 코딩테스트 - 프로그래머스 행렬의 곱셈

공대생철이 — Tue, 14 Nov 2023 21:45:42 +0900

출처 : 프로그래머스

처음 든 생각

- 먼저 행렬 연산을 손으로 직접 써보자

- arr1에서 행을 선택한 후 arr2에서 열 별로 순차적으로 곱해서 더해주면 된다. (아래 그림과 같은 동작)

- arr1의 행 별 반복문(1), arr2의 열 별 반복문(2), 열 안에 행 별 반복문(3) 총 3단계의 반복문이 등장해야겠다.

나의 답

def solution(arr1, arr2):
    answer = []
    for i in range(len(arr1)):
        arr = []
        for j in range(len(arr2[0])):
            tmp = 0
            for k in range(len(arr2)):
                tmp += (arr1[i][k] *arr2[k][j])
            arr.append(tmp)
        answer.append(arr)
        arr=[]
    return answer

arr1의 행 별 반복문으로 크게 감싼 후 범위 지정 -> 반복문 (1)

연산 결과를 한 행 씩 출력해서 append를 해야하므로 빈 리스트 선언해준다.

arr2의 열 별 반복문 감싼 뒤 범위 지정 -> 반복문 (2)

곱셈 연산 결과값을 담기 위한 임시 변수 1개 선언

arr2의 열 안 에서 행 별 반복문 감싼 뒤 범위 지정 -> 반복문 (3)

곱한 값을 다 더해주어 행 별로 연산 마치고 정답 리스트에 추가

행렬 연산의 순서에 따라 반복문의 범위를 지정해주는 것이 굉장히 헷갈렸다. 실제로 처음 했을 때는 인덱스의 오류로 런타임 에러가 났었는데 반복문 (2)의 범위를 arr1[0]으로 실수했었다. 어떤 배열의 행인지 열인지 잘 확인하면서 순서대로 범위, 인덱싱을 잘하자.

python 코딩테스트 - 프로그래머스 네트워크

공대생철이 — Mon, 13 Nov 2023 17:10:00 +0900

출처 : 프로그래머스

처음 든 생각

- 하나를 시작해서 끝까지 어디까지 연결되어있는지 파악해야하므로 이건 DFS를 해야한다.

- DFS를 하는 방식을 다시 곱씹어보자.

- 연결되어있는 노드들이 제시된 리스트가 있고, visited 여부를 확인하는 리스트가 또 있어야한다. 그리고 dfs 함수를 선언한 뒤 노드에 연결된 모든 노드들에 대해 반복문을 돌고 조건에 따라 재귀를 구성한다.

나의 답

answer = 0
def solution(n, computers):
    global answer
    a=[]
    v = [0] * len(computers)
    def dfs(c):
        global answer
        if v[c] == 1:
            return
        v[c] = 1
        a.append(c)
        for n in range(len(computers[c])):
            if v[n] == 0 and computers[c][n]==1:
                dfs(n)
    
    for i in range(len(computers)):
        tmp = a[:]
        dfs(i)
        if a != tmp:
            answer += 1
    
    return answer

하나의 네트워크가 완성될 때마다 연결된 원소들을 넣어줄 리스트를 하나 선언해주었다.

그리고 방문 여부를 확인할 리스트도 선언해주었다. 0은 미방문, 1은 방문했다는 뜻

그 다음 이제 dfs를 돌게 되는데 만약 시작 노드를 이미 방문했다면 다른 네트워크에 포함되어있을테니 바로 함수를 빠져나온다.

방문하지 않은 경우 방문했다고 해주고 해당 원소를 a에 넣어준다.

c에 연결된 노드들을 반복문을 통해서 방문하지 않았다면 다시 dfs를 재귀로 돌아준다.

시작 노드들에 대해서 반복문을 돌고 네트워크가 추가되었는지 확인한 후 개수를 세주면 된다.

문제의 예시를 살짝만 전개해보면,

0번 노드에 대해 dfs를 돌게 되면 a = [0,1]이 될 것이다.

tmp는 dfs이전의 a이므로 []여서 네트워크가 추가됨을 확인할 수 있다.

1번 노드에 대해서 dfs를 돌게 되면 0번 노드를 탐색할 때 이미 방문했기 때문에 a는 변동이 없다.

2번 노드에 대해서 dfs를 돌게 되면 a = [0,1,2]가 되어 네트워크가 추가됨을 확인할 수 있다.

dfs가 어떤 흐름으로 동작하는지 배우기에 아주 좋은 문제였다.

연결 노드 확인, 방문 여부 확인, 다음 재귀적으로 동작하는 함수 구성 이렇게 3박자를 계속 연습해보면 좋을 것 같다.

이 문제에서 조금 어려움을 겪었던 부분은 마지막 네트워크 개수 세는 부분에서 비교를 해주는 부분이었다.

tmp = a
dfs(i)
if a!=tmp:
	answer+=1

dfs이전의 a값을 tmp에 저장해놓고 비교할려고 했더니 계속 tmp와 a가 같은 결과를 나타내었다. 결국 같은 메모리 주소를 참조하고 있는 것이기에 a의 리스트 내의 원소가 바뀌면 tmp도 같이 움직이는 걸 뒤늦게 깨달았다.

그래서 얕은 복사, 깊은 복사에 대해 검색을 좀 해보았고 위의 답안과 같이 얕은 복사를 해서 데이터는 같지만 주소값을 다르게 처리하여 비교할 수 있었다. 복사의 방법들에 대해서도 절대 까먹지 말고 잘 기억해두자.

python 코딩테스트 - 프로그래머스 카펫

공대생철이 — Sun, 12 Nov 2023 22:37:42 +0900

출처 : 프로그래머스

처음 든 생각

- 이건 수학적으로 접근하는 게 맞다

- 테두리 식과 내부의 타일 개수를 세서 가로 세로를 구하는 다항식을 세워서 연립해야겠다

나의 답

import math
def solution(brown, yellow):
    plus = (brown+4)/2
    multi = yellow - 4 + 2 * plus
    answer = []
    for i in range(math.floor(multi**(1/2))+1):
        if i * (plus - i) == multi:
            answer.append(i)
            answer.append(plus-i)
    answer.sort(reverse=True)
    return answer

brown을 통해서 가로 + 세로의 값을

yellow를 통해서 가로 * 세로의 값을 구한다.

그 다음 두 개의 식을 연립방정식으로 놓고 푸는 코드를 작성한 것이다.

곱의 값을 기준으로 제곱근 부근까지 반복문을 돌면서 실제 곱의 결과와 비교를 한다.

문자 2개, 식 2개인 연립 방정식의 해는 유일하므로 정답 리스트에 들어가는 해는 오직 한 쌍이다.

가로가 세로의 길이와 같거나 더 길다고 했으므로 내림차순 정렬만 해주면 끝이다.

머리로 암산해서 식 세우기는 좀 어려웠으나 종이에다가 직접 그려보니 연립방정식을 세우는 과정이 간단해서 굉장히 쉽게 풀렸다.

python 코딩테스트 - 소수 찾기

공대생철이 — Sun, 12 Nov 2023 19:32:25 +0900

출처 : 프로그래머스

처음 든 생각

- 나올 수 있는 모든 수를 구해야겠다 -> permutations 라이브러리 사용

- 소수인지 아닌지 확인하는 함수는 따로 만들어줘야겠다

- string, number 자료형 구분 잘할 것

나의 답

from itertools import permutations
import math

def solution(numbers):
    
    arr =[]
    
    for i in range(1,len(numbers)+1):
        arr.append(list(permutations(numbers,i)))
        
    def checkPrime(num):
        count = 0
        if num <2:
            return False
        for i in range(1, math.floor(num **(1/2))+1):
            if num % i ==0:
                count+=1
            if count >1:
                break
        return True if count <2 else False
        
    numArr = []
    
    for i in arr:
        for j in i:
            num = int("".join(j))
            if checkPrime(num):
                numArr.append(num)
    answer = len(set(numArr))
    
    return answer

모든 경우의 순열을 담을 리스트를 하나 선언해준다.

그 다음 소수인지 아닌지 검사하는 함수는 제곱근까지만 약수를 구하여 약수가 2개라면 소수가 아니고 2 미만이라면 소수라고 판단한다.

약수는 무조건 짝으로 존재하므로 제곱근보다 작은 쪽에서 1 이외에 다른 약수가 존재하면 최소 3개 이상이라는 것이기에 소수가 될 수 없다. 완전제곱수일 때도 저 범위에서는 2개로 개수가 측정되기 때문에 식별이 가능하다.

소수를 담을 큰 리스트인 numArr을 선언한 후 모든 경우에 대하여 join을 하여 정수 자료형으로 변환한 다음 소수인지 아닌지 구별하여 리스트에 넣어준다. 겹치는 원소를 제거해주기 위해 set으로 자료형을 바꾼 다음 개수를 세주면 된다.

가능한 모든 경우를 조사하여 여부를 확인한 다음 개수를 세는 문제였다.

순서대로만 잘 따라가면 풀 수 있었던 문제라 그렇게 어렵지는 않았다.

다만 소수 판별 함수에서의 범위는 유의해서 설정해줘야했다. 처음에 +1 안해줘서 제곱수를 판별하지 못했었다.