├── README.md ├── Solution.md ├── javascript_다시_볼만한_문제.md ├── python_다시_볼만한_문제.md ├── 다시_볼만한_문제.md └── 코딩도장.md /README.md: -------------------------------------------------------------------------------- 1 | # programmersLv0 2 | 프로그래머스 Lv0 문제 풀이 레파지토리 3 | -------------------------------------------------------------------------------- /Solution.md: -------------------------------------------------------------------------------- 1 | # Lv0 2 | 3 | ## 기본 코드 4 | 5 | - python 6 | 7 | ```python 8 | # 무한수 9 | import math 10 | 11 | math.factorial 12 | math.gcd #최대공약수 13 | math.pi 14 | math.inf 15 | -math.inf 16 | math.nan 17 | # 조합(import itertools로는 쌍을 구할 수 있음) 18 | math.perm(n, r) n개 중 r개, 순열 19 | math.comb(n, r) n개 중 r개, 조합 20 | 21 | float("inf") 22 | -float("inf") 23 | ``` 24 | 25 | ```python 26 | import re 27 | # 잘 사용되는 순서 28 | # - compile() : 패턴 컴파일 29 | # - match() : 문자열의 앞 부분이 매치되는가를 체크, 추출 30 | # - sub() : 매치된 부분을 치환 31 | # - search() : 선두에 한해서 매치하는지를 체크, 추출 32 | # - findall() : 매치된 부분 모두 리스트 반환 33 | # - finditer() : 매치된 부분 모두 이터레이터 반환 34 | # - spilt() : 정규표현 패턴으로 문자열을 분할 35 | ``` 36 | 37 | - javascript 38 | ```js 39 | Infinity - Infinity; 40 | ``` 41 | 42 | ## 몫 구하기 43 | 44 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120805 45 | - python 46 | 47 | ```py 48 | def solution(num1, num2): 49 | return num1 // num2 50 | ``` 51 | 52 | - js 53 | 54 | ```js 55 | function solution(num1, num2) { 56 | return ~~(num1 / num2); 57 | } 58 | ``` 59 | 60 | ## 두 수의 곱 61 | 62 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120804 63 | - python 64 | 65 | ```py 66 | def solution(num1, num2): 67 | return num1 * num2 68 | ``` 69 | 70 | - js 71 | 72 | ```js 73 | function solution(num1, num2) { 74 | return num1 * num2; 75 | } 76 | ``` 77 | 78 | ## 두 수의 차 79 | 80 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120803 81 | - python 82 | 83 | ```py 84 | def solution(num1, num2): 85 | return num1 - num2 86 | ``` 87 | 88 | - js 89 | 90 | ```js 91 | function solution(num1, num2) { 92 | return num1 - num2; 93 | } 94 | ``` 95 | 96 | ## 두 수의 합 97 | 98 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120802 99 | - python 100 | 101 | ```py 102 | def solution(num1, num2): 103 | return num1 + num2 104 | ``` 105 | 106 | - js 107 | 108 | ```js 109 | function solution(num1, num2) { 110 | return num1 + num2; 111 | } 112 | ``` 113 | 114 | ## 나머지 구하기 115 | 116 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120810 117 | - python 118 | 119 | ```py 120 | def solution(num1, num2): 121 | return num1 % num2 122 | ``` 123 | 124 | - js 125 | 126 | ```js 127 | function solution(num1, num2) { 128 | return num1 % num2; 129 | } 130 | ``` 131 | 132 | ## 숫자 비교하기 133 | 134 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120807 135 | - python 136 | 137 | ```py 138 | def solution(num1, num2): 139 | if num1 == num2: return 1 140 | else: return -1 141 | 142 | # 3항 연산자로 표현하기 143 | # A if 조건 else B 144 | def solution(num1, num2): 145 | return 1 if num1 == num2 else -1 146 | 147 | def solution(num1, num2): 148 | answer = 1 if num1 == num2 else -1 149 | return answer 150 | 151 | def solution(num1, num2): 152 | answer = {num1 == num2 : 1, num1 != num2 : -1}.get(True, -1) 153 | return answer 154 | ``` 155 | 156 | - js 157 | 158 | ```js 159 | function solution(num1, num2) { 160 | var answer = num1 === num2 ? 1 : -1; 161 | return answer; 162 | } 163 | ``` 164 | 165 | ## 나이 출력 166 | 167 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120820 168 | - python 169 | 170 | ```py 171 | def solution(age): 172 | return 2022 - age + 1 173 | ``` 174 | 175 | - js 176 | 177 | ```js 178 | function solution(age) { 179 | return 2022 - age + 1; 180 | } 181 | ``` 182 | 183 | ## 각도기 184 | 185 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120829 186 | - python 187 | 188 | ```py 189 | def solution(angle): 190 | if angle < 90: 191 | return 1 192 | elif angle == 90: 193 | return 2 194 | elif angle < 180: 195 | return 3 196 | elif angle == 180: 197 | return 4 198 | return answer 199 | 200 | # 3항 연산자로 표현하기 201 | # A if 조건 else B if 조건 else C 202 | 203 | # error 코드 204 | # def solution(angle): 205 | # return 1 if angle < 90 elif angle == 90 2 elif angle < 180 3 elif angle == 180 4 206 | 207 | def solution(angle): 208 | return 1 if angle < 90 else 2 if angle == 90 else 3 if angle < 180 else 4 if angle == 180 else -1 209 | 210 | ``` 211 | 212 | - js 213 | 214 | ```js 215 | function solution(angle) { 216 | if (angle < 90) { 217 | return 1; 218 | } else if (angle == 90) { 219 | return 2; 220 | } else if (angle < 180) { 221 | return 3; 222 | } else if (angle == 180) { 223 | return 4; 224 | } 225 | } 226 | ``` 227 | 228 | ## 두 수의 나눗셈 229 | 230 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120806 231 | - python 232 | 233 | ```py 234 | def solution(num1, num2): 235 | answer = 0 236 | return int(num1 / num2 * 1000) 237 | ``` 238 | 239 | - js 240 | 241 | ```js 242 | function solution(num1, num2) { 243 | return Math.floor((num1 / num2) * 1000); 244 | } 245 | 246 | function solution(num1, num2) { 247 | return parseInt((num1 / num2) * 1000); 248 | } 249 | 250 | // 비트 부정연산자 2회 사용 ~n = -(n+1) 251 | function solution(num1, num2) { 252 | return ~~((num1 / num2) * 1000); 253 | } 254 | ``` 255 | 256 | ## 배열의 평균값 257 | 258 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120817 259 | - python 260 | 261 | ```py 262 | def solution(numbers): 263 | return sum(numbers)/len(numbers) 264 | 265 | # 다차원 배열의 합도 구할 수 있음 266 | import numpy as np 267 | 268 | def solution(numbers): 269 | return np.sum(numbers)/len(numbers) 270 | ``` 271 | 272 | - js 273 | 274 | ```js 275 | function solution(numbers) { 276 | var answer = 0; 277 | for (i of numbers) { 278 | answer += i; 279 | } 280 | return answer / numbers.length; 281 | } 282 | 283 | function solution(numbers) { 284 | var answer = numbers.reduce((a, b) => a + b, 0) / numbers.length; 285 | return answer; 286 | } 287 | ``` 288 | 289 | ## 짝수의 합 290 | 291 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120831 292 | - python 293 | 294 | ```py 295 | def solution(n): 296 | answer = 0 297 | for i in range(0, n+1, 2): 298 | answer += i 299 | return answer 300 | 301 | def solution(n): 302 | return sum([i for i in range(2, n + 1, 2)]) 303 | 304 | def solution(n): 305 | answer = sum(range(2, n + 1, 2)) # list로 형변환 할 필요 없습니다. 306 | return answer 307 | ``` 308 | 309 | - js 310 | 311 | ```js 312 | function solution(n) { 313 | var answer = 0; 314 | for (let i = 0; i <= n; i += 2) { 315 | answer += i; 316 | } 317 | return answer; 318 | } 319 | 320 | function solution(n) { 321 | // Array(Math.floor((n+3)/2)).fill().map((_, i) => i * 2).reduce((a, c) => a + c, 0); // 왜 안되지? 322 | return Array(n) 323 | .fill() 324 | .map((_, i) => i + 1) 325 | .filter((v) => v % 2 === 0) 326 | .reduce((a, c) => a + c, 0); 327 | } 328 | ``` 329 | 330 | ## 중복된 숫자 개수 331 | 332 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120583 333 | - python 334 | 335 | ```py 336 | def solution(array, n): 337 | return array.count(n) 338 | 339 | from collections import Counter 340 | 341 | def solution(array, n): 342 | return Counter(array).get(n) 343 | ``` 344 | 345 | - js 346 | 347 | ```js 348 | function solution(array, n) { 349 | return array.filter((v) => v === n).length; 350 | } 351 | 352 | function solution(array, n) { 353 | var answer = 0; 354 | for (num of array) if (num === n) answer++; 355 | return answer; 356 | } 357 | ``` 358 | 359 | ## 머쓱이보다 키 큰 사람 360 | 361 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120585 362 | - python 363 | 364 | ```py 365 | def solution(array, height): 366 | count = 0 367 | for i in array: 368 | if i > height: 369 | count += 1 370 | return count 371 | 372 | def solution(array, height): 373 | array.append(height) 374 | array.sort(reverse=True) 375 | return array.index(height) 376 | 377 | def solution(array, height): 378 | return len(list(filter(lambda x:x > height, array))) 379 | ``` 380 | 381 | - js 382 | 383 | ```js 384 | function solution(array, height) { 385 | var answer = array.filter((v) => v > height).length; 386 | return answer; 387 | } 388 | ``` 389 | 390 | ## 양꼬치 391 | 392 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120830 393 | - python 394 | 395 | ```py 396 | def solution(n, k): 397 | if n >= 10: 398 | k -= n // 10 399 | 400 | return n*12000 + k*2000 401 | 402 | def solution(n, k): 403 | return 12000 * n + 2000 * (k - n // 10) 404 | ``` 405 | 406 | - js 407 | 408 | ```js 409 | function solution(n, k) { 410 | return n * 12000 + k * 2000 - parseInt(n / 10) * 2000; 411 | } 412 | ``` 413 | 414 | ## 편지 415 | 416 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120898 417 | - python 418 | 419 | ```py 420 | def solution(message): 421 | return len(message) * 2 422 | ``` 423 | 424 | - js 425 | 426 | ```js 427 | function solution(message) { 428 | return message.length * 2; 429 | } 430 | ``` 431 | 432 | ## 자릿수 더하기 433 | 434 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120906 435 | - python 436 | 437 | ```py 438 | def solution(n): 439 | answer = 0 440 | for i in str(n): 441 | answer += int(i) 442 | return answer 443 | 444 | def solution(n): 445 | answer = sum(list(map(int, str(n)))) 446 | return answer 447 | ``` 448 | 449 | - js 450 | 451 | ```js 452 | function solution(n) { 453 | return n 454 | .toString() 455 | .split("") 456 | .reduce((a, c) => a + parseInt(c), 0); 457 | } 458 | ``` 459 | 460 | ## 피자 나눠 먹기(3) 461 | 462 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120816 463 | - python 464 | 465 | ```py 466 | def solution(slice, n): 467 | for i in range(51): 468 | if n <= i * slice: 469 | break 470 | return i 471 | ``` 472 | 473 | - js 474 | 475 | ```js 476 | function solution(slice, n) { 477 | return Math.ceil(n / slice); 478 | } 479 | ``` 480 | 481 | ## 문자열 뒤집기 482 | 483 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120822 484 | - python 485 | 486 | ```py 487 | def solution(my_string): 488 | return my_string[::-1] 489 | 490 | def solution(my_string): 491 | return ''.join(reversed(list(my_string))) 492 | ``` 493 | 494 | - js 495 | 496 | ```js 497 | function solution(my_string) { 498 | return my_string.split("").reverse().join(""); 499 | } 500 | 501 | function solution(my_string) { 502 | return [...my_string].reverse().join(""); 503 | } 504 | ``` 505 | 506 | ## 배열 원소의 길이 507 | 508 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120854 509 | - python 510 | 511 | ```py 512 | def solution(strlist): 513 | return list(map(lambda x : len(x), strlist)) 514 | 515 | def solution(strlist): 516 | answer = [] 517 | return [ len(i) for i in strlist ] 518 | ``` 519 | 520 | - js 521 | 522 | ```js 523 | function solution(strlist) { 524 | return strlist.map((e) => e.length); 525 | } 526 | ``` 527 | 528 | ## 피자 나눠 먹기 (1) 529 | 530 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120814 531 | - python 532 | 533 | ```py 534 | def solution(n): 535 | return ((n - 1) // 7) + 1 536 | 537 | import math 538 | 539 | def solution(n): 540 | return math.ceil(n / 7) 541 | ``` 542 | 543 | - js 544 | 545 | ```js 546 | function solution(n) { 547 | return Math.ceil(n / 7); 548 | } 549 | ``` 550 | 551 | ## 문자열안에 문자열 552 | 553 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120908 554 | - python 555 | 556 | ```py 557 | def solution(str1, str2): 558 | return 2 if str1.find(str2) == -1 else 1 559 | 560 | def solution(str1, str2): 561 | return 1 if str2 in str1 else 2 562 | ``` 563 | 564 | - js 565 | 566 | ```js 567 | function solution(str1, str2) { 568 | return str1.includes(str2) ? 1 : 2; 569 | } 570 | 571 | function solution(str1, str2) { 572 | return str1.split(str2).length > 1 ? 1 : 2; 573 | } 574 | ``` 575 | 576 | ## 짝수 홀수 개수 577 | 578 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120824 579 | - python 580 | 581 | ```py 582 | def solution(num_list): 583 | 짝수 = 0 584 | 홀수 = 0 585 | for i in num_list: 586 | if i % 2 == 0: 587 | 짝수 += 1 588 | else: 589 | 홀수 += 1 590 | 591 | return [짝수, 홀수] 592 | 593 | def solution(num_list): 594 | answer = [0,0] 595 | for n in num_list: 596 | answer[n % 2] += 1 597 | return answer 598 | 599 | def solution(num_list): 600 | 나머지 = list(map(lambda v : v % 2, num_list)) 601 | return [나머지.count(0), 나머지.count(1)] 602 | ``` 603 | 604 | - js 605 | 606 | ```js 607 | function solution(num_list) { 608 | var answer = [0, 0]; 609 | 610 | for (let a of num_list) { 611 | answer[a % 2] += 1; 612 | } 613 | 614 | return answer; 615 | } 616 | 617 | function solution(num_list) { 618 | return [ 619 | num_list.filter((num) => num % 2 === 0).length, 620 | num_list.filter((num) => num % 2 === 1).length, 621 | ]; 622 | } 623 | ``` 624 | 625 | ## 배열 뒤집기 626 | 627 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120821 628 | - python 629 | 630 | ```py 631 | def solution(num_list): 632 | return num_list[::-1] # slicing의 연산 가산이 있습니다. 633 | ``` 634 | 635 | - js 636 | 637 | ```js 638 | function solution(num_list) { 639 | return num_list.reverse(); 640 | } 641 | ``` 642 | 643 | ## 가장 큰 수 찾기 644 | 645 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120899 646 | - python 647 | 648 | ```py 649 | def solution(array): 650 | return [max(array), array.index(max(array))] 651 | ``` 652 | 653 | - js 654 | 655 | ```js 656 | function solution(array) { 657 | return [Math.max(...array), array.indexOf(Math.max(...array))]; 658 | } 659 | ``` 660 | 661 | ## 아이스 아메리카노 662 | 663 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120819 664 | - python 665 | 666 | ```py 667 | def solution(money): 668 | return [money//5500, money%5500] 669 | ``` 670 | 671 | - js 672 | 673 | ```js 674 | function solution(money) { 675 | return [Math.floor(money / 5500), money % 5500]; // parseInt(money/5500) 676 | } 677 | ``` 678 | 679 | ## 최댓값 만들기(1) 680 | 681 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120847 682 | - python 683 | 684 | ```py 685 | def solution(numbers): 686 | numbers.sort() 687 | return numbers[-2] * numbers[-1] 688 | 689 | def solution(numbers): 690 | numbers.sort(reverse=True) 691 | return numbers[0]*numbers[1] 692 | 693 | def solution(numbers): 694 | v = list(reversed(sorted(numbers))) 695 | return v[0] * v[1] 696 | ``` 697 | 698 | - js 699 | 700 | ```js 701 | function solution(numbers) { 702 | numbers.sort((a, b) => b - a); 703 | return numbers[0] * numbers[1]; 704 | } 705 | ``` 706 | 707 | ## 약수 구하기 708 | 709 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120897 710 | - python 711 | 712 | ```py 713 | def solution(n): 714 | answer = [] 715 | for i in range(1, n+1): 716 | if n % i == 0: 717 | answer.append(i) 718 | return answer 719 | 720 | 721 | def solution(n): 722 | answer = [i for i in range(1,n+1) if n%i == 0] 723 | return answer 724 | ``` 725 | 726 | - js 727 | 728 | ```js 729 | function solution(n) { 730 | return Array(n) 731 | .fill(0) 732 | .map((v, i) => v + i + 1) 733 | .filter((v) => n % v === 0); 734 | } 735 | ``` 736 | 737 | ## 배열 두 배 만들기 738 | 739 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120809 740 | - python 741 | 742 | ```py 743 | def solution(numbers): 744 | answer = [i * 2 for i in numbers] 745 | return answer 746 | 747 | def solution(numbers): 748 | return list(map(lambda x : x * 2, numbers)) 749 | 750 | import numpy as np 751 | 752 | def solution(numbers): 753 | return (np.array(numbers) * 2).tolist() 754 | ``` 755 | 756 | - js 757 | 758 | ```js 759 | function solution(numbers) { 760 | return numbers.map((i) => i * 2); 761 | } 762 | ``` 763 | 764 | ## 배열 자르기 765 | 766 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120833 767 | - python 768 | 769 | ```py 770 | def solution(numbers, num1, num2): 771 | return numbers[num1:num2+1] 772 | ``` 773 | 774 | - js 775 | 776 | ```js 777 | function solution(numbers, num1, num2) { 778 | return numbers.splice(num1, num2 - num1 + 1); // 제거한 요소를 반환합니다. 779 | } 780 | 781 | /////// 782 | v = [10, 20, 30, 40, 50, 60, 70]; 783 | v.splice(2, 3); 784 | // [30, 40, 50] 785 | v; 786 | // [10, 20, 60, 70] 787 | v = [10, 20, 30, 40, 50, 60, 70]; 788 | v.splice(2, 3, 1000); 789 | // [30, 40, 50] 790 | v; 791 | // [10, 20, 1000, 60, 70] 792 | 793 | v = [10, 20, 30, 40, 50, 60, 70]; 794 | v.splice(2, 3, [1, 2, 3]); 795 | // (3) [30, 40, 50] 796 | v; 797 | // (5) [10, 20, Array(3), 60, 70] 798 | v = [10, 20, 30, 40, 50, 60, 70]; 799 | v.splice(2, 3, 1, 2, 3); 800 | // (3) [30, 40, 50] 801 | v; 802 | // (7) [10, 20, 1, 2, 3, 60, 70] 803 | /////// 804 | 805 | function solution(numbers, num1, num2) { 806 | return numbers.slice(num1, num2 + 1); // python의 slice 807 | } 808 | 809 | function solution(numbers, num1, num2) { 810 | return numbers.filter((n, i) => num1 <= i && i <= num2); 811 | } 812 | ``` 813 | 814 | ## n의 배수 고르기 815 | 816 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120905 817 | - python 818 | 819 | ```py 820 | def solution(n, numlist): 821 | answer = [] 822 | for i in numlist: 823 | if i % n == 0: 824 | answer.append(i) 825 | return answer 826 | 827 | def solution(n, numlist): 828 | answer = [i for i in numlist if i%n==0] 829 | return answer 830 | ``` 831 | 832 | - js 833 | 834 | ```js 835 | function solution(n, numlist) { 836 | return numlist.filter((v) => v % n === 0); 837 | } 838 | ``` 839 | 840 | ## 제곱수 판별하기 841 | 842 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120909 843 | - python 844 | 845 | ```py 846 | def solution(n): 847 | return 1 if int(n ** 0.5) ** 2 == n else 2 848 | 849 | def solution(n): 850 | return 1 if n ** 0.5 == int else 2 851 | 852 | def solution(n): 853 | return 1 if (n ** 0.5).is_integer() else 2 854 | ``` 855 | 856 | - js 857 | 858 | ```js 859 | function solution(n) { 860 | return Math.sqrt(n) === Math.floor(Math.sqrt(n)) ? 1 : 2; 861 | } 862 | 863 | function solution(n) { 864 | return Number.isInteger(Math.sqrt(n)) ? 1 : 2; 865 | } 866 | ``` 867 | 868 | ## 짝수는 싫어요 869 | 870 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120813 871 | - python 872 | 873 | ```py 874 | def solution(n): 875 | return [i for i in range(1, n + 1, 2)] 876 | ``` 877 | 878 | - js 879 | 880 | ```js 881 | function solution(n) { 882 | var answer = []; 883 | for (let i = 1; i <= n; i += 2) answer.push(i); 884 | return answer; 885 | } 886 | 887 | function solution(n) { 888 | return Array(n) 889 | .fill(1) 890 | .map((v, i) => v + i) 891 | .filter((v) => v % 2 === 1); 892 | } 893 | ``` 894 | 895 | ## 삼각형의 완성조건 (1) 896 | 897 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120889 898 | - python 899 | 900 | ```py 901 | def solution(sides): 902 | sides.sort(reverse=True) 903 | return 1 if sides[0] < sides[1] + sides[2] else 2 904 | ``` 905 | 906 | - js 907 | 908 | ```js 909 | // reduce 910 | // 누산기 (acc) 911 | // 현재 값 (cur) 912 | // 현재 인덱스 (idx) 913 | // 원본 배열 (src) 914 | function solution(sides) { 915 | var answer = 0; 916 | const max = Math.max(...sides); 917 | const sum = sides.reduce((a, c) => a + c, 0) - max; 918 | 919 | answer = max < sum ? 1 : 2; 920 | 921 | return answer; 922 | } 923 | ``` 924 | 925 | ## 옷가게 할인 받기 926 | 927 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120818 928 | - python 929 | 930 | ```py 931 | def solution(price): 932 | if price >= 500000: 933 | price *= 0.8 934 | elif price >= 300000: 935 | price *= 0.9 936 | elif price >= 100000: 937 | price *= 0.95 938 | return int(price) 939 | ``` 940 | 941 | - js 942 | 943 | ```js 944 | function solution(price) { 945 | if (price >= 500000) return parseInt(price * 0.8); 946 | 947 | if (price >= 300000) return parseInt(price * 0.9); 948 | 949 | if (price >= 100000) return parseInt(price * 0.95); 950 | 951 | return price; 952 | } 953 | ``` 954 | 955 | ## 점의 위치 구하기 956 | 957 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120841 958 | - python 959 | 960 | ```py 961 | def solution(dot): 962 | x, y = dot 963 | if x >= 0 and y >= 0: 964 | return 1 965 | elif x < 0 and y >= 0: 966 | return 2 967 | elif x < 0 and y < 0: 968 | return 3 969 | elif x >= 0 and y < 0: 970 | return 4 971 | return answer 972 | ``` 973 | 974 | - js 975 | 976 | ```js 977 | function solution(dot) { 978 | // const [x, y] = dot; 979 | var answer = 0; 980 | if (dot[0] >= 0 && dot[1] >= 0) answer = 1; 981 | if (dot[0] < 0 && dot[1] >= 0) answer = 2; 982 | if (dot[0] < 0 && dot[1] < 0) answer = 3; 983 | if (dot[0] >= 0 && dot[1] < 0) answer = 4; 984 | return answer; 985 | } 986 | ``` 987 | 988 | ## 순서쌍의 개수 989 | 990 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120836 991 | - python 992 | 993 | ```py 994 | # 시간초과 995 | def solution(n): 996 | answer = [] 997 | for i in range(1, n+1): 998 | for j in range(1, n+1): 999 | if i * j == n: 1000 | answer.append([i, j]) 1001 | return len(answer) 1002 | 1003 | 1004 | def solution(n): 1005 | answer = 0 1006 | for i in range(n): 1007 | if n % (i+1) == 0: # 나누어 떨어지면 매칭되는 값이 있다는 얘기임 1008 | answer += 1 1009 | return answer 1010 | ``` 1011 | 1012 | - js 1013 | 1014 | ```js 1015 | function solution(n) { 1016 | var answer = 0; 1017 | for (let i = 0; i <= n; i++) { 1018 | if (n % i === 0) { 1019 | answer += 1; 1020 | } 1021 | } 1022 | return answer; 1023 | } 1024 | 1025 | function solution(n) { 1026 | let answer = 0; 1027 | for (let i = 1; i <= n; i++) { 1028 | if (!(n % i)) answer++; 1029 | } 1030 | return answer; 1031 | } 1032 | ``` 1033 | 1034 | ## 모음 제거 1035 | 1036 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120849 1037 | - python 1038 | 1039 | ```py 1040 | def solution(my_string): 1041 | return my_string.replace('a', '').replace('e', '').replace('i', '').replace('o', '').replace('u', '') 1042 | 1043 | def solution(my_string): 1044 | answer = '' 1045 | 1046 | for c in my_string: 1047 | if c in ['a', 'e', 'i', 'o', 'u']: 1048 | continue 1049 | answer += c 1050 | 1051 | return answer 1052 | 1053 | import re 1054 | 1055 | def solution(my_string): 1056 | return re.sub(r"[aeiou]", "", my_string) 1057 | ``` 1058 | 1059 | - js 1060 | 1061 | ```js 1062 | function solution(my_string) { 1063 | return my_string.replace(/[aeiou]/g, ""); 1064 | } 1065 | 1066 | function solution(my_string) { 1067 | return Array.from(my_string) 1068 | .filter((t) => !["a", "e", "i", "o", "u"].includes(t)) 1069 | .join(""); 1070 | } 1071 | ``` 1072 | 1073 | ## 배열의 유사도 1074 | 1075 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120903 1076 | - python 1077 | 1078 | ```py 1079 | def solution(s1, s2): 1080 | answer = 0 1081 | for i in s1: 1082 | if i in s2: 1083 | answer += 1 1084 | return answer 1085 | 1086 | def solution(s1, s2): 1087 | return len(set(s1) & set(s2)) 1088 | 1089 | # 특이한 풀이 1090 | def solution(s1, s2): 1091 | dic = {i:1 for i in s1} 1092 | answer = sum(dic.get(j,0)for j in s2) 1093 | return answer 1094 | ``` 1095 | 1096 | - js 1097 | 1098 | ```js 1099 | function solution(s1, s2) { 1100 | return s1.filter((x) => s2.includes(x)).length; 1101 | } 1102 | 1103 | function solution(s1, s2) { 1104 | let count = 0; 1105 | for (let v of s1) if (s2.includes(v)) count++; 1106 | return count; 1107 | } 1108 | 1109 | function solution(s1, s2) { 1110 | var answer = 0; 1111 | return s1.length + s2.length - new Set([...s1, ...s2]).size; 1112 | } 1113 | ``` 1114 | 1115 | ## 특정 문자 제거하기 1116 | 1117 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120826 1118 | - python 1119 | 1120 | ```py 1121 | def solution(my_string, letter): 1122 | return my_string.replace(letter, '') 1123 | 1124 | import re 1125 | 1126 | solution = lambda s, l : re.sub(l, "" , s) 1127 | ``` 1128 | 1129 | - js 1130 | 1131 | ```js 1132 | function solution(my_string, letter) { 1133 | const answer = my_string.split(letter).join(""); 1134 | return answer; 1135 | } 1136 | 1137 | function solution(my_string, letter) { 1138 | let reg = new RegExp(letter, "g"); 1139 | return my_string.replace(reg, ""); 1140 | } 1141 | ``` 1142 | 1143 | ## 문자 반복 출력하기 1144 | 1145 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120825 1146 | - python 1147 | 1148 | ```py 1149 | def solution(my_string, n): 1150 | return ''.join(i*n for i in my_string) 1151 | 1152 | def solution(my_string, n): 1153 | answer = '' 1154 | for i in my_string: 1155 | answer += (i * n) 1156 | return answer 1157 | ``` 1158 | 1159 | - js 1160 | 1161 | ```js 1162 | function solution(my_string, n) { 1163 | var answer = [...my_string].map((v) => v.repeat(n)).join(""); 1164 | console.log(answer); 1165 | return answer; 1166 | } 1167 | ``` 1168 | 1169 | ## 세균 증식 1170 | 1171 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120910 1172 | - python 1173 | 1174 | ```py 1175 | def solution(n, t): 1176 | return n << t 1177 | 1178 | def solution(n, t): 1179 | return n*(2**(t)) 1180 | ``` 1181 | 1182 | - js 1183 | 1184 | ```js 1185 | function solution(n, t) { 1186 | return n * 2 ** t; 1187 | } 1188 | 1189 | function solution(n, t) { 1190 | while (t-- > 0) n *= 2; 1191 | return n; 1192 | } 1193 | ``` 1194 | 1195 | ## 숨어있는 숫자의 덧셈 (1) 1196 | 1197 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120851 1198 | - python 1199 | 1200 | ```py 1201 | def solution(my_string): 1202 | answer = 0 1203 | for i in my_string: 1204 | if i.isnumeric(): 1205 | answer += int(i) 1206 | return answer 1207 | 1208 | def solution(my_string): 1209 | return sum(int(i) for i in my_string if i.isdigit()) 1210 | 1211 | import re 1212 | 1213 | def solution(my_string): 1214 | return sum(int(n) for n in re.sub('[^1-9]', '', my_string)) 1215 | ``` 1216 | 1217 | - js 1218 | 1219 | ```js 1220 | function solution(my_string) { 1221 | return my_string 1222 | .replaceAll(/[^\d]/g, "") 1223 | .split("") 1224 | .map((v) => +v) 1225 | .reduce((a, v) => a + v, 0); 1226 | } 1227 | 1228 | function solution(my_string) { 1229 | return my_string 1230 | .match(/[0-9]/g) 1231 | .reduce((a, b) => parseInt(a) + parseInt(b)); 1232 | } 1233 | ``` 1234 | 1235 | ## 개미군단 1236 | 1237 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120837 1238 | - python 1239 | 1240 | ```py 1241 | def solution(hp): 1242 | answer = hp // 5 1243 | hp = hp % 5 1244 | answer += hp // 3 1245 | hp = hp % 3 1246 | answer += hp // 1 1247 | return answer 1248 | 1249 | def solution(hp): 1250 | return hp // 5 + (hp % 5 // 3) + ((hp % 5) % 3) 1251 | ``` 1252 | 1253 | - js 1254 | 1255 | ```js 1256 | function solution(hp) { 1257 | return Math.floor(hp / 5) + Math.floor((hp % 5) / 3) + ((hp % 5) % 3); 1258 | } 1259 | ``` 1260 | 1261 | ## 문자열 정렬하기 (1) 1262 | 1263 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120850 1264 | - python 1265 | 1266 | ```py 1267 | def solution(my_string): 1268 | return sorted(int(i) for i in my_string if i.isdigit()) 1269 | ``` 1270 | 1271 | - js 1272 | 1273 | ```js 1274 | function solution(my_string) { 1275 | return my_string 1276 | .match(/\d/g) 1277 | .sort((a, b) => a - b) 1278 | .map((n) => parseInt(n)); 1279 | } 1280 | 1281 | function solution(my_string) { 1282 | return my_string 1283 | .split("") 1284 | .filter((v) => !isNaN(v)) 1285 | .map((v) => v * 1) 1286 | .sort((a, b) => a - b); 1287 | } 1288 | ``` 1289 | 1290 | ## 중앙값 구하기 1291 | 1292 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120811 1293 | - python 1294 | 1295 | ```py 1296 | def solution(array): 1297 | 중앙 = len(array) // 2 1298 | return sorted(array)[중앙] 1299 | ``` 1300 | 1301 | - js 1302 | 1303 | ```js 1304 | function solution(array) { 1305 | return array.sort((a, b) => a - b)[Math.floor(array.length / 2)]; 1306 | } 1307 | ``` 1308 | 1309 | ## 직각삼각형 출력하기 1310 | 1311 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120823 1312 | - python 1313 | 1314 | ```py 1315 | n = int(input()) 1316 | for i in range(n): 1317 | print('*' * (i+1)) 1318 | ``` 1319 | 1320 | - js 1321 | 1322 | ```js 1323 | // 기본 소스코드 1324 | const readline = require("readline"); 1325 | const rl = readline.createInterface({ 1326 | input: process.stdin, 1327 | output: process.stdout, 1328 | }); 1329 | 1330 | let input = []; 1331 | 1332 | rl.on("line", function (line) { 1333 | input = line.split(" "); 1334 | }).on("close", function () { 1335 | console.log(Number(input[0])); 1336 | }); 1337 | 1338 | // 풀이 1339 | const readline = require("readline"); 1340 | const rl = readline.createInterface({ 1341 | input: process.stdin, 1342 | output: process.stdout, 1343 | }); 1344 | 1345 | let input = []; 1346 | 1347 | rl.on("line", function (line) { 1348 | input = line.split(" "); 1349 | }).on("close", function () { 1350 | for (let i = 1; i <= +input[0]; i++) { 1351 | console.log("*".repeat(i)); 1352 | } 1353 | }); 1354 | ``` 1355 | 1356 | ## 대문자와 소문자 1357 | 1358 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120893 1359 | - python 1360 | 1361 | ```py 1362 | def solution(my_string): 1363 | answer = '' 1364 | for i in my_string: 1365 | if i.isupper(): 1366 | answer += i.lower() 1367 | else: 1368 | answer += i.upper() 1369 | return answer 1370 | ``` 1371 | 1372 | - js 1373 | 1374 | ```js 1375 | function solution(my_string) { 1376 | var answer = ""; 1377 | for (let c of my_string) 1378 | answer += c === c.toLowerCase() ? c.toUpperCase() : c.toLowerCase(); 1379 | return answer; 1380 | } 1381 | ``` 1382 | 1383 | ## 가위 바위 보 - 22년 12월 10일 1384 | 1385 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120839 1386 | - python 1387 | 1388 | ```py 1389 | def solution(rsp): 1390 | d = {'0':'5','2':'0','5':'2'} 1391 | return ''.join(d[i] for i in rsp) 1392 | 1393 | def solution(rsp): 1394 | answer = '' 1395 | for i in rsp: 1396 | if i == "0": 1397 | answer += '5' 1398 | elif i == "2": 1399 | answer += '0' 1400 | else: 1401 | answer += '2' 1402 | return answer 1403 | 1404 | def solution(rsp): 1405 | rsp = rsp.replace('2','s') 1406 | rsp = rsp.replace('5','p') 1407 | rsp = rsp.replace('0','r') 1408 | rsp = rsp.replace('r','5') 1409 | rsp = rsp.replace('s','0') 1410 | rsp = rsp.replace('p','2') 1411 | return rsp 1412 | ``` 1413 | 1414 | - js 1415 | 1416 | ```js 1417 | function solution(rsp) { 1418 | let arr = { 1419 | 2: 0, 1420 | 0: 5, 1421 | 5: 2, 1422 | }; 1423 | var answer = [...rsp].map((v) => arr[v]).join(""); 1424 | return answer; 1425 | } 1426 | ``` 1427 | 1428 | ## 문자열 정렬하기 (2) 1429 | 1430 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120911 1431 | - python 1432 | 1433 | ```py 1434 | def solution(my_string): 1435 | return ''.join(sorted(my_string.lower())) 1436 | ``` 1437 | 1438 | - js 1439 | 1440 | ```js 1441 | function solution(my_string) { 1442 | return my_string.toLowerCase().split("").sort().join(""); 1443 | } 1444 | ``` 1445 | 1446 | ## 배열 회전시키기 - 22년 12월 11일 1447 | 1448 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120844 1449 | - python 1450 | 1451 | ```py 1452 | from collections import deque 1453 | 1454 | def solution(numbers, direction): 1455 | numbers = deque(numbers) 1456 | if direction == "right": direction = 1 1457 | if direction == "left": direction = -1 1458 | numbers.rotate(direction) 1459 | return list(numbers) 1460 | 1461 | def solution(numbers, direction): 1462 | return [numbers[-1]] + numbers[:-1] if direction == 'right' else numbers[1:] + [numbers[0]] 1463 | ``` 1464 | 1465 | - js 1466 | 1467 | ```js 1468 | function solution(numbers, direction) { 1469 | var answer = []; 1470 | if ("right" == direction) { 1471 | numbers.unshift(numbers.pop()); 1472 | } else { 1473 | numbers.push(numbers.shift()); 1474 | } 1475 | answer = numbers; 1476 | return answer; 1477 | } 1478 | 1479 | function solution(numbers, direction) { 1480 | return direction === "right" 1481 | ? [numbers[numbers.length - 1], ...numbers.slice(0, numbers.length - 1)] 1482 | : [...numbers.slice(1), numbers[0]]; 1483 | } 1484 | 1485 | function solution(numbers, direction) { 1486 | if (direction === "right") { 1487 | numbers = [numbers.pop(), ...numbers]; 1488 | } else { 1489 | numbers = [...numbers.slice(1), numbers.shift()]; 1490 | } 1491 | return numbers; 1492 | } 1493 | ``` 1494 | 1495 | ## 피자 나눠 먹기 (2) 1496 | 1497 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120815 1498 | - python 1499 | 1500 | ```py 1501 | def solution(n): 1502 | for answer in range(1, 1000): 1503 | if (answer * 6) % n == 0: 1504 | return answer 1505 | return answer 1506 | 1507 | def solution(n): 1508 | i = 1 1509 | while(1): 1510 | if (6 * i) % n == 0: 1511 | return i 1512 | i += 1 1513 | ``` 1514 | 1515 | - js 1516 | 1517 | ```js 1518 | const solution = (n) => { 1519 | let piece = 6; 1520 | 1521 | while (true) { 1522 | if (piece % n === 0) { 1523 | break; 1524 | } 1525 | piece += 6; 1526 | } 1527 | 1528 | return piece / 6; 1529 | }; 1530 | 1531 | function solution(n) { 1532 | let pizza = 1; 1533 | while ((pizza * 6) % n) { 1534 | pizza++; 1535 | } 1536 | return pizza; 1537 | } 1538 | ``` 1539 | 1540 | ## 숫자 찾기 1541 | 1542 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120904 1543 | - python 1544 | 1545 | ```py 1546 | def solution(num, k): 1547 | num = str(num) 1548 | k = str(k) 1549 | if not k in num: 1550 | answer = -1 1551 | else: 1552 | answer = num.find(k) + 1 1553 | return answer 1554 | ``` 1555 | 1556 | - js 1557 | 1558 | ```js 1559 | function solution(num, k) { 1560 | return num.toString().split("").indexOf(String(k)) + 1 || -1; 1561 | } 1562 | 1563 | function solution(num, k) { 1564 | var answer = num.toString(); 1565 | if (answer.includes(k)) { 1566 | return answer.indexOf(k) + 1; 1567 | } else { 1568 | return -1; 1569 | } 1570 | } 1571 | ``` 1572 | 1573 | ## 주사위의 개수 1574 | 1575 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120845 1576 | - python 1577 | 1578 | ```py 1579 | def solution(box, n): 1580 | return (box[0] // n) * (box[1] // n) * (box[2] // n) 1581 | ``` 1582 | 1583 | - js 1584 | 1585 | ```js 1586 | function solution(box, n) { 1587 | let [width, length, height] = box; 1588 | 1589 | return ( 1590 | Math.floor(width / n) * Math.floor(length / n) * Math.floor(height / n) 1591 | ); 1592 | } 1593 | ``` 1594 | 1595 | ## 외계행성의 나이 - 22년 12월 11일 1596 | 1597 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120834 1598 | - python 1599 | 1600 | ```py 1601 | def solution(age): 1602 | answer = '' 1603 | for i in str(age): 1604 | answer += str(chr(int(i) + 97)) 1605 | return answer 1606 | ``` 1607 | 1608 | - js 1609 | 1610 | ```js 1611 | function solution(age) { 1612 | let char = "abcdefghij"; 1613 | return Array.from(age.toString()) 1614 | .map((t) => char[+t]) 1615 | .join(""); 1616 | } 1617 | 1618 | function solution(age) { 1619 | return age 1620 | .toString() 1621 | .split("") 1622 | .map((v) => "abcdefghij"[v]) 1623 | .join(""); 1624 | } 1625 | ``` 1626 | 1627 | ## 암호 해독 1628 | 1629 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120892 1630 | - python 1631 | 1632 | ```py 1633 | def solution(cipher, code): 1634 | return cipher[code-1::code] 1635 | ``` 1636 | 1637 | - js 1638 | 1639 | ```js 1640 | function solution(cipher, code) { 1641 | return cipher 1642 | .split("") 1643 | .filter((_, index) => (index + 1) % code === 0) 1644 | .join(""); 1645 | } 1646 | 1647 | function solution(cipher, code) { 1648 | var answer = ""; 1649 | for (let i = code - 1; i < cipher.length; i += code) { 1650 | answer += cipher[i]; 1651 | } 1652 | return answer; 1653 | } 1654 | ``` 1655 | 1656 | ## 인덱스 바꾸기 1657 | 1658 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120895 1659 | - python 1660 | 1661 | ```py 1662 | def solution(my_string, num1, num2): 1663 | answer = my_string[:num1] + my_string[num2] + my_string[num1+1:num2] + my_string[num1] + my_string[num2+1:] 1664 | return answer 1665 | 1666 | def solution(my_string, num1, num2): 1667 | s = list(my_string) 1668 | s[num1],s[num2] = s[num2],s[num1] 1669 | return ''.join(s) 1670 | ``` 1671 | 1672 | - js 1673 | 1674 | ```js 1675 | function solution(my_string, num1, num2) { 1676 | my_string = my_string.split(""); 1677 | [my_string[num1], my_string[num2]] = [my_string[num2], my_string[num1]]; 1678 | return my_string.join(""); 1679 | } 1680 | ``` 1681 | 1682 | ## 최댓값 만들기 (2) 1683 | 1684 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120862 1685 | - python 1686 | 1687 | ```py 1688 | def solution(numbers): 1689 | numbers.sort() 1690 | if numbers[0] * numbers[1] > numbers[-1] * numbers[-2]: 1691 | return numbers[0] * numbers[1] 1692 | return numbers[-1] * numbers[-2] 1693 | 1694 | def solution(numbers): 1695 | numbers = sorted(numbers) 1696 | return max(numbers[0] * numbers[1], numbers[-1]*numbers[-2]) 1697 | ``` 1698 | 1699 | - js 1700 | 1701 | ```js 1702 | function solution(numbers) { 1703 | numbers.sort((a, b) => a - b); 1704 | return Math.max( 1705 | numbers[0] * numbers[1], 1706 | numbers[numbers.length - 1] * numbers[numbers.length - 2] 1707 | ); 1708 | } 1709 | ``` 1710 | 1711 | ## 369게임 1712 | 1713 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120891 1714 | - python 1715 | 1716 | ```py 1717 | def solution(order): 1718 | answer = str(order).count('3') 1719 | answer += str(order).count('6') 1720 | answer += str(order).count('9') 1721 | return answer 1722 | 1723 | def solution(order): 1724 | return sum(map(lambda x: str(order).count(str(x)), [3, 6, 9])) 1725 | 1726 | list(filter(lambda x : x in '369', '29423')) 1727 | 1728 | import re 1729 | re.findall('[369]', '29423') 1730 | ``` 1731 | 1732 | - js 1733 | 1734 | ```js 1735 | function solution(order) { 1736 | return ("" + order).split(/[369]/).length - 1; 1737 | } 1738 | 1739 | function solution(order) { 1740 | let value = order.toString().match(/[369]/g) ?? []; 1741 | return value.length; 1742 | } 1743 | 1744 | function solution(order) { 1745 | const mySet = new Set([3, 6, 9]); 1746 | return String(order) 1747 | .split("") 1748 | .filter((num) => mySet.has(Number(num))).length; 1749 | } 1750 | ``` 1751 | 1752 | ## 7의 개수 1753 | 1754 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120912 1755 | - python 1756 | 1757 | ```py 1758 | def solution(array): 1759 | return ''.join(map(str, array)).count('7') 1760 | ``` 1761 | 1762 | - js 1763 | 1764 | ```js 1765 | function solution(array) { 1766 | return array.join("").split("7").length - 1; 1767 | } 1768 | ``` 1769 | 1770 | ## 합성수 찾기 1771 | 1772 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120846 1773 | - python 1774 | 1775 | ```py 1776 | # 7 * 7 = 49를 놓침 1777 | def solution(n): 1778 | answer = 0 1779 | if n == 1 or n == 2 or n == 3: 1780 | return 0 1781 | for i in range(2, n+1): 1782 | for j in range(2, i): 1783 | if i % j == 0: 1784 | answer += 1 1785 | break 1786 | return answer 1787 | ``` 1788 | 1789 | - js 1790 | 1791 | ```js 1792 | // 최고의 풀이 1793 | function solution(n) { 1794 | if (n === 1) return 0; 1795 | if (n === 2) return 0; 1796 | if (n === 3) return 0; 1797 | if (n === 4) return 1; 1798 | if (n === 5) return 1; 1799 | if (n === 6) return 2; 1800 | if (n === 7) return 2; 1801 | if (n === 8) return 3; 1802 | if (n === 9) return 4; 1803 | if (n === 10) return 5; 1804 | if (n === 11) return 5; 1805 | if (n === 12) return 6; 1806 | if (n === 13) return 6; 1807 | if (n === 14) return 7; 1808 | if (n === 15) return 8; 1809 | if (n === 16) return 9; 1810 | if (n === 17) return 9; 1811 | if (n === 18) return 10; 1812 | if (n === 19) return 10; 1813 | if (n === 20) return 11; 1814 | if (n === 21) return 12; 1815 | if (n === 22) return 13; 1816 | if (n === 23) return 13; 1817 | if (n === 24) return 14; 1818 | if (n === 25) return 15; 1819 | if (n === 26) return 16; 1820 | if (n === 27) return 17; 1821 | if (n === 28) return 18; 1822 | if (n === 29) return 18; 1823 | if (n === 30) return 19; 1824 | if (n === 31) return 19; 1825 | if (n === 32) return 20; 1826 | if (n === 33) return 21; 1827 | if (n === 34) return 22; 1828 | if (n === 35) return 23; 1829 | if (n === 36) return 24; 1830 | if (n === 37) return 24; 1831 | if (n === 38) return 25; 1832 | if (n === 39) return 26; 1833 | if (n === 40) return 27; 1834 | if (n === 41) return 27; 1835 | if (n === 42) return 28; 1836 | if (n === 43) return 28; 1837 | if (n === 44) return 29; 1838 | if (n === 45) return 30; 1839 | if (n === 46) return 31; 1840 | if (n === 47) return 31; 1841 | if (n === 48) return 32; 1842 | if (n === 49) return 33; 1843 | if (n === 50) return 34; 1844 | if (n === 51) return 35; 1845 | if (n === 52) return 36; 1846 | if (n === 53) return 36; 1847 | if (n === 54) return 37; 1848 | if (n === 55) return 38; 1849 | if (n === 56) return 39; 1850 | if (n === 57) return 40; 1851 | if (n === 58) return 41; 1852 | if (n === 59) return 41; 1853 | if (n === 60) return 42; 1854 | if (n === 61) return 42; 1855 | if (n === 62) return 43; 1856 | if (n === 63) return 44; 1857 | if (n === 64) return 45; 1858 | if (n === 65) return 46; 1859 | if (n === 66) return 47; 1860 | if (n === 67) return 47; 1861 | if (n === 68) return 48; 1862 | if (n === 69) return 49; 1863 | if (n === 70) return 50; 1864 | if (n === 71) return 50; 1865 | if (n === 72) return 51; 1866 | if (n === 73) return 51; 1867 | if (n === 74) return 52; 1868 | if (n === 75) return 53; 1869 | if (n === 76) return 54; 1870 | if (n === 77) return 55; 1871 | if (n === 78) return 56; 1872 | if (n === 79) return 56; 1873 | if (n === 80) return 57; 1874 | if (n === 81) return 58; 1875 | if (n === 82) return 59; 1876 | if (n === 83) return 59; 1877 | if (n === 84) return 60; 1878 | if (n === 85) return 61; 1879 | if (n === 86) return 62; 1880 | if (n === 87) return 63; 1881 | if (n === 88) return 64; 1882 | if (n === 89) return 64; 1883 | if (n === 90) return 65; 1884 | if (n === 91) return 66; 1885 | if (n === 92) return 67; 1886 | if (n === 93) return 68; 1887 | if (n === 94) return 69; 1888 | if (n === 95) return 70; 1889 | if (n === 96) return 71; 1890 | if (n === 97) return 71; 1891 | if (n === 98) return 72; 1892 | if (n === 99) return 73; 1893 | if (n === 100) return 74; 1894 | return undefined; 1895 | } 1896 | 1897 | function solution(n) { 1898 | let dp = new Array(n + 1).fill(1); 1899 | for (let i = 2; i <= n; i++) { 1900 | if (dp[i]) { 1901 | for (let j = 2; i * j <= n; j++) { 1902 | dp[i * j] = 0; 1903 | } 1904 | } 1905 | } 1906 | 1907 | return dp.filter((el) => el === 0).length; 1908 | } 1909 | ``` 1910 | 1911 | ## 모스부호 (1) 1912 | 1913 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120838 1914 | - python 1915 | 1916 | ```py 1917 | def solution(letter): 1918 | morse = morse = { 1919 | ".-": "a", 1920 | "-...": "b", 1921 | "-.-.": "c", 1922 | "-..": "d", 1923 | ".": "e", 1924 | "..-.": "f", 1925 | "--.": "g", 1926 | "....": "h", 1927 | "..": "i", 1928 | ".---": "j", 1929 | "-.-": "k", 1930 | ".-..": "l", 1931 | "--": "m", 1932 | "-.": "n", 1933 | "---": "o", 1934 | ".--.": "p", 1935 | "--.-": "q", 1936 | ".-.": "r", 1937 | "...": "s", 1938 | "-": "t", 1939 | "..-": "u", 1940 | "...-": "v", 1941 | ".--": "w", 1942 | "-..-": "x", 1943 | "-.--": "y", 1944 | "--..": "z", 1945 | } 1946 | answer = '' 1947 | for i in letter.split(' '): 1948 | answer += morse[i] 1949 | return answer 1950 | ``` 1951 | 1952 | - js 1953 | 1954 | ```js 1955 | function solution(letter) { 1956 | let morse = { 1957 | ".-": "a", 1958 | "-...": "b", 1959 | "-.-.": "c", 1960 | "-..": "d", 1961 | ".": "e", 1962 | "..-.": "f", 1963 | "--.": "g", 1964 | "....": "h", 1965 | "..": "i", 1966 | ".---": "j", 1967 | "-.-": "k", 1968 | ".-..": "l", 1969 | "--": "m", 1970 | "-.": "n", 1971 | "---": "o", 1972 | ".--.": "p", 1973 | "--.-": "q", 1974 | ".-.": "r", 1975 | "...": "s", 1976 | "-": "t", 1977 | "..-": "u", 1978 | "...-": "v", 1979 | ".--": "w", 1980 | "-..-": "x", 1981 | "-.--": "y", 1982 | "--..": "z", 1983 | }; 1984 | return letter 1985 | .split(" ") 1986 | .map((v) => morse[v]) 1987 | .join(""); 1988 | } 1989 | ``` 1990 | 1991 | ## 중복된 문자 제거 - 12월 14일 1992 | 1993 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120888 1994 | - python 1995 | 1996 | ```py 1997 | def solution(my_string): 1998 | answer = '' 1999 | set(my_string) # 순서를 보장하지 않음 2000 | for i in my_string: 2001 | if not i in answer: 2002 | answer += i 2003 | return answer 2004 | 2005 | def solution(my_string): 2006 | return ''.join(dict.fromkeys(my_string)) 2007 | ``` 2008 | 2009 | - js 2010 | 2011 | ```js 2012 | function solution(my_string) { 2013 | return [...new Set(my_string)].join(""); 2014 | } 2015 | 2016 | function solution(my_string) { 2017 | let s = new Set(Array.from(my_string)); 2018 | return [...s.values()].join(""); 2019 | } 2020 | ``` 2021 | 2022 | ## 2차원으로 만들기 2023 | 2024 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120842 2025 | - python 2026 | 2027 | ```py 2028 | def solution(num_list, n): 2029 | answer = [] 2030 | for i in range(len(num_list)//n): 2031 | answer.append(num_list[:n]) 2032 | num_list = num_list[n:] 2033 | return answer 2034 | 2035 | import numpy as np 2036 | def solution(num_list, n): 2037 | li = np.array(num_list).reshape(-1,n) 2038 | return li.tolist() 2039 | 2040 | # 참고 2041 | # np.array([1, 2, 3, 4, 5, 6, 7, 8]).reshape(4, 2) # 4행 2열 2042 | ``` 2043 | 2044 | - js 2045 | 2046 | ```js 2047 | function solution(num_list, n) { 2048 | var answer = []; 2049 | 2050 | while (num_list.length) { 2051 | answer.push(num_list.splice(0, n)); 2052 | } 2053 | 2054 | return answer; 2055 | } 2056 | ``` 2057 | 2058 | ## A로 B 만들기 - 12월 15일 2059 | 2060 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120886 2061 | - python 2062 | 2063 | ```py 2064 | def solution(before, after): 2065 | if len(before) != len(after): 2066 | return 0 2067 | before = list(before) 2068 | after = list(after) 2069 | for i in before: 2070 | if not i in after: 2071 | return 0 2072 | else: 2073 | after.remove(i) 2074 | return 1 2075 | 2076 | def solution(before, after): 2077 | before=sorted(before) 2078 | after=sorted(after) 2079 | if before==after: 2080 | return 1 2081 | else: 2082 | return 0 2083 | 2084 | def solution(before, after): 2085 | return 1 if sorted(list(before)) == sorted(list(after)) else 0 2086 | ``` 2087 | 2088 | - js 2089 | 2090 | ```js 2091 | function solution(before, after) { 2092 | return before.split("").sort().join("") === after.split("").sort().join("") 2093 | ? 1 2094 | : 0; 2095 | } 2096 | ``` 2097 | 2098 | ## 팩토리얼 - 12월 15일 2099 | 2100 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120848 2101 | - python 2102 | 2103 | ```py 2104 | def solution(n): 2105 | f = 1 2106 | i = 1 2107 | while f <= n: 2108 | i += 1 2109 | f *= i 2110 | return i - 1 2111 | 2112 | from math import factorial 2113 | 2114 | def solution(n): 2115 | i = 1 2116 | while factorial(i) <= n: 2117 | i += 1 2118 | return i - 1 2119 | 2120 | #### 2121 | 2122 | def factorial(i): 2123 | result = 1 2124 | for j in range(1, i+1): 2125 | result *= j 2126 | return result 2127 | 2128 | def solution(n): 2129 | for i in range(1, 11): 2130 | if factorial(i) <= n: 2131 | answer = i 2132 | else: 2133 | break 2134 | return answer 2135 | 2136 | from math import factorial 2137 | 2138 | def solution(n): 2139 | k = 10 2140 | while n < factorial(k): 2141 | k -= 1 2142 | return k 2143 | ``` 2144 | 2145 | - js 2146 | 2147 | ```js 2148 | function solution(n) { 2149 | let i = 1; 2150 | let f = 1; 2151 | while (f * i < n) f *= ++i; 2152 | return i; 2153 | } 2154 | ``` 2155 | 2156 | ## k의 개수 - 12월 18일 2157 | 2158 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120887 2159 | - python 2160 | 2161 | ```py 2162 | def solution(i, j, k): 2163 | return str([num for num in range(i, j+1)]).count(str(k)) 2164 | 2165 | def solution(i, j, k): 2166 | return sum(map(lambda v: str(v).count(str(k)), range(i, j+1))) 2167 | ``` 2168 | 2169 | - js 2170 | 2171 | ```js 2172 | function solution(i, j, k) { 2173 | let a = ""; 2174 | for (i; i <= j; i++) { 2175 | a += i; 2176 | } 2177 | 2178 | return a.split(k).length - 1; 2179 | } 2180 | 2181 | function solution(i, j, k) { 2182 | return ( 2183 | Array(j - i + 1) 2184 | .fill(i) 2185 | .map((v, i) => v + i) 2186 | .join("") 2187 | .split(k).length - 1 2188 | ); 2189 | } 2190 | 2191 | function solution(i, j, k) { 2192 | let str = Array(j - i + 1) 2193 | .fill(i) 2194 | .map((v, i) => v + i) 2195 | .join(""); 2196 | return Array.from(str).filter((t) => +t === k).length; 2197 | } 2198 | ``` 2199 | 2200 | ## 가까운 수 - 12월 18일 2201 | 2202 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120890 2203 | - python 2204 | 2205 | ```py 2206 | def solution(array, n): 2207 | value = sorted(array, key=lambda x:abs(n-x)) 2208 | if abs(value[0] - n) == abs(value[1] - n): 2209 | return min(value[0], value[1]) 2210 | return sorted(array, key=lambda x:abs(n-x))[0] 2211 | 2212 | def solution(array, n): 2213 | sorted(array, key=lambda x:(abs(x-n),x-n))[0] 2214 | 2215 | # 첫번째 인자를 오름차순 2216 | # 두번째 인자를 내림차순 2217 | # sorted(a, key=lambda x:(x[0], -x[1])) 2218 | ``` 2219 | 2220 | - js 2221 | 2222 | ```js 2223 | function solution(array, n) { 2224 | array.sort((a, b) => a - b); 2225 | let diff = Infinity; 2226 | let ind = Infinity; 2227 | for (let i in array) { 2228 | let calc = Math.abs(n - array[i]); 2229 | if (calc < diff) { 2230 | diff = calc; 2231 | ind = i; 2232 | } 2233 | } 2234 | return array[ind]; 2235 | } 2236 | 2237 | function solution(array, n) { 2238 | return array[ 2239 | array 2240 | .sort((a, b) => a - b) 2241 | .map((v) => Math.abs(v - n)) 2242 | .indexOf(Math.min(...array.map((v) => Math.abs(v - n)))) 2243 | ]; 2244 | } 2245 | ``` 2246 | 2247 | ## 한 번만 등장한 문자 - 12월 19일 2248 | 2249 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120896 2250 | - python 2251 | 2252 | ```py 2253 | import collections 2254 | 2255 | def solution(s): 2256 | answer = '' 2257 | for i, j in collections.Counter(s).items(): 2258 | if j == 1: 2259 | answer += i 2260 | return ''.join(sorted(answer)) 2261 | 2262 | def solution(s): 2263 | answer = "".join(sorted([ ch for ch in s if s.count(ch) == 1])) 2264 | return answer 2265 | ``` 2266 | 2267 | - js 2268 | 2269 | ```js 2270 | function solution(s) { 2271 | let res = []; 2272 | for (let c of s) if (s.indexOf(c) === s.lastIndexOf(c)) res.push(c); 2273 | return res.sort().join(""); 2274 | } 2275 | 2276 | function solution(s) { 2277 | return [...s] 2278 | .filter((c) => s.match(new RegExp(c, "g")).length == 1) 2279 | .sort() 2280 | .join(""); 2281 | } 2282 | ``` 2283 | 2284 | ## 이진수 더하기 2285 | 2286 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120885 2287 | - python 2288 | 2289 | ```py 2290 | def solution(bin1, bin2): 2291 | return bin(int(bin1, 2) + int(bin2, 2))[2:] 2292 | ``` 2293 | 2294 | - js 2295 | 2296 | ```js 2297 | function solution(bin1, bin2) { 2298 | return (parseInt(bin1, 2) + parseInt(bin2, 2)).toString(2); 2299 | } 2300 | ``` 2301 | 2302 | ## 잘라서 배열로 저장하기 - 12월 19일 2303 | 2304 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120913 2305 | - python 2306 | 2307 | ```py 2308 | import re 2309 | 2310 | n = 3 2311 | p = re.compile(f'.{{1,{n}}}') #1 ~ n회 반복 2312 | print(p) 2313 | m = p.findall("python hello world hello") 2314 | print(m) 2315 | 2316 | ######### 2317 | 2318 | import re 2319 | 2320 | def solution(my_str, n): 2321 | p = re.compile(f'.{{1,{n}}}') #1 ~ n회 반복 2322 | return p.findall(my_str) 2323 | 2324 | ######### 2325 | 2326 | import math 2327 | 2328 | def solution(my_str, n): 2329 | answer = [] 2330 | for i in range(math.ceil(len(my_str)/n)): 2331 | answer.append(my_str[n * i : n * (i+1)]) 2332 | return answer 2333 | 2334 | def solution(my_str, n): 2335 | return [my_str[i: i + n] for i in range(0, len(my_str), n)] 2336 | ``` 2337 | 2338 | - js 2339 | 2340 | ```js 2341 | // {n, m}는 바로 앞에 있는 문자가 n번 이상, m번 이하 2342 | function solution(my_str, n) { 2343 | return my_str.match(new RegExp(`.{1,${n}}`, "g")); 2344 | } 2345 | 2346 | function solution(my_str, n) { 2347 | let res = []; 2348 | for (let i = 0; i < my_str.length; i += n) res.push(my_str.slice(i, i + n)); 2349 | return res; 2350 | } 2351 | ``` 2352 | 2353 | ## 진료순서 정하기 - 12월 26일 2354 | 2355 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120835 2356 | - python 2357 | 2358 | ```py 2359 | arr = [3, 76, 24] 2360 | #응급순서 = [76, 24, 3] 2361 | 응급순서 = sorted(arr, reverse=True) 2362 | list(map(lambda x: 응급순서.index(x) + 1, arr)) 2363 | 2364 | def solution(arr): 2365 | 응급순서 = sorted(arr, reverse=True) 2366 | return list(map(lambda x: 응급순서.index(x) + 1, arr)) 2367 | 2368 | def solution(emergency): 2369 | 응급순서 = sorted(emergency, reverse=True) 2370 | return [응급순서.index(i) + 1 for i in emergency] 2371 | ``` 2372 | 2373 | - js 2374 | 2375 | ```js 2376 | function solution(emergency) { 2377 | let sorted = emergency.slice().sort((a, b) => b - a); 2378 | return emergency.map((v) => sorted.indexOf(v) + 1); 2379 | } 2380 | ``` 2381 | 2382 | ## 공 던지기 2383 | 2384 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120843 2385 | - python 2386 | 2387 | ```py 2388 | def solution(numbers, k): 2389 | numbers = numbers * k 2390 | return numbers[(k-1) * 2] 2391 | ``` 2392 | 2393 | - js 2394 | 2395 | ```js 2396 | function solution(numbers, k) { 2397 | let answer = []; 2398 | for (let i = 0; i < k; i++) { 2399 | answer = answer.concat(numbers); 2400 | } 2401 | return answer[(k - 1) * 2]; 2402 | } 2403 | ``` 2404 | 2405 | ## 숨어있는 숫자의 덧셈 (2) 2406 | 2407 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120864 2408 | - python 2409 | 2410 | ```py 2411 | import re 2412 | 2413 | def solution(my_string): 2414 | return sum(map(int, re.findall(r'[0-9]+', my_string))) 2415 | ``` 2416 | 2417 | - js 2418 | 2419 | ```js 2420 | function solution(my_string) { 2421 | return my_string.split(/\D+/).reduce((a, c) => a + parseInt(c), 0); 2422 | } 2423 | ``` 2424 | 2425 | ## 소인수분해 2426 | 2427 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120852 2428 | - python 2429 | 2430 | ```py 2431 | def solution(n): 2432 | d = 2 2433 | s = set() 2434 | while d <= n: 2435 | if n % d == 0: 2436 | s.add(d) 2437 | n = n / d 2438 | else: 2439 | d = d + 1 2440 | return sorted(list(s)) 2441 | ``` 2442 | 2443 | - js 2444 | 2445 | ```js 2446 | function solution(n) { 2447 | let answer = []; 2448 | 2449 | let i = 2; 2450 | while (i <= n) { 2451 | if (n % i === 0) { 2452 | answer.push(i); 2453 | n = n / i; 2454 | } else { 2455 | i++; 2456 | } 2457 | } 2458 | 2459 | return [...new Set(answer.sort((a, b) => (a > b ? 1 : -1)))]; 2460 | } 2461 | ``` 2462 | 2463 | ## 종이 자르기 2464 | 2465 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120922 2466 | - python 2467 | 2468 | ```py 2469 | def solution(M, N): 2470 | answer = M * N 2471 | if answer == 1: 2472 | return 0 2473 | else: 2474 | return answer-1 2475 | ``` 2476 | 2477 | - js 2478 | 2479 | ```js 2480 | function solution(M, N) { 2481 | return M * N - 1; 2482 | } 2483 | ``` 2484 | 2485 | ## 구슬을 나누는 경우의 수 2486 | 2487 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120840 2488 | - python 2489 | 2490 | ```py 2491 | import math 2492 | 2493 | def solution(balls, share): 2494 | answer = 1 2495 | for i in range(balls, balls-share, -1): 2496 | answer *= i 2497 | answer = answer // math.factorial(share) 2498 | return answer 2499 | 2500 | import math 2501 | 2502 | def solution(balls, share): 2503 | return math.comb(balls, share) 2504 | ``` 2505 | 2506 | - js 2507 | 2508 | ```js 2509 | const 팩토리얼 = (num) => (num === 0 ? 1 : num * 팩토리얼(num - 1)); 2510 | 2511 | function solution(balls, share) { 2512 | return Math.round( 2513 | 팩토리얼(balls) / 팩토리얼(balls - share) / 팩토리얼(share) 2514 | ); 2515 | } 2516 | ``` 2517 | 2518 | ## 영어가 싫어요 - 12월 27일 2519 | 2520 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120894 2521 | - python 2522 | 2523 | ```py 2524 | def solution(numbers): 2525 | return int(numbers.replace('one', '1').replace('two', '2').replace('three', '3').replace('four', '4').replace('five', '5').replace('six', '6').replace('seven', '7').replace('eight', '8').replace('nine', '9').replace('zero', '0')) 2526 | 2527 | import re 2528 | 2529 | def solution(numbers): 2530 | s = '' 2531 | d = { 2532 | 'zero' : '0', 2533 | 'one' : '1', 2534 | 'two' : '2', 2535 | 'three' : '3', 2536 | 'four' : '4', 2537 | 'five' : '5', 2538 | 'six' : '6', 2539 | 'seven' : '7', 2540 | 'eight' : '8', 2541 | 'nine' : '9' 2542 | } 2543 | for i in re.findall(r'(zero|one|two|three|four|five|six|seven|eight|nine)', numbers): 2544 | s += d[i] 2545 | return int(s) 2546 | 2547 | def solution(numbers): 2548 | for num, eng in enumerate(["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]): 2549 | numbers = numbers.replace(eng, str(num)) 2550 | return int(numbers) 2551 | ``` 2552 | 2553 | - js 2554 | 2555 | ```js 2556 | 2557 | function solution(numbers) { 2558 | return +numbers.replaceAll('one', '1').replaceAll('two', '2').replaceAll('three', '3').replaceAll('four', '4').replaceAll('five', '5').replaceAll('six', '6').replaceAll('seven', '7').replaceAll('eight', '8').replaceAll('nine', '9').replaceAll('zero', '0'); 2559 | } 2560 | 2561 | 2562 | function solution(numbers) { 2563 | const obj = { 2564 | zero: 0, 2565 | one: 1, 2566 | two: 2, 2567 | three: 3, 2568 | four: 4, 2569 | five: 5, 2570 | six: 6, 2571 | seven: 7, 2572 | eight: 8, 2573 | nine: 9, 2574 | }; 2575 | 2576 | const num = numbers.replace( 2577 | /zero|one|two|three|four|five|six|seven|eight|nine/g, 2578 | (v) => { 2579 | return obj[v]; 2580 | } 2581 | ); 2582 | 2583 | return Number(num); 2584 | } 2585 | ``` 2586 | 2587 | ## 외계어 사전 - 12월 27일 2588 | 2589 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120869 2590 | - python 2591 | 2592 | ```py 2593 | def solution(spell, dic): 2594 | for i in dic: 2595 | if set(spell) == set(i): 2596 | return 1 2597 | return 2 2598 | 2599 | def solution(spell, dic): 2600 | for d in dic: 2601 | if sorted(d) == sorted(spell): 2602 | return 1 2603 | return 2 2604 | 2605 | # list('hello') == list('hello') 2606 | # set('hello') == set('hello') 2607 | # 2개 모두 True 2608 | ``` 2609 | 2610 | - js 2611 | 2612 | ```js 2613 | function solution(spell, dic) { 2614 | return dic.some((s) => spell.sort().toString() == [...s].sort().toString()) 2615 | ? 1 2616 | : 2; 2617 | } 2618 | // some() 메서드는 배열 안의 어떤 요소라도 주어진 판별 함수를 통과하는지 테스트 2619 | 2620 | // Array('hello') == Array('hello') 2621 | // new Set('hello') == new Set('hello') 2622 | // 2개 모두 false(==, === 모두!) 2623 | // [1, 2, 3] == [1, 2, 3] // false! 2624 | ``` 2625 | 2626 | ## 문자열 계산하기 2627 | 2628 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120902 2629 | - python 2630 | 2631 | ```py 2632 | def solution(my_string): 2633 | return eval(my_string) 2634 | 2635 | solution=eval 2636 | ``` 2637 | 2638 | - js 2639 | 2640 | ```js 2641 | var solution = eval; 2642 | ``` 2643 | 2644 | ## 캐릭터의 좌표 2645 | 2646 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120861 2647 | - python 2648 | 2649 | ```py 2650 | # if가 밖에 있을 때에 실행 안됨 2651 | # 안으로 들어와야 함 2652 | # 예를 들어 보드가 11이면 2653 | # -100갔다가 뒤로 2번오면 2654 | # -98에 위치되어 -5가 되어야 하는데 2655 | # 실제로는 -3임 2656 | def solution(keyinput, board): 2657 | answer = [] 2658 | x = 0 2659 | y = 0 2660 | for i in keyinput: 2661 | if i == 'right': 2662 | x +=1 2663 | elif i == 'left': 2664 | x -=1 2665 | elif i == 'up': 2666 | y += 1 2667 | elif i == 'down': 2668 | y -= 1 2669 | if abs(x) >= (board[0] // 2): 2670 | x = (x // abs(x)) * (board[0] // 2) 2671 | if abs(y) >= (board[1] // 2): 2672 | y = (y // abs(y)) * (board[1] // 2) 2673 | return [x, y] 2674 | ``` 2675 | 2676 | - js 2677 | 2678 | ```js 2679 | function solution(keyinput, board) { 2680 | let res = [0, 0]; 2681 | for (let p of keyinput) { 2682 | switch (p) { 2683 | case "left": 2684 | if (-res[0] < board[0] / 2 - 1) res[0]--; 2685 | break; 2686 | case "right": 2687 | if (res[0] < board[0] / 2 - 1) res[0]++; 2688 | break; 2689 | case "up": 2690 | if (res[1] < board[1] / 2 - 1) res[1]++; 2691 | break; 2692 | case "down": 2693 | if (-res[1] < board[1] / 2 - 1) res[1]--; 2694 | break; 2695 | } 2696 | } 2697 | return res; 2698 | } 2699 | ``` 2700 | 2701 | ## 문자열 밀기 - 12월 28일 2702 | 2703 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120921 2704 | - python 2705 | 2706 | ```py 2707 | 2708 | # 이러한 문제 유형이 많이 나옴 2709 | # 1차원 배열을 뒤로 미는 것 2710 | # 2차원 좌표평면에서 이동하는 것 2711 | 2712 | import collections 2713 | 2714 | def solution(A, B): 2715 | if A == B: 2716 | return 0 2717 | 비교 = collections.deque(A) 2718 | for i in range(len(A)): 2719 | 비교.rotate(1) 2720 | if ''.join(비교) == B: 2721 | return i+1 2722 | return -1 2723 | 2724 | 2725 | solution=lambda a,b:(b*2).find(a) 2726 | 2727 | 2728 | def solution(A, B): 2729 | #if A == "": 2730 | # return 0 2731 | 2732 | AA = A+A 2733 | answer = AA.find(B) 2734 | 2735 | if answer >0: 2736 | answer = len(A) - answer 2737 | 2738 | return answer 2739 | 2740 | def solution(A, B): 2741 | return (B*2).find(A) 2742 | ``` 2743 | 2744 | - js 2745 | 2746 | ```js 2747 | let solution = (a, b) => (b + b).indexOf(a); 2748 | ``` 2749 | 2750 | ## 유한소수 판별하기 2751 | 2752 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120878 2753 | - python 2754 | 2755 | ```py 2756 | def solution(a, b): 2757 | 2758 | return 1 if a/b * 1000 % 1 == 0 else 2 2759 | ``` 2760 | 2761 | - js 2762 | 2763 | ```js 2764 | function solution(a, b) { 2765 | return Number((a / b).toFixed(10)) == a / b ? 1 : 2; 2766 | } 2767 | ``` 2768 | 2769 | ## 직사각형 넓이 구하기 2770 | 2771 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120860 2772 | - python 2773 | 2774 | ```py 2775 | def solution(dots): 2776 | [[x1, y1], [x2, y2], [x3, y3], [x4, y4]] = dots 2777 | return (max([x1, x2, x3, x4]) - min([x1, x2, x3, x4])) * (max([y1, y2, y3, y4]) - min([y1, y2, y3, y4])) 2778 | 2779 | def solution(dots): 2780 | return (max(dots)[0] - min(dots)[0])*(max(dots)[1] - min(dots)[1]) 2781 | ``` 2782 | 2783 | - js 2784 | 2785 | ```js 2786 | function solution(dots) { 2787 | let x = [], 2788 | y = []; 2789 | 2790 | for (let pos of dots) { 2791 | x.push(pos[0]); 2792 | y.push(pos[1]); 2793 | } 2794 | 2795 | return ( 2796 | (Math.max(...x) - Math.min(...x)) * (Math.max(...y) - Math.min(...y)) 2797 | ); 2798 | } 2799 | ``` 2800 | 2801 | ## 삼각형의 완성조건 (2) 2802 | 2803 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120868 2804 | - python 2805 | 2806 | ```py 2807 | def solution(sides): 2808 | a = max(sides) - min(sides) 2809 | b = max(sides) + min(sides) 2810 | return b-a-1 2811 | 2812 | def solution(sides): 2813 | return sum(sides) - max(sides) + min(sides) - 1 2814 | ``` 2815 | 2816 | - js 2817 | 2818 | ```js 2819 | function solution(sides) { 2820 | return Math.min(...sides) * 2 - 1; 2821 | } 2822 | ``` 2823 | 2824 | ## 컨트롤 제트 - 12월 28일 2825 | 2826 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120853 2827 | - python 2828 | 2829 | ```py 2830 | def solution(s): 2831 | result = [] 2832 | for i in s.split(' '): 2833 | if i == 'Z': 2834 | result.pop() 2835 | else: 2836 | result.append(int(i)) 2837 | return sum(result) 2838 | ``` 2839 | 2840 | - js 2841 | 2842 | ```js 2843 | function solution(s) { 2844 | s = s.split(" "); 2845 | let arr = []; 2846 | for (let v of s) v === "Z" ? (arr.length ? arr.pop() : "") : arr.push(v); 2847 | return arr.reduce((a, v) => a + +v, 0); 2848 | } 2849 | ``` 2850 | 2851 | ## 등수 매기기 - 1월 6일 2852 | 2853 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120882 2854 | - python 2855 | 2856 | ```py 2857 | def solution(score): 2858 | 평균 = [(i + j) / 2 for i, j in score] 2859 | 정렬된점수 = sorted(평균, reverse=True) 2860 | return [i+1 for i in list(map(정렬된점수.index, 평균))] 2861 | 2862 | def solution(score): 2863 | a = sorted([sum(i) for i in score], reverse = True) 2864 | return [a.index(sum(i))+1 for i in score] 2865 | ``` 2866 | 2867 | - js 2868 | 2869 | ```js 2870 | function solution(score) { 2871 | let avg = score.map((v) => (v[0] + v[1]) / 2); 2872 | let sorted = avg.slice().sort((a, b) => b - a); 2873 | return avg.map((v) => sorted.indexOf(v) + 1); 2874 | } 2875 | 2876 | function solution(score) { 2877 | return score.map((el) => { 2878 | return ( 2879 | score.filter((v) => (v[0] + v[1]) / 2 > (el[0] + el[1]) / 2) 2880 | .length + 1 2881 | ); 2882 | }); 2883 | } 2884 | ``` 2885 | 2886 | ## 로그인 성공? 2887 | 2888 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120883 2889 | - python 2890 | 2891 | ```py 2892 | def solution(id_pw, db): 2893 | result = 'fail' 2894 | if str(id_pw) in str(db): 2895 | result = 'login' 2896 | elif str(id_pw[0]) in str(db): 2897 | if id_pw[0] in [i[0] for i in db]: 2898 | result = 'wrong pw' 2899 | else: 2900 | result = 'fail' 2901 | return result 2902 | 2903 | def solution(id_pw, db): 2904 | if db_pw := dict(db).get(id_pw[0]): 2905 | return "login" if db_pw == id_pw[1] else "wrong pw" 2906 | return "fail" 2907 | ``` 2908 | 2909 | - js 2910 | 2911 | ```js 2912 | function solution(id_pw, db) { 2913 | db = db.filter((v) => v[0] === id_pw[0]); 2914 | 2915 | if (!db.length) return "fail"; 2916 | 2917 | for (let d of db) if (d[1] === id_pw[1]) return "login"; 2918 | 2919 | return "wrong pw"; 2920 | } 2921 | ``` 2922 | 2923 | ## 특이한 정렬 2924 | 2925 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120880 2926 | - python 2927 | 2928 | ```py 2929 | def solution(numlist, n): 2930 | d = [[i, abs(i-n)] for i in numlist] 2931 | return list(map(lambda x:x[0], sorted(d, key=lambda x:(x[1], -x[0])))) 2932 | 2933 | def solution(numlist, n): 2934 | answer = sorted(numlist,key = lambda x : (abs(x-n), n-x)) 2935 | return answer 2936 | 2937 | # {i:i-n for i in numlist} 2938 | # [[i, i-n] for i in numlist] 2939 | # sorted(d, key=lambda x:x[1]) 2940 | # sorted(d, key=lambda x:(x[1], -x[0])) # 다중조건 2941 | ``` 2942 | 2943 | - js 2944 | 2945 | ```js 2946 | function solution(numlist, n) { 2947 | return numlist.sort((a, b) => Math.abs(a - n) - Math.abs(b - n) || b - a); 2948 | } 2949 | 2950 | function solution(numlist, n) { 2951 | numlist.sort((a, b) => { 2952 | let n1 = Math.abs(a - n), 2953 | n2 = Math.abs(b - n); 2954 | 2955 | return n1 < n2 ? -1 : n1 === n2 ? (a < b ? 1 : -1) : 1; 2956 | }); 2957 | return numlist; 2958 | } 2959 | ``` 2960 | 2961 | ## 분수의 덧셈 2962 | 2963 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120808 2964 | - python 2965 | 2966 | ```py 2967 | import fractions 2968 | 2969 | def solution(denum1, num1, denum2, num2): 2970 | 분자 = (denum1 * num2) + (denum2 * num1) 2971 | 분모 = num1 * num2 2972 | 분수 = fractions.Fraction(분자, 분모) 2973 | 분자 = 분수.numerator 2974 | 분모 = 분수.denominator 2975 | return [분자, 분모] 2976 | 2977 | from fractions import Fraction 2978 | 2979 | def solution(denum1, num1, denum2, num2): 2980 | answer = Fraction(denum1, num1) + Fraction(denum2, num2) 2981 | return [answer.numerator, answer.denominator] 2982 | 2983 | import math 2984 | 2985 | def solution(denum1, num1, denum2, num2): 2986 | denum = denum1 * num2 + denum2 * num1 2987 | num = num1 * num2 2988 | gcd = math.gcd(denum, num) 2989 | return [denum//gcd, num//gcd] 2990 | ``` 2991 | 2992 | - js 2993 | 2994 | ```js 2995 | function fnGCD(a, b) { 2996 | return a % b ? fnGCD(b, a % b) : b; 2997 | } 2998 | 2999 | function solution(denum1, num1, denum2, num2) { 3000 | let denum = denum1 * num2 + denum2 * num1; 3001 | let num = num1 * num2; 3002 | let gcd = fnGCD(denum, num); //최대공약수 3003 | 3004 | return [denum / gcd, num / gcd]; 3005 | } 3006 | ``` 3007 | 3008 | ## 치킨 쿠폰 3009 | 3010 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120884 3011 | - python 3012 | 3013 | ```py 3014 | def solution(chicken): 3015 | answer = 0 3016 | while chicken >= 10: 3017 | chicken, mod = divmod(chicken, 10) 3018 | answer += chicken 3019 | chicken += mod 3020 | return answer 3021 | 3022 | def solution(chicken): 3023 | answer = (max(chicken, 1) - 1) // 9 3024 | return answer 3025 | 3026 | def solution(chicken): 3027 | return int(chicken*0.11111111111) 3028 | ``` 3029 | 3030 | - js 3031 | 3032 | ```js 3033 | function solution(chicken) { 3034 | let answer = 0; 3035 | let rest = 0; 3036 | while (chicken > 1) { 3037 | answer += parseInt(chicken / 10); 3038 | rest += chicken % 10; 3039 | chicken = chicken / 10; 3040 | } 3041 | answer += parseInt(rest / 10); 3042 | return answer; 3043 | } 3044 | ``` 3045 | 3046 | ## 저주의 숫자 3 - 1월 10일 3047 | 3048 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120871 3049 | - python 3050 | 3051 | ```py 3052 | def solution(n): 3053 | return list(filter(lambda x: '3' not in str(x), filter(lambda x: x % 3 != 0, range(n*1000))))[n-1] 3054 | 3055 | def solution(n): 3056 | answer = 0 3057 | for _ in range(n): 3058 | answer += 1 3059 | while answer % 3 == 0 or '3' in str(answer): 3060 | answer += 1 3061 | return answer 3062 | ``` 3063 | 3064 | - js 3065 | 3066 | ```js 3067 | function solution(n) { 3068 | var count3x = 0; 3069 | while (n > 0) { 3070 | count3x = count3x + 1; 3071 | if (count3x.toString().split("").includes("3")) { 3072 | continue; 3073 | } 3074 | if (count3x % 3 == 0) { 3075 | continue; 3076 | } 3077 | 3078 | n = n - 1; 3079 | } 3080 | return count3x; 3081 | } 3082 | 3083 | function solution(n) { 3084 | let arr = []; 3085 | let num = 0; 3086 | while (arr.length !== n && ++num) 3087 | if (num % 3 !== 0 && !("" + num).includes("3")) arr.push(num); 3088 | return arr.pop(); 3089 | } 3090 | ``` 3091 | 3092 | ## 최빈값 구하기 3093 | 3094 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120812 3095 | - python 3096 | 3097 | ```py 3098 | # from collections import Counter 3099 | 3100 | # x = Counter([1, 2, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2]) 3101 | # sorted(x, key=lambda v:x[v], reverse=True) 3102 | 3103 | from collections import Counter 3104 | 3105 | def solution(array): 3106 | if len(array) == 1: 3107 | return array[0] 3108 | x = Counter(array) 3109 | 정렬 = sorted(x.items(), key=lambda v:v[1], reverse=True) 3110 | if 정렬[0][1] == 정렬[1][1]: 3111 | return -1 3112 | return 정렬[0][0] 3113 | 3114 | # # 가장 자주 나오는 값 3115 | # answer.most_common(1)[0][0] 3116 | 3117 | # # 가장 자주 나오는 값의 개수 3118 | # answer.most_common(2)[0][1] 3119 | 3120 | # # 두번째로 가장 자주 나오는 값의 개수 3121 | # answer.most_common(2)[1][1] 3122 | 3123 | from collections import Counter 3124 | 3125 | def solution(array): 3126 | answer = Counter(array) 3127 | 3128 | if len(answer) == 1: 3129 | return answer.most_common(1)[0][0] 3130 | else: 3131 | first = answer.most_common(2)[0][1] 3132 | second = answer.most_common(2)[1][1] 3133 | if first == second: 3134 | return -1 3135 | else: 3136 | return answer.most_common(1)[0][0] 3137 | 3138 | def solution(array): 3139 | while len(array) != 0: 3140 | for i, a in enumerate(set(array)): 3141 | array.remove(a) 3142 | if i == 0: return a 3143 | return -1 3144 | ``` 3145 | 3146 | - js 3147 | 3148 | ```js 3149 | const solution = (array) => { 3150 | const counter = array.reduce( 3151 | (acc, cur) => ({ 3152 | ...acc, 3153 | [cur]: (acc[cur] || 0) + 1, 3154 | }), 3155 | {} 3156 | ); 3157 | 3158 | const items = Object.keys(counter) 3159 | .map((key) => [Number(key), counter[key]]) 3160 | .sort((a, b) => b[1] - a[1]); 3161 | 3162 | if (items[0][1] === items?.[1]?.[1]) { 3163 | return -1; 3164 | } 3165 | 3166 | return items[0][0]; 3167 | }; 3168 | 3169 | function solution(array) { 3170 | let m = new Map(); 3171 | for (let n of array) m.set(n, (m.get(n) || 0) + 1); 3172 | m = [...m].sort((a, b) => b[1] - a[1]); 3173 | return m.length === 1 || m[0][1] > m[1][1] ? m[0][0] : -1; 3174 | } 3175 | ``` 3176 | 3177 | ## 다항식 더하기 - 1월 11일 3178 | 3179 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120863 3180 | - python 3181 | 3182 | ```py 3183 | def solution(입력값): 3184 | 항 = [0, 0] # x항, 일반항 3185 | for i in 입력값.replace(' ', '').split('+'): 3186 | if 'x' in i: 3187 | if len(i) == 1: 3188 | 항[0] += 1 3189 | else: 3190 | 항[0] += int(i[:-1]) 3191 | else: 3192 | 항[1] += int(i) 3193 | 3194 | # if 항[0] == 1 and 항[1] == 0: 3195 | # return f"x" 3196 | # if 항[0] == 1 and 항[1] != 0: 3197 | # return f"x + {항[1]}" 3198 | # 간소화 3199 | if 항[0] == 1: 3200 | return f"x" if 항[1] == 0 else f"x + {항[1]}" 3201 | 3202 | 3203 | 3204 | if 항[0] == 0 and 항[1] == 0: 3205 | return f"" 3206 | if 항[0] == 0 and 항[1] != 0: 3207 | return f"{항[1]}" 3208 | if 항[0] != 0 and 항[1] == 0: 3209 | return f"{항[0]}x" 3210 | if 항[0] != 0 and 항[1] != 0: 3211 | return f"{항[0]}x + {항[1]}" 3212 | 3213 | solution("3x + 7 + x") 3214 | ``` 3215 | 3216 | - js 3217 | 3218 | ```js 3219 | function solution(polynomial) { 3220 | const arr = polynomial.split(' + ') 3221 | const x항 = arr.filter(v => v.includes('x')).map(v => parseInt(v.replace('x', '')) || 1).reduce((a, c) => a + c, 0) 3222 | const 일반항 = arr.filter(v => !v.includes('x')).reduce((a, c) => a + parseInt(c), 0) 3223 | const answer = [] 3224 | if (x항){ 3225 | if (x항 === 1){ 3226 | answer.push('x') 3227 | } else { 3228 | answer.push(`${x항}x`) 3229 | } 3230 | } 3231 | if (일반항){ 3232 | answer.push(일반항) 3233 | } 3234 | return answer.join(' + '); 3235 | } 3236 | ``` 3237 | 3238 | ## 다음에 올 숫자 3239 | 3240 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120924 3241 | - python 3242 | 3243 | ```py 3244 | # 왜 오답이 나왔는지 모르겠음 3245 | s = [2, 4, 6] 3246 | s = [1, 2, 3, 4] 3247 | s = [2, 4, 8] 3248 | s = [3, 6, 12] 3249 | s = [-3, -6, -12] 3250 | s = [-3, 6, -12] 3251 | 3252 | if s[1] - s[0] == s[2] - s[1]: 3253 | 등차 = s[1] - s[0] 3254 | s.append((len(s) + 1) * 등차) 3255 | else: 3256 | 등비 = s[1] // s[0] 3257 | s.append(s[0] * (등비**len(s))) 3258 | 3259 | 3260 | def solution(common): 3261 | if common[2] - common[1] == common[1] - common[0]: 3262 | return common[-1] + (common[1] - common[0]) 3263 | else: 3264 | return common[-1] * (common[2] // common[1]) 3265 | 3266 | def solution(common): 3267 | answer = 0 3268 | a,b,c = common[:3] 3269 | if (b-a) == (c-b): 3270 | return common[-1]+(b-a) 3271 | else: 3272 | return common[-1] * (b//a) 3273 | return answer 3274 | ``` 3275 | 3276 | - js 3277 | 3278 | ```js 3279 | function solution(common) { 3280 | if (common[1] - common[0] == common[2] - common[1]) { 3281 | return common.pop() + common[1] - common[0]; 3282 | } else { 3283 | return (common.pop() * common[1]) / common[0]; 3284 | } 3285 | } 3286 | ``` 3287 | 3288 | ## OX퀴즈 3289 | 3290 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120907 3291 | - python 3292 | 3293 | ```py 3294 | def solution(quiz): 3295 | answer = [] 3296 | for i in quiz: 3297 | c = i.split('=') 3298 | for j in range (len(c)): 3299 | if eval(c[0]) == eval(c[1]): 3300 | answer.append('O') 3301 | break 3302 | else: 3303 | answer.append('X') 3304 | break 3305 | return answer 3306 | 3307 | 3308 | 3309 | def valid(equation): 3310 | equation = equation.replace('=', '==') 3311 | return eval(equation) 3312 | 3313 | def solution(equations): 3314 | return ["O" if valid(equation) else "X" for equation in equations] 3315 | ``` 3316 | 3317 | - js 3318 | 3319 | ```js 3320 | function solution(quiz) { 3321 | return quiz 3322 | .map((el) => el.split(" = ")) 3323 | .map((el) => { 3324 | return eval(el[0]) == el[1] ? "O" : "X"; 3325 | }); 3326 | } 3327 | ``` 3328 | 3329 | ## 연속된 수의 합 3330 | 3331 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120923 3332 | - python 3333 | 3334 | ```py 3335 | n = 3 3336 | s = 12 3337 | def solution(num, total): 3338 | x = [i for i in range(-500, 501)] 3339 | for i in range(1001): 3340 | if(sum(x[i:i+num]) == total): 3341 | return x[i:i+num] 3342 | solution(n, s) 3343 | 3344 | def solution(num, total): 3345 | return [(total - (num * (num - 1) // 2)) // num + i for i in range(num)] 3346 | ``` 3347 | 3348 | - js 3349 | 3350 | ```js 3351 | function solution(num, total) { 3352 | var min = Math.ceil(total / num - Math.floor(num / 2)); 3353 | var max = Math.floor(total / num + Math.floor(num / 2)); 3354 | 3355 | return new Array(max - min + 1).fill(0).map((el, i) => { 3356 | return i + min; 3357 | }); 3358 | } 3359 | 3360 | function solution(num, total) { 3361 | const a = ((2 * total) / num + 1 - num) / 2; 3362 | return Array(num) 3363 | .fill() 3364 | .map((_, i) => i + a); 3365 | } 3366 | ``` 3367 | 3368 | ## 안전지대 - 1월 12일 3369 | 3370 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120866 3371 | - python 3372 | 3373 | ```py 3374 | import numpy as np 3375 | 3376 | def solution(board): 3377 | print('--------') 3378 | board = np.array(board) 3379 | print(board) 3380 | print(np.where(board == 1)) 3381 | rows, cols = np.where(board == 1) 3382 | print(list(zip(rows, cols))) 3383 | for r, c in zip(rows, cols): 3384 | if r != 0 and c != 0: 3385 | board[r-1:r+2, c-1:c+2] = 1 3386 | elif r == 0 and c != 0: 3387 | board[0:r+2, c-1:c+2] = 1 3388 | elif r != 0 and c == 0: 3389 | board[r-1:r+2, 0:c+2] = 1 3390 | elif r == 0 and c == 0: 3391 | board[0:r+2, 0:c+2] = 1 3392 | else: 3393 | board[r-1:r+2, c-1:c+2] = 1 3394 | print(board) 3395 | return len(board[board==0]) 3396 | 3397 | 3398 | solution([[0, 0, 0, 0, 0], 3399 | [0, 0, 0, 0, 0], 3400 | [0, 0, 1, 0, 0], 3401 | [0, 0, 1, 0, 0], 3402 | [0, 0, 0, 0, 0]]) 3403 | 3404 | solution([[0, 0, 0, 0, 0], 3405 | [0, 0, 0, 0, 0], 3406 | [0, 0, 1, 0, 1], 3407 | [0, 0, 1, 0, 0], 3408 | [0, 0, 0, 0, 0]]) 3409 | 3410 | 3411 | solution([[0, 0, 0, 1, 0], 3412 | [0, 0, 0, 0, 0], 3413 | [0, 0, 0, 0, 1], 3414 | [0, 0, 0, 0, 0], 3415 | [0, 0, 0, 0, 0]]) 3416 | 3417 | solution([[0, 0, 0, 1, 0], 3418 | [1, 0, 0, 0, 0], 3419 | [0, 0, 0, 0, 1], 3420 | [0, 0, 0, 0, 0], 3421 | [0, 0, 0, 0, 0]]) 3422 | 3423 | danger.update('hello') 3424 | danger 3425 | 3426 | danger.update((di, dj) for di in [-1,0,1] for dj in [-1, 0, 1]) 3427 | danger.update((di+x좌표, dj+y좌표) for di in [-1,0,1] for dj in [-1, 0, 1]) 3428 | 3429 | def solution(board): 3430 | n = len(board) 3431 | danger_zone = set() 3432 | 3433 | for row, row_value in enumerate(board): 3434 | for col, row_col_value in enumerate(row_value): 3435 | print(row, col, row_value, row_col_value) 3436 | if not row_col_value: 3437 | continue 3438 | danger.update() 3439 | 3440 | def solution(board): 3441 | n = len(board) 3442 | danger = set() 3443 | for i, row in enumerate(board): 3444 | for j, x in enumerate(row): 3445 | if not x: 3446 | continue 3447 | danger.update((i+di, j+dj) for di in [-1,0,1] for dj in [-1, 0, 1]) 3448 | return n*n - sum(0 <= i < n and 0 <= j < n for i, j in danger) 3449 | ``` 3450 | 3451 | - js 3452 | 3453 | ```js 3454 | function solution(b) { 3455 | const directions = [ 3456 | [0, 0], 3457 | [0, 1], 3458 | [0, -1], 3459 | [1, 1], 3460 | [1, 0], 3461 | [1, -1], 3462 | [-1, -1], 3463 | [-1, 0], 3464 | [-1, 1], 3465 | ]; 3466 | let bombSet = new Set(); 3467 | 3468 | for (let i = 0; i < b.length; i++) { 3469 | for (let j = 0; j < b[i].length; j++) { 3470 | if (b[i][j] == 1) { 3471 | directions.forEach((el) => { 3472 | let [nextX, nextY] = el; 3473 | [nextX, nextY] = [i + nextX, j + nextY]; 3474 | if ( 3475 | nextX >= 0 && 3476 | nextX < b.length && 3477 | nextY >= 0 && 3478 | nextY < b[i].length 3479 | ) { 3480 | bombSet.add(nextX + " " + nextY); 3481 | } 3482 | }); 3483 | } 3484 | } 3485 | } 3486 | return b.length * b[0].length - bombSet.size; 3487 | } 3488 | ``` 3489 | 3490 | ## 겹치는 선분의 길이 - 1월 13일 3491 | 3492 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120876 3493 | - python 3494 | 3495 | ```py 3496 | # 오답 3497 | def solution(lines): 3498 | 하나, 둘, 셋 = lines 3499 | 길이 = [] 3500 | if 하나[1] <= 둘[0]: 3501 | pass 3502 | else: 3503 | 길이.append([min(둘[1], 하나[1]), max(둘[0], 하나[0])]) 3504 | if 하나[1] <= 셋[0]: 3505 | pass 3506 | else: 3507 | 길이.append([min(하나[1], 셋[1]), max(하나[0], 셋[0])]) 3508 | if 둘[1] <= 셋[0]: 3509 | pass 3510 | else: 3511 | 길이.append([min(셋[1], 둘[1]), max(셋[0], 둘[0])]) 3512 | 3513 | # [길이[0][0], 길이[1][0], 길이[2][0]] 3514 | # [길이[0][1], 길이[1][1], 길이[2][1]] 3515 | if 길이 == []: 3516 | return 0 3517 | # 중간에 끊어진 경우가 있을 수 있음, test case 1번과 9번 통과 못함 3518 | # 반례 : [[0, 5], [3, 9], [8, 9]] 3519 | 시작 = [i[0] for i in 길이] 3520 | 끝 = [i[1] for i in 길이] 3521 | print(길이) 3522 | # return max(시작) - min(끝) 3523 | 3524 | solution([[0, 5], [3, 9], [8, 9]]) 3525 | solution([[0, 5], [3, 9], [1, 10]]) 3526 | solution([[0, 1], [2, 5], [3, 9]]) 3527 | 3528 | # 정답 3529 | 3530 | def solution(lines): 3531 | line = [0 for i in range(200)] 3532 | for a, b in lines: 3533 | while a < b: 3534 | line[a+100] += 1 3535 | a += 1 3536 | return len(list(filter(lambda x: x>1, line))) 3537 | 3538 | 3539 | def solution(lines): 3540 | lines.sort(key=lambda x:x[1]) 3541 | 하나, 둘, 셋 = lines 3542 | 길이 = [] 3543 | if 하나[1] <= 둘[0]: 3544 | pass 3545 | else: 3546 | 길이.append([max(둘[0], 하나[0]), min(둘[1], 하나[1])]) 3547 | if 하나[1] <= 셋[0]: 3548 | pass 3549 | else: 3550 | 길이.append([max(하나[0], 셋[0]), min(하나[1], 셋[1])]) 3551 | if 둘[1] <= 셋[0]: 3552 | pass 3553 | else: 3554 | 길이.append([max(셋[0], 둘[0]), min(셋[1], 둘[1])]) 3555 | 3556 | if 길이 == []: 3557 | return 0 3558 | print(길이) 3559 | l = 길이 3560 | # 중간에 끊어진 경우가 있을 수 있음, test case 1번과 9번 통과 못함 3561 | # 반례 : [[0, 5], [3, 9], [8, 9]] 3562 | if len(l) == 1: 3563 | return l[0][1] - l[0][0] 3564 | elif len(l) == 2: 3565 | if l[0][1] <= l[1][0]: 3566 | return (l[0][1] - l[0][0]) + (l[1][1] - l[1][0]) 3567 | else: 3568 | return max(l[1]) - min(l[0]) 3569 | elif len(l) == 3: 3570 | # 겹치지 않고 and 겹치지 않는다 3571 | if l[0][1] <= l[1][0] and l[1][1] <= l[2][0]: 3572 | return (l[0][1] - l[0][0]) + (l[1][1] - l[1][0]) + (l[2][1] - l[2][0]) 3573 | # 모두 겹친다 3574 | elif l[0][1] > l[1][0] and l[1][1] > l[2][0]: 3575 | 시작 = [i[0] for i in l] 3576 | 끝 = [i[1] for i in l] 3577 | return max(끝) - min(시작) 3578 | # 부분적으로 겹친다 3579 | else: 3580 | # 겹치지 않고 and 겹친다 3581 | if l[0][1] <= l[1][0] and l[1][1] > l[2][0]: 3582 | return (l[0][1] - l[0][0]) + (max(l[2]) - min(l[1])) 3583 | # 겹치고 and 겹치지 않는다 3584 | if l[0][1] > l[1][0] and l[1][1] <= l[2][0]: 3585 | return (max(l[1]) - min(l[0])) + (l[2][1] - l[2][0]) 3586 | return max(l[2][1]) - min(l[0][1]) 3587 | 3588 | 3589 | solution([[0, 1], [2, 5], [3, 9]]) 3590 | solution([[0, 5], [3, 9], [8, 9]]) 3591 | solution([[0, 5], [3, 9], [1, 10]]) 3592 | 3593 | # 정답 코드 2 3594 | def solution(lines): 3595 | sets = [set(range(min(l), max(l))) for l in lines] 3596 | return len(sets[0] & sets[1] | sets[0] & sets[2] | sets[1] & sets[2]) 3597 | ``` 3598 | 3599 | - js 3600 | 3601 | ```js 3602 | 3603 | function solution(lines) { 3604 | let line = new Array(200).fill(0) 3605 | lines.forEach(([min, max]) => { 3606 | for (; min < max; min++) { 3607 | line[min+100]++ 3608 | } 3609 | }) 3610 | return line.filter(v => v > 1).length; 3611 | } 3612 | 3613 | 3614 | function solution(lines) { 3615 | let line = new Array(200).fill(0); 3616 | 3617 | lines.forEach(([a, b]) => { 3618 | for (; a < b; a++) line[a + 100]++; 3619 | }); 3620 | 3621 | return line.reduce((a, c) => (c > 1 ? a + 1 : a), 0); 3622 | } 3623 | ``` 3624 | 3625 | ## 평행 3626 | 3627 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120875 3628 | - python 3629 | 3630 | ```py 3631 | from itertools import combinations 3632 | 3633 | def solution(dots): 3634 | a = [] 3635 | for (x1,y1),(x2,y2) in combinations(dots,2): 3636 | a.append((y2-y1,x2-x1)) 3637 | 3638 | for (x1,y1),(x2,y2) in combinations(a,2): 3639 | if x1*y2==x2*y1: 3640 | return 1 3641 | return 0 3642 | ``` 3643 | 3644 | - js 3645 | 3646 | ```js 3647 | function solution(dots) { 3648 | const leans = []; 3649 | 3650 | for (let i = 0; i < dots.length; i++) { 3651 | const dotA = dots[i]; 3652 | for (let j = i + 1; j < dots.length; j++) { 3653 | const dotB = dots[j]; 3654 | const lean = (dotB[1] - dotA[1]) / (dotB[0] - dotA[0]); 3655 | 3656 | if (leans.includes(lean)) return 1; 3657 | else leans.push(lean); 3658 | } 3659 | } 3660 | 3661 | return 0; 3662 | } 3663 | ``` 3664 | 3665 | ## 옹알이 (1) 3666 | 3667 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120956 3668 | - python 3669 | 3670 | ```py 3671 | def solution(babbling): 3672 | c = 0 3673 | for b in babbling: 3674 | for w in [ "aya", "ye", "woo", "ma" ]: 3675 | if w * 2 not in b: 3676 | b = b.replace(w, ' ') 3677 | if len(b.strip()) == 0: 3678 | c += 1 3679 | return c 3680 | 3681 | def solution(babbling): 3682 | answer = 0 3683 | prono = ['aya','ye','woo','ma'] 3684 | for i in babbling : 3685 | for j in prono : 3686 | if j+j in i : 3687 | break 3688 | else : 3689 | i = i.replace(j,"").strip() 3690 | if i : 3691 | continue 3692 | else : 3693 | answer += 1 3694 | return answer 3695 | 3696 | ``` 3697 | 3698 | - js 3699 | 3700 | ```js 3701 | function solution(babbling) { 3702 | let df = ["aya", "ye", "woo", "ma"]; 3703 | let res = 0; 3704 | for (let w of babbling) { 3705 | if (df.some((f) => w.includes(f + f))) continue; 3706 | 3707 | let rest = df.reduce((a, f) => a.replaceAll(f, ""), w); 3708 | 3709 | if (rest.length > 0) continue; 3710 | 3711 | res++; 3712 | } 3713 | 3714 | return res; 3715 | } 3716 | function solution(babbling) { 3717 | const 가능한_발음_목록 = ["aya", "ye", "woo", "ma"]; 3718 | return babbling.filter((e) => { 3719 | 가능한_발음_목록.forEach((가능한_발음) => { 3720 | e = e.replace( 3721 | new RegExp(가능한_발음 + 가능한_발음, "gi"), 3722 | "어려웡ㅎ" 3723 | ); 3724 | e = e.replace(new RegExp(가능한_발음, "gi"), ""); 3725 | }); 3726 | return e === ""; 3727 | }).length; 3728 | } 3729 | ``` 3730 | -------------------------------------------------------------------------------- /javascript_다시_볼만한_문제.md: -------------------------------------------------------------------------------- 1 | # 간단한 코드 스니펫 2 | 3 | ```js 4 | Infinity; 5 | -Infinity; 6 | 7 | Math.ceil(); // 올림 8 | Math.floor(); // 내림 9 | 10 | parseInt(10 / 3); 11 | Math.floor(10 / 3); 12 | ~~(10 / 3); 13 | (10 / 3) << 0; 14 | // 2 << 1 15 | // 4 16 | // 2 << 2 17 | // 8 18 | // 2 << 3 19 | // 16 20 | (10 / 3) | 0; // why? bit단위 or 연산자 21 | // 2 | 3 // 3 22 | 23 | "aAb1B2cC34oOp".replace(/[a-zA-Z]/g, "!"); 24 | // '!!!1!2!!34!!!' 25 | "aAb1B2cC34oOp".replace(/[a-zA-Z]/g, ""); 26 | // '1234' 27 | "aAb1B2cC34oOp".replace(/[^\d]/g, ""); 28 | // '1234' 29 | "aAb1B2cC34oOp".replace(/[\D]/g, ""); 30 | // '1234' 31 | "abcAb1B2abcC34oOp".replaceAll("abc", ""); 32 | // 'Ab1B2C34oOp' 33 | "abcAb1B2abcC34oOp".replaceAll(/[a-zA-Z]/g, ""); 34 | // '1234' 35 | "aAb1B2cC34oOp".match(/[\d]/g); 36 | // ['1', '2', '3', '4'] 37 | 38 | // 깊은 복사 39 | // 전개 구문으로 복사 40 | // slice로 복사 41 | // JSON.stringify()로 복사 42 | // Object.assign()으로 복사 43 | // Lodash 라이브러리 사용 44 | 45 | Math.max([ 46 | [0, 1], 47 | [2, 5], 48 | [3, 9], 49 | ]); 50 | // NaN 51 | let value = [ 52 | [0, 1], 53 | [2, 5], 54 | [3, 9], 55 | ]; 56 | let value2 = [ 57 | [0, [1, 2]], 58 | [2, 5], 59 | [3, 9], 60 | ]; 61 | value.flat(); 62 | // [0, 1, 2, 5, 3, 9] 63 | value2.flat(); 64 | // [0, Array(2), 2, 5, 3, 9] 65 | value2.flat(Infinity); 66 | // [0, 1, 2, 2, 5, 3, 9] 67 | Math.max(...value2.flat(Infinity)); 68 | // 9 69 | ``` 70 | 71 | ## 배열의 평균값 72 | 73 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120817 74 | 75 | ```js 76 | function solution(numbers) { 77 | // 배열이 빈배열이면 error 78 | return numbers.reduce((a, c) => a + c, 0) / numbers.length; 79 | } 80 | 81 | function solution(numbers) { 82 | // 아래와 같이 0으로 초기화를 꼭 해주세요. 83 | return numbers.reduce((a, c) => a + c, 0) / numbers.length; 84 | } 85 | ``` 86 | 87 | ## 문자열안에 문자열 88 | 89 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120908 90 | 91 | ```js 92 | // 'abcdefg'.indexOf('cde') 93 | // 2 94 | // 'abcdefg'.indexOf('zee') 95 | // -1 96 | function solution(str1, str2) { 97 | if (str1.indexOf(str2) === -1) { 98 | return 2; 99 | } 100 | return 1; 101 | } 102 | 103 | function solution(str1, str2) { 104 | return str1.indexOf(str2) === -1 ? 2 : 1; 105 | } 106 | 107 | function solution(str1, str2) { 108 | return str1.includes(str2) ? 1 : 2; 109 | } 110 | 111 | function solution(str1, str2) { 112 | return str1.split(str2).length > 1 ? 1 : 2; 113 | } 114 | ``` 115 | 116 | ## 숨어있는 숫자의 덧셈 (1) 117 | 118 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120851 119 | 120 | ```js 121 | Array.from("aAb1B2cC34oOp"); 122 | "aAb1B2cC34oOp".split(""); 123 | Array.from("aAb1B2cC34oOp").map((v) => +v); 124 | Array.from("aAb1B2cC34oOp") 125 | .map((v) => +v) 126 | .filter((v) => !Number.isNaN(v)); 127 | // 순서를 바꿔도 어차피 map으로 숫자를 변환해야 합니다. 128 | // Array.from('aAb1B2cC34oOp').filter(v => +v) 129 | Array.from("aAb1B2cC34oOp") 130 | .map((v) => +v) 131 | .filter((v) => !Number.isNaN(v)) 132 | .reduce((a, c) => a + c, 0); 133 | 134 | function solution(my_string) { 135 | return Array.from(my_string) 136 | .map((v) => +v) 137 | .filter((v) => !Number.isNaN(v)) 138 | .reduce((a, c) => a + c, 0); 139 | } 140 | 141 | "aAb1B2cC34oOp".replace(/[a-zA-Z]/g, "!"); 142 | // '!!!1!2!!34!!!' 143 | "aAb1B2cC34oOp".replace(/[a-zA-Z]/g, ""); 144 | // '1234' 145 | "aAb1B2cC34oOp".replace(/[^\d]/g, ""); 146 | // '1234' 147 | "aAb1B2cC34oOp".replace(/[\D]/g, ""); 148 | // '1234' 149 | "abcAb1B2abcC34oOp".replaceAll("abc", ""); 150 | // 'Ab1B2C34oOp' 151 | "abcAb1B2abcC34oOp".replaceAll(/[a-zA-Z]/g, ""); 152 | // '1234' 153 | "aAb1B2cC34oOp".match(/[\d]/g); 154 | // ['1', '2', '3', '4'] 155 | 156 | function solution(my_string) { 157 | return my_string 158 | .match(/[\d]/g) 159 | .map((v) => +v) 160 | .reduce((a, c) => a + c, 0); 161 | } 162 | ``` 163 | 164 | ## 진료순서 정하기 165 | 166 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120835 167 | 168 | ```js 169 | // 원본이 변경이 되어버리기 때문에 원하는 결과가 안나옵니다. 170 | function solution(emergency) { 171 | const sorted = emergency.sort((a, b) => b - a); 172 | return sorted.map((v) => indexOf(v) + 1); 173 | } 174 | 175 | let 원본 = [3, 76, 24]; 176 | let 사본 = 원본.sort((a, b) => b - a); 177 | 사본; 178 | // [76, 24, 3] 179 | 원본; 180 | // [76, 24, 3] 181 | 182 | function solution(emergency) { 183 | const sorted = [...emergency].sort((a, b) => b - a); 184 | return emergency.map((v) => sorted.indexOf(v) + 1); 185 | } 186 | 187 | function solution(emergency) { 188 | const sorted = emergency.slice().sort((a, b) => b - a); 189 | return emergency.map((v) => sorted.indexOf(v) + 1); 190 | } 191 | 192 | // 깊은 복사 193 | // 전개 구문으로 복사 194 | // slice로 복사 195 | // JSON.stringify()로 복사 196 | // Object.assign()으로 복사 197 | // Lodash 라이브러리 사용 198 | ``` 199 | 200 | ## 문자열 밀기 201 | 202 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120921 203 | 204 | ```js 205 | // slice나 for이용하면 어렵게 풀게 됩니다. 206 | ("ohell" + "ohell") 207 | .indexOf("hello")("lohel" + "lohel") 208 | .indexOf("hello"); 209 | 210 | function solution(A, B) { 211 | return (B + B).indexOf(A); 212 | } 213 | 214 | let solution = (A, B) => (B + B).indexOf(A); 215 | 216 | // 회전 초밥 문제 처럼 몇 번씩 순회를 돌아야 하고, 중간에 먹는 초밥이 사라진다라고 하면 for를 이용합니다. 217 | // 아래와 같이 for 문 안에 length가 줄어드는 것을 '이용'하셔야 합니다. 218 | l = [10, 20, 30, 40, 50]; 219 | for (let i = 0; i < l.length; i++) { 220 | console.log(l.pop()); 221 | } 222 | ``` 223 | 224 | ## 특이한 정렬 225 | 226 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120880 227 | 228 | ```js 229 | // 일반 숫자 정렬 230 | [10, 20, 30, 40, 32, 35, 37] 231 | .sort((a, b) => a - b) 232 | 233 | [ 234 | // 어떠한 값 기준 정렬 235 | (10, 20, 30, 40, 32, 35, 37) 236 | ].sort((a, b) => Math.abs(a - 35) - Math.abs(b - 35)) 237 | 238 | [ 239 | // 어떠한 값 기준 정렬, 값이 같을 때에는 뒤에 || 240 | (10, 20, 30, 40, 32, 35, 37) 241 | ].sort((a, b) => Math.abs(a - 35) - Math.abs(b - 35) || b - a); 242 | 243 | function solution(numlist, n) { 244 | return numlist.sort((a, b) => Math.abs(a - n) - Math.abs(b - n) || b - a); 245 | } 246 | ``` 247 | 248 | ## 다항식 더하기 249 | 250 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120863 251 | 252 | ```js 253 | [3, 10].join("x + "); 254 | // '3x + 10' 255 | 256 | "3x + 7 + x".split(" + "); 257 | 258 | "3x + 7 + x".split(" + ").filter((v) => v.includes("x")); 259 | 260 | // x 항만 골라내기 261 | "3x + 7 + x" 262 | .split(" + ") 263 | .filter((v) => v.includes("x")) 264 | .map((v) => v.replace("x", "") || "1"); 265 | 266 | "3x + 7 + x" 267 | .split(" + ") 268 | .filter((v) => v.includes("x")) 269 | .map((v) => +v.replace("x", "") || 1); 270 | 271 | "3x + 7 + x" 272 | .split(" + ") 273 | .filter((v) => v.includes("x")) 274 | .map((v) => +v.replace("x", "") || 1) 275 | .reduce((a, c) => a + c, 0); 276 | 277 | // 숫자 항만 골라내기 278 | "3x + 7 + x" 279 | .split(" + ") 280 | .filter((v) => !v.includes("x")) 281 | .map((v) => +v) 282 | .reduce((a, c) => a + c, 0); 283 | 284 | function solution(polynomial) { 285 | answer = []; 286 | answer.push( 287 | polynomial 288 | .split(" + ") 289 | .filter((v) => v.includes("x")) 290 | .map((v) => +v.replace("x", "") || 1) 291 | .reduce((a, c) => a + c, 0) 292 | ); 293 | answer.push( 294 | polynomial 295 | .split(" + ") 296 | .filter((v) => !v.includes("x")) 297 | .map((v) => +v) 298 | .reduce((a, c) => a + c, 0) 299 | ); 300 | if (answer[0] === 1 && answer[1] !== 0) { 301 | return `x + ${answer[1]}`; 302 | } 303 | if (answer[0] === 1 && answer[1] === 0) { 304 | return `x`; 305 | } 306 | if (answer[0] !== 1 && answer[1] === 0) { 307 | return `${answer[0]}x`; 308 | } 309 | if (answer[0] === 0 && answer[1] !== 0) { 310 | return `${answer[1]}`; 311 | } 312 | if (answer[0] === 0 && answer[1] === 0) { 313 | return ``; 314 | } 315 | return answer.join("x + "); 316 | } 317 | 318 | // 코드 간소화 319 | function solution(polynomial) { 320 | let answer = []; 321 | answer.push( 322 | polynomial 323 | .split(" + ") 324 | .filter((v) => v.includes("x")) 325 | .map((v) => +v.replace("x", "") || 1) 326 | .reduce((a, c) => a + c, 0) 327 | ); 328 | answer.push( 329 | polynomial 330 | .split(" + ") 331 | .filter((v) => !v.includes("x")) 332 | .map((v) => +v) 333 | .reduce((a, c) => a + c, 0) 334 | ); 335 | 336 | let result = []; 337 | if (answer[0]) result.push(`${answer[0] === 1 ? "" : answer[0]}x`); 338 | if (answer[1]) result.push(answer[1]); 339 | // [10].join(' + ') 340 | // '10' 341 | return result.join(" + "); 342 | } 343 | ``` 344 | 345 | ## OX퀴즈 346 | 347 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120907?language=javascript 348 | 349 | ```js 350 | // 코딩테스트 중 eval을 사용하지 못하도록 막아놓은 곳이 있습니다. 참고하세요. 351 | 352 | eval(); 353 | eval("10 + 10"); 354 | // 20 355 | eval("10 - 3"); 356 | // 7 357 | eval("5 + 6 = 11"); // error 358 | eval("5 + 6 == 11"); // true 359 | 360 | quiz.split(" = ")[0] + 361 | // '5 + 6' 362 | quiz.split(" = ")[1]; 363 | // 11 364 | 365 | function solution(quiz) { 366 | let result = []; 367 | for (item of quiz) { 368 | const 연산식 = eval(item.split(" = ")[0]); 369 | const 결과값 = +item.split(" = ")[1]; 370 | result.push(eval(연산식) === 결과값 ? "O" : "X"); 371 | } 372 | return result; 373 | } 374 | ``` 375 | 376 | ## 겹치는 선분의 길이 377 | 378 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120876 379 | 380 | ```python 381 | def solution(lines): 382 | sets = [set(range(min(l), max(l))) for l in lines] 383 | return len(sets[0] & sets[1] | sets[0] & sets[2] | sets[1] & sets[2]) 384 | ``` 385 | 386 | ```js 387 | function solution(lines) { 388 | // 100이 0, 101은 1 389 | // 99는 -1, 98은 -2 390 | let line = Array(201).fill(0); // 0 포함 201개 391 | for (let [i, j] of lines) { 392 | for (; i < j; i++) { 393 | line[100 + i]++; 394 | } 395 | } 396 | return line.filter((v) => v >= 2).length; 397 | } 398 | 399 | // 큰값 = Math.max(...lines.flat()) 400 | // 작은값 = Math.min(...lines.flat()) 401 | // Math.max([[0, 1], [2, 5], [3, 9]]) 402 | // NaN 403 | // let value = [[0, 1], [2, 5], [3, 9]] 404 | // let value2 = [[0, [1, 2]], [2, 5], [3, 9]] 405 | // value.flat() 406 | // [0, 1, 2, 5, 3, 9] 407 | // value2.flat() 408 | // [0, Array(2), 2, 5, 3, 9] 409 | // value2.flat(Infinity) 410 | // [0, 1, 2, 2, 5, 3, 9] 411 | // Math.max(...value2.flat(Infinity)) 412 | // 9 413 | ``` 414 | -------------------------------------------------------------------------------- /python_다시_볼만한_문제.md: -------------------------------------------------------------------------------- 1 | # 간단한 코드 스니펫 2 | 3 | ```python 4 | 5 | ``` 6 | 7 | ## 특정 문자 제거하기 8 | 9 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120826 10 | 11 | ```python 12 | import re 13 | 14 | re.sub('A', '', 'abcde12345ABCDEabcde12345ABCDE') 15 | re.sub('[a-z]', '', 'abcde12345ABCDEabcde12345ABCDE') 16 | re.sub('[123]', '', 'abcde12345ABCDEabcde12345ABCDE') 17 | re.sub('[135]', '', 'abcde12345ABCDEabcde12345ABCDE') 18 | re.sub('[a-zA-Z]', '', 'abcde12345ABCDEabcde12345ABCDE') 19 | re.sub('[0-9]', '', 'abcde12345ABCDEabcde12345ABCDE') 20 | 21 | import re 22 | 23 | re.sub('[a-zA-Z]', '', 'aAb1B2cC34oOp') 24 | list(re.sub('[a-zA-Z]', '', 'aAb1B2cC34oOp')) 25 | list(map(int, list(re.sub('[a-zA-Z]', '', 'aAb1B2cC34oOp')))) 26 | # list(map(lambda x:int(x), list(re.sub('[a-zA-Z]', '', 'aAb1B2cC34oOp')))) 27 | map(int, list(re.sub('[a-zA-Z]', '', 'aAb1B2cC34oOp'))) 28 | sum(map(int, list(re.sub('[a-zA-Z]', '', 'aAb1B2cC34oOp')))) 29 | 30 | re.findall('[0-9]', 'aAb1B2cC34oOp') 31 | sum(map(int, re.findall('[0-9]', 'aAb1B2cC34oOp'))) 32 | 33 | if True: print('hello') 34 | print('if') if True else print('else') 35 | 1 if True else 2 36 | 1 if False else 2 37 | 38 | 39 | # result = 0 40 | # for i in 'hello134': 41 | # if i.isdigit(): 42 | # result += int(i) 43 | 44 | # '1'.isdigit() 45 | # 't'.isdigit() 46 | # '1'.isnumeric() 47 | # 't'.isnumeric() 48 | # 'abc'.islower() 49 | # 'aBc'.islower() 50 | # 'abc'.isalpha() 51 | # 'abc123'.isalpha() 52 | 53 | # https://www.bigocheatsheet.com/ 54 | ``` 55 | 56 | ## 문자열안에 문자열 57 | 58 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120908 59 | 60 | ```js 61 | def solution(str1, str2): 62 | return 1 if str2 in str1 else 2 63 | ``` 64 | 65 | ## 숨어있는 숫자의 덧셈 (1) 66 | 67 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120851 68 | 69 | ```python 70 | def solution(my_string): 71 | result = 0 72 | for i in my_string: 73 | if i.isdigit(): 74 | result += int(i) 75 | return result 76 | 77 | import re 78 | 79 | def solution(my_string): 80 | return sum(map(int, re.findall(r'[0-9]', my_string))) 81 | ``` 82 | 83 | ## 진료순서 정하기 84 | 85 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120835 86 | 87 | ```py 88 | def solution(emergency): 89 | # 원본은 a라는 이름으로 가지고 있습니다. 90 | # emergency를 정렬한 값을 b라고 합니다. 91 | # a에 있는 값을 b에서 찾는데 index만 찾아서 92 | # 새로운 리스트로 만듭니다. 93 | a = emergency 94 | b = sorted(a, reverse=True) 95 | result = [] 96 | for i in a: 97 | result.append(b.index(i) + 1) 98 | 99 | return result 100 | 101 | 102 | def solution(emergency): 103 | s_emergency = sorted(emergency, reverse=True) 104 | return [s_emergency.index(i) + 1 for i in emergency] 105 | 106 | def solution(emergency): 107 | s_emergency = sorted(emergency, reverse=True) 108 | return list(map(lambda x:s_emergency.index(x)+1, emergency)) 109 | ``` 110 | 111 | ## 문자열 밀기 112 | 113 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120921 114 | 115 | ```py 116 | import collections 117 | 118 | collections.Counter('aaabbccccccddddd') 119 | sample = collections.deque("hello") 120 | # sample.rotate(2) 121 | sample.rotate(-1) 122 | ''.join(sample) 123 | 124 | import collections 125 | 126 | def solution(A, B): 127 | if A == B: 128 | return 0 129 | 비교 = collections.deque(A) 130 | for i in range(len(A)): 131 | 비교.rotate(1) 132 | if ''.join(비교) == B: 133 | return i + 1 134 | return -1 135 | 136 | def solution(A, B): 137 | return (B*2).find(A) 138 | ``` 139 | 140 | ## 특이한 정렬 141 | 142 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120880 143 | 144 | ## 다항식 더하기 145 | 146 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120863 147 | 148 | ## OX퀴즈 149 | 150 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120907?language=javascript 151 | 152 | ## 겹치는 선분의 길이 153 | 154 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120876 155 | -------------------------------------------------------------------------------- /다시_볼만한_문제.md: -------------------------------------------------------------------------------- 1 | ## 몫 구하기 2 | 3 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120805 4 | - python 5 | 6 | ```py 7 | def solution(num1, num2): 8 | return num1 // num2 9 | ``` 10 | 11 | - js 12 | 13 | ```js 14 | function solution(num1, num2) { 15 | return ~~(num1 / num2); 16 | } 17 | ``` 18 | 19 | ## 배열의 평균값 20 | 21 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120817 22 | - python 23 | 24 | ```py 25 | def solution(numbers): 26 | return sum(numbers)/len(numbers) 27 | 28 | # 다차원 배열의 합도 구할 수 있음 29 | import numpy as np 30 | 31 | def solution(numbers): 32 | return np.sum(numbers)/len(numbers) 33 | ``` 34 | 35 | - js 36 | 37 | ```js 38 | function solution(numbers) { 39 | var answer = 0; 40 | for (i of numbers) { 41 | answer += i; 42 | } 43 | return answer / numbers.length; 44 | } 45 | 46 | function solution(numbers) { 47 | var answer = numbers.reduce((a, b) => a + b, 0) / numbers.length; 48 | return answer; 49 | } 50 | ``` 51 | 52 | ## 문자열안에 문자열 53 | 54 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120908 55 | - python 56 | 57 | ```py 58 | def solution(str1, str2): 59 | return 2 if str1.find(str2) == -1 else 1 60 | 61 | def solution(str1, str2): 62 | return 1 if str2 in str1 else 2 63 | ``` 64 | 65 | - js 66 | 67 | ```js 68 | function solution(str1, str2) { 69 | return str1.includes(str2) ? 1 : 2; 70 | } 71 | 72 | function solution(str1, str2) { 73 | return str1.split(str2).length > 1 ? 1 : 2; 74 | } 75 | ``` 76 | 77 | ## 숨어있는 숫자의 덧셈 (1) 78 | 79 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120851 80 | - python 81 | 82 | ```py 83 | def solution(my_string): 84 | answer = 0 85 | for i in my_string: 86 | if i.isnumeric(): 87 | answer += int(i) 88 | return answer 89 | 90 | def solution(my_string): 91 | return sum(int(i) for i in my_string if i.isdigit()) 92 | 93 | import re 94 | 95 | def solution(my_string): 96 | return sum(int(n) for n in re.sub('[^1-9]', '', my_string)) 97 | ``` 98 | 99 | - js 100 | 101 | ```js 102 | function solution(my_string) { 103 | return my_string 104 | .replaceAll(/[^\d]/g, "") 105 | .split("") 106 | .map((v) => +v) 107 | .reduce((a, v) => a + v, 0); 108 | } 109 | 110 | function solution(my_string) { 111 | return my_string 112 | .match(/[0-9]/g) 113 | .reduce((a, b) => parseInt(a) + parseInt(b)); 114 | } 115 | ``` 116 | 117 | ## 진료순서 정하기 118 | 119 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120835 120 | - python 121 | 122 | ```py 123 | arr = [3, 76, 24] 124 | #응급순서 = [76, 24, 3] 125 | 응급순서 = sorted(arr, reverse=True) 126 | list(map(lambda x: 응급순서.index(x) + 1, arr)) 127 | 128 | def solution(arr): 129 | 응급순서 = sorted(arr, reverse=True) 130 | return list(map(lambda x: 응급순서.index(x) + 1, arr)) 131 | 132 | def solution(emergency): 133 | 응급순서 = sorted(emergency, reverse=True) 134 | return [응급순서.index(i) + 1 for i in emergency] 135 | ``` 136 | 137 | - js 138 | 139 | ```js 140 | function solution(emergency) { 141 | let sorted = emergency.slice().sort((a, b) => b - a); 142 | return emergency.map((v) => sorted.indexOf(v) + 1); 143 | } 144 | ``` 145 | 146 | ## 문자열 밀기 147 | 148 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120921 149 | - python 150 | 151 | ```py 152 | import collections 153 | 154 | def solution(A, B): 155 | if A == B: 156 | return 0 157 | 비교 = collections.deque(A) 158 | for i in range(len(A)): 159 | 비교.rotate(1) 160 | if ''.join(비교) == B: 161 | return i+1 162 | return -1 163 | 164 | 165 | solution=lambda a,b:(b*2).find(a) 166 | 167 | 168 | def solution(A, B): 169 | #if A == "": 170 | # return 0 171 | 172 | AA = A+A 173 | answer = AA.find(B) 174 | 175 | if answer >0: 176 | answer = len(A) - answer 177 | 178 | return answer 179 | ``` 180 | 181 | - js 182 | 183 | ```js 184 | let solution = (a, b) => (b + b).indexOf(a); 185 | ``` 186 | 187 | ## 특이한 정렬 188 | 189 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120880 190 | - python 191 | 192 | ```py 193 | def solution(numlist, n): 194 | d = [[i, abs(i-n)] for i in numlist] 195 | return list(map(lambda x:x[0], sorted(d, key=lambda x:(x[1], -x[0])))) 196 | 197 | def solution(numlist, n): 198 | answer = sorted(numlist,key = lambda x : (abs(x-n), n-x)) 199 | return answer 200 | 201 | # {i:i-n for i in numlist} 202 | # [[i, i-n] for i in numlist] 203 | # sorted(d, key=lambda x:x[1]) 204 | # sorted(d, key=lambda x:(x[1], -x[0])) # 다중조건 205 | ``` 206 | 207 | - js 208 | 209 | ```js 210 | function solution(numlist, n) { 211 | return numlist.sort((a, b) => Math.abs(a - n) - Math.abs(b - n) || b - a); 212 | } 213 | 214 | function solution(numlist, n) { 215 | numlist.sort((a, b) => { 216 | let n1 = Math.abs(a - n), 217 | n2 = Math.abs(b - n); 218 | 219 | return n1 < n2 ? -1 : n1 === n2 ? (a < b ? 1 : -1) : 1; 220 | }); 221 | return numlist; 222 | } 223 | ``` 224 | 225 | ## 다항식 더하기 226 | 227 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120863 228 | - python 229 | 230 | ```py 231 | def solution(polynomial): 232 | # 양수만 고려했어도 됨. 233 | x = polynomial.split(' ') 234 | x항 = 0 235 | 일반항 = 0 236 | for i, value in enumerate(x): 237 | if 'x' in value: 238 | if len(value) == 1: 239 | if x[i-1] == '+' or i == 0: 240 | x항 += 1 241 | else: 242 | if x[i-1] == '+' or i == 0: 243 | x항 += int(value[:-1]) 244 | elif value != '+': 245 | 일반항 += int(value) 246 | 247 | if 일반항 == 0 and x항 == 0: 248 | return f'0' 249 | elif 일반항 == 0 and x항 != 0: 250 | if x항 == 1: 251 | return 'x' 252 | return f'{x항}x' 253 | elif 일반항 != 0 and x항 == 0: 254 | return f'{일반항}' 255 | elif 일반항 < 0 and x항 > 0: 256 | if x항 == 1: 257 | return f'x - {일반항}' 258 | return f'{x항}x - {일반항}' 259 | elif 일반항 > 0 and x항 > 0: 260 | if x항 == 1: 261 | return f'x + {일반항}' 262 | return f'{x항}x + {일반항}' 263 | elif 일반항 > 0 and x항 < 0: 264 | if x항 == -1: 265 | return f'-x + {일반항}' 266 | return f'-{x항}x + {일반항}' 267 | elif 일반항 < 0 and x항 < 0: 268 | if x항 == -1: 269 | return f'-x + {일반항}' 270 | return f'-{x항}x + {일반항}' 271 | ``` 272 | 273 | - js 274 | 275 | ```js 276 | function solution(polynomial) { 277 | const arr = polynomial.split(" + "); 278 | const xNum = arr 279 | .filter((n) => n.includes("x")) 280 | .map((n) => n.replace("x", "") || "1") 281 | .reduce((acc, cur) => acc + parseInt(cur, 10), 0); 282 | const num = arr 283 | .filter((n) => !isNaN(n)) 284 | .reduce((acc, cur) => acc + parseInt(cur, 10), 0); 285 | 286 | let answer = []; 287 | if (xNum) answer.push(`${xNum === 1 ? "" : xNum}x`); 288 | if (num) answer.push(num); 289 | 290 | return answer.join(" + "); 291 | } 292 | ``` 293 | 294 | ## OX퀴즈 295 | 296 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120907 297 | - python 298 | 299 | ```py 300 | def solution(quiz): 301 | answer = [] 302 | for i in quiz: 303 | c = i.split('=') 304 | for j in range (len(c)): 305 | if eval(c[0]) == eval(c[1]): 306 | answer.append('O') 307 | break 308 | else: 309 | answer.append('X') 310 | break 311 | return answer 312 | 313 | 314 | 315 | def valid(equation): 316 | equation = equation.replace('=', '==') 317 | return eval(equation) 318 | 319 | def solution(equations): 320 | return ["O" if valid(equation) else "X" for equation in equations] 321 | ``` 322 | 323 | - js 324 | 325 | ```js 326 | function solution(quiz) { 327 | return quiz 328 | .map((el) => el.split(" = ")) 329 | .map((el) => { 330 | return eval(el[0]) == el[1] ? "O" : "X"; 331 | }); 332 | } 333 | ``` 334 | 335 | ## 겹치는 선분의 길이 336 | 337 | - 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120876 338 | - python 339 | 340 | ```py 341 | # 오답 342 | def solution(lines): 343 | 하나, 둘, 셋 = lines 344 | 길이 = [] 345 | if 하나[1] <= 둘[0]: 346 | pass 347 | else: 348 | 길이.append([min(둘[1], 하나[1]), max(둘[0], 하나[0])]) 349 | if 하나[1] <= 셋[0]: 350 | pass 351 | else: 352 | 길이.append([min(하나[1], 셋[1]), max(하나[0], 셋[0])]) 353 | if 둘[1] <= 셋[0]: 354 | pass 355 | else: 356 | 길이.append([min(셋[1], 둘[1]), max(셋[0], 둘[0])]) 357 | 358 | # [길이[0][0], 길이[1][0], 길이[2][0]] 359 | # [길이[0][1], 길이[1][1], 길이[2][1]] 360 | if 길이 == []: 361 | return 0 362 | # 중간에 끊어진 경우가 있을 수 있음, test case 1번과 9번 통과 못함 363 | # 반례 : [[0, 5], [3, 9], [8, 9]] 364 | 시작 = [i[0] for i in 길이] 365 | 끝 = [i[1] for i in 길이] 366 | print(길이) 367 | # return max(시작) - min(끝) 368 | 369 | solution([[0, 5], [3, 9], [8, 9]]) 370 | solution([[0, 5], [3, 9], [1, 10]]) 371 | solution([[0, 1], [2, 5], [3, 9]]) 372 | 373 | # 정답 374 | def solution(lines): 375 | lines.sort(key=lambda x:x[1]) 376 | 하나, 둘, 셋 = lines 377 | 길이 = [] 378 | if 하나[1] <= 둘[0]: 379 | pass 380 | else: 381 | 길이.append([max(둘[0], 하나[0]), min(둘[1], 하나[1])]) 382 | if 하나[1] <= 셋[0]: 383 | pass 384 | else: 385 | 길이.append([max(하나[0], 셋[0]), min(하나[1], 셋[1])]) 386 | if 둘[1] <= 셋[0]: 387 | pass 388 | else: 389 | 길이.append([max(셋[0], 둘[0]), min(셋[1], 둘[1])]) 390 | 391 | if 길이 == []: 392 | return 0 393 | print(길이) 394 | l = 길이 395 | # 중간에 끊어진 경우가 있을 수 있음, test case 1번과 9번 통과 못함 396 | # 반례 : [[0, 5], [3, 9], [8, 9]] 397 | if len(l) == 1: 398 | return l[0][1] - l[0][0] 399 | elif len(l) == 2: 400 | if l[0][1] <= l[1][0]: 401 | return (l[0][1] - l[0][0]) + (l[1][1] - l[1][0]) 402 | else: 403 | return max(l[1]) - min(l[0]) 404 | elif len(l) == 3: 405 | # 겹치지 않고 and 겹치지 않는다 406 | if l[0][1] <= l[1][0] and l[1][1] <= l[2][0]: 407 | return (l[0][1] - l[0][0]) + (l[1][1] - l[1][0]) + (l[2][1] - l[2][0]) 408 | # 모두 겹친다 409 | elif l[0][1] > l[1][0] and l[1][1] > l[2][0]: 410 | 시작 = [i[0] for i in l] 411 | 끝 = [i[1] for i in l] 412 | return max(끝) - min(시작) 413 | # 부분적으로 겹친다 414 | else: 415 | # 겹치지 않고 and 겹친다 416 | if l[0][1] <= l[1][0] and l[1][1] > l[2][0]: 417 | return (l[0][1] - l[0][0]) + (max(l[2]) - min(l[1])) 418 | # 겹치고 and 겹치지 않는다 419 | if l[0][1] > l[1][0] and l[1][1] <= l[2][0]: 420 | return (max(l[1]) - min(l[0])) + (l[2][1] - l[2][0]) 421 | return max(l[2][1]) - min(l[0][1]) 422 | 423 | 424 | solution([[0, 1], [2, 5], [3, 9]]) 425 | solution([[0, 5], [3, 9], [8, 9]]) 426 | solution([[0, 5], [3, 9], [1, 10]]) 427 | 428 | # 정답 코드 2 429 | def solution(lines): 430 | sets = [set(range(min(l), max(l))) for l in lines] 431 | return len(sets[0] & sets[1] | sets[0] & sets[2] | sets[1] & sets[2]) 432 | ``` 433 | 434 | - js 435 | 436 | ```js 437 | function solution(lines) { 438 | let line = new Array(200).fill(0); 439 | 440 | lines.forEach(([a, b]) => { 441 | for (; a < b; a++) line[a + 100]++; 442 | }); 443 | 444 | return line.reduce((a, c) => (c > 1 ? a + 1 : a), 0); 445 | } 446 | ``` 447 | -------------------------------------------------------------------------------- /코딩도장.md: -------------------------------------------------------------------------------- 1 | ## 구글 입사문제 중에서 2 | 3 | - 링크 : https://codingdojang.com/scode/393 4 | - python 5 | 6 | ```py 7 | str(list(range(10000))).count('8') 8 | ``` 9 | 10 | - js 11 | 12 | ```js 13 | Array(10000).fill(0).map((v, i) => i).toString().split('').filter(v => v === '8').length 14 | ``` 15 | 16 | ## 다음 입사문제 중에서 17 | 18 | - 링크 : https://codingdojang.com/scode/408 19 | - python 20 | 21 | ```py 22 | s = [1, 3, 4, 8, 13, 17, 20] 23 | index = 0 24 | minim = float('inf') #float('-inf') 25 | for i in range(1, len(s)): 26 | if (s[i] - s[i-1]) < minim: 27 | index = i 28 | minim = s[i] - s[i-1] 29 | 30 | s[index-1], s[index] 31 | 32 | s = [1, 3, 4, 8, 13, 17, 20] 33 | ss = s[1:] 34 | sorted(zip(s, ss), key=lambda x:x[1]-x[0])[0] 35 | ``` 36 | 37 | - js 38 | 39 | ```js 40 | s = [1, 3, 4, 8, 13, 17, 20] 41 | index = 0 42 | minim = Infinity 43 | for (let i = 1; i < s.length; i++) { 44 | if (s[i] - s[i-1] < minim) { 45 | index = i 46 | minim = s[i] - s[i-1] 47 | } 48 | } 49 | 50 | console.log(s[index], s[index-1]) 51 | 52 | s = [1, 3, 4, 8, 13, 17, 20] 53 | ss = s.slice(1) 54 | s.map((v, i) => [v, ss[i]]) 55 | s.map((v, i) => [v, ss[i]]).sort((a, b) => (a[1]-a[0]) - (b[1]-b[0]))[0] 56 | ``` 57 | 58 | ## 문자열 압축하기 59 | 60 | - 링크 : https://codingdojang.com/scode/465 61 | - python 62 | 63 | ```py 64 | s = 'aaabbcccccca' 65 | 66 | result = s[0] 67 | count = 0 68 | 69 | for string in s: 70 | print(result) 71 | if string == result[-1]: 72 | count += 1 73 | else: 74 | result += str(count) + string 75 | count = 1 76 | 77 | result += str(count) 78 | result 79 | 80 | ### 81 | 82 | import re 83 | 84 | s = 'aaabbcccccca' 85 | p = re.compile('(\w)(\\1*)') # \w는 문자 클래스 \1은 재참조 메타문자, *는 0번또는 여러번 86 | p.findall(s) 87 | ``` 88 | 89 | - js 90 | 91 | ```js 92 | const s = 'aaabbcccccca' 93 | 94 | let result = s[0] 95 | let count = 0 96 | 97 | for (let str of s){ 98 | console.log(str) 99 | console.log(result) 100 | if (str == result.slice(-1)){ 101 | count += 1 102 | } 103 | else { 104 | result += count + str 105 | count = 1 106 | } 107 | } 108 | 109 | result += count 110 | console.log(result) 111 | 112 | // --- 113 | 114 | const s = "aaabbcccccca"; 115 | const reg = /(\w)\1*/g; 116 | 117 | [...s.matchAll(reg)] 118 | 119 | // --- 120 | 121 | var strzip = str => str.replace(/(\D)\1*/g, s => s[0] + s.length); 122 | 123 | console.log(strzip("aaabbcccccca")); 124 | console.log(strzip("abcdefg")); 125 | 126 | ``` 127 | 128 | ## Special Sort 129 | 130 | - 링크 : https://codingdojang.com/scode/414 131 | - python 132 | 133 | ```py 134 | def solution(value): 135 | return [i for i in value if i < 0] + [i for i in value if i >= 0] 136 | 137 | solution([-1, 1, 3, -2, 2]) 138 | ``` 139 | 140 | - js 141 | 142 | ```js 143 | function solution(value){ 144 | return [...value.filter(v => v < 0), ...value.filter(v => v >= 0)] 145 | } 146 | 147 | solution([-1, 1, 3, -2, 2]) 148 | ``` 149 | 150 | ## 숫자 출력하기 151 | 152 | - 링크 : https://codingdojang.com/scode/471 153 | - python 154 | 155 | ```py 156 | # 32진수가 맥시멈 157 | 158 | 159 | int('aa', 16) 160 | int('aa', 32) 161 | 162 | chr(32) 163 | chr(33) 164 | ord(32) 165 | ord(33) 166 | 167 | bin(20150111), oct(20150111), hex(20150111) 168 | format(20150111, 'b'), format(20150111, 'o'), format(20150111, 'x') 169 | print(int('j6tqv', ord(' '))) # js로 진법 변환 170 | # let number = 20150111; 171 | # let test = number.toString(16); 172 | # let test = number.toString(32); 173 | # let test = number.toString(33); 174 | 175 | ord('!') 176 | print(int('gwnae', ord('!'))) 177 | ``` 178 | 179 | - js 180 | 181 | ```js 182 | //36을 초과할 수 없음 183 | let number = 20150111; 184 | 185 | let b = number.toString(2); // 2진수로 186 | let o = number.toString(8); // 8진수로 187 | let h = number.toString(16); // 16진수로 188 | 189 | number.toString(33); 190 | parseInt('gwnae', 33) 191 | 192 | ' '.charCodeAt() 193 | '!'.charCodeAt() 194 | 195 | console.log(parseInt('gwnae', '!'.charCodeAt())) 196 | ``` 197 | 198 | ## 아마존 면접문제 중에서 199 | 200 | - 링크 : https://codingdojang.com/scode/416 201 | - python 202 | 203 | ```py 204 | def solution(l): 205 | n = len(l) // 2 206 | return list(zip(l[:n], l[n:])) 207 | 208 | l = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5'] 209 | sum(solution(l), ()) 210 | # sum(iterable, start) 211 | 212 | def solution(l): 213 | n = len(l)//2 214 | l[::2], l[1::2] = l[:n], l[n:] 215 | 216 | l = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5'] 217 | solution(l) 218 | l 219 | 220 | 221 | ``` 222 | 223 | - js 224 | 225 | ```js 226 | // swap을 하는 방법 227 | const arr = [10, 20, 30, 40, 50, 60]; 228 | 229 | [arr[1], arr[2]] = [arr[2], arr[1]]; 230 | 231 | console.log(arr); 232 | 233 | // 234 | const l = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5'] 235 | 236 | function solution(list) { 237 | var n = list.length / 2; 238 | for (let i = 1; i < n; i++) { 239 | for (let j = i * 2 - 1; j < n + i; j++) { 240 | [list[j], list[n + i - 1]] = [list[n + i - 1], list[j]]; 241 | } 242 | } 243 | return list; 244 | } 245 | 246 | console.log(solution(l)); 247 | 248 | /////////// 249 | 250 | let list = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"] 251 | 252 | for (let i = 0; i < (list.length/2); i++) { 253 | list.splice(((list.length/2)- i),0, list.pop()) 254 | } 255 | console.log(list) 256 | 257 | //////////// 258 | 259 | const zip = (a, b) => a.map((v, i) => [v, b[i]]); 260 | // zip('hello', [10, 20, 30, 40, 50]) // error 261 | zip([10, 20, 30, 40, 50], "hello"); // 성공 262 | // (2) [10, 'h'] 263 | // (2) [20, 'e'] 264 | // (2) [30, 'l'] 265 | // (2) [40, 'l'] 266 | // (2) [50, 'o'] 267 | 268 | let list = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"] 269 | let l1 = list.slice(0,list.length/2) 270 | let l2 = list.slice(list.length/2) 271 | const zip = (a, b) => a.map((v, i) => [v, b[i]]); 272 | zip(l1, l2) 273 | zip(l1, l2).flat(2) 274 | 275 | ``` 276 | 277 | ## 가성비 최대화 278 | 279 | - 링크 : https://codingdojang.com/scode/490 280 | - python 281 | 282 | ```py 283 | 가격 = 10 284 | 성능 = 150 285 | 부품가격 = 3 286 | 부품성능 = [30, 70, 15, 40, 65] 287 | 288 | 부품성능.sort(reverse=True) 289 | 290 | for i in 부품성능 : 291 | if 성능 / 가격 > ( 성능 + i ) / ( 가격 + 부품가격 ) : 292 | break 293 | else: 294 | 성능 += i 295 | 가격 += 부품가격 296 | 297 | print(int( 성능 / 가격 )) 298 | ``` 299 | 300 | - js 301 | 302 | ```js 303 | let 가격 = 10 304 | let 성능 = 150 305 | let 부품가격 = 3 306 | let 부품성능 = [30, 70, 15, 40, 65] 307 | 308 | 부품성능.sort((a, b) => a - b) 309 | 부품성능.sort((a, b) => b - a) 310 | 311 | for (let i of 부품성능){ 312 | if ((성능 / 가격) > ((성능 + i) / (가격 + 부품가격))) { 313 | break 314 | } else { 315 | 성능 += i 316 | 가격 += 부품가격 317 | } 318 | } 319 | console.log(~~(성능/가격)) 320 | ``` 321 | 322 | ## 그 시간 사무실에 몇 명이 있었나? 323 | 324 | - 링크 : https://codingdojang.com/scode/418 325 | - python 326 | 327 | ```py 328 | # 시간이라고 해서 꼭 시간으로 비교할 필요는 없음 329 | t = ''.join(input().split(':')) 330 | count = 0 331 | 332 | log = '''09:12:23 11:14:35 333 | 10:34:01 13:23:40 334 | 10:34:31 11:20:10''' 335 | 336 | logs = log.split('\n') 337 | for log in logs: 338 | l = [''.join(time.split(':')) for time in log.split()] 339 | # print(l) 340 | if l[0] <= t <= l[1]: 341 | count += 1 342 | 343 | count 344 | #10:35:00 345 | #11:21:00 346 | #13:25:00 347 | ``` 348 | 349 | - js 350 | 351 | ```js 352 | let t = '09:12:23' 353 | t = t.split(':').join('') 354 | let count = 0 355 | 356 | let logs = `09:12:23 11:14:35 357 | 10:34:01 13:23:40 358 | 10:34:31 11:20:10` 359 | let log = logs.split('\n') 360 | 361 | for (let l of log){ 362 | let 출근 = l.split(' ')[0].split(':').join('') 363 | let 퇴근 = l.split(' ')[1].split(':').join('') 364 | if (출근 <= t && t <= 퇴근){ 365 | count += 1 366 | } 367 | } 368 | 369 | count 370 | 371 | //10:35:00 372 | //11:21:00 373 | //13:25:00 374 | ``` 375 | 376 | ## 120번째 죄수 377 | 378 | - 링크 : https://codingdojang.com/scode/525 379 | - python 380 | 381 | ```py 382 | room = [-1] * 120 383 | 384 | for i in range(1, 121): 385 | for n in range(1, 121): 386 | if n % i == 0: 387 | room[n-1] *= -1 388 | 389 | room.count(1) 390 | ``` 391 | 392 | - js 393 | 394 | ```js 395 | let room = Array(120).fill(-1) 396 | for(let i = 1; i < 121; i++){ 397 | for(let n = 1; n < 121; n++){ 398 | if (n % i == 0){ 399 | room[n-1] *= -1 400 | } 401 | } 402 | } 403 | room.filter(v => v == 1).length 404 | ``` 405 | 406 | ## 407 | 408 | - 링크 : 409 | - python 410 | 411 | ```py 412 | def OneEditApart(a, b): 413 | while a and b: 414 | if a[-1] == b[-1]: 415 | a = a[:-1] 416 | b = b[:-1] 417 | continue 418 | elif a[0] == b[0]: 419 | a = a[1:] 420 | b = b[1:] 421 | continue 422 | else: 423 | break 424 | return len(a) <= 1 and len(b) <= 1 425 | 426 | print(OneEditApart("cat", "dog")) 427 | print(OneEditApart("cat", "cats")) 428 | print(OneEditApart("cat", "cut")) 429 | print(OneEditApart("cat", "cast")) 430 | print(OneEditApart("cat", "at")) 431 | print(OneEditApart("cat", "acts")) 432 | ``` 433 | 434 | - js 435 | 436 | ```js 437 | function OneEditApart(a, b){ 438 | while (a.length != 0 && b.length != 0){ 439 | if (a.slice(-1) == b.slice(-1) ){ 440 | a = a.slice(0,-1) 441 | b = b.slice(0,-1) 442 | continue 443 | } 444 | else if (a[0] == b[0]){ 445 | a = a.slice(1) 446 | b = b.slice(1) 447 | continue 448 | } 449 | else { 450 | break 451 | } 452 | } 453 | return a.length <= 1 && b.length <= 1 454 | } 455 | 456 | console.log(OneEditApart("cat", "dog")) 457 | console.log(OneEditApart("cat", "cats")) 458 | console.log(OneEditApart("cat", "cut")) 459 | console.log(OneEditApart("cat", "cast")) 460 | console.log(OneEditApart("cat", "at")) 461 | console.log(OneEditApart("cat", "acts")) 462 | ``` 463 | 464 | ## Subdate 465 | 466 | - 링크 : https://codingdojang.com/scode/394 467 | - python 468 | 469 | ```py 470 | def subdate(date): 471 | 년 = int(date[:4]) 472 | 월 = int(date[4:6]) 473 | 일 = int(date[6:]) 474 | 월별일 = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] 475 | 일수 = 년 * 365 + 일 476 | for i in range(1, 월): 477 | 일수 += 월별일[i] 478 | return 일수 479 | 480 | def solution(a, b): 481 | return abs(subdate(a) - subdate(b)) 482 | 483 | solution('20070515', '20070501') #14 484 | solution('20070301', '20070515') #75 485 | ``` 486 | 487 | - js 488 | 489 | ```js 490 | function subdate(date){ 491 | 년 = parseInt(date.slice(0, 4)) 492 | 월 = parseInt(date.slice(4, 6)) 493 | 일 = parseInt(date.slice(6)) 494 | console.log(년, 월, 일) 495 | 월별일 = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] 496 | 일수 = 년 * 365 + 일 497 | for(let i=1; i<월;i++){ 498 | 일수 += 월별일[i] 499 | } 500 | return 일수 501 | } 502 | 503 | function solution(a, b){ 504 | return Math.abs(subdate(a) - subdate(b)) 505 | } 506 | 507 | solution('20070515', '20070501') //14 508 | solution('20070301', '20070515') //75 509 | ``` 510 | 511 | ## Happy Number 512 | 513 | - 링크 : https://codingdojang.com/scode/496 514 | - python 515 | 516 | ```py 517 | testcase = [3, 7, 4, 13] 518 | def happyNumber(입력숫자): 519 | 더할숫자 = [] 520 | 더한숫자 = 입력숫자 521 | 제곱의합리스트 = [] 522 | while(더한숫자 != "1"): 523 | for i in range(len(더한숫자)): 524 | a = int(더한숫자[i]) * int(더한숫자[i]) 525 | 더할숫자.append(a) 526 | 더한숫자 = str(sum(더할숫자)) 527 | print(더할숫자, 제곱의합리스트) 528 | 더할숫자 = [] 529 | if 더한숫자 == 입력숫자: 530 | return False 531 | if 더한숫자 in 제곱의합리스트: 532 | return False 533 | 제곱의합리스트.append(더한숫자) 534 | return True 535 | 536 | for i, number in enumerate(testcase): 537 | if happyNumber(str(number)): 538 | print(f'Case #{(str(i+1))}: {number} is a Happy number.') 539 | else: 540 | print(f'Case #{(str(i+1))}: {number} is an Unhappy number.') 541 | ''' 542 | [9] [] 543 | [81] ['9'] 544 | [64, 1] ['9', '81'] 545 | [36, 25] ['9', '81', '65'] 546 | [36, 1] ['9', '81', '65', '61'] 547 | [9, 49] ['9', '81', '65', '61', '37'] 548 | [25, 64] ['9', '81', '65', '61', '37', '58'] 549 | [64, 81] ['9', '81', '65', '61', '37', '58', '89'] 550 | [1, 16, 25] ['9', '81', '65', '61', '37', '58', '89', '145'] 551 | [16, 4] ['9', '81', '65', '61', '37', '58', '89', '145', '42'] 552 | [4, 0] ['9', '81', '65', '61', '37', '58', '89', '145', '42', '20'] 553 | [16] ['9', '81', '65', '61', '37', '58', '89', '145', '42', '20', '4'] 554 | [1, 36] ['9', '81', '65', '61', '37', '58', '89', '145', '42', '20', '4', '16'] 555 | Case #1: 3 is an Unhappy number. 556 | [49] [] 557 | [16, 81] ['49'] 558 | [81, 49] ['49', '97'] 559 | [1, 9, 0] ['49', '97', '130'] 560 | [1, 0] ['49', '97', '130', '10'] 561 | Case #2: 7 is a Happy number. 562 | [16] [] 563 | [1, 36] ['16'] 564 | [9, 49] ['16', '37'] 565 | [25, 64] ['16', '37', '58'] 566 | [64, 81] ['16', '37', '58', '89'] 567 | [1, 16, 25] ['16', '37', '58', '89', '145'] 568 | [16, 4] ['16', '37', '58', '89', '145', '42'] 569 | [4, 0] ['16', '37', '58', '89', '145', '42', '20'] 570 | Case #3: 4 is an Unhappy number. 571 | [1, 9] [] 572 | [1, 0] ['10'] 573 | Case #4: 13 is a Happy number. 574 | ''' 575 | ``` 576 | 577 | - js 578 | 579 | ```js 580 | testcase = [3, 7, 4, 13] 581 | 582 | function happyNumber(입력숫자){ 583 | let 더할숫자 = [] 584 | let 더한숫자 = 입력숫자 585 | let 제곱의합리스트 = [] 586 | while (더한숫자 != '1'){ 587 | for (let i of 더한숫자){ 588 | let sq = parseInt(i) ** 2 589 | 더할숫자.push(sq) 590 | } 591 | 더한숫자 = String(더할숫자.reduce((a, b) => a + b, 0)) 592 | console.log(더할숫자, 더한숫자, 제곱의합리스트) 593 | 더할숫자 = [] 594 | if (더한숫자 == 입력숫자){ 595 | return false 596 | } 597 | for (let i of 제곱의합리스트){ 598 | if(i === 더한숫자){ 599 | return false 600 | } 601 | } 602 | 제곱의합리스트.push(더한숫자) 603 | } 604 | return true 605 | } 606 | 607 | // happyNumber(String(7)) 608 | 609 | for (let i = 0; i < testcase.length; i++) { 610 | if (happyNumber(String(testcase[i]))){ 611 | console.log(`Case #${i+1}: ${testcase[i]} is a Happy number.`) 612 | 613 | } else { 614 | console.log(`Case #${i+1}: ${testcase[i]} is an Unhappy number.`) 615 | } 616 | } 617 | 618 | // 참고사항 619 | function test(value){ 620 | value.forEach(v =>{ 621 | if (v === 10){ 622 | return false 623 | } 624 | }) 625 | return true 626 | } 627 | 628 | test([20, 30, 10, 40]) 629 | ``` 630 | 631 | ## Ugly Numbers 632 | 633 | - 링크 : https://codingdojang.com/scode/436 634 | - python 635 | 636 | ```py 637 | def uglyNumber(n): 638 | ugly_number_list = [1] 639 | for i in range(n-1): 640 | last = ugly_number_list[-1] 641 | 642 | temp = [] 643 | for i in ugly_number_list: 644 | for j in [i*2, i*3, i*5]: 645 | if j > last: 646 | temp.append(j) 647 | 648 | ugly_number_list.append(min(temp)) 649 | return ugly_number_list[-1] 650 | 651 | uglyNumber(1500) 652 | ``` 653 | 654 | - js 655 | 656 | ```js 657 | function uglyNumber(n){ 658 | let ugly_number_list = [1] 659 | for(i = 0; i < n-1; i++){ 660 | let last = ugly_number_list.slice(-1) 661 | 662 | let temp = [] 663 | for (let i of ugly_number_list){ 664 | for (let j of [i*2, i*3, i*5]){ 665 | if (j > last){ 666 | temp.push(j) 667 | } 668 | } 669 | } 670 | 671 | ugly_number_list.push(Math.min(...temp)) 672 | } 673 | return ugly_number_list.slice(-1) 674 | } 675 | 676 | uglyNumber(1500) 677 | ``` 678 | 679 | ## Two Printers 680 | 681 | - 링크 : https://codingdojang.com/scode/449 682 | - python 683 | 684 | ```py 685 | def two_printers(x, y, page): 686 | time = 1 687 | while True: 688 | if time // x + time // y >= page: 689 | return time 690 | time+=1 691 | 692 | two_printers(1, 1, 5) #3 693 | two_printers(3, 5, 4) #9 694 | two_printers(1, 100, 1) #1 695 | two_printers(1, 100, 2) #2 696 | ``` 697 | 698 | - js 699 | 700 | ```js 701 | function solution(x, y, page){ 702 | let time = 1 703 | while (true) { 704 | if (Math.floor(time / x) + Math.floor(time / y) >= page) { 705 | return time 706 | } 707 | time += 1 708 | } 709 | } 710 | 711 | two_printers(1, 1, 5) 712 | two_printers(3, 5, 4) 713 | two_printers(1, 100, 1) 714 | two_printers(1, 100, 2) 715 | ``` 716 | 717 | ## tic-tac-toe game 718 | 719 | - 링크 : https://codingdojang.com/scode/464 720 | - python 721 | 722 | ```py 723 | import numpy as np 724 | 725 | board = np.array([['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]) 726 | marker = ['X', 'O'] 727 | player = 0 728 | 729 | def printBoard(): 730 | for i in board: 731 | print(f'| {" | ".join(i)} |') 732 | 733 | 734 | def checkWinner(): 735 | if board[0][0] == board[1][1] == board[2][2]: 736 | printBoard() 737 | return board[0][0] 738 | elif board[0][2] == board[1][1] == board[2][0]: 739 | printBoard() 740 | return board[0][2] 741 | else: 742 | for i in range(3): 743 | if len(set([board[0][i], board[1][i], board[2][i]])) == 1: 744 | printBoard() 745 | return board[0][i] 746 | elif len(set([board[i][0], board[i][1], board[i][2]])) == 1: 747 | printBoard() 748 | return board[i][0] 749 | if len(np.unique(board)) == 2: 750 | printBoard() 751 | return 'Draw' 752 | return False 753 | 754 | 755 | def solution(): 756 | printBoard() 757 | position = input() 758 | pos = np.where(board == position) 759 | 760 | if list(pos[0]): 761 | board[pos[0][0]][pos[1][0]] = marker[player] 762 | 763 | ch = checkWinner() 764 | if ch: 765 | if ch == 'Draw': 766 | print('비김!') 767 | else: 768 | print(ch, '이김!') 769 | return False 770 | return True 771 | 772 | while solution(): 773 | player ^= 1 774 | 775 | 776 | ## 참고사항 ## 777 | test = [1, 2, 3, 4] 778 | 779 | def t(): 780 | test[1] = 1000 781 | 782 | t() 783 | test 784 | 785 | 786 | board = np.array([['1','2','3'],['4','5','6'],['7','8','9']]) 787 | # 있는 값 788 | pos = np.where(board == '3') 789 | pos 790 | pos[0] 791 | pos[0][0] 792 | 793 | pos[1] 794 | pos[1][0] 795 | 796 | # 없는 값 797 | pos = np.where(board == '33') 798 | pos 799 | pos[0] 800 | list(pos[0]) 801 | ``` 802 | 803 | - js 804 | 805 | ```js 806 | let board = [['1','2','3'],['4','5','6'],['7','8','9']] 807 | let marker = ['X', 'O'] 808 | let player = 1 809 | 810 | function printBoard(){ 811 | for (let i of board) { 812 | console.log('| ' + i.join(' | ') + ' |') 813 | } 814 | console.log('----------') 815 | } 816 | 817 | function checkWinner(){ 818 | if (board[0][0] == board[1][1] && board[1][1] == board[2][2]){ 819 | return board[0][0] 820 | } else if (board[0][2] == board[1][1] && board[1][1] == board[2][0]){ 821 | return board[0][2] 822 | } else { 823 | for (let i = 0; i < 3; i++) { 824 | if (new Set([board[0][i], board[1][i], board[2][i]]).size == 1){ 825 | return board[0][i] 826 | } 827 | else if (new Set([board[i][0], board[i][1], board[i][2]]).size == 1){ 828 | return board[i][0] 829 | } 830 | } 831 | } 832 | if (new Set(board.flat()).size == 2){ 833 | return 'Draw' 834 | } 835 | return false 836 | } 837 | 838 | function solution(){ 839 | let userInput = window.prompt() 840 | let pos = [] 841 | for (let i = 0; i < 3; i++) { 842 | for (let j = 0; j < 3; j++) { 843 | if (board[i][j] === userInput) { 844 | pos = [i, j] 845 | } 846 | } 847 | } 848 | if (pos.length === 2){ 849 | board[pos[0]][pos[1]] = marker[player] 850 | printBoard() 851 | } 852 | 853 | let ch = checkWinner() 854 | if (ch){ 855 | if (ch === 'Draw') { 856 | console.log('비김!') 857 | } else { 858 | console.log(ch, '이김!') 859 | } 860 | return false 861 | } 862 | return true 863 | } 864 | 865 | while(solution()){ 866 | player ^= 1 867 | } 868 | ``` 869 | 870 | ## 871 | 872 | - 링크 : 873 | - python 874 | 875 | ```py 876 | 877 | ``` 878 | 879 | - js 880 | 881 | ```js 882 | 883 | ``` 884 | 885 | ## 886 | 887 | - 링크 : 888 | - python 889 | 890 | ```py 891 | 892 | ``` 893 | 894 | - js 895 | 896 | ```js 897 | 898 | ``` 899 | 900 | ## 901 | 902 | - 링크 : 903 | - python 904 | 905 | ```py 906 | 907 | ``` 908 | 909 | - js 910 | 911 | ```js 912 | 913 | ``` --------------------------------------------------------------------------------