์๋ ํ์ธ์ yunamom ์ ๋๋ค ๐
Google’s Online Challenge [LIVE @ 09:00 KST]
GOCC48 - Coding - SWE Intern (Seoul) ๋ฌธ์ 1 / ๋ฌธ์ 2 ํฌ์คํ ํ๊ฒ ์ต๋๋ค :D
๊ตฌ๊ธ์ฝ๋ฆฌ์ ์ง๋ง ๋ชจ๋ ๊ณผ์ ์ ์์ด๋ค!
๋ค๋ฅธ ํ๋ฉด ํด๋ฆญ์ ๋ฐ๋ก ํ๋ฉด์ดํํ๋ฉด ๋ก๊ทธ์์๋๋ค๊ตฌ ๊ฒฝ๊ณ ์ฐฝ์ด ๋ฌ๋ค.
(๋ฌธ์ ๋ณต์ฌ X, ์ฝ๋๋ธ๋ญ์ ๋ณต๋ถ๋ X, ๋์ผ๋ชจ๋ํฐ X)
๐ ๋ฌธ์ 1.
์ฝ๋ฉํ ์คํธ ๋ณธ ์ฌ์ดํธ๋ Hackerearth ์ ๋๋ค.
LeetCode ๋ ๋ง์ด ๋ค์ด๋ณด์๋๋ฐ Hackerearth ์ด๊ณณ์ ์ด๋ฒ์ ์ฒ์๋ดค๋ค..
๐ ๋ฌธ์ 2.
๋ฌธ์ 2 ๊ฐ์ ๊ฒฝ์ฐ์๋ ํ์ด๋ฅผ ํ์๋ฉด, ๋๋ฐฐ์ด์ ํฉ์นํ ์ ์ผํฐ์, ์ ์ผ์์์ ์ ๊ตฌํ๋ค์
max = 1+(์ ์ผํฐ์*๋ฐฐ์ด๊ธธ์ด-1);
min = 1+(์ ์ผ์์์*๋ฐฐ์ด๊ธธ์ด-1);
๊ทธ๋ฆฌ๊ณ max ์์ min ์ ๋นผ์ฃผ๋ฉด ์๋ฃ.
๊ทธ๋ฐ๋ฐ ๋๋ ๋ ๋ค๋ฅธ๋ฐ์ ๐ชด์ฝ์งํ๋๋ผ ์๊ฐ ๋ค๊ฐ๋ค.
์ ๋ฐฐ์ด ๋ฃ๋๊ฑฐ์ ๊ฝํ๊ฐ์ง๊ตฌ ใ ใ ์์ ์ง๋ฌธ์ ๋ณด๋ฉด
int N = 3;
int[] A = {1,2,3};
int M = 2;
int[] B = {4,1};
/* ํฉ์ณ์ง ๋ฐฐ์ด */
int[] S = {1,4,1,2,3};
์ด๋ ๊ฒ ์๋๋ฐ ์๋ ๋์ด ์ด๋ป๊ฒ ๋ฌ๋??
๋ฐฐ์ด์ ๊ผญ ์ ๋ ๊ฒ ๋ฃ์ด์ผ ํ๋์ค์๊ณ S[] = A[] ๋ฃ๊ณ S[] = B[] ๋ฃ๋๋ผ ์ฝ์งํ๊ณ ์ค๊ฐ์ ์ฌ์ดํธ ํ ๊น ํํ
๋จ์ํ๊ฒ ์๊ฐํ๋ฉด ๋ฌ์๋ค. ( 7๋ถ ๋จ์ ใทใท)
์๋ก์ด๋ฐฐ์ด์ ๋ชฝ๋ ํฉ์ณ์ค๋ค Arrays.sort(S); ๋ก ์ ๋ ฌํ๋ค ๊ฐ์ ํ์ธ [1, 1, 2, 3, 4]
๐๋ฐฐ์ด๋ก ์์ฑํ ์ฝ๋
package ๊ตฌ๊ธ์ฝ๋ฉํ
์คํธ;
import java.util.Arrays;
class Solution{
public long hybridMaximum(int N, int[] A, int M, int[] B) {
// write your code here
int [] S = new int[A.length + B.length];
int index = 0;
for(int i=0; i<A.length; i++){
S[i] = A[i]; index++;
}
for(int i=index,j=0; i<index+B.length; i++){
S[i] = B[j]; j++;
}
Arrays.sort(S);
long length = S.length-1;
long max = 1+(S[S.length-1] * length);
long min = 1+(S[0] * length);
return max-min;
}
}
public class Algorithm {
public static void main(String[] args) {
/* ํ
์คํธ ์ฝ๋ ์
๋๋ค. */
int N = 3;
int[] A = {1,2,3};
int M = 2;
int[] B = {4,1};
Solution test = new Solution();
System.out.println(test.hybridMaximum(N, A, M, B));
}
}
๐TreeMap ์ผ๋ก ์์ฑํ ์ฝ๋ ( *HashMap ๊ณผ ๋ฌ๋ฆฌ ํญ์์ ๋ ฌ์ด ๋์ด์๋ค. )
package ๊ตฌ๊ธ์ฝ๋ฉํ
์คํธ;
import java.util.TreeMap;
class Solution2{
public long hybridMaximum(int N, int[] A, int M, int[] B) {
// write your code here
long length = (A.length+B.length)-1;
TreeMap<Integer,Integer> map = new TreeMap<Integer,Integer>(){{
for(int e:A) put(e,e);
for(int e:B) put(e,e);
}};
long max = map.lastKey();
long min = map.firstKey();
return 1+(max*length) - 1+(min*length);
}
}
public class Algorithm2 {
public static void main(String[] args) {
/* ํ
์คํธ ์ฝ๋ ์
๋๋ค. */
int N = 1000;
int[] A = new int[1000];
for(int i=0; i<N; i++) {
A[i] = i*9999;
}
int M = 1000;
int[] B = new int[1000];
for(int i=0; i<M; i++) {
B[i] = i*9;
}
Solution2 test = new Solution2();
System.out.println(test.hybridMaximum(N, A, M, B));
}
}//19968012999
๐กint -> long ์ผ๋ก ๋ฐ๊ฟ์ฃผ์ด์ผํฉ๋๋ค.
์๋์ ๊ฐ์ด ์์ ๋ค๋ฅธ ๋ต์ด ๋์ฌ์ ์์ต๋๋ค. ( *์์๋ก ํ ์คํธ ์ฝ๋๋ฅผ ๋ฃ์ด์ ์์ฑํ์์ต๋๋ค.)
/* max ๊ฐ intํ ์ผ๋ */
max : -1506823480
min : 1
-1506823481
/* max ๊ฐ longํ ์ผ๋*/
max : 19968013000
min : 1
19968012999
์ฒซ๋ฒ์งธ ๋ฌธ์ ๋ ์ ์ถ๋ ๋ชปํ์์ง๋ง (์ถํ์ ํ์ด๋ฅผ ์ ๋ก๋ํ๊ฒ ์ต๋๋ค :D)
์์ผ๋ก ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ์ด๋ป๊ฒ ํด์ผํ ์ง ๋ฐฉํฅ์ฑ์ ์๊ฐํ๊ฒ๋ ์ข์ ๊ฒฝํ์ด์์ต๋๋ค ๐
๐TreeMap ์ด๋?
[JAVA] TreeMap ์ฌ์ฉ๋ฒ
โจ TreeMap ์ด๋ ๋ฌด์์ธ๊ฐ์? TreeMap์ ์ด์งํธ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ Map ์ปฌ๋ ์ ์ ๋๋ค. ๊ฐ์ Tree๊ตฌ์กฐ๋ก ์ด๋ฃจ์ด์ง TreeSet๊ณผ์ ์ฐจ์ด์ ์ TreeSet์ ๊ทธ๋ฅ ๊ฐ๋ง ์ ์ฅํ๋ค๋ฉด TreeMap์ ํค์ ๊ฐ์ด ์ ์ฅ๋ Map, Etnry๋ฅผ..
yunamom.tistory.com
ํ๋ก๊ทธ๋๋จธ์ค (x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์)
๐int -> long ์ผ๋ก ๋ณํํ ํต๊ณผํ๋ ๋ฌธ์
[Java] ํ๋ก๊ทธ๋๋จธ์ค - x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์
๐ก๋ฌธ์ ์ค๋ช ํจ์ solution์ ์ ์ x์ ์์ฐ์ n์ ์ ๋ ฅ ๋ฐ์, x๋ถํฐ ์์ํด x์ฉ ์ฆ๊ฐํ๋ ์ซ์๋ฅผ n๊ฐ ์ง๋๋ ๋ฆฌ์คํธ๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ๋ค์ ์ ํ ์กฐ๊ฑด์ ๋ณด๊ณ , ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํจ์, solution์ ์
yunamom.tistory.com
๊ตฌ๊ธ ์ฝ๋ฉํ ์คํธ ๋ฌธ์ ๋ชจ์์ฌ์ดํธ : ๋งํฌ
'Algorithm > Etc' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์ซ์ ๋ค์ง๊ธฐ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.05.15 |
---|---|
[๊ตฌ๊ธ์ฝํ ] GOCC48 - Coding - SWE Intern (Seoul) ํ๊ธฐ (14) | 2022.04.08 |
[Java] ์ผํ๋ชฐ ํ์ ๋ฑ๊ธ์ ๋ฐ๋ฅธ ํ ์ธ์จ - COS2๊ธ (0) | 2022.04.01 |
[Java] ํฐ์ ์ธ ์ฌ์ด์ฆ๋ณ๋ก ๊ฐ์์ธ๊ธฐ - COS2๊ธ (0) | 2022.04.01 |
[Java] 10 ์ง์๋ฅผ x ์ง์๋ก ๋ณํํ๊ธฐ (0) | 2022.03.10 |