
ํด๋ฆฌ์ปค์์ ์ฌ์ค ๋๋จ์ ๋์ด๊ฐ๋ฉด ๊ฑฐ์ ์๋ฏธ์๋ ์๊ฐ ๋์์?
๊ฒ์ํด๋ ํ๊ตญ์ด ์๋ฃ๋ ๋ณ๋ก ์๊ณ ์์ด๋ก๋ ๊ฒ์์ ๋ชปํ๊ฒ ์ด์ ๋๋ฆ๋๋ก ์๊ฐํด์ ์ง๋ดค์.
6์๋ฆฌ + ์ซ์ ์๋ฆฌ์๋ก ๋ฐ์ดํฐ ์ ์ฅํ๋ ๋ฐฉ์์
ํด๋ฆฌ์ปค์์ ๊ณ ๋ คํด์ผํ ์ฐ์ฐ์
1. ๊ฐ์ง ๋์ด ๋ ๋ง์๊ฐ?
2. ์ผ๋ง๋งํผ์ ๋์ ๋ํด์ฃผ๊ฑฐ๋ ๋บ๋ค.
3. ~~%๋งํผ ํ๋๋์ ์ฆ๊ฐ์ํจ๋ค.
4. ํน์ ๋จ์๋ง๋ค ์์์ ๊ณผ ์๋ฆฌ์ ๋ถ์ฌ (1234๋ง = 1.23B)
์ด ๋ค๊ฐ์ง๊ฒ ์ง.
์ด ๋ค๊ฐ์ง ๊ฐ๊ฐ์ ํจ์๋ก ๊ตฌํด๋ณด๊ฒ ์.
3๋ฒ์ ๊ทธ๋ฅ ๊ณฑํด์ฃผ๊ณ ์๋ฆฌ ๋ณํ ๊ณต์ ๋ฃ์ผ๋ฉด ๋๋ ๊ตณ์ด ์ํ๊ฒ ์.
๊ท์ฐฎ์์ Vector2Int๋ก ๊ตฌํํ์ง๋ง ์ธ ์ฌ๋์ ์ ๋งํด์ ๊ตฌ์กฐ์ฒด ๋ฐ๋ก ๋ง๋ค์ด์ ์ฐ๊ธธ ๋ฐ๋. ์๋ํ๋ฉด ๊ฒฐ๊ตญ ๋ชจ๋ ์ซ์ ์ ์ฅ์ Vector2Int๋ก ํ๊ฒ ๋๋ฉด ๊ธ์ ์๊ฐ ๊ธธ์ด์ ์ ๊ธฐ ๊ท์ฐฎ์ ์ ์์.
๋จผ์ ๋งํ์ง๋ง ๋ณธ์ธ์ ์ฝ๋ฉ๊ด๋ จ ์ง์์ด ๋์ ํธ์ด ์๋๋ผ ๋ ์งง๊ณ ๊ฐ๊ฒฐํ ์ฝ๋๋ฅผ ์ ์ง ๋ชปํจ. ์ถ๊ฐ๋ก ์ธ์คํํฐ๋ก๋ง ํ
์คํธ ํด๋ด์ ๋ฒ๊ทธ ์๊ธธ ์ ์์. ๊ทธ๋ฅ ๋จธ๋ฆฌ์์ ๋ ์ค๋ฅธ ์ด๋ก ๋๋ก ๊ตฌํํ๊ธฐ์ ์๊ธฐ์น ๋ชปํ ๋ฒ๊ทธ๊ฐ ์์ ์๋ ์์.
์ฐธ๊ณ ๋ก Vector2Int(6์๋ฆฌ, ์๋ฆฌ์)๋ผ์
(100000, 1)์ด ์ซ์ 1์ด๋ผ๋์ .
(120000, 2)๋ฉด 12,
(999999, 12)๋ฉด 999,999,000,000 ์ด๋ฐ ๋๋์.
bool CompareNum(Vector2Int money
, Vector2Int num
) //1. ๊ฐ์ง ๋์ด ๋ ๋ง์๊ฐ? money ํฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด true, num ํฌ๋ค๋ฉด false.
{
if(money
.y
> num
.y
) { return true; } //์๋ฆฌ์ ๋น๊ตํด์ ํฌ๋ฉด true ์์ผ๋ฉด false ๊ฐ์ผ๋ฉด ์ซ์ ๋น๊ต.
else if (money
.y
< num
.y
) { return false; }
else if (num
.x
> money
.x
) { return false; } //num์ด ๋ ํฌ๋ค๋ฉด false, ์๊ฑฐ๋ ๊ฐ๋ค๋ฉด true.
else { return true; }
}
void AddNum(ref Vector2Int money
, Vector2Int num
) //2. money์ num๋งํผ์ ๋์ ๋ํด์ฃผ๊ฑฐ๋ ๋บ๋ค. (Compare ์ ์ ์ ์ฒ๋ฆฌํ๊ณ ์ฐ์ฐํ๊ธธ ๋ฐ๋.)
{
if(Mathf
.Abs(money
.y
- num
.y
) > 5) //6์๋ฆฌ ์ฐจ์ด๋ถํด ์ฐ์ฐ์ ์๋ฏธ๊ฐ ์์. ๋ ํฐ ์ซ์๋ก ์ ์ฉ.
{
if(money
.y
< num
.y
) { money
= num
; }
else { return; }
}
else
{
float temp
= (Mathf
.Pow(10, money
.y
- num
.y
) * money
.x
+ num
.x
) * Mathf
.Pow(10, num
.y
- money
.y
); //money์ 10์ money์ num์๋ฆฌ์ ์ฐจ์ด ๋งํผ ์ ๊ณฑํด์ฃผ๊ณ num ๊ฐ๊ณผ ๋ํ ๋ค, num๊ณผ money ์๋ฆฌ์ ์ฐจ์ด๋งํผ ๋ค์ ์ ๊ณฑํด์ ๊ฐ ์ฌ๋ณด์
if (temp
== 0)
{
money
= new Vector2Int(0, 0);
}
else
{
while (true) //์ซ์ ์๋ฆฌ 6์๋ฆฌ๋ก ๋ณด์ .
{
if (Mathf
.Abs(temp
) > 999999) //ํน์๋ ์ค์๋ก ์๋ชจ๋์ด ๋๋ณด๋ค ํฌ๊ฒ ๋์ ๊ฒฝ์ฐ ๋ฒ๊ทธ ๋ฐฉ์ง์ฉ ์ ๋๊ฐ.
{
temp
*= 0.1f;
money
.y
++;
}
else if (Mathf
.Abs(temp
) < 100000)
{
temp
*= 10f;
money
.y
--;
}
else
{
money
.x
= (int)temp
;
break;
}
}
}
}
}
char[] numChar
= { '0', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' }; //๋์๋ฆฌ ์ด์์ผ๋ก ๋๊ธธ๊ฑฐ๋ฉด string์ผ๋ก ๋ฐ๊พธ๊ณ ๋๋จธ์ง๋ ์์์ ์ ์ผ์
.
string StringNum(Vector2Int money
) //์ซ์ ์ธ๊ฐ๋ก ์๋ฅด๊ณ , ์๋ฆฟ์ ๊ณ์ฐํด์ ์์ซ์ ๊ณผ ๋จ์๋ฅผ ๋ํด์ค.
{
if(money
.x
== 0)
{
return "0";
}
string result
= money
.x
.ToString().Substring(0, 3); //3๊ธ์ ์๋ฅด๊ธฐ
if (money
.y
% 3 != 0)
{
result
= result
.Insert(money
.y
% 3, ".");
}
result
+= numChar
[(money
.y
- 1)/ 3];
return result
;
}๋ด ๊ฒ์์๋ ๋ฃ์ด๋ณผ ์๊ฐ
๋ ๋ก์
์ ๊ทผ๋ฐ ํด๋ฆฌ์ปค๋ฉด ๊ทธ ํผ์ผํฐ์ง ๊ณ์ฐ์ด ํ๋ฒ์ ๋ง 100์กฐ%์ฉ ์ด๋ฃจ์ด์ง๋ฉด ์ผ์ผ ๋๋๊ฑฐ์ง? ๊ทธ๊ฒ๊น์ง ๊ณ ๋ ค๋ฅผ ๋ชปํ๋ค
10์ ์ ๊ณฑ์น์ผ๋ก ๋ณํํด์ ์๋ฆฌ์๋ ๋ฐฐ์ ์์๋ฆฌ ๊ฐ์ ธ์์ ์๋ ๊ณต์ ๋ฐ๋ก ์ธ์์ฃผ๋ฉด ๋๊ธด ํ๋๋ฐ
๋ฐฐ์๋ ๊ฒฐ๊ตญ ์ 6์๋ฆฌ ์๋๋ก๋ ๊ทธ๋ฅ ์ํฅ ๋ชป๋ฏธ์น ํ ๋๊น...
๋ผ์์ค์ค์ค
๊ฐ์ฌํ ํ์ฟ ๋ฆฌ ํ๊ฒ ์ต๋๋ค ๊พธ๋ฒ ๊พธ๋ฒ
์์ง ๋ฒ๊ทธ๊ฐ ์ข ๋จ์์์ด์ ๋ง์ ์ ๊ด์ฐฎ์๋ฐ ๋์ผ๊ฐ ๋นผ๊ธฐ์ ์ ๋ํฐ๊ฐ ๋ฉ์ถ๋ ๋ฒ๊ทธ๊ฐ ์์ด์ - dc App
์๋ง๋ 6์๋ฆฌ์ ๊ฐ์ด 0์ด๋ ๋ temp๊ฐ ๋ฌดํํ ๋์๊ฐ๋ ๋ฒ๊ทธ๊ฐ์์ - dc App
๊ธํ๋ฉด ๋์ถฉ ๊ณ ์ณ์ฐ๊ณ ์๊ธํ๋ฉด ๊ธธ์๋์ด ๊ณ ์ณ์ฃผ์ค๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ฉด๋์ฃ ๋ญ ใ ใ ใ ใ ใ ๊ทธ๋์ ๋ ๊ฐ๋ฐ์๋ ์ง์ง ๋น ๋ฅด์๋ค์ ๋ฒ์ง๊ฐ๋ฐํ๋๊ฑฐ๋ ๊ฒ๋ ๋นก์ ๊ฑฐ ๊ฐ์๋ฐ ใทใทใท
๋ค ๊ณ ์ณค์ต๋๋ค!
๊ด์๊ฐ๋ฐ์ ใ ใ ใทใทใทใท
์ ๋น ์ธํธ ์์ด vector2int ๋ก ํฐ์๋ฅผ ์ฌ์ฉํ๋๊ฑฐ์?
์๋ซ์๋ฆฌ ์์ด ์์๋ฆฌ 6์๋ฆฌ + ์๋ฆฌ์๋ก ์ซ์ ํํํด์ ์ฐ์ฐํ๋๊ฑฐ์ - dc App
ํด๋น ๋๊ธ์ ์ญ์ ๋์์ต๋๋ค.
์ฐ์ฐ์ int๋ float๋ฐ์ ์์ผ๊ณ double์ ํด๋ฆฌ์ปค๋ก ์ฐ๊ธฐ์ 6๋จ์(๊ฒฝ ๋จ์ ๋)์ดํ๋ก ๋ชป๋๊ฒจ์ ๋ง๋ค์์ผ์ - dc App
๊ฐ์ด 1๋ณด๋ค ์์์ง๋ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ๋ฉด ์ค๋ฅ๊ฐ ์๋ค
์ ์ด์ ์์๋ ๊ณ ๋ ค๋ฅผ ์ํ์. Compare ์ดํ์ ์ฐ์ฐ์ ์ถ์ฒ๋๋ฆผ - dc App
์์์ ๋ง์. 0.9์ ๊ฐ์๊ฑฐ. ์๋ฅผ๋ค์ด 1์์ ๊ฐ์ง๊ณ ์๊ณ 1์์ง๋ฆฌ ๋ฌผ๊ฑด์ ์ฌ๋๋ฐ, ํ ์ธ 5%ํด์ 0.95์์ ๊ตฌ๋งคํ ๊ฒฝ์ฐ ์์ก์ด 0.05์์ด ๋๋ ๊ทธ๋ฐ ๊ฒฝ์ฐ๊ฐ ์์ ์ ์์์ด. ํน์๋ ์ฐ๋ ์ฌ๋์ด ๊ทธ๋ฐ ์ค์๋ฅผ ํ ์ ์์ผ๋๊น ~.~
๊ทธ๋ฐ ๊ฐ ์ ๋ฃ์ผ๋ฉด ๋๊ธดํ๋ฐ, ์ฌ์ฉํ ๋ ์กฐ์ฌํ๋ผ๊ณ ์๋ ค์ฃผ๊ธด ํด์ผ๊ฒ ์ง.
์ค ๋ด๊ฐ ๊ตฌํํ๊ฑฐ๋ ๋น์ทํ๋ค