Programming වැඩ්ඩොන්ගෙන් හෙල්ප් එකක්, Come here

[sithija.h]

Programming වැඩ්ඩොන්ගෙන් හෙල්ප් එකක්, Come here

මචං මම මේක නිකං හිතද්දි හිතුන පොඩි ප්‍රශ්නයක්, මේක හැබැයි සමහර ලොකු Programs හදද්දි Practically ප්‍රශ්නයක් වෙන්නත් පුලුවන් කියලා හිතෙනවා, මගේ මේ ප්‍රශ්නෙ උඹලට තේරෙන විදියට මම කියන්නම්, මේ උදාහරණය බලපංකො එතකොට සීන් එක තේරෙවි,

1st Program

int i=0;
while (i<5)
{
cout<<"Testing"<<endl;
i++;
}

2nd Program

cout<<"Testing"<<endl;
cout<<"Testing"<<endl;
cout<<"Testing"<<endl;
cout<<"Testing"<<endl;
cout<<"Testing"<<endl;

මේ දෙකම C++ Source Code දෙකක් මම දැන් උඹලට වැඩේ තේරෙන්න ඕන නිසා මේ දෙකම ලිව්වේ,
මේ ප්‍රෝග්‍රෑම් දෙකේම Result එක එකමයි, 5 වතාවක් Testing කියලා ප්‍රින්ට් වෙනවා, ඒත් බං මට තියෙන ලොකුම ප්‍රශ්නෙ තමයි එකම Performance, Condition තියන CPU දෙකක මේ ප්‍රෝග්‍රෑම් දෙක රන් කළොත් මුලින් රිසාල්ට් එක දෙන්නෙ මොන කෝඩ් එකේද කියන එක(තේරෙන්නෙත් නැති වෙලාවකින් දෙකම වෙනවා කියලා දන්නවා බං, ඒත් Nanoseconds වලින් හරි Fast මොකක්ද) තමයි ප්‍රශ්නෙ තියෙන්නේ,
මේ දෙකෙන් වැඩියෙන් Advanced Source Code එක පළවෙනි එක කියලා ඕන කෙනෙක් දන්නවා බං, අපි වුණත් වැඩ කරන්නෙ ඒ විදියට ඒත් බං Programmer පැත්තෙන් නොහිත User ගෙ පැත්තෙන් හිතුවොත් Execution Time එක අඩුම මොන කෝඩ් එකේද කියල මට දැන ගන්න ඕන බං,

මට හිතෙන විදියට මේ දෙකෙන් ඉක්මණටම Result එක දෙන්නෙ දෙවැනි කෝඩ් එකෙන්, මම එහෙම කියන්න හේතුව තමයි මේක,

1st Source Code එකේ Loop එකක් වැඩ කරනවා, එතකොට 5වතාවක් Print Statement එක Execute වෙනවා, ඊට පස්සේ 5වතාවක් i Variable එක Increment කරනවා තව 5 වතාවක් Condition Check කරනවා, ඒත් 2nd Source Code එකේ Print Statement 5 විතරයි තියෙන්නේ, එතකොට ඒක ඉක්මණට වෙන්න ඕන නේද බං?
තවත් සරළව කිව්වොත් බං 1st Source Code එකේ Execution 15ක් වෙනවා(5- Print Statement, 5 Variable Increment and 5 Condition Checking) ඒත් 2nd Program එකේ 5 Print Statement Only

මට ඔය සීන් එක ලොකුවටම හිතුනෙ මම Time Table Process කරන සොෆ්ට්වෙයාර් එකක් කරා බං VB .Net වලින්, ඒකෙ Process එකේ Source Code එක විතරක් Lines 10000කට කිට්ටු වෙන්න තියෙනවා බං, මට ඒක Loops දාලා 1500කට වගේ අඩු කරන්න පුලුවන් බං, ඒත් මම ඒක කරන්න යද්දි මට මේ සීන් එක හිතුනා බං, මොකද දැනටමත් ඒ Program එක Time Table Process කරද්දි 30sec වගේ යනවා බං නෝමල් P4 මැෂින් එකකත්, මට තියෙන ප්‍රශ්නෙ මේක Loops දාලා Source Code එක පොඩි කළාම මෙයිට වඩා Processing Time එක වැඩි වෙයිද කියන එක? මට මේ ප්‍රශ්නෙට හොඳට හිතලා බලලා හොඳ වැඩ්ඩෙක් උත්තරයක් දීපං බලන්න,

එල!

 

[Hasantha125]

yata eka ikman kiyala mata ayya kiwwa. eya computer science special karanne.hethuwath qwa mchn. mata therune na. uda eka repeat wena kathaawak thamaa qwe. iterations wadiy kiyalath qwa. ubata hariyayama dana ganna ona nam mata pm karanna. mama ayyata kiyannam uththare daanna kiyala..... ela

 

[SENCE]

Mate, in this code, since it does not have any third party dependency (like IO requests) speed is depend on the number of instructions.

So in the first program as you mentioned, number of instructions are higher than the second one and it takes more time than the second one. you can check this using a high frequency stopwatch (You can find some code here)

But in today's computers, this time is infinitesimal(even in your P4 machine).

If your code is slow, the major reason could be the IO requests; Database calls, file read write, service calls etc. Additionally it could be due to if you process large number of records in run-time (like 10K+).
You can use a stopwatch in .net as well n see where the bottleneck is.

 

[ChootyKuku]

deweni eka ban...

eka code ekak repeat karana ekane eken karanne.. enisa processor eka first line eka process kalama e result eka store wela tiyenne ekama dena eka tamai karanne...

 

[SENCE]

deweni eka ban...

eka code ekak repeat karana ekane eken karanne.. enisa processor eka first line eka process kalama e result eka store wela tiyenne ekama dena eka tamai karanne...

wrong. It does not store the previous result and use it. all are different instructions.

 

[Executer]

bump

 

[Bataya01]

මචං මම මේක නිකං හිතද්දි හිතුන පොඩි ප්‍රශ්නයක්, මේක හැබැයි සමහර ලොකු Programs හදද්දි Practically ප්‍රශ්නයක් වෙන්නත් පුලුවන් කියලා හිකෙනවා, මගේ මේ ප්‍රශ්නෙ උඹලට තේරෙන විදියට මම කියන්නම්, මේ උදාහරණය බලපංකො එතකොට සීන් එක තේරෙවි,

1st Program

int i=0;
while (i<5)
{
cout<<"Testing"<<endl;
i++;
}

2nd Program

cout<<"Testing"<<endl;
cout<<"Testing"<<endl;
cout<<"Testing"<<endl;
cout<<"Testing"<<endl;
cout<<"Testing"<<endl;

මේ දෙකම C++ Source Code දෙකක් මම දැන් උඹලට වැඩේ තේරෙන්න ඕන නිසා මේ දෙකම ලිව්වේ,
මේ ප්‍රෝග්‍රෑම් දෙකේම Result එක එකමයි, 5 වතාවක් Testing කියලා ප්‍රින්ට් වෙනවා, ඒත් බං මට තියෙන ලොකුම ප්‍රශ්නෙ තමයි එකම Performance, Condition තියන CPU දෙකක මේ ප්‍රෝග්‍රෑම් දෙක රන් කළොත් මුලින් රිසාල්ට් එක දෙන්නෙ මොන කෝඩ් එකේද කියන එක(තේරෙන්නෙත් නැති වෙලාවකින් දෙකම වෙනවා කියලා දන්නවා බං, ඒත් Nanoseconds වලින් හරි Fast මොකක්ද) තමයි ප්‍රශ්නෙ තියෙන්නේ,
මේ දෙකෙන් වැඩියෙන් Advanced Source Code එක පළවෙනි එක කියලා ඕන කෙනෙක් දන්නවා බං, අපි වුණත් වැඩ කරන්නෙ ඒ විදියට ඒත් බං Programmer පැත්තෙන් නොහිත User ගෙ පැත්තෙන් හිතුවොත් Execution Time එක අඩුම මොන කෝඩ් එකේද කියල මට දැන ගන්න ඕන බං,

මට හිතෙන විදියට මේ දෙකෙන් ඉක්මණටම Result එක දෙන්නෙ දෙවැනි කෝඩ් එකෙන්, මම එහෙම කියන්න හේතුව තමයි මේක,

1st Source Code එකේ Loop එකක් වැඩ කරනවා, එතකොට 5වතාවක් Print Statement එක Execute වෙනවා, ඊට පස්සේ 5වතාවක් i Variable එක Increment කරනවා තව 5 වතාවක් Condition Check කරනවා, ඒත් 2nd Source Code එකේ Print Statement 5 විතරයි තියෙන්නේ, එතකොට ඒක ඉක්මණට වෙන්න ඕන නේද බං?
තවත් සරළව කිව්වොත් බං 1st Source Code එකේ Execution 15ක් වෙනවා(5- Print Statement, 5 Variable Increment and 5 Condition Checking) ඒත් 2nd Program එකේ 5 Print Statement Only

මට ඔය සීන් එක ලොකුවටම හිතුනෙ මම Time Table Process කරන සොෆ්ට්වෙයාර් එකක් කරා බං VB .Net වලින්, ඒකෙ Process එකේ Source Code එක විතරක් Lines 10000කට කිට්ටු වෙන්න තියෙනවා බං, මට ඒක Loops දාලා 1500කට වගේ අඩු කරන්න පුලුවන් බං, ඒත් මම ඒක කරන්න යද්දි මට මේ සීන් එක හිතුනා බං, මොකද දැනටමත් ඒ Program එක Time Table Process කරද්දි 30sec වගේ යනවා බං නෝමල් P4 මැෂින් එකකත්, මට තියෙන ප්‍රශ්නෙ මේක Loops දාලා Source Code එක පොඩි කළාම මෙයිට වඩා Processing Time එක වැඩි වෙයිද කියන එක? මට මේ ප්‍රශ්නෙට හොඳට හිතලා බලලා හොඳ වැඩ්ඩෙක් උත්තරයක් දීපං බලන්න,

එල!

මේ ලින්ක් එක පොඩ්ඩක් බලපන් මචං
සෑහෙන පැති වලින් උත්තර දීල තියනවා
https://www.quora.com/In-computer-programming-what-is-faster-a-for-loop-that-prints-Hello-World-to-the-screen-1000-times-or-1000-print-statements-that-each-display-Hello-World-once

 

[slickdeath]

mn dnna widihatanm 2nd code eka fast..oka hoyanna puluwn time complexity calculate karala..mata dn hriyata mathaka ne..2nd code eke time complexity eka enne n..for loop ekak thyeddi eka n wargayak wenwa..dnna ekek kiyai..matath hriyata mathaka ne

 

[kellsupun]

 

[Bataya01]

mn dnna widihatanm 2nd code eka fast..oka hoyanna puluwn time complexity calculate karala..mata dn hriyata mathaka ne..2nd code eke time complexity eka enne n..for loop ekak thyeddi eka n wargayak wenwa..dnna ekek kiyai..matath hriyata mathaka ne

එක loop එකක් හරි nested නැත්නම් හරි n ම තමයි මචං.

 

[AloneGuy90]

අනිවා උබ programming වලට අලුත් එකෙක්.
ඇත්තම කිව්වොත් මේක කිසිම තේරුමක් නැති ප්‍රශ්නයක්.

software ලියනකොට speed එකට වඩා හිතන්න ඕන code maitainability, scalability ගැන.

ඕව ගැන තර්ක කරන්න පුලුවන්. නමුත් ඕව ප්‍රායෝගිකව භාවිතා වෙන්නේ නැත්නම් සහ එහෙම කරන එකත් පිස්සුවක් නිසා.

මේ වගේ ප්‍රශ්නත් තේරුමක් නැති ප්‍රශ්න.

 

[sithija.h]

අනිවා උබ programming වලට අලුත් එකෙක්.
ඇත්තම කිව්වොත් මේක කිසිම තේරුමක් නැති ප්‍රශ්නයක්.

software ලියනකොට speed එකට වඩා හිතන්න ඕන code maitainability, scalability ගැන.

ඕව ගැන තර්ක කරන්න පුලුවන්. නමුත් ඕව ප්‍රායෝගිකව භාවිතා වෙන්නේ නැත්නම් සහ එහෙම කරන එකත් පිස්සුවක් නිසා.

මේ වගේ ප්‍රශ්නත් තේරුමක් නැති ප්‍රශ්න.

Mama eka dannawa bn therumak na kiyala, anith de mama paththakin kiyala thiyanawa bn api unath programming karanne first method eken kiyala, bt mata meka nikan iddi hithuna logically prashnayak bn nikamata wage dana ganna ahuwe bn, api hamoma meka karanne first method eken kiyala dannawa bn, eth bn meh wage prashne hoyana interest ekak thiyana wena kenekta unath wadagath wenawa bn ekai ahuwe, ela,

 

[Edward Kenway]

අනිවා උබ programming වලට අලුත් එකෙක්.
ඇත්තම කිව්වොත් මේක කිසිම තේරුමක් නැති ප්‍රශ්නයක්.

software ලියනකොට speed එකට වඩා හිතන්න ඕන code maitainability, scalability ගැන.

ඕව ගැන තර්ක කරන්න පුලුවන්. නමුත් ඕව ප්‍රායෝගිකව භාවිතා වෙන්නේ නැත්නම් සහ එහෙම කරන එකත් පිස්සුවක් නිසා.

මේ වගේ ප්‍රශ්නත් තේරුමක් නැති ප්‍රශ්න.

ඔව් එයා ඔයා වගේ meteor වලින් SaaS ගහන ප්‍රවීනයෙක් නෙවෙයි වෙන්න ඇති
​

Mama eka dannawa bn therumak na kiyala, anith de mama paththakin kiyala thiyanawa bn api unath programming karanne first method eken kiyala, bt mata meka nikan iddi hithuna logically prashnayak bn nikamata wage dana ganna ahuwe bn, api hamoma meka karanne first method eken kiyala dannawa bn, eth bn meh wage prashne hoyana interest ekak thiyana wena kenekta unath wadagath wenawa bn ekai ahuwe, ela,

උඹට ඔහොම හිතෙනවා කියන්නේ උඹ උනන්දුවෙන් ඉගනගන්නවා සහ හිතන්න පුළුවන් කොල්ලෙක් කියන එක මචං

එක එකා පස්සේ ගිහින් වැටෙන ඒවා අහුලන් කන හීනමානයෙන් පෙලෙන පිස්සෝ ගණන් ගන්න එපා
​

 

[thilina91]

අනිවා උබ programming වලට අලුත් එකෙක්.
ඇත්තම කිව්වොත් මේක කිසිම තේරුමක් නැති ප්‍රශ්නයක්.

software ලියනකොට speed එකට වඩා හිතන්න ඕන code maitainability, scalability ගැන.

ඕව ගැන තර්ක කරන්න පුලුවන්. නමුත් ඕව ප්‍රායෝගිකව භාවිතා වෙන්නේ නැත්නම් සහ එහෙම කරන එකත් පිස්සුවක් නිසා.

මේ වගේ ප්‍රශ්නත් තේරුමක් නැති ප්‍රශ්න.

Embedded software algorithm efficiency balanne nathuwa liwwoth ta hike mithrawaruni.

 

[thilina91]

එක loop එකක් හරි nested නැත්නම් හරි n ම තමයි මචං.

2nd algorith eka O(1)
1st eka O(N)
Ref - https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/

 

[Necromancer]

Surely machan loop is more expensive in the sense of a computation . But comparatively present day computers thats nothing . As some mentioned here, you should be more focus on implementing good design and architectural patterns to reduce IO calls performance and make sure to improve the readability and maintainability of the code. Good luck

 

[DJ_HarDWelL]

මම c++ නොදනිමි. එ හින්ද ඔය දෙකෙන් වඩිය ස්පීඩ් මොකක්ද බලන්න ජාවා වලින් ට්‍රයි කරා මෙන්න මෙහෙම.


public class Loop {

public static void main(String[] args) {

long startTime = System.currentTimeMillis();

int value = 0;
while (value < 5)
{
System.out.println("Hello Elakiri..");
value++;
}

long endTime = System.currentTimeMillis();
System.out.println(endTime - startTime);
}
}

මේ තියෙන්නෙ අර ලූප් එක තියෙන කෝඩ් එක. ඕකේ ඔය System.currentTimeMillis(); කියන මෙතඩ් එකෙන් කරන්නේ 1970-1-1 රෑ 12 ඉදන් මේ වෙනකන් ගියපු මිලිසෙකන්ඩ්ස් ගාන ගාන ගන්න එක.(වෙන්න ඇති)ප්‍රොග්‍රෑම් එක පටන් ගද්දි වෙලාවයි ඉවර වෙද්දි වෙලාවයි අරන් වෙනසෙන් ප්‍රොග්‍රෑම් එක රන් වෙන්න ගියපු කාලෙ අරන් අවසානෙට ප්‍රින්ට් වෙන්නයි තියේන්නේ. ඔය කෝඩ් එක රන් කරපුවාම අව රිසාල්ට් එක මෙන්න.

Hello Elakiri..
Hello Elakiri..
Hello Elakiri..
Hello Elakiri..
Hello Elakiri..
0


(කාල වෙනස 0 යි )

මේ පහල තියෙන්නෙ අර ස්ටේට්මන්ට් තියෙන කෝඩ් එක.


public class Statement {

public static void main(String[] args) {

long startTime = System.currentTimeMillis();


System.out.println("Hello Elakiri..");
System.out.println("Hello Elakiri..");
System.out.println("Hello Elakiri..");
System.out.println("Hello Elakiri..");
System.out.println("Hello Elakiri..");


long endTime = System.currentTimeMillis();

System.out.println(endTime - startTime);
}
}

මෙන්න එකේ අපු රිසාල්ට් එක.

Hello Elakiri..
Hello Elakiri..
Hello Elakiri..
Hello Elakiri..
Hello Elakiri..
0

(කාල වෙනස 0 යි )

මේ කෝඩ් දෙක ගොඩක් පොඩි නිසා වැඩි වෙනසක් නෑ.නමුත් ජවා වල ArrayList & LinkedList වගේ ගත්තාම සමහර අවස්ථාවල පොඩි එනසක් තියෙනවා.

https://dzone.com/articles/arraylist-vs-linkedlist-vs

 

[CorD SaC]

Data structure and algorithms වල මචන් measurements 2k තියේ.
1. time complexity
2. space complexity

මචන් මේ වගේ එකක් බලන විදිහ තමා Time complexity එක..
ඔයාගේ උදාහරනෙට අනුව

(1st Program)මේකේ මචන් තියෙන්නේ ලූප් එකක්නේ එතකොට

1st Program

int i=0; මේක O(1) වෙනවා..
while (i<5) මෙතනදි n වාරයක් ඔයාගේ ලූප් එක රන් වෙනවා..5 තිබ්බට n තිබ්බ කියලා හිතන්ඩකෝ,එතකොට O
{
cout<<"Testing"<<endl; ලූප් එකේ n වාරයක් රන් වෙද්දි ලූප් එක තුල දේත් n වාරයක් රන් වෙනවා O
i++; // i = i+1 එතකොට මෙතනදි i ට අගයක් එකතු වෙනවත් එක්කම තව iට අගයයක් assign වෙනවා..ඒක n වාරයකුත් සිද්ද් වෙනවා,එතකොට O(1)+O(1) * n = 2n

}

එතකොට මුලු එකතුව O(1) + n + n + 2n = 4n + 1

''1'' constant value එකක්,මේක ගනන් ගන්නෙ නෑ


මේකේ මචන්

2nd Program

cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)

O(1) + O(1)+ O(1)+ O(1)+ O(1) = 5

උදාහරනෙට අනුව 2 එක ස්පීඩ් උනත් ප්‍රෝග්‍රැමර්ගෙ පහසුව සහ මේන්ටේන් කිරිමේ පහසුවට පලවෙනි ක්‍රමේ යූස් කරනවා...
O(1) = මේක කියවන්නේ බිග් ඕ වන්
O = මේක කියවන්නේ බිග් ඕ න්

සැ.යු
මචන් මේ මම දන්න දේ කියලා තියෙන්නේ,මාත් තාම ඉගෙන ගන්න එකෙක්,වැරදි ඇති සමහරවිට..එහෙමනම් දන්න කෙනෙක් පොඩ්ඩක් ඒක හදන්ඩ

 

[sbr]

big O

 

[DJ_HarDWelL]

Data structure and algorithms වල මචන් measurements 2k තියේ.
1. time complexity
2. space complexity

මචන් මේ වගේ එකක් බලන විදිහ තමා Time complexity එක..
ඔයාගේ උදාහරනෙට අනුව

(1st Program)මේකේ මචන් තියෙන්නේ ලූප් එකක්නේ එතකොට

1st Program

int i=0; මේක O(1) වෙනවා..
while (i<5) මෙතනදි n වාරයක් ඔයාගේ ලූප් එක රන් වෙනවා..5 තිබ්බට n තිබ්බ කියලා හිතන්ඩකෝ,එතකොට O
{
cout<<"Testing"<<endl; ලූප් එකේ n වාරයක් රන් වෙද්දි ලූප් එක තුල දේත් n වාරයක් රන් වෙනවා O
i++; // i = i+1 එතකොට මෙතනදි i ට අගයක් එකතු වෙනවත් එක්කම තව iට අගයයක් assign වෙනවා..ඒක n වාරයකුත් සිද්ද් වෙනවා,එතකොට O(1)+O(1) * n = 2n

}

එතකොට මුලු එකතුව O(1) + n + n + 2n = 4n + 1

''1'' constant value එකක්,මේක ගනන් ගන්නෙ නෑ


මේකේ මචන්

2nd Program

cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)
cout<<"Testing"<<endl; O(1)

O(1) + O(1)+ O(1)+ O(1)+ O(1) = 5

උදාහරනෙට අනුව 2 එක ස්පීඩ් උනත් ප්‍රෝග්‍රැමර්ගෙ පහසුව සහ මේන්ටේන් කිරිමේ පහසුවට පලවෙනි ක්‍රමේ යූස් කරනවා...
O(1) = මේක කියවන්නේ බිග් ඕ වන්
O = මේක කියවන්නේ බිග් ඕ න්

සැ.යු
මචන් මේ මම දන්න දේ කියලා තියෙන්නේ,මාත් තාම ඉගෙන ගන්න එකෙක්,වැරදි ඇති සමහරවිට..එහෙමනම් දන්න කෙනෙක් පොඩ්ඩක් ඒක හදන්ඩ