Binary Journey

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

function solution(n) {
    let ternary = [];
    let answer = 0;
    while (n >= 1) {
        if (n > 1) {
            ternary.push(n % 3);
        } else {
            ternary.push(n);
        }
        n = parseInt(n / 3);
    }
    for (let i = 0; i < ternary.length; i++) {
        answer += ternary[i] * Math.pow(3, ternary.length - 1 - i);
    }
    return answer;
}

toString 을 이용한 방법 효율성은 위 코드가 더 높다

const solution = (n) => {
    return parseInt([...n.toString(3)].reverse().join(""), 3);
}

이 식이 내 맘 속 베스트,,

function solution(n) {
    const answer = [];
    while(n !== 0) {
        answer.unshift(n % 3);
        n = Math.floor(n/3);
    }
    return answer.reduce((acc,v,i) => acc + (v * Math.pow(3, i)),0);   
}

** Python

def solution(n):
    arr = []
    result = 0
    while True :
        if n == 0:
            break
        arr.append(n % 3)
        n = n // 3
    for i, x in enumerate(arr):
        result += x * 3 ** (len(arr) - i - 1)
    return result

** Java

log3N + 1 해서 자릿수 먼저 구해준 다음에 거꾸로 제곱해감

class Solution {
    public int solution(int n) {
        int answer = 0;
        int cnt = (int) (Math.log(n) / Math.log(3));
        while (cnt >= 0) {
            int div = n % 3;
            answer += div * Math.pow(3, cnt);
            n = n / 3;
            --cnt;
        }
        return answer;
    }
}

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

sort를 이용하여 내림차순으로 바꿔도 되지만 map 자체에서 그냥 비교한 후 바로 배열을 리턴하는 것도 좋다.

function solution(sizes) {
    // sizes.map((item) => item.sort((a, b) => b - a));
    sizes = sizes.map(([w, h]) => w < h ? [h, w] : [w, h]);
    let hMax = Math.max.apply(null, sizes.map((item) => item[0]));
    let vMax = Math.max.apply(null, sizes.map((item) => item[1]));
    return hMax * vMax;
}

** Python

def solution(sizes):
    v_max = 0
    h_max = 0
    for v, h in sizes:
        if v < h: v, h = h, v
        if v > v_max: v_max = v
        if h > h_max: h_max = h
    return v_max * h_max

** Java

class Solution {
    public long solution(int[][] sizes) {
        int vMax = 0;
        int hMax = 0;
        for (int[] size : sizes) {
            int temp = 0;
            if (size[1] > size[0]) {
                temp = size[0];
                size[0] = size[1];
                size[1] = temp;
            }
            vMax = size[0] > vMax ? size[0] : vMax;
            hMax = size[1] > hMax ? size[1] : hMax;
        }
        return vMax * hMax;
    }
}

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

function solution(numbers) {
    let answer = [];
    for (var i = 0; i < numbers.length; i++) {
        for (var j = 0; j < numbers.length; j++) {
            if (i !== j) {
                answer.push(numbers[i] + numbers[j]);
            }
        }
    }   
    return [ ...new Set(answer)].sort((a, b) => a - b);
}

** Python

def solution(numbers):
    answer = []
    for i in range(len(numbers)):
        for j in range(len(numbers)):
            if not i == j:
                answer.append(numbers[i] + numbers[j])
    return sorted(list(set(answer)))

** Java

import java.util.*;
class Solution {
    public Integer[] solution(int[] numbers) {
        Set<Integer> answer = new HashSet<Integer>();
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < numbers.length; j++) {
                if (i != j) answer.add(numbers[i] + numbers[j]);
            }
        }
        Integer[] arr = answer.toArray(new Integer[0]);
        Arrays.sort(arr);
        return arr;
    }
}

나는 리턴타입을 Integer로 바꿨는데 그냥 ArrayList로 바꿔도 되나 보다.

추천 많이 받은 풀이 투톱

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;

class Solution {
    public static ArrayList<Integer> solution(int[] numbers) {
        ArrayList<Integer> answer = new ArrayList<>();
        HashSet<Integer> set = new HashSet<>();

        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = i + 1; j < numbers.length; j++) {
                set.add(numbers[i] + numbers[j]);
            }
        }

        Iterator<Integer> iter = set.iterator();
        while(iter.hasNext()) {
            answer.add(iter.next());
        }

        Collections.sort(answer);
        return answer;
    }
}

import java.util.HashSet;
import java.util.Set;

class Solution {
     public int[] solution(int[] numbers) {
        Set<Integer> set = new HashSet<>();

        for(int i=0; i<numbers.length; i++) {
            for(int j=i+1; j<numbers.length; j++) {
                set.add(numbers[i] + numbers[j]);
            }
        }

        return set.stream().sorted().mapToInt(Integer::intValue).toArray();
    }
}

풀이 댓글에서 조언도 있었다. 

HashSet이 아닌 TreeSet을 사용하면 add하면서 정렬도 같이 됩니당

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

function solution(a, b) {
    const date = new Date();
    date.setFullYear(2016, a - 1, b);
    const days = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
    return days[date.getDay()];
}

** Python

import datetime
def solution(a, b):
    return datetime.datetime(2016, a, b).strftime("%A")[:3].upper()

import datetime
def solution(a, b):
    return datetime.datetime(2016, a, b).strftime("%a").upper()

참고: https://stackoverflow.com/questions/8380389/how-to-get-day-name-from-datetime

** Java

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.TextStyle;
import java.util.Locale;

class Solution {
    public String solution(int a, int b) {
        LocalDate date = LocalDate.of(2016, a, b);
        DayOfWeek  dayOfWeek = date.getDayOfWeek();
        return dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.US).toUpperCase();
    }
}

참고: https://hianna.tistory.com/610

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

function solution(s) {
    if (s.length % 2 === 1) {
        return s[parseInt(s.length / 2)];
    } else {
        return `${s[s.length / 2 - 1]}${s[s.length / 2]}`;
    }
}

** Python

def solution(s):
    return s[len(s) // 2] if len(s) % 2 else s[len(s) // 2 - 1 : len(s) // 2 + 1]

** Java

import java.util.*;
class Solution {
    public String solution(String s) {
        int median = Math.round(s.length() / 2);
        String[] ss = s.split("");
        return s.length() % 2 == 1 ? ss[median] : String.join("", Arrays.copyOfRange(ss, median - 1, median + 1));
    }
}

참고: https://stackoverflow.com/questions/11001720/get-only-part-of-an-array-in-java

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

비트연산자를 이용했다.

그리고 padStart 를 이용하여 출력되지 않은 0들을 채워주었다.

function solution(n, arr1, arr2) {
    let answer = [];
    for (let i = 0; i < n; i++) {
        answer.push((arr1[i]|arr2[i]).toString(2).padStart(n, '0').replace(/[1]/g, "#").replace(/[0]/g, " "));
    }
    return answer;
}

** Java

Java에는 따로 padStart 가 없어서 구글링하여 찾아보았다.

여러 추천 방법들이 있었는데 String.format 을 쓰는 게 가장 나을 듯하다.

class Solution {
    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n];
        for (int i = 0; i < n; i++) {
            answer[i] = String.format("%" + n + "s", Integer.toBinaryString(arr1[i] | arr2[i])).replaceAll("1", "#").replaceAll("0", " ");
        }
        return answer;
    }
}

참고: https://www.baeldung.com/java-pad-string

** Python

def solution(n, arr1, arr2):
    answer = [""] * n
    for i in range(n):
        # answer[i] = str(bin(arr1[i]|arr2[i]))[2:].rjust(n,'0').replace('1','#').replace('0',' ')
        answer[i] = str(bin(arr1[i]|arr2[i]))[2:].zfill(n).replace('1','#').replace('0',' ')
    return answer

숫자의 경우 앞에 0을 채워줘야 하는 경우가 생기는 데 python 의 경우 rjust 와 zfill 을 사용할 수 있다.

rjust 는 채우고 싶은 string 을 원하는 대로 지정할 수 있고

zfill 은 말 그대로 fill zero여서 총 글자 수만 지정해주면 된다.

참고: https://kkamikoon.tistory.com/136

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

function solution(arr)
{
    return arr.filter((item, index) => arr[index] !== arr[index + 1]);
}

굳이 arr[index] 쓸 필요가 없었는데 왜 썼지..

function solution(arr)
{
    return arr.filter((item, index) => item !== arr[index + 1]);
}

** Java

java는 효율성 테스트 때문에 추천 풀이 오픈...!

import java.util.*;
public class Solution {
    public int[] solution(int []arr) {
        List<Integer> list = new ArrayList<Integer>();
        int top = 10;
        for (int i : arr) {
            if (i != top) {
                list.add(i);
                top = i;
            }
        }
        int[] answer = new int[list.size()];
        for(int i=0; i<answer.length; i++) {
            answer[i] = list.get(i).intValue();
        }
        return answer;
    }
}

array 의 경우 사이즈를 정해서 선언해야 하므로 (고정된 수의 요소를 보유하는 컨테이너 객체임) 변동성이 있을 경우 List 나 ArrayList를 먼저 이용하는 것이 좋다.

index out of range 에러가 나는 것을 피하려면 swap 을 이용하면 된다.

** Python

def solution(arr):
    answer = []
    top = 10
    for i in arr:
        if i != top:
            answer.append(i)
            top = i
    return answer

가장 많이 추천을 받은 풀이는 다음과 같다.

def solution(arr):
    a = []
    for i in arr:
        if a[-1:] == [i]: continue
        a.append(i)
    return a

댓글 설명에 따르면

a[-1:]은 a값의 가장 뒤의 값을 list로 만든거라, list가 아닌 i랑 list인 a[-1:]값이랑 같은지 물어보면 당연히 다르다고 나오기 때문입니다.

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

1)

처음 제출한 풀이

function solution(arr, divisor) {
    var answer = arr.filter((item) => item % divisor === 0).sort((a, b) => a - b);
    return answer.length > 0 ? answer : [-1];
}

2)

reduce 이용한 풀이

1번이 더 나은 듯

function solution(arr, divisor) {
    let answer = arr.reduce((acc, curr) => {
        if (curr % divisor === 0) acc.push(curr);
        return acc;
    }, []).sort((a, b) => a - b);
    return answer.length ? answer : [-1];
}

* 더 빠르게 하려면 sort를 return 절 안에 넣는 게 낫다.

** Java

import java.util.*;
class Solution {
    public int[] solution(int[] arr, int divisor) {
        int[] answer = Arrays.stream(arr).filter(x -> x % divisor == 0).toArray();
        Arrays.sort(answer);
        return answer.length > 0 ? answer : new int[] {-1};
    }
}

** Python

def solution(arr, divisor):
    answer = [i for i in arr if i % divisor == 0]
    return sorted(answer) if len(answer) > 0 else [-1]

출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges

** Javascript

1)

처음에 제출했던 풀이

function solution(a, b) {
    var answer = 0;
    if (a > b) {
        for (var i = b; i <= a; i++) {
        answer += parseInt(i);
    }  
    } else {
        for (var i = a; i <= b; i++) {
            answer += parseInt(i);
        }
    }
    return answer;
}

2) 

다시 푼 풀이

function solution(a, b) {
    let answer = 0;
    let start = (a > b) ? b : a;
    let end = (a > b) ? a : b
    for (let i = start; i <= end; i++) {
        answer += i
    }
    return answer;
}

3)

가우스의 등차수열의 합을 이용한 풀이

(더할 항의 개수) * (첫항 + 마지막 항) / 2

function solution(a, b) {
    return (Math.abs(a-b) + 1) * (a + b) / 2;
}

** Python

def solution(a, b):
    return (abs(a - b) + 1) * (a + b) / 2

이렇게 풀 수도 있는데 위보단 느리다.

def solution(a, b):
    if a > b:
        a, b = b, a
    return sum(range(a, b + 1))

** Java

long 캐스트 하지 않으면 통과되지 않는다.

class Solution {
    public long solution(int a, int b) {
        return (long) (Math.abs(a - b) + 1) * (a + b) / 2;
    }
}

추천 1등 풀이도 등차수열의 합을 이용하였는데 절대값을 이용하지 않고 max, min를 구해 비교하였다

class Solution {

    public long solution(int a, int b) {
        return sumAtoB(Math.min(a, b), Math.max(b, a));
    }

    private long sumAtoB(long a, long b) {
        return (b - a + 1) * (a + b) / 2;
    }
}

출처: https://programmers.co.kr/learn/challenges

** Javascript

function solution(dartResult) {
    const bo = dartResult.split(/\d/g).filter((item) => item.length);
    const s = dartResult.split(/[SDT]|\*|\#/g).filter((item) => item.length);
    let strg = [];
    for (let i = 0; i < 3; i++) {
        const [ bonus, option ] = bo[i].split("");
        let score = Number(s[i]) ** "_SDT".indexOf(bonus);
        strg.push(score);
        if (option === "*") {
            for (let j = i - 1; j < i + 1; j++) {
                strg[j] = strg[j] * 2;
            }
        }
        if (option === "#") {
            strg[i] = strg[i] * -1;
        }
    }
    return strg.reduce((acc, curr) => acc += curr, 0);
}

** Python

import re
def solution(dartResult):
    s = re.findall(r'\d+', dartResult)
    bo = [i for i in re.split(r'(\d+)', dartResult) if not i.isdigit()][1:]
    _sum = [0, 0, 0]
    for i in range(len(s)):
        _sum[i] = int(s[i])
        for j in bo[i]:
            if '_SDT'.find(j) > 0:
                _sum[i] = _sum[i] ** '_SDT'.find(j)
            elif j == "*":
                _sum[i] = _sum[i] * 2
                if i != 0:
                    _sum[i-1] = _sum[i-1] * 2
            else:
                _sum[i] = _sum[i] * -1
    return sum(_sum)