from. programmers.com algorithm
sort
๋๋์ด ๋จ์ด์ง๋ ์ซ์ ๋ฐฐ์ด
๋ฌธ์ ์ค๋ช
array์ ๊ฐ element ์ค divisor๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ฐฐ์ด์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
divisor๋ก ๋๋์ด ๋จ์ด์ง๋ element๊ฐ ํ๋๋ ์๋ค๋ฉด ๋ฐฐ์ด์ -1์ ๋ด์ ๋ฐํํ์ธ์.
์ ํ์ฌํญ
- arr์ ์์ฐ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๋๋ค.
- ์ ์ i, j์ ๋ํด i ≠ j ์ด๋ฉด arr[i] ≠ arr[j] ์ ๋๋ค.
- divisor๋ ์์ฐ์์ ๋๋ค.
- array๋ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค.
์ ์ถ๋ ฅ ์arrdivisorreturn[5, 9, 7, 10]5[5, 10][2, 36, 1, 3]1[1, 2, 3, 36][3,2,6]10[-1]์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์#1
arr์ ์์ ์ค 5๋ก ๋๋์ด ๋จ์ด์ง๋ ์์๋ 5์ 10์
๋๋ค. ๋ฐ๋ผ์ [5, 10]์ ๋ฆฌํดํฉ๋๋ค.
์
์ถ๋ ฅ ์#2
arr์ ๋ชจ๋ ์์๋ 1์ผ๋ก ๋๋์ด ๋จ์ด์ง๋๋ค. ์์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด [1, 2, 3, 36]์ ๋ฆฌํดํฉ๋๋ค.
์
์ถ๋ ฅ ์#3
3, 2, 6์ 10์ผ๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ต๋๋ค. ๋๋์ด ๋จ์ด์ง๋ ์์๊ฐ ์์ผ๋ฏ๋ก [-1]์ ๋ฆฌํดํฉ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
|
function solution(arr, divisor) {
let result =[]
for(let i =0; i<arr.length; i++){
if(arr[i] % divisor === 0){
result.push(arr[i])
}
}
if(result.length ===0){
return result = [-1]
}
return result.sort((a,b)=>a-b);
}
|
cs |
๋ฌธ์์ด ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ
๋ฌธ์ ์ค๋ช
๋ฌธ์์ด s์ ๋ํ๋๋ ๋ฌธ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํด ์๋ก์ด ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
s๋ ์๋ฌธ ๋์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ๋๋ฌธ์๋ ์๋ฌธ์๋ณด๋ค ์์ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
์ ํ ์ฌํญ
- str์ ๊ธธ์ด 1 ์ด์์ธ ๋ฌธ์์ด์ ๋๋ค.
์ ์ถ๋ ฅ ์sreturn
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
function solution(s) {
let result =[];
for(let i=0; i< s.length; i++){
if(s[i] < s[i+1]){
result.push(s[i])
}
}
return result.reverse().join('')
}
๋ด๋ฆผ์ฐจ์
๋ฌธ์์ด์ผ ๋,
function solution(s) {
// 1. return s.split('').sort((a,b)=> b > a ? 1 : b < a ? -1 : 0).join('')
// 2. return s.split('').sort().reverse().join('')
}
์ซ์์ผ ๋,
.sort((a,b) => a-b)
์ฌ๋ฆผ์ฐจ์
๋ฌธ์์ด์ผ ๋,
function solution(s) {
// 1. return s.split('').sort((a,b)=> b < a ? 1 : b > a ? -1 : 0).join('')
// 2. return s.split('').sort().reverse().join('')
}
์ซ์์ผ ๋,
.sort((a,b)=>b-a)
|
cs |
๋ฌธ์์ด ๋ค๋ฃจ๊ธฐ ๊ธฐ๋ณธ
๋ฌธ์ ์ค๋ช
๋ฌธ์์ด s์ ๊ธธ์ด๊ฐ 4 ํน์ 6์ด๊ณ , ์ซ์๋ก๋ง ๊ตฌ์ฑ๋ผ์๋์ง ํ์ธํด์ฃผ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด s๊ฐ a234์ด๋ฉด False๋ฅผ ๋ฆฌํดํ๊ณ 1234๋ผ๋ฉด True๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์ฌํญ
- s๋ ๊ธธ์ด 1 ์ด์, ๊ธธ์ด 8 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
function solution(s) {
if(s.length !== 4 && s.length !==6){
return false;
}
return [...s].filter(function(el){
return isNaN(el)
}).length === 0
}
function solution(s) {
if(s.length !== 4 && s.length !==6){
return false;
}
for(let i = 0; i < s.length; i++){
if(isNaN(s[i])) {
return false ////๋ฐฐ์ด์ ์ํ๋ฒณ์ด ์๋ ๊ฒฝ์ฐ ๋ฐํํ๊ณ
}
return true; //์ด๋ค s[i]๋ ์๋์จ๋ค๋ฉด return true
//else๋ก ์ธ ์ ์๋ ์ด์ ๋ ๋ฌธ์์ด์ ๋ค ์ํํด์ผ๋๊ธฐ ๋๋ฌธ
}
|
cs |
์ง์ํ์ = ‘1e22’๋ฅผ ์ ์ฒด๋ก ์ซ์๋ก ๋ณํํ๋ฉด ์ซ์๊ฐ ๋จ
๊ทธ๋ ๊ธฐ์ isNaN์ ์ฌ์ฉํด์ผ ๋จ!!!!!!!!!
isNaN ()===Number.isNaN()
isNaN(NaN์ด true์ผ ๋) => true
isNaN(NaN์ด false์ผ ๋) => false
1
2
3
4
5
|
let a='as11'
[...a]; //['a', 's', '1', '1']
isNaN('a'); // true
isNaN(Number('a'));// true
|
cs |
isNaN์ ์๋์ ์ผ๋ก ๋๋ฒ ํ์ ์ผ๋ก ๋ณํํด์ ์คํ ๋จ!!
๊ฐ์ ์ซ์๋ ์ซ์ด!!
๋ฌธ์ ์ค๋ช
๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด,
- arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค.
- arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค.
๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์
- ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ : 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์
์ ์ถ๋ ฅ ์arranswer[1,1,3,3,0,1,1][1,3,0,1][4,4,4,3,3][4,3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
function solution(arr){
var answer = [];
for(let i =0; i<arr.length; i++){
if(arr[i] !== arr[i+1]){
answer.push(arr[i])
}
}
return answer;
}
function solution(arr){
return arr.filter(function(el, i){
return arr[i] !== arr[i+1]
})
}
function solution(arr){
return arr.filter(function(el, i){
return el !==arr[i+1]
})
}
|
cs |
map, forEach, filter๋ (value, index, array) 3๊ฐ์ ์ธ์๋ฅผ ๋ฐ์์ด.
value๋ array์ ์์์ด๋ฉฐ, index๋ array์ index์ด๊ณ , array๋ ๋ฐฐ์ด ๊ทธ ์์ฒด์ด๋ฆ์ด๋ค.
๋ง์ฝ์ ๋ณ์๋ช ์ด ๊ธธ์ด์ง๊ณ ํจ์ ์์ ์ฌ์ฉํ๊ณ ์ถ์ผ๋ฉด, ๊ฐ๊ฒฐํ๊ฒ ๋ค๋ฅธ ์ด๋ฆ์ผ๋ก ์ ๊ธฐ์ํด, ๋งค๊ฐ๋ณ์์ ์ด๋ฆ์ ์ค์ ํ ์ ์๋ค.
ex) const fjaiepfjwpifjwaefpwifj = [];
๋งค๊ฐ๋ณ์=ํจ์ ์์ ๋ค์ด์์ ์ธ์๊ฐ ๋ถ๋ฆด ์ด๋ฆ
์ธ์= ํจ์ ํธ์ถํ ๋ ๋ฃ๋ ๊ฐ
ํ์ค๋ ์
๋ฌธ์ ์ค๋ช
์์ ์ ์ x๊ฐ ํ์ค๋ ์์ด๋ ค๋ฉด x์ ์๋ฆฟ์์ ํฉ์ผ๋ก x๊ฐ ๋๋์ด์ ธ์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 18์ ์๋ฆฟ์ ํฉ์ 1+8=9์ด๊ณ , 18์ 9๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 18์ ํ์ค๋ ์์ ๋๋ค. ์์ฐ์ x๋ฅผ ์ ๋ ฅ๋ฐ์ x๊ฐ ํ์ค๋ ์์ธ์ง ์๋์ง ๊ฒ์ฌํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- x๋ 1 ์ด์, 10000 ์ดํ์ธ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์arrreturn10true12true11false13false์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
10์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 1์
๋๋ค. 10์ 1๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 10์ ํ์ค๋ ์์
๋๋ค.
์
์ถ๋ ฅ ์ #2
12์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 3์
๋๋ค. 12๋ 3์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 12๋ ํ์ค๋ ์์
๋๋ค.
์
์ถ๋ ฅ ์ #3
11์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 2์
๋๋ค. 11์ 2๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฏ๋ก 11๋ ํ์ค๋ ์๊ฐ ์๋๋๋ค.
์
์ถ๋ ฅ ์ #4
13์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 4์
๋๋ค. 13์ 4๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฏ๋ก 13์ ํ์ค๋ ์๊ฐ ์๋๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
function solution(x) {
x= String(x)
let result =0;
for(let i=0; i<x.length; i++){
result += Number(x[i]);
}
return x % result === 0
// if(x % result === 0){
// return true;
// }
// else{
// return false;
// }
}
|
cs |
Please write code simple!!!!!!!!!!!!
์ฒด์ก๋ณต
๋ฌธ์ ์ค๋ช
์ ์ฌ์๊ฐ์ ๋๋์ด ๋ค์ด, ์ผ๋ถ ํ์์ด ์ฒด์ก๋ณต์ ๋๋๋นํ์ต๋๋ค. ๋คํํ ์ฌ๋ฒ ์ฒด์ก๋ณต์ด ์๋ ํ์์ด ์ด๋ค์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ ค์ฃผ๋ ค ํฉ๋๋ค. ํ์๋ค์ ๋ฒํธ๋ ์ฒด๊ฒฉ ์์ผ๋ก ๋งค๊ฒจ์ ธ ์์ด, ๋ฐ๋ก ์๋ฒํธ์ ํ์์ด๋ ๋ฐ๋ก ๋ท๋ฒํธ์ ํ์์๊ฒ๋ง ์ฒด์ก๋ณต์ ๋น๋ ค์ค ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, 4๋ฒ ํ์์ 3๋ฒ ํ์์ด๋ 5๋ฒ ํ์์๊ฒ๋ง ์ฒด์ก๋ณต์ ๋น๋ ค์ค ์ ์์ต๋๋ค. ์ฒด์ก๋ณต์ด ์์ผ๋ฉด ์์ ์ ๋ค์ ์ ์๊ธฐ ๋๋ฌธ์ ์ฒด์ก๋ณต์ ์ ์ ํ ๋น๋ ค ์ต๋ํ ๋ง์ ํ์์ด ์ฒด์ก์์ ์ ๋ค์ด์ผ ํฉ๋๋ค.
์ ์ฒด ํ์์ ์ n, ์ฒด์ก๋ณต์ ๋๋๋นํ ํ์๋ค์ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด lost, ์ฌ๋ฒ์ ์ฒด์ก๋ณต์ ๊ฐ์ ธ์จ ํ์๋ค์ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด reserve๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ฒด์ก์์ ์ ๋ค์ ์ ์๋ ํ์์ ์ต๋๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ์ ์ฒด ํ์์ ์๋ 2๋ช ์ด์ 30๋ช ์ดํ์ ๋๋ค.
- ์ฒด์ก๋ณต์ ๋๋๋นํ ํ์์ ์๋ 1๋ช ์ด์ n๋ช ์ดํ์ด๊ณ ์ค๋ณต๋๋ ๋ฒํธ๋ ์์ต๋๋ค.
- ์ฌ๋ฒ์ ์ฒด์ก๋ณต์ ๊ฐ์ ธ์จ ํ์์ ์๋ 1๋ช ์ด์ n๋ช ์ดํ์ด๊ณ ์ค๋ณต๋๋ ๋ฒํธ๋ ์์ต๋๋ค.
- ์ฌ๋ฒ ์ฒด์ก๋ณต์ด ์๋ ํ์๋ง ๋ค๋ฅธ ํ์์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ ค์ค ์ ์์ต๋๋ค.
- ์ฌ๋ฒ ์ฒด์ก๋ณต์ ๊ฐ์ ธ์จ ํ์์ด ์ฒด์ก๋ณต์ ๋๋๋นํ์ ์ ์์ต๋๋ค. ์ด๋ ์ด ํ์์ ์ฒด์ก๋ณต์ ํ๋๋ง ๋๋๋นํ๋ค๊ณ ๊ฐ์ ํ๋ฉฐ, ๋จ์ ์ฒด์ก๋ณต์ด ํ๋์ด๊ธฐ์ ๋ค๋ฅธ ํ์์๊ฒ๋ ์ฒด์ก๋ณต์ ๋น๋ ค์ค ์ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์nlostreservereturn5[2, 4][1, 3, 5]55[2, 4][3]43[3][1]2์ ์ถ๋ ฅ ์ ์ค๋ช
์์ #1
1๋ฒ ํ์์ด 2๋ฒ ํ์์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ ค์ฃผ๊ณ , 3๋ฒ ํ์์ด๋ 5๋ฒ ํ์์ด 4๋ฒ ํ์์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ ค์ฃผ๋ฉด ํ์ 5๋ช
์ด ์ฒด์ก์์
์ ๋ค์ ์ ์์ต๋๋ค.
์์ #2
3๋ฒ ํ์์ด 2๋ฒ ํ์์ด๋ 4๋ฒ ํ์์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ ค์ฃผ๋ฉด ํ์ 4๋ช
์ด ์ฒด์ก์์
์ ๋ค์ ์ ์์ต๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
function solution(n, lost, reserve) {
const obj = {};
for (let i = 1; i <= n; i++) {
obj[i] = 1; //๋ชจ๋ ์ ๋คํํ
ํ ๋ฒ์ฉ ์ฃผ๊ธฐ
}
for (let i = 0; i < reserve.length; i++) {
obj[reserve[i]] += 1; // ์ฌ๋ถ ์๋ ์ ๋คํํ
๋ ํ ๋ฒ ๋ ์ถ๊ฐ
}
for (let i = 0; i < lost.length; i++) {
obj[lost[i]] -= 1;// ์๊ฐ์ ธ์จ ์ ๋ค์ ํ ๋ฒ๋นผ๊ธฐ
}
const arr = Object.values(obj); //value๋ก๋ง ๋ฐฐ์ด ๋ง๋ค๊ธฐ
for (let i = 0; i < arr.length; i++) {
if (arr[i] === 2) { //์ฌ๋ถ์ด ์๋ค๋ฉด
if (arr[i - 1] === 0) {// ์์ ์ ๊ฐ ์๊ฐ์ ธ์จ ์ ๋ผ๋ฉด
arr[i] -= 1; //๋ด๊ฐ ์ฌ๋ถ์ ์ค์ผํ๋ ํ ๋ฒ ๋นผ๊ณ
arr[i - 1] += 1; // ์๊ฐ์ ธ์๋๋ฐ ์ฌ๋ฒ์ ๋ฐ์์ผ๋ ์ถ๊ฐ
}
else if (arr[i + 1] === 0) { // ๋ด ๋ค์ ์ ๊ฐ ์๋ค๋ฉด
arr[i] -= 1; //๋ด๊ฐ ์ฌ๋ถ์ ์ค์ผํ๋ ํ ๋ฒ ๋นผ๊ณ
arr[i + 1] += 1; // ์๊ฐ์ ธ์๋๋ฐ ์ฌ๋ฒ์ ๋ฐ์์ผ๋ ์ถ๊ฐ
}
}
}
return n-arr.filter(function(v){ //๋ฐฐ์ด์ ๋๋ฉด์
return v===0 //value๊ฐ 0์ด๋ผ๋ ๊ฒ์ ์ฌ๋ฒ์ ๋ชป๋ฐ์๋ ์ ๋ค
}).length // ๋ชป๋ฐ์ ์ ๋ค์ ์๋ฅผ ๋ฐ์ ์ ์ฒด ํ์์์ ๋นผ๊ธฐ
}
|
cs |
'TIL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
TIL 2020.11.13 (0) | 2020.11.14 |
---|---|
TIL 2020.11.12 (0) | 2020.11.14 |
TIL 2020.11.11 (0) | 2020.11.14 |
TIL 2020.11.09 (0) | 2020.11.09 |
TIL 2020.11.08 (0) | 2020.11.08 |