Ohh I saw it now.
eka hodai bro. nath nam course resources hoya ganna amarui. okkoma eka gode ne thiyenne. purchase kalama lesson eka laginma course resources thiyenawa. patta wasi eka.
I'm doing that too. But I spent 2 and 1/2 hours to complete the day two even though it says 1 hr and 12 minutes.
day_01_variables
day_02_string_manipulate
day_03_control_flow
Dr. Angela thama ehema kiyanne. e ai kiyala motivational video ekaka thiyenawa. Wallpaper ekath course resource wala thiyena ekak."80% of success is showing up!" කියලා දැම්මෙ ඇයි මචන්?
ඇයි බන් ඔය ෆයිල් ඩවුන්ලෝඩ් කරගන්නෙ. ආයෙ බලන්නෙ නෑනෙ. මොලේට දාගන්න එකනෙ වෙන්න ඕනෙ මෙහෙම දේවල් තියෙනවා කියලා. එතකොට කෝඩ් එක ඕන නම් ගූගල් සර්ච් එකෙන් ගත්තැකි.#Day_15
Local Development Environment Setup & the Coffee Machine (1hr 6min)
අද තමයි අපි Python අපේ PC එකට download කරල install කරගන්නෙ. මෙච්චර දවසක් repl එකෙන් නෙ වැඩ කලේ. මම නම් මේ ටික කලින්ම කරගෙන තිබ්බෙ. ඒ නිසා මුල් 30mins වගේ ඉතුරු උනා.
TIP 1
repl එකේ කරපු වැඩ ටික ඔක්කොම local pc එකට download කරගන්න. repl files ඔක්කොම තියෙන්නෙ එකම නමින්. repl name එකනෙ වෙනස්. download කරද්දි repl name එක වැඩක් නෑ අපිට. file name එකයි වැදගත්. ඔක්කොම files තියෙන්නෙ main.py, art.py නමින්. ඒ නිසා මේ files ටික ඔක්කොම එක පාර download කරගන්න එපා. එතකොට browser එකෙන් rename කරනව main(1).py, art(1).py. etc.. ඊලගට ඔය files වැඩ කරන්නෙ නෑ.
එ නිසා folder එකක් හදල ඒ folder එක ඇතුලෙ lesson name එකෙන් folder එකක් හදල වෙන වෙනම ඒ folder ඇතුලට download කරගන්න. නැත්නම් එක day එකක files ටික download කරල ඒ files ටික අදාල lesson folder එකට drag n drop කරල ඊලග දවසෙ files download කරගන්න.
TIP 2
Folder හදද්දි Day name එකෙන් Folder හදන්න එපා. ඒක කිසිම වැඩක් නැති දෙයක්. මොකද පසූ කාලීනව code එකක් ආපහු ඕනෙ උනොත් අපිට මතක් වෙනව course එකේ මෙහෙම දෙයක් කලා ඒ lesson එකේ code එක තියෙනවනෙ කියල. ඊලගට day name එකෙන් Folder save කරල තිබ්බොත් අපිට මතක නෑ මොන day එකේද ඉගැන්නුවෙ කියල, ඔක්කොම හොය හොය බලන්න වෙනව. ඒ නිසා lesson name එකෙන් folder save කරගන්න. ඕනෙම නම් මුලට day name එකත් එක්ක දාගන. එතකොට folder ටිකත් ලස්සනට sort වෙනව.
Code:day_01_variables day_02_string_manipulate day_03_control_flow
මම Java වලින් Python ආපු නිසා PEP8 guides වලට file names නෑ. java rules වලට හදල තියෙන්නෙ. PEP8 rules දැනන් හිටියෙ නෑ මුලදි. ඔක්කොම lower case use කරන්න. word දෙකක් අතර underscore තියන්න.
Ex - logical_operators.py
1. Google search කලාට එකම problem එකට solutions කීපයක් තියෙනව. ඒත්කොට ඒ ඔක්කොම solutions අපේ input එකත් එක්ක වැලීඩ් කියල ආයිත් ආයිත් බලන්න වෙනව. ඒත් දන්න solution code එක අපි already check කරල තියෙන නිසා input එකත් එක්ක ආයිආයි check කරන්න දෙයක් නෑ.
phonenumber = "3662277"
words = ["foo","bar","baz","foobar","emo","cap","car","cat"]
output = []
dictionary = {"a":2,"b":2,"c":2,"d":3,"e":3,"f":3,"g":4,"h":4,"i":4,"j":5,"k":5,"l":5,"m":6,"n":6,"o":6,"p":7,"q":7,"r":7,"s":7,"t":8,"u":8,"v":8,"w":9,"x":9,"y":9,"z":9}
def converter(word):
number = ""
for letters in word:
number = number + str(dictionary[letters])
return(number)
for word in words:
if converter(word) in phonenumber:
output.append(word)
print(output)මම මේකට තව ටිකක් එකතු කරන්නම්. තාම Day 14 කරල නැති අය නම් මේව බලන්නවත් එපා තේරුමක් නෑ. demotivate වෙනව. අනික මේ problem එකට දෙන solution එක පට්ටම complex solution එකක්. interview එකේදි කියනව එච්චර දෙයක් බලාපොරොත්තු උනෙත් නෑ කියල. අඩුම ගානෙ මම වත් try කලේ නෑ. ඒතරමට අමාරුයි. එතකොට මේ @hancok 10min වලින්හැදුව කියන්නෙ මොකද්ද?
search_item = 33
items = [10, 14, 19, 26, 27, 31, 33, 35, 42, 44]print(items.index(search_item))def linear_search(ar, search):
for index in range(len(ar)):
if ar[index] == search:
return index
return 'Trace Error'
print(linear_search(items, search_item))def binary_search(ar, search):
low = 0
high = len(ar) - 1
while True:
# search not found
if high < low:
return 'Trace Error'
mid = low + (high - low) // 2
if ar[mid] == search:
return mid
elif ar[mid] < search:
# upper bound
low = mid + 1
else:
# lower bound
high = mid - 1
print(binary_search(items, search_item))
Mage solution eke awula thiyanneමම මේකට තව ටිකක් එකතු කරන්නම්. තාම Day 14 කරල නැති අය නම් මේව බලන්නවත් එපා තේරුමක් නෑ. demotivate වෙනව. අනික මේ problem එකට දෙන solution එක පට්ටම complex solution එකක්. interview එකේදි කියනව එච්චර දෙයක් බලාපොරොත්තු උනෙත් නෑ කියල. අඩුම ගානෙ මම වත් try කලේ නෑ. ඒතරමට අමාරුයි. එතකොට මේ @hancok 10min වලින්හැදුව කියන්නෙ මොකද්ද?
ඒ ප්රශ්නෙ හරියට තේරුම් නොගැනීම. මෙතන අපිට output එක කොහොමහරි ගන්න එක නෙමේ challenge එක. algorithm එකක් ලියල output එක ගන්න එකයි challenge එක. ඒකට මම වෙන ප්රශ්නෙකින් පැහැදිලි කරන්නම්
දැන් අපිට list එකක තියෙන value එකක index එක හොයන්න කියල code challenge එකක් interview එකකදි දෙනව.
example
candidateල තුන් දෙනෙක් සහභාගි වෙනව.Python:search_item = 33 items = [10, 14, 19, 26, 27, 31, 33, 35, 42, 44]
1st candidate @hancok වගේ කෙනා මෙහෙම ලියනව. ලියල කියනව තත්පර 10වත් ගියෙ නෑ කියල.
Python:print(items.index(search_item))
2nd candidate මෙහෙම algorithm එකක් ලියනව.
Python:def linear_search(ar, search): for index in range(len(ar)): if ar[index] == search: return index return 'Trace Error' print(linear_search(items, search_item))
3rd candidate මෙහෙම algorithm එකක් ලියනව.
Python:def binary_search(ar, search): low = 0 high = len(ar) - 1 while True: # search not found if high < low: return 'Trace Error' mid = low + (high - low) // 2 if ar[mid] == search: return mid elif ar[mid] < search: # upper bound low = mid + 1 else: # lower bound high = mid - 1 print(binary_search(items, search_item))
දැන් interview එක අවසානෙදි තෝරගන්න කවුද. අනිවාර්යෙන්ම candidate 3. ඒකට හේතුව එයා තමා #හොදටම_කරල_තියෙන්නෙ.
එහෙම වෙන්න හේතුව මෙතන ඉල්ලන්නෙ algorithm එකක් මිසක් කොහොමහරි output එක print කරන එක නෙමේ. ඒ නිසා candidate 1 @hancok පයින් ගහල එලවන්නෙ.
2nd, 3rd candidate අතරෙන් 3rd එක්කෙනා හොද වෙන්න හේතුව මොකද්ද? ඒකට Big 'O' notation කියල එකක් තියෙනව. ඒකෙ සරල තේරුම අපි ප්රශ්නයකට විසදුමක් ලබා දීමේදි විසදුම ලැබෙන්න steps කීයක් යනවද කියන එක. ඒ කියන්නෙ ලියපු code lines ගාන නෙමේ. අවාසාන පිලිතුර ලැබෙන්න යන steps ගානයි. worst case scenario (දරුණුම දේ තමා) Big 'O' notation එකෙන් බලන්නෙ.
2nd candidate ලියපු පිලිතුරේ කරන්නෙ list එකේ මුල ඉදන් අගට loop කරල බලනව index value එක search value එකත් එක්ක match වෙනවද කියල match වෙනව නම් index එක return කරනව.
දැන් මේ solution එකේ ප්රශ්නයක් තියෙනව. අපිට දෙන list එක එන්න එන්න ලොකු වැඩි වෙනකොට අපිට ඕනෙ value එක හොයන්න යන කාලය එන්න එන්න වැඩි වෙනව. ලොකු වට ප්රමානයක් ඕනෙ වෙනව. ඒකියන්නෙ ලොකු steps ප්රමානයක් ඕනෙ වෙනව. හිතන්න items 1000ක් තියෙන list එකක 998වෙනි index එකේ තමා අපි හොයන value එක තියෙන්නෙ . දැන් මේ search algorithm එක පාවිච්චි කලොත් loop එක වට 998ක් ගියාම තමා අපිට ඕනෙ index එක return වෙන්නෙ.
Big 'O' notation එක බැලුවොත් O ( N )
https://www.tutorialspoint.com/data_structures_algorithms/linear_search_algorithm.htm
3rd candidate ලියපු පිලිතුරේ කරන්නෙ Divide and conquer approach එක. main problem එක sub problem වලට divide කරගෙන ඒ පොඩි sub problems වෙන වෙනම විසදන එක,
මේ algorithm එකේදි list එකේ මුල ඉදන් අගට බලන්නෙ නෑ. මුලින්ම list එකේ මැද්දෙන් පටන් අරන් search value එක තියෙන්න පුලුවන් පැත්ත හදුනාගෙන ඒ පැත්ත ආයිත් මැද්ද අරන් ඉස්සරහට යන algorithm එකක් තියෙන්නෙ.
Big 'O' notation එක බැලුවොත් O(log n)
https://www.tutorialspoint.com/data_structures_algorithms/binary_search_algorithm.htm
දැන් එතකොට 3rd candidate ගෙ algorithm එක තමා හොදම.
තව search algorithm වර්ග තියෙනව. දැන් තාම course එකේ මුල් දවස් වල ඉන්න අය මේක කියවල demotivate වෙන්න එපා. මේව ටිකක් programming ඇඟට සෙට් උනාම කරල බලන්න ඕනෙ වැඩ. දැන්ම මේව කරන්න ගිහින් මේව නම් බෑ කියල ඔක්කොම අතාරින්න එපා.
දවස් 14 complete අයට try කරල බලන්න හොද මේ වගේ තවත් problem එකක් තමා Largest prime factor problem එක.
https://projecteuler.net/problem=3
example දීල තියෙන 13195 number එකට algorithm code එකක් ලියාගන්න පුලුවන් උනත් අන්තිමට අහන number එකට algorithm එක වැඩ කරන්නෙ නැ කියල ඔයාලටම තේරෙයි. Big 'O' notation
Good explanation muchn!මම මේකට තව ටිකක් එකතු කරන්නම්. තාම Day 14 කරල නැති අය නම් මේව බලන්නවත් එපා තේරුමක් නෑ. demotivate වෙනව. අනික මේ problem එකට දෙන solution එක පට්ටම complex solution එකක්. interview එකේදි කියනව එච්චර දෙයක් බලාපොරොත්තු උනෙත් නෑ කියල. අඩුම ගානෙ මම වත් try කලේ නෑ. ඒතරමට අමාරුයි. එතකොට මේ @hancok 10min වලින්හැදුව කියන්නෙ මොකද්ද?
ඒ ප්රශ්නෙ හරියට තේරුම් නොගැනීම. මෙතන අපිට output එක කොහොමහරි ගන්න එක නෙමේ challenge එක. algorithm එකක් ලියල output එක ගන්න එකයි challenge එක. ඒකට මම වෙන ප්රශ්නෙකින් පැහැදිලි කරන්නම්
දැන් අපිට list එකක තියෙන value එකක index එක හොයන්න කියල code challenge එකක් interview එකකදි දෙනව.
example
candidateල තුන් දෙනෙක් සහභාගි වෙනව.Python:search_item = 33 items = [10, 14, 19, 26, 27, 31, 33, 35, 42, 44]
1st candidate @hancok වගේ කෙනා මෙහෙම ලියනව. ලියල කියනව තත්පර 10වත් ගියෙ නෑ කියල.
Python:print(items.index(search_item))
2nd candidate මෙහෙම algorithm එකක් ලියනව.
Python:def linear_search(ar, search): for index in range(len(ar)): if ar[index] == search: return index return 'Trace Error' print(linear_search(items, search_item))
3rd candidate මෙහෙම algorithm එකක් ලියනව.
Python:def binary_search(ar, search): low = 0 high = len(ar) - 1 while True: # search not found if high < low: return 'Trace Error' mid = low + (high - low) // 2 if ar[mid] == search: return mid elif ar[mid] < search: # upper bound low = mid + 1 else: # lower bound high = mid - 1 print(binary_search(items, search_item))
දැන් interview එක අවසානෙදි තෝරගන්න කවුද. අනිවාර්යෙන්ම candidate 3. ඒකට හේතුව එයා තමා #හොදටම_කරල_තියෙන්නෙ.
එහෙම වෙන්න හේතුව මෙතන ඉල්ලන්නෙ algorithm එකක් මිසක් කොහොමහරි output එක print කරන එක නෙමේ. ඒ නිසා candidate 1 @hancok පයින් ගහල එලවන්නෙ.
2nd, 3rd candidate අතරෙන් 3rd එක්කෙනා හොද වෙන්න හේතුව මොකද්ද? ඒකට Big 'O' notation කියල එකක් තියෙනව. ඒකෙ සරල තේරුම අපි ප්රශ්නයකට විසදුමක් ලබා දීමේදි විසදුම ලැබෙන්න steps කීයක් යනවද කියන එක. ඒ කියන්නෙ ලියපු code lines ගාන නෙමේ. අවාසාන පිලිතුර ලැබෙන්න යන steps ගානයි. worst case scenario (දරුණුම දේ තමා) Big 'O' notation එකෙන් බලන්නෙ.
2nd candidate ලියපු පිලිතුරේ කරන්නෙ list එකේ මුල ඉදන් අගට loop කරල බලනව index value එක search value එකත් එක්ක match වෙනවද කියල match වෙනව නම් index එක return කරනව.
දැන් මේ solution එකේ ප්රශ්නයක් තියෙනව. අපිට දෙන list එක එන්න එන්න ලොකු වැඩි වෙනකොට අපිට ඕනෙ value එක හොයන්න යන කාලය එන්න එන්න වැඩි වෙනව. ලොකු වට ප්රමානයක් ඕනෙ වෙනව. ඒකියන්නෙ ලොකු steps ප්රමානයක් ඕනෙ වෙනව. හිතන්න items 1000ක් තියෙන list එකක 998වෙනි index එකේ තමා අපි හොයන value එක තියෙන්නෙ . දැන් මේ search algorithm එක පාවිච්චි කලොත් loop එක වට 998ක් ගියාම තමා අපිට ඕනෙ index එක return වෙන්නෙ.
Big 'O' notation එක බැලුවොත් O ( N )
https://www.tutorialspoint.com/data_structures_algorithms/linear_search_algorithm.htm
3rd candidate ලියපු පිලිතුරේ කරන්නෙ Divide and conquer approach එක. main problem එක sub problem වලට divide කරගෙන ඒ පොඩි sub problems වෙන වෙනම විසදන එක,
මේ algorithm එකේදි list එකේ මුල ඉදන් අගට බලන්නෙ නෑ. මුලින්ම list එකේ මැද්දෙන් පටන් අරන් search value එක තියෙන්න පුලුවන් පැත්ත හදුනාගෙන ඒ පැත්ත ආයිත් මැද්ද අරන් ඉස්සරහට යන algorithm එකක් තියෙන්නෙ.
Big 'O' notation එක බැලුවොත් O(log n)
https://www.tutorialspoint.com/data_structures_algorithms/binary_search_algorithm.htm
දැන් එතකොට 3rd candidate ගෙ algorithm එක තමා හොදම.
තව search algorithm වර්ග තියෙනව. දැන් තාම course එකේ මුල් දවස් වල ඉන්න අය මේක කියවල demotivate වෙන්න එපා. මේව ටිකක් programming ඇඟට සෙට් උනාම කරල බලන්න ඕනෙ වැඩ. දැන්ම මේව කරන්න ගිහින් මේව නම් බෑ කියල ඔක්කොම අතාරින්න එපා.
දවස් 14 complete අයට try කරල බලන්න හොද මේ වගේ තවත් problem එකක් තමා Largest prime factor problem එක.
https://projecteuler.net/problem=3
example දීල තියෙන 13195 number එකට algorithm code එකක් ලියාගන්න පුලුවන් උනත් අන්තිමට අහන number එකට algorithm එක වැඩ කරන්නෙ නැ කියල ඔයාලටම තේරෙයි. Big 'O' notation
Oya project eular q3 eke karanna thiyanne oya maha ilakkame wargamulaya wenakan prime list eka hadala maha ilakkama e prime list eken bedan yanna neda aga idan mulata. Ita wada adu kaalayak yana kramayak thiyanawadaමම මේකට තව ටිකක් එකතු කරන්නම්. තාම Day 14 කරල නැති අය නම් මේව බලන්නවත් එපා තේරුමක් නෑ. demotivate වෙනව. අනික මේ problem එකට දෙන solution එක පට්ටම complex solution එකක්. interview එකේදි කියනව එච්චර දෙයක් බලාපොරොත්තු උනෙත් නෑ කියල. අඩුම ගානෙ මම වත් try කලේ නෑ. ඒතරමට අමාරුයි. එතකොට මේ @hancok 10min වලින්හැදුව කියන්නෙ මොකද්ද?
ඒ ප්රශ්නෙ හරියට තේරුම් නොගැනීම. මෙතන අපිට output එක කොහොමහරි ගන්න එක නෙමේ challenge එක. algorithm එකක් ලියල output එක ගන්න එකයි challenge එක. ඒකට මම වෙන ප්රශ්නෙකින් පැහැදිලි කරන්නම්
දැන් අපිට list එකක තියෙන value එකක index එක හොයන්න කියල code challenge එකක් interview එකකදි දෙනව.
example
candidateල තුන් දෙනෙක් සහභාගි වෙනව.Python:search_item = 33 items = [10, 14, 19, 26, 27, 31, 33, 35, 42, 44]
1st candidate @hancok වගේ කෙනා මෙහෙම ලියනව. ලියල කියනව තත්පර 10වත් ගියෙ නෑ කියල.
Python:print(items.index(search_item))
2nd candidate මෙහෙම algorithm එකක් ලියනව.
Python:def linear_search(ar, search): for index in range(len(ar)): if ar[index] == search: return index return 'Trace Error' print(linear_search(items, search_item))
3rd candidate මෙහෙම algorithm එකක් ලියනව.
Python:def binary_search(ar, search): low = 0 high = len(ar) - 1 while True: # search not found if high < low: return 'Trace Error' mid = low + (high - low) // 2 if ar[mid] == search: return mid elif ar[mid] < search: # upper bound low = mid + 1 else: # lower bound high = mid - 1 print(binary_search(items, search_item))
දැන් interview එක අවසානෙදි තෝරගන්න කවුද. අනිවාර්යෙන්ම candidate 3. ඒකට හේතුව එයා තමා #හොදටම_කරල_තියෙන්නෙ.
එහෙම වෙන්න හේතුව මෙතන ඉල්ලන්නෙ algorithm එකක් මිසක් කොහොමහරි output එක print කරන එක නෙමේ. ඒ නිසා candidate 1 @hancok පයින් ගහල එලවන්නෙ.
2nd, 3rd candidate අතරෙන් 3rd එක්කෙනා හොද වෙන්න හේතුව මොකද්ද? ඒකට Big 'O' notation කියල එකක් තියෙනව. ඒකෙ සරල තේරුම අපි ප්රශ්නයකට විසදුමක් ලබා දීමේදි විසදුම ලැබෙන්න steps කීයක් යනවද කියන එක. ඒ කියන්නෙ ලියපු code lines ගාන නෙමේ. අවාසාන පිලිතුර ලැබෙන්න යන steps ගානයි. worst case scenario (දරුණුම දේ තමා) Big 'O' notation එකෙන් බලන්නෙ.
2nd candidate ලියපු පිලිතුරේ කරන්නෙ list එකේ මුල ඉදන් අගට loop කරල බලනව index value එක search value එකත් එක්ක match වෙනවද කියල match වෙනව නම් index එක return කරනව.
දැන් මේ solution එකේ ප්රශ්නයක් තියෙනව. අපිට දෙන list එක එන්න එන්න ලොකු වැඩි වෙනකොට අපිට ඕනෙ value එක හොයන්න යන කාලය එන්න එන්න වැඩි වෙනව. ලොකු වට ප්රමානයක් ඕනෙ වෙනව. ඒකියන්නෙ ලොකු steps ප්රමානයක් ඕනෙ වෙනව. හිතන්න items 1000ක් තියෙන list එකක 998වෙනි index එකේ තමා අපි හොයන value එක තියෙන්නෙ . දැන් මේ search algorithm එක පාවිච්චි කලොත් loop එක වට 998ක් ගියාම තමා අපිට ඕනෙ index එක return වෙන්නෙ.
Big 'O' notation එක බැලුවොත් O ( N )
https://www.tutorialspoint.com/data_structures_algorithms/linear_search_algorithm.htm
3rd candidate ලියපු පිලිතුරේ කරන්නෙ Divide and conquer approach එක. main problem එක sub problem වලට divide කරගෙන ඒ පොඩි sub problems වෙන වෙනම විසදන එක,
මේ algorithm එකේදි list එකේ මුල ඉදන් අගට බලන්නෙ නෑ. මුලින්ම list එකේ මැද්දෙන් පටන් අරන් search value එක තියෙන්න පුලුවන් පැත්ත හදුනාගෙන ඒ පැත්ත ආයිත් මැද්ද අරන් ඉස්සරහට යන algorithm එකක් තියෙන්නෙ.
Big 'O' notation එක බැලුවොත් O(log n)
https://www.tutorialspoint.com/data_structures_algorithms/binary_search_algorithm.htm
දැන් එතකොට 3rd candidate ගෙ algorithm එක තමා හොදම.
තව search algorithm වර්ග තියෙනව. දැන් තාම course එකේ මුල් දවස් වල ඉන්න අය මේක කියවල demotivate වෙන්න එපා. මේව ටිකක් programming ඇඟට සෙට් උනාම කරල බලන්න ඕනෙ වැඩ. දැන්ම මේව කරන්න ගිහින් මේව නම් බෑ කියල ඔක්කොම අතාරින්න එපා.
දවස් 14 complete අයට try කරල බලන්න හොද මේ වගේ තවත් problem එකක් තමා Largest prime factor problem එක.
https://projecteuler.net/problem=3
example දීල තියෙන 13195 number එකට algorithm code එකක් ලියාගන්න පුලුවන් උනත් අන්තිමට අහන number එකට algorithm එක වැඩ කරන්නෙ නැ කියල ඔයාලටම තේරෙයි. Big 'O' notation
