Chapter 3: နှိုင်းယှဉ်ခြင်းနှင့် Logical Operator များ (Comparison and Logical Operators)

Program တွေက လူတွေလို ဆုံးဖြတ်ချက်ချတတ်ရတယ်။ ATM စက်က PIN မှန်မမှန် စစ်တယ်။ online shop က stock ရှိမရှိ စစ်တယ်။ game ထဲက ဇာတ်ကောင်က အသက်ရှိသေးလား စစ်တယ်။ ဒီလို ဆုံးဖြတ်ချက်တိုင်းရဲ့ နောက်ကွယ်မှာ နှိုင်းယှဉ်မှုနဲ့ logic ရှိတယ်။ ဒီအခန်းမှာ အဲဒီအခြေခံအုတ်မြစ်ကို တည်ဆောက်မယ်။

Boolean ဆိုတာဘာလဲ

Program ရေးတဲ့အခါ ဟုတ်လား မဟုတ်လား ဆိုတဲ့ မေးခွန်းတွေ အမြဲမေးရတယ်။ အသက် ၁၈ ပြည့်ပြီလား။ password မှန်လား။ ပစ္စည်း stock ရှိသေးလား။ ဒီလို မှန်/မှား အဖြေတွေကို ကိုယ်စားပြုဖို့ Python မှာ Boolean type ရှိတယ်။

မီးခလုတ်ကို စိတ်ကူးကြည့်ပါ — ဖွင့်ထားတယ် (ON) ဒါမှမဟုတ် ပိတ်ထားတယ် (OFF)၊ နှစ်မျိုးထဲက တစ်မျိုးပဲ ဖြစ်နိုင်တယ်။ Boolean လည်း အဲဒီလိုပဲ။ တန်ဖိုးနှစ်မျိုးပဲရှိတယ် — True (မှန်တယ်) နဲ့ False (မှားတယ်)။

is_raining = True
shop_open = False
print(is_raining)
print(type(shop_open))

True
<class 'bool'>

အရေးကြီးတာက စာလုံးအကြီးအသေး — အမြဲ T နဲ့ F အကြီး နဲ့ ရေးရတယ်။ true လို့ အသေးနဲ့ရေးရင် Python က မသိဘူး၊ error တက်မယ်။

has_ticket = True
is_member = False
print(f"လက်မှတ်ရှိလား: {has_ticket}")
print(f"အသင်းဝင်လား: {is_member}")

လက်မှတ်ရှိလား: True
အသင်းဝင်လား: False

Boolean expression ဆိုတာ တန်ဖိုးနှစ်ခုကို နှိုင်းယှဉ်ပြီး True ဒါမှမဟုတ် False ထုတ်ပေးတဲ့ စကားစုပါ။ ဥပမာ age >= 18 — အဖြေက True ဒါမှမဟုတ် False ပဲ ဖြစ်နိုင်တယ်။ လက်တွေ့မှာ boolean တန်ဖိုးအများစုက ဒီလို နှိုင်းယှဉ်မှုတွေကနေ ထွက်လာတာပါ။

age = 20
adult = age >= 18   # နှိုင်းယှဉ်မှုရဲ့ အဖြေကို variable ထဲ သိမ်းထားတယ်
print(adult)
print(type(adult))

True
<class 'bool'>

Boolean variable တွေကို နာမည်ပေးတဲ့အခါ မေးခွန်းပုံစံ နာမည်ပေးလေ့ရှိတယ် — is_ (ဟုတ်လား)၊ has_ (ရှိလား)၊ can_ (လုပ်နိုင်လား) တို့လို စကားလုံးတွေနဲ့ စတယ်။ is_raining၊ has_ticket၊ can_enter တို့လို နာမည်တွေက code ဖတ်တဲ့သူကို ဒီ variable က True/False ပဲ ဖြစ်မယ်ဆိုတာ ချက်ချင်းသိစေတယ်။ ဒါ industry မှာ ကျယ်ကျယ်ပြန့်ပြန့် သုံးတဲ့ အလေ့အကျင့်ကောင်းတစ်ခုပါ။

Reference

• Built-in types — bool type အကြောင်း တရားဝင်ရှင်းလင်းချက်
• Operators — comparison နဲ့ logical operator များ

Comparison Operator များ

တန်ဖိုးနှစ်ခုကို နှိုင်းယှဉ်ဖို့ operator ၆ မျိုးရှိတယ်။ တစ်ခုချင်းစီက မေးခွန်းတစ်ခုလိုပဲ — မေးလိုက်ရင် အဖြေက True ဒါမှမဟုတ် False ပဲ ပြန်လာတယ်။

Operator	မေးခွန်း (အဓိပ္ပာယ်)	ဥပမာ	အဖြေ
==	တူညီလား	5 == 5	True
!=	မတူညီဘူးလား	5 != 3	True
>	ကြီးလား	10 > 7	True
<	ငယ်လား	4 < 9	True
>=	ကြီးတယ် ဒါမှမဟုတ် တူတယ်	8 >= 8	True
<=	ငယ်တယ် ဒါမှမဟုတ် တူတယ်	6 <= 5	False

Code မှာ သုံးကြည့်ရအောင် —

age = 20
print(age >= 18)   # အသက် ၁၈ ပြည့်ပြီလား?
print(age < 13)    # ကလေးအရွယ်လား?

price = 5000
budget = 4500
print(price <= budget)  # ဈေးက ဘတ်ဂျက်ထဲ ဝင်လား?

True
False
False

user ဆီက ရတဲ့ input နဲ့လည်း နှိုင်းယှဉ်လို့ရတယ်။ ဒီနေရာမှာ အခန်း ၂ က သင်ခန်းစာ ပြန်အသုံးဝင်လာပြီ — input() က string ပြန်ပေးတာမို့ ဂဏန်းနဲ့နှိုင်းယှဉ်ချင်ရင် int() နဲ့ အရင်ပြောင်းရတယ် —

age = int(input("အသက်ထည့်ပါ: "))
print(age >= 18)
print(age == 18)

အသက်ထည့်ပါ: 20
True
False

String တွေကိုလည်း နှိုင်းယှဉ်လို့ရတယ်။ == နဲ့ != က စာသားတိုက်စစ်တဲ့အခါ အသုံးအများဆုံး —

username = "aungkhant"
print(username == "aungkhant")
print(username != "aungkhant")

password = input("Password ထည့်ပါ: ")
print(password == "secret123")

True
False
True

(နောက်ဆုံးလိုင်းက user က secret123 လို့ ရိုက်ထည့်တဲ့အခါ True ထွက်တာ။)

စာသားနှိုင်းယှဉ်တဲ့အခါ အကြီးအသေး အတိအကျကိုက်မှ တူတယ်လို့ သတ်မှတ်တယ် —

print("Admin" == "admin")  # False — A အကြီးနဲ့ a အသေး မတူဘူး
print("apple" != "Apple")  # True

> နဲ့ < ကိုလည်း string မှာ သုံးလို့ရတယ် — အဘိဓာန်စီသလို တစ်လုံးချင်း ယှဉ်ပေးတယ်။

print("ant" < "banana")  # True — a က b ထက် အဘိဓာန်မှာ စောတယ်
print("cat" > "car")     # True — တတိယလုံး t က r ထက် နောက်ကျတယ်

ဆက်တိုက်နှိုင်းယှဉ်ခြင်း (Chained Comparison)

Python ရဲ့ အဆင်ပြေတဲ့အချက်တစ်ခု — နှိုင်းယှဉ်မှုတွေကို ဆက်တိုက်ရေးလို့ရတယ်။ 18 <= age <= 60 ဆိုတာ 18 <= age and age <= 60 ဆိုတဲ့ အဓိပ္ပာယ်ပဲ။

age = 25
print(18 <= age <= 60)  # ၁၈ နဲ့ ၆၀ ကြားလား?

score = 45
print(0 <= score < 50)  # ၀ နဲ့ ၅၀ ကြားလား?

True
True

သင်္ချာမှာ 18 ≤ age ≤ 60 လို့ရေးသလိုပဲ ဖတ်ရလွယ်တယ်။ ဒါ Python ရဲ့ ထူးခြားချက်တစ်ခု — ဘာသာစကားတော်တော်များများမှာ ဒီလိုရေးလို့မရဘူး။

↻ ပြန်ဖွင့်ရန်

Reference

• Operators — comparison operator ဇယားနဲ့ ဥပမာများ
• Operator precedence — operator တွေရဲ့ ဦးစားပေးအစီအစဉ်

Logical Operator များ

တစ်ခါတစ်လေ အခြေအနေတစ်ခုတည်းနဲ့ မလုံလောက်ဘူး။ အသက် ၁၈ ပြည့်ပြီးတော့ လက်မှတ်လည်းရှိရမယ် လိုမျိုး အခြေအနေနှစ်ခုကို တွဲစစ်ချင်တဲ့အခါ logical operator တွေသုံးတယ်။ English လို စာကြောင်းရှည်တွေမှာ and နဲ့ or သုံးသလိုပါပဲ။

Python မှာ logical operator သုံးမျိုးရှိတယ် — and၊ or၊ not။

and — နှစ်ခုလုံးမှန်မှ True

and က ဘေးနှစ်ဖက်လုံး True ဖြစ်မှ အဖြေက True။ တစ်ခုခု False ဖြစ်ရင် အဖြေက False ပဲ။

A	B	A and B
True	True	True
True	False	False
False	True	False
False	False	False

ဇယားကို အလွတ်ကျက်စရာမလိုဘူး — စဉ်းစားနည်းက ဒါပဲ။ and ဆိုတာ တင်းကျပ်တယ်။ နှစ်ဖက်လုံး မှန်မှ ပေးဝင်တယ်။

age = 20
has_ticket = True
can_enter = (age >= 18) and has_ticket
print(can_enter)   # True — နှစ်ခုလုံး မှန်တယ်

age = 16
can_enter = (age >= 18) and has_ticket
print(can_enter)   # False — အသက်မပြည့်ဘူး

or — တစ်ခုခုမှန်ရင် True

or ကတော့ ပြောင်းပြန် — တစ်ခုခုမှန်နေရင် True။ နှစ်ခုလုံး False ဖြစ်မှ False။

A	B	A or B
True	True	True
True	False	True
False	True	True
False	False	False

or ဆိုတာ လျော့ပေါ့တယ်။ တစ်ခုခုမှန်ရင် လုံလောက်ပြီ။

is_weekend = False
is_holiday = True
can_rest = is_weekend or is_holiday
print(can_rest)   # True — တစ်ခုမှန်နေတယ်

is_weekend = False
is_holiday = False
print(is_weekend or is_holiday)   # False — နှစ်ခုလုံး မှားတယ်

not — ပြောင်းပြန်လှန်

not က တန်ဖိုးတစ်ခုတည်းနဲ့ သုံးတယ်။ True ကို False၊ False ကို True အဖြစ် ပြောင်းပေးတယ်။

A	not A
True	False
False	True

shop_open = False
print(not shop_open)   # True — ဆိုင်ဖွင့်တယ် ဆိုတာ မမှန်ဘူး

is_raining = True
going_out = not is_raining
print(going_out)       # False — မိုးရွာနေတော့ အပြင်မထွက်ဘူး

အခြေအနေအများအပြားကို ပေါင်းစပ်ခြင်း

အခြေအနေသုံးခု ဒါမှမဟုတ် ပိုများတာကို တွဲချင်ရင်လည်း ရတယ်။ ရှုပ်ထွေးလာတဲ့အခါ parenthesis () နဲ့ အုပ်စုဖွဲ့ရေးတာ ပိုဖတ်ရလွယ်တယ်။

age = 25
has_license = True
has_car = False

can_drive = (age >= 18) and has_license and has_car
print(can_drive)   # False — ကားမရှိဘူး

is_banned = False
allowed = (age >= 18) and (not is_banned)
print(allowed)     # True

Expression တစ်ခုကို အဆင့်ဆင့် တွက်ကြည့်ခြင်း

ရှည်လျားတဲ့ boolean expression တွေ့ရင် အပိုင်းလိုက် ခွဲတွက်ပါ။ ဥပမာ —

age = 17
has_id = True
result = (age >= 18) and has_id or (not has_id)
print(result)

တွက်ပုံ အဆင့်ဆင့် —

1. (age >= 18) → (17 >= 18) → False
2. (not has_id) → (not True) → False
3. ကျန်တာ False and True or False — and က အရင်ဆုံး → (False and True) → False
4. နောက်ဆုံး False or False → False

False

ဒီလို ခွဲတွက်တတ်ရင် ဘယ် expression မဆို ကြိုတွက်နိုင်ပြီ။ နောက်ဥပမာတစ်ခု ထပ်လေ့ကျင့်ကြည့်ရအောင် —

temp = 38
is_sunny = False
go_picnic = (temp > 30) and (not is_sunny) or (temp < 20)
print(go_picnic)

1. (temp > 30) → (38 > 30) → True
2. (not is_sunny) → (not False) → True
3. (temp < 20) → (38 < 20) → False
4. ကျန်တာ True and True or False — and အရင် → True or False → True

True

ကိုယ်တိုင်စမ်းကြည့်ပါ — အောက်ပါ expression တွေရဲ့ အဖြေကို ကိုယ်တိုင်ကြိုတွက်ပါ။ ပြီးမှ Python မှာ run ကြည့်ပါ။

p = True
q = False
print(p and q or p)      # ?
print(not p or q and p)  # ?

အဖြေများ — ပထမတစ်ကြောင်း: (True and False) or True → True။ ဒုတိယတစ်ကြောင်း: (not True) or (False and True) → False or False → False။ ကိုယ်တွက်တာနဲ့ တူလား တိုက်စစ်ကြည့်ပါ။

မသေချာရင် () ထည့်ရေးတာ အကောင်းဆုံးနည်းဆိုတာ မမေ့နဲ့။

a = True
b = True
c = False
print(a or b and c)      # True — b and c ကို အရင်တွက်
print((a or b) and c)    # False — () ထဲက အရင်တွက်

ပထမစာကြောင်းမှာ and က or ထက် ဦးစားပေးခံရလို့ True or (True and False) → True or False → True။ ဒုတိယစာကြောင်းမှာတော့ () ကြောင့် (True or True) and False → False။

ဥပမာ program — ရုပ်ရှင်ရုံ ဝင်ခွင့်စစ်ဆေးခြင်း

ဒီအခန်းသင်ထားသမျှကို ပေါင်းသုံးတဲ့ program အသေးလေးတစ်ခု ကြည့်ရအောင် —

age = int(input("အသက်ထည့်ပါ: "))
ticket = input("လက်မှတ်ရှိလား (yes/no): ") == "yes"

adult = age >= 18
can_watch = adult and ticket

print(f"လူကြီးလား: {adult}")
print(f"ဝင်လို့ရလား: {can_watch}")

အသက်ထည့်ပါ: 20
လက်မှတ်ရှိလား (yes/no): yes
လူကြီးလား: True
ဝင်လို့ရလား: True

ဒီမှာ အခန်း ၂ က ပညာနှစ်ခုပြန်ပါလာတယ် — int(input(...)) နဲ့ == "yes" ဆိုတဲ့ string နှိုင်းယှဉ်မှု။ အခန်းတွေက တစ်ခုနဲ့တစ်ခု ဆက်စပ်နေတာကို သတိထားမိမှာပါ။

↻ ပြန်ဖွင့်ရန်

Reference

• Operators — logical operator ဥပမာများ
• Operator precedence — not / and / or တွက်တဲ့အစီအစဉ်

ပုံမှန်သုံးတဲ့ ပုံစံများ (Common Patterns)

လက်တွေ့ program တွေမှာ ထပ်ခါထပ်ခါ တွေ့ရတဲ့ boolean ပုံစံသုံးမျိုးရှိတယ်။ ဒါတွေကို မှတ်ထားရင် code ရေးတဲ့အခါ မြန်မယ်။

ပုံစံ ၁: အကွာအဝေးစစ်ဆေးခြင်း — တန်ဖိုးတစ်ခုက သတ်မှတ်ထားတဲ့ အကွာအဝေးထဲမှာ ရှိမရှိ။ and သုံးတယ်။

score = 75
valid = (score >= 0) and (score <= 100)
print(valid)  # True — ၀ ကနေ ၁၀၀ ကြားထဲမှာ ရှိတယ်

ပုံစံ ၂: တစ်ခုခုဖြစ်နေလား — ရွေးချယ်စရာအများအပြားထဲက တစ်ခုခု ကိုက်ညီလား။ or သုံးတယ်။

day = "Sunday"
weekend = (day == "Saturday") or (day == "Sunday")
print(weekend)  # True

ပုံစံ ၃: မဖြစ်သင့်တာကို တားခြင်း — not နဲ့ အခြေအနေကို ပြောင်းပြန်စစ်တယ်။

is_raining = True
go_out = not is_raining
print(go_out)  # False — မိုးရွာနေလို့ မထွက်ဘူး

ပုံစံ ၄: အဖွင့်/အပိတ် ပြောင်းလဲခြင်း (toggle) — not ကို ကိုယ့်ဟာကိုယ် ပြန်သုံးပြီး True/False ကို လှန်ပေးတယ်။ မီးခလုတ်နှိပ်သလိုပါပဲ။

light_on = False
light_on = not light_on
print(light_on)  # True — ခလုတ်နှိပ်လိုက်သလို ပြောင်းသွားတယ်
light_on = not light_on
print(light_on)  # False — နောက်တစ်ခါနှိပ်တော့ ပြန်ပိတ်သွားတယ်

ဒီပုံစံတွေကို ပေါင်းပြီး စာမေးပွဲအောင်စာရင်း စစ်တဲ့ program လေး ရေးကြည့်ရအောင် —

score = int(input("ရမှတ်: "))
attendance = int(input("ကျောင်းတက်ရက် %: "))

passed = (score >= 40) and (attendance >= 75)
print(f"အောင်လား: {passed}")

ရမှတ်: 65
ကျောင်းတက်ရက် %: 80
အောင်လား: True

ရမှတ် ၄၀ ပြည့်ပြီး ကျောင်းတက်ရက် ၇၅% ပြည့်မှ အောင်တယ် — and က နှစ်ခုလုံးကို တင်းတင်းကျပ်ကျပ် စစ်ပေးတယ်။

ပုံစံ ၅: အကွာအဝေးပြင်ပ ရောက်နေလား — ပုံစံ ၁ ရဲ့ ပြောင်းပြန်။ not နဲ့ ပေါင်းသုံးတယ်။

score = 150
invalid = not (0 <= score <= 100)
print(invalid)  # True — အကွာအဝေးပြင်ပ ရောက်နေတယ်

ပုံစံ ၆: တစ်ခုမှ မဖြစ်ဘူး — or ရဲ့ အဖြေကို not နဲ့ လှန်တယ်။

is_weekend = False
is_holiday = False
open_today = not (is_weekend or is_holiday)
print(open_today)  # True — ပိတ်ရက်မဟုတ်တော့ ဆိုင်ဖွင့်တယ်

Reference

• Operators — လက်တွေ့ပုံစံတွေနဲ့ ယှဉ်လေ့လာရန်
• Operator precedence — ပုံစံတွေကို တွဲရေးတဲ့အခါ ဦးစားပေးအစီအစဉ်

အမှားများလေ့ရှိတဲ့အချက်များ

ဒီအခန်းရဲ့ သင်ခန်းစာတွေကို ပြန်ချုပ်ရင်း beginner တွေ ခဏခဏမှားတတ်တဲ့အချက်တွေကို စုပေးထားတယ်။

၁။ = နဲ့ == မှားတာ — အဖြစ်အများဆုံး။ နှိုင်းယှဉ်ချင်ရင် == နှစ်ခုဆိုတာ လက်နဲ့ရေးမှတ်ထားသလို မှတ်ထားပါ။

age = 20
print(age == 20)  # True — နှိုင်းယှဉ်တာ
# print(age = 20)   ← ဒါဆို error တက်မယ်

၂။ and နဲ့ or မှားသုံးတာ — လိုချင်တာက နှစ်ခုလုံးမှန်မှ ဖြစ်တာကို or ရေးမိတာ။ ဥပမာ အသက် ၁၈ ပြည့်ပြီး လက်မှတ်ရှိမှ ဝင်လို့ရမယ်ဆိုရင် and သုံးရမယ်။ or သုံးမိရင် အသက်မပြည့်လည်း လက်မှတ်ရှိရင် ဝင်သွားလိမ့်မယ်။

age = 16
has_ticket = True
# အမှား: can_enter = (age >= 18) or has_ticket  ← အသက်မပြည့်ဘဲ ဝင်သွားမယ်
can_enter = (age >= 18) and has_ticket  # False — အမှန်

၃။ type မတူတာကို နှိုင်းယှဉ်တာ — error မတက်ဘူး၊ ဒါပေမဲ့ အမြဲ False ပဲ။

print(5 == "5")  # False — int နဲ့ str မတူဘူး

ဒါ အခန်း ၂ က input() သင်ခန်းစာနဲ့ တိုက်ရိုက်ဆက်စပ်တယ်။ input() က string ပြန်ပေးတာမို့ int() နဲ့ ပြောင်းပြီးမှ ဂဏန်းနဲ့နှိုင်းယှဉ်ပါ။

၄။ not နဲ့ comparison တွဲတဲ့အခါ () မေ့တာ — ရှင်းရှင်းရေးချင်ရင် parenthesis ထည့်ပါ။

age = 16
print(not (age >= 18))  # True — ရှင်းတယ်

၅။ ရှည်လျားတဲ့ expression မှာ () မထည့်တာ — a or b and c လို့ ရေးထားရင် ဖတ်တဲ့သူက ဘယ်အပိုင်းကို အရင်တွက်မလဲ ဝေခွဲရတယ်။ (a or b) and c ဒါမှမဟုတ် a or (b and c) လို့ ရည်ရွယ်ချက်ကို () နဲ့ ဖော်ပြရေးပါ။ ကိုယ်တိုင်တောင် ရက်အနည်းငယ်ကြာရင် မေ့သွားတတ်တယ်။

၆။ operator အစီအစဉ် မှားရေးတာ — >= ကို => လို့ မှားရေးမိရင် SyntaxError တက်မယ်။ အကြီး/အသေး သင်္ကေတတွေမှာ = က အမြဲ နောက်မှာ နေရတယ် — >=၊ <=၊ ==၊ !=။

print(5 >= 3)  # True — အမှန်
# print(5 => 3)  ← SyntaxError! => လို့ ရေးလို့မရဘူး

၇။ input() ရလဒ်ကို ဂဏန်းနဲ့ တိုက်ရိုက်နှိုင်းယှဉ်တာ — input() က string ပြန်ပေးတာမို့ >= လို operator နဲ့ ဂဏန်းယှဉ်ရင် TypeError တက်မယ်။

age = input("အသက်: ")  # "20" (string) ရမယ်
# print(age >= 18)  ← TypeError! string နဲ့ int နှိုင်းယှဉ်လို့မရဘူး
print(int(age) >= 18)  # True — အရင် int ပြောင်းရတယ်

Reference

• Operators — operator များ ပြန်လည်လေ့လာရန်
• Built-in types — bool အပါအဝင် type များ ပြန်လည်လေ့လာရန်

လေ့ကျင့်ခန်းများ

၁။ ဂဏန်းနှစ်ခုကို input ယူပြီး အောက်ပါမေးခွန်းတွေရဲ့ အဖြေ (True/False) ကို တစ်ကြောင်းချင်း print ထုတ်တဲ့ program ရေးပါ —

• ပထမဂဏန်းက ဒုတိယဂဏန်းထက် ကြီးလား?
• ဂဏန်းနှစ်ခု တူညီလား?
• ပထမဂဏန်းက 0 နဲ့ မတူဘူးလား?

ပထမဂဏန်း: 15
ဒုတိယဂဏန်း: 10
True
False
True

၂။ အသက်ကို input ယူပြီး မဲပေးနိုင်လား (age >= 18)၊ ကလေးအရွယ်လား (age < 13) ဆိုတာကို True/False နဲ့ print ထုတ်ပါ။

အသက်ထည့်ပါ: 20
မဲပေးနိုင်လား: True
ကလေးအရွယ်လား: False

၃။ username နဲ့ password ကို input ယူပြီး နှစ်ခုလုံး မှန်မှ True ပြတဲ့ login စစ်ဆေးတဲ့ program ရေးပါ။ မှန်ကန်တဲ့ username က "admin"၊ password က "12345" လို့ သတ်မှတ်ထားပါ။ and သုံးပါ။

Username: admin
Password: 12345
True

၄။ အောက်ပါ code ရဲ့ output ကို computer မသုံးဘဲ ကိုယ်တိုင်ကြိုတွက်ပါ။ ပြီးမှ တကယ် run ကြည့်ပြီး တိုက်စစ်ပါ။

x = 10
y = 3
print(x > 5 and y < 5)
print(x == 10 or y == 10)
print(not (x < y))
print(x % 2 == 0 and y % 2 != 0)

၅။ (အနည်းငယ်ခက်သည်) Discount ရထိုက်မှုစစ်ဆေးတဲ့ program ရေးပါ။ စုစုပေါင်းဈေးကို input ယူပြီး၊ member ဟုတ်/မဟုတ်ကို "True" ဒါမှမဟုတ် "False" စာသားနဲ့ ရိုက်ထည့်ခိုင်းပါ။ စည်းကမ်းက — ဈေး 50000 ထက်ကြီးရင် ဒါမှမဟုတ် member ဖြစ်ရင် discount ရမယ်။ အဖြေကို boolean expression တစ်ကြောင်းတည်းနဲ့ တွက်ထုတ်ပါ။ (Hint: == "True" နဲ့ စာသားကို boolean အဖြစ် ပြောင်းစစ်လို့ရတယ်။)

စုစုပေါင်းဈေး: 30000
Member လား (True/False): True
Discount ရလား: True