මේ කොටසින් මම කරන්නේ HackerRank වල තියන සමහර ප්‍රශ්න (බොහෝ දුරට Algorithm වලට අයත් ගැටළු) විසඳන්නේ කොහොමද කියන එක සවිස්තරාත්මකව ඉදිරිපත් කරන එකයි.

ඉතින් ඒකෙ පළමු පියවර විදිහට Between Two Sets කියන ගැටළුව (Algorithms > Implementation > Between Two Sets) විසඳන්නේ කොහොමද කියල ඉදිරිපත් කරන්න මන් මේ විදිහට පටන් ගන්නම්.

ඔක්කොටම කලින් මෙන්න මෙතනින් ගිහින් ප්‍රශ්නය හොඳට තේරුම් අරගෙන විසඳන්න උත්සහ කරන්න.

ඔක්කොටම කලින් ප්‍රශ්නේ හොඳට තේරුම් අරන් ඉමු.
මොකද්ද මේ කියන්නේ.

a සහ b කියල Arrays 2 ක් තියනවා.
a වල elements n ගණනකුත්,
b වල elements m ගණනකුත් තියනව.

  1. All elements is A are factors of x.
  2. x is a factor of all elements in B.

මේකේ අදහස මෙන්න මේකයි.

  1. A Array එකේ තියන හැම අගයක්ම x වල සාධකයක් වෙන්න ඕනේ.
  2. B Array එකේ හැම අගයකම සාධකයක් විදිහට x ව ගන්න පුළුවන්කම තියෙන්න ඕනේ.

ඉතින් මෙතැනදී අපෙන් අහන්නේ මේ අවශ්‍යතා දෙකම තෘප්ත වෙන විදිහට x ට ගන්න පුළුවන් අගයන් කියක් තියනවද කියන එකයි.

තව ටිකක් මේක පැහැදිලි වෙන්න නිසා මම පොඩි උදාහරණයක් කියන්නම්.
හිතන්න…
A = { 1 , 2 , 4 }
B = { 32 , 48 }

පළවෙනි අවශ්‍යතාවයට අනුව නම් x ව A Array එකේ තියන හැම element එකකින්ම ඉතුරු නැතිව බෙදෙන්න ඕනේ. ඒ කියන්නේ 12 , 16 වගේ අගයන් මේකට ගැලපෙනවා.
දෙවෙනි අවශ්‍යතාවයට අනුව හිතුවොත් x ගෙන් B Array එකේ තියන ඕනෑම අගයක් බෙදුවොත් ඉතුරු 0 ක් වෙන්න ඕනේ.
ඒ කියන්නේ 8 , 16 වගේ අගයන් මේකට ගැලපෙනවා.

තවත් වැදගත් දෙයක් තියනවා. අපි මෙතැනදී පරික්ෂා කරන්න ඕන x ගේ පරාසය මොකද්ද ?
A Array එකේ තියන වැඩිම අගයට වඩා අඩු අගයක් x ට ගන්න පුළුවන් ද ?
බෑ …
හේතුව : එතකොට A Array එකේ වැඩිම අගය x වල සාධකයක් වන්නේ නෑ. (A Array එකේ වැඩිම අගය > x නිසා)

මේ විදිහටම B Array එක ගැනත් හිතුවොත් …
B Array එකේ අඩුම අගයට වඩා x වල අගය වැඩි වෙන්න පුලුවන්ද ?
බෑ …
හේතුව : එතකොට B Array එකේ අඩුම අගයෙහි සාධකයක් විදිහට x ගන්න බැරි වෙනවා (B Array එකේ අඩුම අගය < x නිසා )

ඉතින් එහෙනම් අපිට කරන්න තියෙන්නේ : A Array එකේ වැඩිම අගය හා B Array එකේ අඩුම අගය අතර කලින් කියපු අවශ්‍යතා දෙකම තෘප්ත වෙන විදිහට අගයන් කීයක් තියනවද කියන එකයි.

මම මේකට python programming language එක පාවිච්චි කරලා හදා ගත්ත code එක මේ විදිහට ඉදිරිපත් කරන්නම්.

Note : මම මෙතැනදී python තොර ගන්න එක හේතුවක් තියනවා. Array වල උපරිම අවම අගයන් හරිම ලේසියෙන් return කර ගන්න පුළුවන් වීම තමයි එකම හේතුව.
හදන්න ඕන විදිහ ගැන හොඳ අවබෝධයක් තියනවා නම් ඕන කෙනෙකුට ඕන Programming Language එකක් use කරලා මේ වගේ දෙයක් implement කර ගන්න පුළුවන්.

n,m = input().strip().split(' ')
n,m = [int(n),int(m)]
a = [int(a_temp) for a_temp in input().strip().split(' ')]
b = [int(b_temp) for b_temp in input().strip().split(' ')]
count = 0
for i in range(max(a),min(b)+1):
    flag1 = 0
    flag2 = 0
    for j in a: 
        if i%j!=0:
            flag1 = 1
            break
    for k in b:
        if k%i!=0:
            flag2 = 1
            break     
    if flag1==0 and flag2==0:
        count = count + 1           
print(count)  

මම මෙතැනදී පලවෙනි අවශ්‍යතාවය ඉෂ්ට උනාද කියල දැනගන්න flag1 variable එකත් දෙවෙනි අවශ්‍යතාවය ඉෂ්ට උනාද කියල දැනගන්න flag2 variable එකත් පාවිච්චි කරා. ඒ වගේම මොකක් හරි අවශ්‍යතා දෙකෙන් එකක් හෝ යම් i අගයකට අදාලව ඉෂ්ට නොවෙනවා නම් loop එක break කරනු ලැබුවා. (එම i අගයෙන් ඉදිරි අගයන් පරික්ෂා කරලා තේරුමක් නැති නිසා).

Advertisements