๋ฌธ์
solved.ac๋ Sogang ICPC Team ํํ์๋ค์ ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ์ ๋์์ ์ฃผ๊ณ ์ ๋ง๋ ์๋น์ค์ด๋ค. ์ง๊ธ์ ์๊ฐ๋๋ฟ๋ง ์๋๋ผ ์๋ง์ ์ฌ๋๋ค์ด solved.ac์ ๋์์ ๋ฐ์ ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ํ๊ณ ์๋ค.
ICPC Team์ ๋ฐฑ์ค ์จ๋ผ์ธ ์ ์ง์์ ๋ฌธ์ ํ์ด๋ฅผ ์ฐ์ตํ๋๋ฐ, ๋ฐฑ์ค ์จ๋ผ์ธ ์ ์ง์ ๋ฌธ์ ๋ค์๋ ๋์ด๋ ํ๊ธฐ๊ฐ ์์ด์, ์ง๊ธ๊น์ง๋ ๋ค์ํ ๋ฌธ์ ๋ฅผ ํ์ด ๋ณด๊ณ ์ถ๋๋ผ๋ ๋์ด๋๋ฅผ ๊ฐ๋ ํ๊ธฐ ์ด๋ ค์ ๋ฌด์จ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํ ์ง ํ๋จํ๊ธฐ ๊ณค๋ํ๊ธฐ ๋๋ฌธ์ solved.ac๊ฐ ๋ง๋ค์ด์ก๋ค. solved.ac๊ฐ ์๊ธด ์ดํ ์ ๊ตญ์์ 200๋ช
์ด์์ ๊ธฐ์ฌ์ ๋ถ๋ค๊ป์ ์์คํ ๋์ด๋ ์๊ฒฌ์ ๊ณต์ ํด ์ฃผ์
จ๊ณ , ์ง๊ธ์ ์ฝ 7,000๋ฌธ์ ์ ๋์ด๋ ํ๊ธฐ๊ฐ ๋ถ๊ฒ ๋์๋ค.
์ด๋ค ๋ฌธ์ ์ ๋์ด๋๋ ๊ทธ ๋ฌธ์ ๋ฅผ ํผ ์ฌ๋๋ค์ด ์ ์ถํ๋์ด๋ ์๊ฒฌ์ ๋ฐํ์ผ๋ก ๊ฒฐ์ ํ๋ค. ๋์ด๋ ์๊ฒฌ์ ๊ทธ ์ฌ์ฉ์๊ฐ ์๊ฐํ ๋์ด๋๋ฅผ ์๋ฏธํ๋ ์ ์ ํ๋๋ก ์ฃผ์ด์ง๋ค. solved.ac๊ฐ ์ฌ์ฉ์๋ค์ ์๊ฒฌ์ ๋ฐํ์ผ๋ก ๋์ด๋๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ๋ค.
์ ์ฌํ๊ท ์ด๋ ๊ทน๋จ์ ์ธ ๊ฐ๋ค์ด ํ๊ท ์ ์๊ณกํ๋ ๊ฒ์ ๋ง๊ธฐ ์ํด ๊ฐ์ฅ ํฐ ๊ฐ๋ค๊ณผ ๊ฐ์ฅ ์์ ๊ฐ๋ค์ ์ ์ธํ๊ณ ํ๊ท ์ ๋ด๋ ๊ฒ์ ๋งํ๋ค. 30% ์ ์ฌํ๊ท ์ ๊ฒฝ์ฐ ์์์ 15%, ์๋์์ 15%๋ฅผ ๊ฐ๊ฐ ์ ์ธํ๊ณ ํ๊ท ์ ๊ณ์ฐํ๋ค. ๋ฐ๋ผ์ 20๋ช
์ด ํฌํํ๋ค๋ฉด, ๊ฐ์ฅ ๋์ ๋์ด๋์ ํฌํํ 3๋ช
๊ณผ ๊ฐ์ฅ ๋ฎ์ ๋์ด๋์ ํฌํํ 3๋ช
์ ํฌํ๋ ํ๊ท ๊ณ์ฐ์ ๋ฐ์ํ์ง ์๋๋ค๋ ๊ฒ์ด๋ค.
์ ์ธ๋๋ ์ฌ๋์ ์๋ ์, ์๋์์ ๊ฐ๊ฐ ๋ฐ์ฌ๋ฆผํ๋ค. 25๋ช
์ด ํฌํํ ๊ฒฝ์ฐ ์, ์๋์์ ๊ฐ๊ฐ 3.75๋ช
์ ์ ์ธํด์ผ ํ๋๋ฐ, ์ด ๊ฒฝ์ฐ ๋ฐ์ฌ๋ฆผํด 4๋ช
์ฉ์ ์ ์ธํ๋ค.
๋ง์ง๋ง์ผ๋ก, ๊ณ์ฐ๋ ํ๊ท ๋ ์ ์๋ก ๋ฐ์ฌ๋ฆผ๋๋ค. ์ ์ฌํ๊ท ์ด 16.7์ด์๋ค๋ฉด ์ต์ข
๋์ด๋๋ 17์ด ๋๋ค.
์ฌ์ฉ์๋ค์ด ์ด๋ค ๋ฌธ์ ์ ์ ์ถํ ๋์ด๋ ์๊ฒฌ ๋ชฉ๋ก์ด ์ฃผ์ด์ง ๋, solved.ac๊ฐ ๊ฒฐ์ ํ ๋ฌธ์ ์ ๋์ด๋๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ๋์ด๋ ์๊ฒฌ์ ๊ฐ์n์ด ์ฃผ์ด์ง๋ค. (0 ≤n≤ 3 × 105)
์ดํ ๋ ๋ฒ์งธ ์ค๋ถํฐ 1 +n๋ฒ์งธ ์ค๊น์ง ์ฌ์ฉ์๋ค์ด ์ ์ถํ ๋์ด๋ ์๊ฒฌn๊ฐ๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค. ๋ชจ๋ ๋์ด๋ ์๊ฒฌ์ 1 ์ด์ 30 ์ดํ์ด๋ค.
์ถ๋ ฅ
solved.ac๊ฐ ๊ณ์ฐํ ๋ฌธ์ ์ ๋์ด๋๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
// ํ์ด : https://whkakrkr.tistory.com
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int getRounded(double num) {
if(num - (int)num >= 0.5) {
return (int)num + 1;
} else {
return (int)num;
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
double n;
cin >> n;
vector<int>v(n);
for(int i=0; i<n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double sum = 0;
int removed = getRounded(n*15/100);
for(int i=removed; i<n-removed; i++) {
sum += v[i];
}
int len = n - (2*removed);
int ans = n==0 ? 0 : getRounded(sum/len);
cout << ans;
return 0;
}
'๐ BOJ > Class 2' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ][C++] ๋ฐฑ์ค 15829๋ฒ: Hashing (0) | 2023.04.06 |
---|---|
[BOJ][C++] ๋ฐฑ์ค 1085๋ฒ: ์ง์ฌ๊ฐํ์์ ํ์ถ (0) | 2023.04.06 |
[BOJ][C++] ๋ฐฑ์ค 108282๋ฒ: ์คํ (0) | 2023.03.15 |
[BOJ][C++] ๋ฐฑ์ค 11650๋ฒ: ์ขํ ์ ๋ ฌํ๊ธฐ (0) | 2023.03.13 |
[BOJ][C++] ๋ฐฑ์ค 1697๋ฒ: ์จ๋ฐ๊ผญ์ง (0) | 2023.02.28 |