๋ฌธ์ ๐
Forth๋ผ๋ ์ปดํจํฐ ์ธ์ด๋ ์คํ ์ฐ์ฐ์ ๊ธฐ๋ฐ์ผ๋ก ํ๊ณ ์์ด ํ์ ํ๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ค. ์๋ฅผ ๋ค์ด 3+4๋ ๋ค์๊ณผ ๊ฐ์ด ํ๊ธฐํ๋ค.
3 4 + .
Forth์์๋ ๋์์ ๋ค์๊ณผ ๊ฐ๋ค.
์ซ์๋ ์คํ์ ๋ฃ๋๋ค.
์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด ์คํ์ ์ซ์ ๋ ๊ฐ๋ฅผ ๊บผ๋ด ๋ํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ์คํ์ ๋ฃ๋๋ค.
โ.โ์ ์คํ์์ ์ซ์๋ฅผ ๊บผ๋ด ์ถ๋ ฅํ๋ค.
Forth ์ฝ๋์ ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋์์ค. ๋ง์ฝ ํ์์ด ์๋ชป๋์ด ์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅํ ๊ฒฝ์ฐ โerrorโ๋ฅผ ์ถ๋ ฅํ๋ค.
๋ค์์ Forth ์ฐ์ฐ์ ์์ด๋ค.
์ฝ๋ | ์ถ๋ ฅ |
4 2 / . | 2 |
4 3 - . | 1 |
[์
๋ ฅ]
์ฒซ ์ค์ ํ
์คํธ ์ผ์ด์ค ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. 1โคTโค50
๋ค์ ์ค๋ถํฐ ํ
์คํธ ์ผ์ด์ค์ ๋ณ๋ก ์ ์์ ์ฐ์ฐ์๊ฐ 256์ ์ด๋ด์ ์ฐ์ฐ์ฝ๋๊ฐ ์ฃผ์ด์ง๋ค. ํผ์ฐ์ฐ์์ ์ฐ์ฐ์๋ ์ฌ๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์์ผ๋ฉฐ, ์ฝ๋๋ โ.โ๋ก ๋๋๋ค.
๋๋์
์ ๊ฒฝ์ฐ ํญ์ ๋๋์ด ๋จ์ด์ง๋ค.
[์ถ๋ ฅ]
#๊ณผ 1๋ฒ๋ถํฐ์ธ ํ ์คํธ์ผ์ด์ค ๋ฒํธ, ๋น์นธ์ ์ด์ด ๊ณ์ฐ๊ฒฐ๊ณผ๋ฅผ ์ ์๋ก ์ถ๋ ฅํ๊ฑฐ๋ ๋๋ โerrorโ๋ฅผ ์ถ๋ ฅํ๋ค.
๋ด ํ๐ฆท
# 4874. Forth
# ์
๋ ฅ๋ฐ๊ธฐ
T = int(input())
for tc in range(1, T + 1):
# ์ฌ๊ธฐ์ ๋ฌธ์๋ก ๋ฐ์์ ๋์ค์ ์ซ์๋ก ๋ฐ๋ก ๋ฐ๊ฟ์ค์ผ ํจ
susik = input().split()
# ๋ง์ง๋ง์ ์ ์ด ์์ด์ ๋ฏธ๋ฆฌ ์ง์์ค
susik.pop()
# ์ฐ์ฐ์ ๋ด์์ค ๋ฆฌ์คํธ ๋ง๋ค๊ธฐ
num = []
# ๊ฒฐ๊ณผ๊ฐ 1๋ก ์ด๊ธฐํ, 0์ด๋ฉด ์๋ฌ๋ก ์ถ๋ ฅ, 1์ด๋ฉด ๋ฆฌ์คํธ์ ๋ง์ง๋ง ๊ฐ ์ถ๋ ฅ
result = 1
# ์์์ ๋๋ ๋์
for i in range(len(susik)):
# ์์์ด ํผ์ฐ์ฐ์๋ฉด
if susik[i] not in ['+','-','*','/']:
# ์์์ ๊ทธ ์ซ์๋ฅผ ์ ์๋ก ๋ฐ๊ฟ์ ๋ฃ์ด์ค๋ค
num.append(int(susik[i]))
# ์์์ด ์ฐ์ฐ์๋ฉด
else:
# ์ซ์๊ฐ ๋๊ฐ ์ด์ ๋จ์์์ด์ผ ์ฐ์ฐ์๋ฅผ ์ฒ๋ฆฌํด ์ฃผ๋๋ฐ ์๋๋ฉด
# ๋ง๋ ์์์ด ์๋๋๊น ํ๋ ธ์ผ๋ฏ๋ก ๊ฒฐ๊ณผ๊ฐ์ 0์ผ๋ก ๋ฐ๊ฟ์ค๋ค
if len(num) < 2:
result = 0
break
else: # ๋ฆฌ์คํธ์ ๊ธธ์ด๊ฐ 2 ์ด์์ด๋ฉด ๋ง๋ ์์์ด๋ฏ๋ก ์งํ
n1 = num.pop() # ๋๊ฐ์ง ์ซ์๋ฅผ ๋ฝ๋๊ฑฐ๋ ๋ชจ๋ ๊ณผ์ ์์ ์งํ๋๋ฏ๋ก ๋ฏธ๋ฆฌ ๋ฝ์์ค
n2 = num.pop()
new = 0
if susik[i] == '*':
new = n2 * n1
num.append(new) # ์ฐ์ฐ ํ ๋ค์ ๋ฆฌ์คํธ์ ๋ฃ์ด์ค๋ค
# num.append(n2*n1) # => ์ด๋ฐ์์ผ๋ก ๋ฐ๋ก ์ฒ๋ฆฌํ๋๊ฒ ๋ ์ข์ ๋ฏ
elif susik[i] == '+':
new = n2 + n1
num.append(new)
elif susik[i] == '-':
new = n2 - n1
num.append(new)
elif susik[i] == '/':
new = n2 // n1
####### ์ด๋ผ ๋ชซ ์ฐ์ฐ์๋ก ์ํด์ฃผ๋ฉด ๋์ค์ .0์ด ๋์ค๋ ์ผ์ด์ค๊ฐ ๋ฐ์ํ๋ค!!####
num.append(new)
# ๋ฆฌ์คํธ์ ๊ธธ์ด๊ฐ 1์ด ์๋๋ฉด ์ฐ์ฐ์์ ์ซ์๊ฐ ๋จ์์๊ฑฐ๋
# ์๋๋ฉด ์์ ์์ด์ง๋ ํ๋ฆฐ ์์์ด๋ค
if len(num) != 1:
result = 0
if result:
print(f'#{tc} {num[-1]}')
else:
print(f'#{tc} error')
#####
์ด ๋ฌธ์ ํ๋ฉด์ 2๊ฐ์ง๋ฅผ ์๋ชปํ๋๋ฐ....
- ์ซ์๋ฅผ ์ ์๋ก ์ ๋ฐ์์ผ๋ฉด์ ๋์ค์ int๋ก ๊ฐ์ ๋ฃ์ง ์์ ๊ฒ..
- ๋๋๊ธฐ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฑ ์ ์๋ก ๋๋ ๋จ์ด์ง๋ ๊ฒ์ด ์๋ ๊ฒฝ์ฐ๋ ๋ฐ์ํ๋ฏ๋ก // ๋ชซ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด์ฃผ์ด์ผ ํ๋ค..
์ฐธ๊ณ ํจ๋ฉด ์ข์ ๊ฐ๋ ๋ค โ๏ธ
์ค์ ํ๊ธฐ๋ฒ(infix notation)
: ์ฐ์ฐ์๋ฅผ ํผ์ฐ์ฐ์์ ๊ฐ์ด๋ฐ ํ๊ธฐํ๋ ๋ฐฉ๋ฒ
ex) A + B (์ฐ๋ฆฌ๊ฐ ํ์์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ)
ํ์ ํ๊ธฐ๋ฒ(postfix notation)
: ์ฐ์ฐ์๋ฅผ ํผ์ฐ์ฐ์ ๋ค์ ํ๊ธฐํ๋ ๋ฐฉ๋ฒ
ex) AB + (์ปดํจํฐ๊ฐ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ)
ํ์ ํ๊ธฐ๋ฒ์ ์์์ ์คํ์ ์ด์ฉํด์ ๊ณ์ฐํ๊ธฐ
- ํผ์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด ์คํ push
- ์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด ํ์ํ ๋งํผ์ ํผ์ฐ์ฐ์๋ฅผ ์คํ์์ pop ํ์ฌ ์ฐ์ฐํ๊ณ , ์ฐ์ฐ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ์คํ์ push
- ์์์ด ๋๋๋ฉด, ๋ง์ง๋ง์ผ๋ก ์คํ์ popํ์ฌ ์ถ๋ ฅ!!!

'algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑ์ค 24444. ์๊ณ ๋ฆฌ์ฆ ์์ - ๋๋น ์ฐ์ ํ์ 1 (BFS) (0) | 2023.08.19 |
---|---|
swea 4875. ๋ฏธ๋ก (์ฌ๋ฐฉํ์ & DFS) (0) | 2023.08.19 |
๋ฐฑ์ค 1920. ์์ฐพ๊ธฐ (set(), Binary Search) (0) | 2023.08.15 |
swea 4875. ๋ฏธ๋ก(dfs & ๋ธํ ํ์) (0) | 2023.08.15 |
[๋ฐฑ์ค/์คํ] 9012. ๊ดํธ (์ง๊ธ์ง๊ธ ๐ ๐ ๐ ) (4) | 2023.08.10 |