අද කතා කරන්නේ HackerRank වල Algorithms > Implementation යටතේ තියන මේ Save the Prisoner! කියන ගැටළුව විසඳන්නේ කොහොමද කියන එක ගැනයි.

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

හරි එහෙනම් මුලින්ම ප්‍රශ්නය හොඳට තේරුම් ගෙන ඉමු.

           මේකේ කියන විදිහට සිරකරුවන් N ප්‍රමාණයක් ඉන්නවා. ඉතින් මේ හැම සිරකරුවෙකුටම 1 සිට N දක්වා තියන අංක වලින් unique id එකක් තියනවා (පළමු සිරකරුට 1 , දෙවන සිරකරුට 2 , තුන්වන සිරකරුට 3 …. ආදී වශයෙන්) මේ id එක S කියල තමා අරගෙන තියෙන්නේ.
ඉතින් මෙතන ඉන්න නිලධාරියාගේ රාජකාරිය වෙන්නේ සිරකරුවන්ට කෑම දෙන එකයි (රසකැවිලි). ඉතින් මෙයා මේ වැඩේ කරන්නේ මෙහෙමයි. සිරකරුවන්ගේ id එකේ පිළිවෙලට රවුමක් ආකාරයෙන් මෙයාලව පෙළ ගස්වනවා.ඊට පස්සේ ඉතින් කැමති තැනකින් පටන් අරන් id එක වැඩි වෙන පැත්තට තමා කෑම බෙදන්න පටන් ගන්නේ. උදාහරණයක් විදිහට සිරකරුවන් 5 ක් ඉන්න තැනක 3 කියන id එකෙන් කෑම බෙදන්න පටන් ගත්ත නම්, මෙන්න මේ id පිළිවෙලට තමයි කෑම හම්බවෙන්නේ …
3 , 4 , 5 , 1 , 2

        ඉතින් දැන් පැහැදිලි නේද වැඩේ වෙන්නේ කොහොමද කියන එක.
තව වැදහත් දෙයක් තියනවා. මේ බෙදන කෑම වලින් අන්තිමට බෙදන කෑම එකේ තියෙන්නේ වස. ඉතින් අපිට හොයන්න තියෙන්නේ මේ අන්තිම කෑම එක හම්බෙන ඒ අවාසනාවන්ත සිරකරුවා කවුද කියල හොයාගෙන එයාට අනතුරු අඟවන එකයි.
හොඳයි දැන් වැඩේ පැහැදිලිනේ …
තව එක වැදගත් දෙයක් කියන්න මට අමතක උනා. මේකෙදි කෑම වර්ග ගණන සිරකරුවන් ගණන ට සමාන නොවෙන්නත් පුළුවන් (බොහෝ විට එහෙම තමයි වෙන්නේ). කෑම වර්ග ගණන M කියල තමා මෙතැනදී අරගෙන තියෙන්නේ.
හරි එහෙම නම් වැඩේ පටන් ගමු.

සිරකරුවන් ගණන n විදිහටත්
කෑම වර්ග ගණන m විදිහටත්
කෑම බෙදන්න පටන් ගන්න සිරකරුවගේ id එක s විදිහටත් ගන්නම්.
(මේ තුනම Integer)

            පටන් ගන්න තැන ඉඳන් m ප්‍රමාණයක් එකතු කරහම එ  න තැන n ගේ ගුනාකරයක්ද කියන එක බලන එක තමයි කරන්න ඕනේ. හැබැයි එකක් අමතක කරන්න එපා , මෙතැනදී ආරම්භක කෙනාටත් කෑම දීල තියන නිසා n ගේ ගුනාකරයකින් අවසන් වෙනවද කියල බලන්න නම්,
( s + m )% n -1 මෙන්න මේක 0 ක් වෙනවද කියලයි බලන්න ඕනේ. ඉතින් මේක 0 ක් වෙනවා කියන්නේ අන්තිම කෑම එක (වස එක) හම්බෙන්නේ n ට.
එහෙම නොවෙනවා නම් ( s + m )%n -1 කියන තැන ඉන්න කෙනාට නේද වස සහිත කෑම එක ලැබෙන්නේ.
හොඳයි මේ කරුණු සැලකිල්ලට අරගෙන හදාගත්තු code එක මේ විදිහට ඉදිරිපත් කරන්නම්.

(මෙතැනදී java programming language එක භාවිතා කරපු එකට නම් විශේෂ හේතුවක් නෑ )

Note : මේක ගොඩක් සරල ප්‍රශ්නයක් වෙන්න පුළුවන්. නමුත් මෙතැනදී පාවිච්චි කරන්න වෙන concept එක ගොඩක් වැදගත්. ඉදිරියේදී තරමක් අපහසු සමහර ගැටළු වලදී මේ concept එක ඕන වෙන තැන් දැකගන්න පුළුවන් … 

   public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for(int i=0;i<t;i++){
            int n = in.nextInt();
            int m = in.nextInt();
            int s = in.nextInt();
            
            if(((s+m)%n)-1 != 0)
              System.out.println(((s+m)%n)-1);
            else 
                System.out.println(n);    
        }
    }
Advertisements