[programmers] ์์ ์ง๊ฟ - Java
- ์์ ์ง๊ฟ ๋ฌธ์ ๋ ๋ ์ฌ๋์ด ์์์์ ์์ ํ ๊ท ํ์ ์ด๋ฃจ๋ ์์ ์๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ด๋ค.
- ์์๋ 2m, 3m, 4m ๊ฑฐ๋ฆฌ์ ์ข์์ด ์์ผ๋ฉฐ, ๋ฌด๊ฒ์ ๊ฑฐ๋ฆฌ์ ๊ณฑ์ด ์์ชฝ์ด ๊ฐ์์ผ ๊ท ํ์ ์ด๋ฃฌ๋ค.
- HashMap์ ํ์ฉํ์ฌ ๊ฐ ๋ฌด๊ฒ์ ๋ฐ์ ํ์๋ฅผ ์ ์ฅํ๊ณ , ๊ฐ์ ๋ฌด๊ฒ์ ๋ค๋ฅธ ๋ฌด๊ฒ์ ์์ ๊ฐ๊ฐ ๊ณ์ฐํ๋ค.
- ๊ฐ๋ฅํ ๊ฑฐ๋ฆฌ ๋น์จ (1:1, 2:3, 3:4, 2:4)์ ๊ณ ๋ คํ์ฌ ๊ท ํ์ ์ด๋ฃจ๋ ๋ชจ๋ ์์ ์๋ฅผ ๊ตฌํ๋ค.
Dec 23, 2024
์์ ์ง๊ฟ
๋ฌธ์ ์ค๋ช
์ด๋ ๊ณต์ ๋์ดํฐ์๋ ์์๊ฐ ํ๋ ์ค์น๋์ด ์์ต๋๋ค. ์ด ์์๋ ์ค์ฌ์ผ๋ก๋ถํฐ 2(m), 3(m), 4(m) ๊ฑฐ๋ฆฌ์ ์ง์ ์ ์ข์์ด ํ๋์ฉ ์์ต๋๋ค.
์ด ์์๋ฅผ ๋ ๋ช
์ด ๋ง์ฃผ ๋ณด๊ณ ํ๋ค๊ณ ํ ๋, ์์๊ฐ ํํ์ธ ์ํ์์ ๊ฐ๊ฐ์ ์ํด ์์์ ๊ฑธ๋ฆฌ๋ ํ ํฌ์ ํฌ๊ธฐ๊ฐ ์๋ก ์์๋์ด ์์ ํ ๊ท ํ์ ์ด๋ฃฐ ์ ์๋ค๋ฉด ๊ทธ ๋ ์ฌ๋์ ์์ ์ง๊ฟ์ด๋ผ๊ณ ํฉ๋๋ค. ์ฆ, ํ์นํ ์ฌ๋์ ๋ฌด๊ฒ์ ์์ ์ถ๊ณผ ์ข์ ๊ฐ์ ๊ฑฐ๋ฆฌ์ ๊ณฑ์ด ์์ชฝ ๋ค ๊ฐ๋ค๋ฉด ์์ ์ง๊ฟ์ด๋ผ๊ณ ํ ์ ์์ต๋๋ค.
์ฌ๋๋ค์ ๋ชธ๋ฌด๊ฒ ๋ชฉ๋ก
weights
์ด ์ฃผ์ด์ง ๋, ์์ ์ง๊ฟ์ด ๋ช ์ ์กด์ฌํ๋์ง ๊ตฌํ์ฌ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.์ ํ ์ฌํญ
- 2 โค
weights
์ ๊ธธ์ด โค 100,000
- 100 โค
weights
[i] โค 1,000 - ๋ชธ๋ฌด๊ฒ ๋จ์๋ N(๋ดํด)์ผ๋ก ์ฃผ์ด์ง๋๋ค.
- ๋ชธ๋ฌด๊ฒ๋ ๋ชจ๋ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
weights | result |
[100,180,360,100,270] | 4 |
์ ์ถ๋ ฅ ์ ์ค๋ช
{100, 100} ์ ์๋ก ๊ฐ์ ๊ฑฐ๋ฆฌ์ ๋ง์ฃผ๋ณด๊ณ ์์ผ๋ฉด ๊ท ํ์ ์ด๋ฃน๋๋ค.
{180, 360} ์ ๊ฐ๊ฐ 4(m), 2(m) ๊ฑฐ๋ฆฌ์ ๋ง์ฃผ๋ณด๊ณ ์์ผ๋ฉด ๊ท ํ์ ์ด๋ฃน๋๋ค.
{180, 270} ์ ๊ฐ๊ฐ 3(m), 2(m) ๊ฑฐ๋ฆฌ์ ๋ง์ฃผ๋ณด๊ณ ์์ผ๋ฉด ๊ท ํ์ ์ด๋ฃน๋๋ค.
{270, 360} ์ ๊ฐ๊ฐ 4(m), 3(m) ๊ฑฐ๋ฆฌ์ ๋ง์ฃผ๋ณด๊ณ ์์ผ๋ฉด ๊ท ํ์ ์ด๋ฃน๋๋ค.
solution.java
import java.util.*; class Solution { public long solution(int[] weights) { // HashMap์ ์ฌ์ฉํ์ฌ ๊ฐ ๊ฐ์ค์น์ ๋ฐ์ ํ์๋ฅผ ๊ณ์ฐ Map<Integer, Long> weightCount = new HashMap<>(); for (int weight : weights) { weightCount.put(weight, weightCount.getOrDefault(weight, 0L) + 1); } long totalPairs = 0; // ๊ฐ๋ฅํ ๊ฑฐ๋ฆฌ ๋น์จ int[][] ratios = {{1, 1}, {2, 3}, {3, 4}, {2, 4}}; for (Map.Entry<Integer, Long> entry : weightCount.entrySet()) { int weight = entry.getKey(); long count = entry.getValue(); // ๊ฐ์ ๋ฌด๊ฒ๋ฅผ ๊ฐ์ง pair ์ ์ธ๊ธฐ if (count > 1) { totalPairs += (count * (count - 1)) / 2; } // ์๋ก ๋ค๋ฅธ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง pair ์ ์ธ๊ธฐ for (int[] ratio : ratios) { int num = ratio[0]; int denom = ratio[1]; if (weight * denom % num == 0) { int pairedWeight = weight * denom / num; if (pairedWeight > weight && weightCount.containsKey(pairedWeight)) { totalPairs += count * weightCount.get(pairedWeight); } } } } return totalPairs; } }
ํต์ฌ ํค์๋
HashMap
์ ์ฌ์ฉํ์ฌ ๊ฐ์ค์น๋ณ๋ก ๋ฐ์ ํ์๋ฅผ ์ ์ฅํ๋ค.
- ๊ฐ์ ๋ฌด๊ฒ๋ฅผ ๊ฐ์ง ์์ ์ซ์๋ฅผ ์ธ์, ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์๋ฅผ
totalPairs
๋ก ์ ์ฅํ๋ค.
- ๋ค๋ฅธ ๋ฌด๊ฒ๋ฅผ ๊ฐ์ง ์์ค, ๊ท ํ์ ์ด๋ฃจ๋ ์์ ์ซ์๋ฅผ ์ธ์
totalPairs
์ ๋ํ๋ค. - ์๋ฅผ ๋ค์ด, 2m์ 3m ์๋ฆฌ์ ์์นํ์ ๋ ๊ท ํ์ ์ด๋ฃจ๋ ๊ฒฝ์ฐ, ์์ผ๋ก๋ ๋ค์๊ณผ ๊ฐ์ด ํํํ ์ ์๋ค.
- ์ด๋ฅผ ์ด์ฉํด ๋ค์ ์์ ๋์ด๋ผ ์ ์๋ค.
- ๋ง์ฝ ๋ ๋ฌด๊ฒ๊ฐ ๊ท ํ์ ์ด๋ฃฌ๋ค๋ฉด, ๋ค์ ๋ ์กฐ๊ฑด์ ํ ์คํธํ๋ค.
pairedWeight > weight
- ์ด๋ฏธ ๊ณ์ฐํ๋ ์์ ๋ฐ๋ณตํด์ ๊ณ์ฐํ์ง ์๊ธฐ ์ํ ์กฐ๊ฑด์ด๋ค.
weightCount.containsKey(pairedWeight)
- ๊ณ์ฐ๋
pairedWeight
๊ฐ ์ ๋ ฅ ๋ฐฐ์ด์ ์์ผ๋ฉด ์์ด ์ฑ๋ฆฝํ์ง ์์ผ๋ฏ๋ก ์ด ์กฐ๊ฑด์์ ํํฐ๋งํ๋ค.
- ๋ง์ง๋ง์ผ๋ก ๋ ๋ฌด๊ฒ๊ฐ ์์ ์ด๋ฃจ๋ ๊ฒฝ์ฐ, ํด๋น ์์ ์ด ๊ฐ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ฒฐ๋ก !
ํด๋น ๋ฌธ์ ๋ฅผ ํตํด
HashMap
์ ๋ค๋ฃจ๋ ๋ฒ์ ์ตํ ์ ์์๋ค.Share article