අද කතා කරන්නේ HackerRank වල Algorithms > Implementation යටතේ තියන මේ Lisa’s Workbook කියන ගැටළුව විසඳන්නේ කොහොමද කියන එක ගැනයි.

ඔක්කොටම කලින් මෙන්න මෙතනින් ගිහින් ගැටළුව තේරුම් අරගෙන විසඳන්න උත්සහ කරන්න.

කලින් කරපු ගැටළු දෙකත් එක්ක සංසන්දනය කරලා බලනකොට මේ ගැටළුව තරමක් අපහසු වෙන්න පුළුවන්.
ඒක නිසා පියවරෙන් පියවර වැඩේ පටන් ගමු. මේකේ දීල තියන sample test case එකට අදාලව කරලා තියන Explanation එක බලල හොඳට තේරුම් ගන්න උත්සහ කරන්න. එකෙන් පුළුවන් මේ ගැටළුව ගැන හොඳ අවබෝධයක් ගන්න.

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

  • පිටු අංක 1 ඉඳන් පටන් ගන්න පොතක් තියනවා (හිතන්න ගණිත ගැටළු පොතක් කියල).
  • මේ පොත පරිච්ඡේද වලට වෙන් කරලයි තියෙන්නේ (පරිච්ඡේද 1 සිට පටන් අරගෙන).
  • එක් එක් පරිච්ඡේදයට අදාලව තියන ගණිත ගැටළු ගණන අපිට ලබා දෙනවා.
  • එක් පිටුවකට අදාලව තියෙන්න පුළුවන් උපරිම ගණිත ගැටළු ප්‍රමාණයක් තියනවා.
  • ඉතින් මේ ගණිත ගැටළු වලටත් අංක තියනවා. 1 සිට පටන් අරගෙන තමයි අංක කරන්නේ. ඒ වගේම එක් පරිච්ඡේදයක් ඉවර උනහම ඊළඟ පරිච්ඡේදයේ ගණිත ගැටළු වල අංක මුල ඉඳල (1 සිට) පටන් ගන්න ඕනේ.
  • තවත් එක වැදගත් දෙයක් තියනව : අළුත් පරිච්ඡේදයක් අළුත් පිටුවකින් පටන් ගන්න ඕනේ.

දැන් පැහැදිලි ඇති මේ පොත හැදිල තියෙන්නේ කොහොමද කියන එක. ඉතින් අපෙන් අහන්නේ මෙන්න මේකයි.
යම් ගණිත ගැටළුවක අංකය සහ එම ගැටළුව අඩංගු පිටු අංකය හරියටම සමාන වෙන විදිහේ ගණිත ගැටළු කියක් තියනවද ?

ඉතින් දැන් ප්‍රශ්නය සම්පුර්ණයෙන්ම පැහැදිලි ඇති කියල මම හිතනවා.

එහෙනම් වැඩේ පටන් ගමු.
n සහ k අගයන් user input විදිහට ගත්තට පස්සේ,
මම problem කියල array එකකට එක් එක් පරිච්ඡේදකට අදාලව තියන ගැටළු ගණන ලබා ගන්නවා.
problem[1] කියන එකේ තියෙන්නේ 1 වන පරිච්ඡේදයේ අඩංගු ගණිත ගැටළු ගණන.
problem[2] කියන එකේ තියෙන්නේ 2 වන පරිච්ඡේදයේ අඩංගු ගණිත ගැටළු ගණන.
problem[3] කියන එකේ තියෙන්නේ 3 වන පරිච්ඡේදයේ අඩංගු ගණිත ගැටළු ගණන.
ඔන්න ඔය විදිහට.

Note : මම මෙතැනදී Array එකේ 0 index එක අතහැරලා තමා අගයන් ඇතුලත් කරන්න පටන් අරන් තියෙන්නේ. ඒකට ප්‍රධානම හේතුව වෙන්නේ , ඉස්සරහදි chapter number එක සහ array එකේ index එක සමාන උනොත් තේරුම් ගන්න පහසු වෙන එකයි. අවශ්‍ය නම් index 0 ඉඳන් පටන් ගන්න පුළුවන්. හැබැයි එතකොට මොකක් හරි පරිච්ඡේද අංකයකට අදාලව array එකේ index එක එකකින් අඩු වෙන බව මතක තියා ගන්න.

හරි දැන් මම ඉතුරු ටික ගැන හිතන්න යන්නේ පරිච්ඡේදයෙන් පරිච්ඡේදය. ඒ කියන්නේ පරිච්ඡේද ගණන n ට සමාන වෙනකන් පරිච්ඡේද එකින් එක වැඩි කරමින් යනවා .

ඉතින් මේක ලේසියෙන්ම while loop එකක් ආධාරයෙන් කර ගන්න පුළුවන්. (chapter number එක n ට අඩු වෙනකන් while loop එක run වෙන විදිහට, ආරම්භයේදී chapter number එක 1 ක් වෙන්න ඕනේ)

දැන් මේ loop එක ඇතුලේ තමා අපි වැඩේ කරන්න තියෙන්නේ. කොටින්ම කියනවා නම් while loop එක එක සැරයක් run වෙලා ඉවර වෙද්දී එක පරිච්ඡේදයකට අදාලව විශේෂ පිටු කීයක් තිබුනද කියල ගණන් කර ගන්න ඕනේ.
හරි ඒක කරන්නේ මෙන්න මෙහෙමයි.
ඉතින් මේ while loop එක ඇතුලේ එක් එක් පරිච්ඡේදයට අදාලව තියන ප්‍රශ්න ගණනට සමාන වාර ගණනක් run වෙන for loop එකක් ආධාරයෙන් ගොඩක් ලේසියෙන් විශේෂ පිටු කියක් තියනවද කියන එක දැනගන්න පුළුවන්. ඉතින් මේ for loop එක ඇතුලෙදි ප්‍රශ්න ගණන k ට සමාන වෙනකොට පිටු අංකය එකකින් වැඩි කරන්නත්, ඒ වගේම දැනට පවතින පිටුවේ ප්‍රශ්න ගණන 1 ක් විදිහට වෙනස් කරන්නත් වෙනවා.

සමහර විට මෙහෙම කියවද්දී මෙලෝ දෙයක් නොතේරෙන්න පුළුවන්. පහල දාල තියන code එකත් එක්ක බලමින් මේක කියවන්න. එතකොට තේරුම් ගන්න පුළුවන් වෙයි.

හරි … මෙතෙක් කරපු දේවල් තේරෙන්න ඇති කියල මම විශ්වාස කරනවා.
ඉතින් මීළඟට කරන්න තියෙන්නේ මේ while loop එක අවසානයේ chapter number එක එකකින් වැඩි කිරීමත් ,ඒ වගේම බාගෙට පිරුණු පිටුවකින් නම් chapter එක ඉවර වෙලා තියෙන්නේ, පිටු අංකය තවත් එකකින් වැඩි කිරීමත් යන දේවලුයි.

ඉතින් මේ විදිහට සලකල බලල හදා ගත්තු code එක පහල තියනවා.
(C ++ භාවිතා කරන්න විශේෂ හේතුවක් නම් නෑ)


int main() {
    int n,k;
    cin >> n >> k;
    vector problem(n);
    for(int i=1; i<=n; i++){                     
              cin >> problem[i];
    }
    int pg_no=1;
    int ch_no=1;
    int count=0; 
    while(ch_no <= n){
        int pr_now=1;
        for(int i=1; i<=problem[ch_no]; i++){
            if(i==pg_no) count++;
            if(pr_now==k){
                pr_now=1;
                pg_no++;
            }
            else pr_now++;
        }
        if(pr_now!=1) pg_no++;
        ch_no++;
    }
    cout << count;
    return 0;
}
Advertisements