8์ ๊ฐ์ ๊ตฌํ๊ธฐ (1~10์ต) C++
๊ตฌ๊ธ ์ ์ฌ๋ฌธ์
๊ตฌ๊ธ ์
์ฌ ๋ฌธ์ ์ค, 1๋ถํฐ 100000 ์ฌ์ด์ธ N์ด ์ฃผ์ด์ง๊ณ , 1๋ถํฐ N
๊น์ง์ ์์์ 8์ด ๋์ค๋ ํ์๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ๊ฐ ์๋ค.
์ฌ๊ธฐ์ 88์ด๋ผ๋ ์ซ์๊ฐ ์์ผ๋ฉด, 88์ 8์ด ๋ ๊ฐ ๋ค์ด๊ฐ๋ฏ๋ก, 2๋ก ์นด์ดํธํด์ผ ๋๋ค.N
์ด ์ต๋ 10๋ง์ด๊ธฐ ๋๋ฌธ์, 10๋ง์ ์๋ฆฌ์๋ 6์ด๋ฏ๋ก, ์ต์
์ ์๊ฐ ๋ณต์ก๋๋ก ์๊ฐํด๋ 60๋ง์ด ๋๋ค.
๋ฐ๋ผ์ ์ฌ๋ฌ ๊ฐ์ง ํ์ด๋ค์ด ์๊ฒ ์ง๋ง, ๊ฐ ์ซ์๋ฅผ ์ํํ๋ฉด์ ๊ฐ ์ซ์์ ์๋ฆฌ์๋ฅผ ํ๋ํ๋ ํ์ธํด๋ 1์ด ์์ ์นด์ดํธ๊ฐ ๊ฐ๋ฅํ๋ค.
10์ต์ผ๋ก ํ์ฅ
N์ด 1๋ถํฐ ์ต๋ 10์ต๊น์ง๋ผ๊ณ ์ฃผ์ด์ง๋ค๋ฉด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ํ์ด์ผ ํ ๊น?
9์ต๊น์ง๋ผ๊ณ ๋ง ํด๋ 9์ต * 9์ต์ ์๋ฆฌ์์ด๊ธฐ ๋๋ฌธ์ ๋จ์ํ๊ฒ ์์ ํ์์ ํ๋ฉด ์๊ฐ ์ด๊ณผ๊ฐ ๋๋ค.
์์ ํ์์ด ์๋ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ ์ฐพ์์ผ ํ๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ
ํ์ฅ๋ ๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐฉ๋ฒ์, ๊ฐ ์๋ฆฌ ์๋ง๋ค ๋๋ ์ 8์ด ๋ฑ์ฅํ๋ ํ์๋ฅผ ๊ตฌํด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด N์ด 4์๋ฆฌ์ ์ ๋ผ๋ฉด, ๊ฒฝ์ฐ๋ฅผ 4๊ฐ์ง๋ก ๋๋ ๋ค ํ์๋ฅผ ๋ํด์ค์ผ ํ๋ค.
์ด๋ ํ์๋ฆฌ ํ์๋ฆฌ๋ง๋ค ํ์ธํ ๋, ๊ทธ ํ ์๋ฆฟ์๋ฅผ ์ธ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋ ์ผ ํ๋ค.
8 ๋ณด๋ค ์์ ๋
8 ์ผ ๋
8 ๋ณด๋ค ํด ๋
์ธ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋ ๋ค, ํด๋นํ๋ ์๋ฆฌ์์ ์ผ์ชฝ ์๋ค๊ณผ ์ค๋ฅธ์ชฝ ์ ๋ค์ ํ์ธํ๊ณ ์นด์ดํธํ๋ ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ๋ค.
8 ๋ณด๋ค ์์ ๋
52723
์ด๋ผ๋ ์ซ์๊ฐ ์๊ณ , ์ธ ๋ฒ์งธ ์๋ฆฌ์์ 8์ด ๋ช ๋ฒ ๋์ฌ ์ ์๋์ง ํ์ธํ๋ค๊ณ ํ์.
52xxx ์ผ ๋๋, ์ธ ๋ฒ์งธ ์๋ฆฌ์๊ฐ 7์์ผ๋ก 8์ด ๋ฑ์ฅํ ์ ์๋ค.00
8.., 01
8.., 02
8.., ... 51
8..๊น์ง ์์ ์๋ฅผ ํ์ธํ๋ฉด ์ด 0~51๊น์ง๊น์ง 52์ ๊ฒฝ์ฐ์ ์๊ฐ ๋์จ๋ค.
8๋ค์ .. ์ 0๋ถํฐ 99๊น์ง ์ด 100๊ฐ์ง์ ๊ฒฝ์ฐ์ ์๊ฐ ๋์จ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก 52*100
์ฆ, (์์๋ฆฌ ์) * 10^๋ท์๋ฆฌ์
๋ฅผ ๋ํด์ผ ํ๋ค.
8 ์ผ ๋
์์์ 8๋ณด๋ค ์์ ๋์์ 528
..๊น์ง ์นด์ดํธ๊ฐ ๋๋ฏ๋ก 8๋ณด๋ค ์์ ๋์ ๊ฒฝ์ฐ์ ์์์,
๋ค์ ..์์ ๋์ฌ ์ ์๋ ๊ฒฝ์ฐ์ ์์ธ 0~ ๋ท์๋ฆฌ ์ -> ๋ท์๋ฆฌ ์ + 1์ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ํด์ผ ํ๋ค.
์ฆ (์์๋ฆฌ ์) * 10^๋ท์๋ฆฌ์ + ๋ท์๋ฆฌ ์+1
์ ๋ํด์ผ ํ๋ค.
8 ๋ณด๋ค ํด ๋
8 ๋ณด๋ค ํด ๋๋ 529.. ์์ผ๋ก 528..
๋ก ์์ํ๋ ๋ชจ๋ ์๋ฅผ ๋ํ ์ ์๋ค.
์ฆ 0~52๊น์ง์ธ ๊ฒฝ์ฐ์ ์๋ 52+1์ด๋ฏ๋ก (์์๋ฆฌ ์+1) * 10^๋ท์๋ฆฌ์
๋ฅผ ๋ํด์ผ ๋๋ค.
์์ค์ฝ๋
#include <iostream>
using namespace std;
long long result;
long long sumResult(int leftNum, int rightNum, int swc, int digit);
int main(void) {
int N;
cin >> N;
int rightNum = 0;
int leftNum = N;
int nowdigit = 1;
while (leftNum) {
int lastNum = leftNum % 10;
leftNum /= 10;
int swc;
if (lastNum < 8) swc = -1;
else if (lastNum == 8) swc = 0;
else swc = 1;
result += sumResult(leftNum, rightNum, swc, nowdigit);
rightNum += lastNum * nowdigit;
nowdigit *= 10;
}
cout << result << '\n';
return 0;
}
long long sumResult(int leftNum, int rightNum, int swc, int digit) {
if (swc == -1) {
return leftNum * digit;
}
else if (swc == 0) {
return leftNum * digit + rightNum + 1;
}
else {
return (leftNum + 1) * digit;
}
}
๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ค์ ์ฝ๋๋ก ๋ํ๋ด๋ฉด ์์ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค.
'Algorithm > ์ด๋ก ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํฌํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.03.09 |
---|---|
์ ํ, ๋ฒ๋ธ, ์ฝ์ ์ ๋ ฌ (0) | 2022.03.09 |
Trie(ํธ๋ผ์ด) ์๊ณ ๋ฆฌ์ฆ (0) | 2022.03.08 |
์๋ผํ ์คํ ๋ค์ค์ ์ฒด (0) | 2022.03.05 |
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ (0) | 2022.03.05 |