Algorithms, Pseudocode and Flowchartsئەلگۆریزمەکان، نیمچەکۆد و هێڵکارییەکانی ڕەوت

Before you write code, you need a plan. An algorithm is a finite list of clear, ordered steps that turns some input into the output you want. A recipe, the directions to a friend's house and the steps for taking cash from an ATM are all everyday algorithms.

پێش ئەوەی کۆد بنووسیت، پێویستت بە پلانێکە. ئەلگۆریزم لیستێکی کۆتاییداری هەنگاوی ڕوون و ڕیزکراوە کە نێوخستەیەک دەکات بە ئەو دەرخستەیەی (Output) دەتەوێت. ڕێنمایی چێشتلێنان، ڕێنمایی گەیشتن بە ماڵی هاوڕێیەک و هەنگاوەکانی وەرگرتنی پارە لە ئامێری ATM هەموویان ئەلگۆریزمی ڕۆژانەن.

For example, here is an algorithm in plain words for finding the largest of three numbers: “Remember the first number as the largest so far. Look at the second number; if it is bigger, remember it instead. Do the same with the third number. Say the number you remember.”

بۆ نموونە، ئەمە ئەلگۆریزمێکە بە وشەی ئاسایی بۆ دۆزینەوەی گەورەترینی سێ ژمارە: «یەکەم ژمارە وەک گەورەترینی تا ئێستا لەبیر بگرە. سەیری ژمارەی دووەم بکە؛ ئەگەر گەورەتر بوو، لە جیاتی ئەو ئەمیان لەبیر بگرە. هەمان کار بە ژمارەی سێیەم بکە. ئەو ژمارەیە بڵێ کە لەبیرتە.»

Pseudocode writes an algorithm in short, structured lines that look a little like code but are meant for people, not computers. It has no single official standard, but most books use similar words: INPUT and OUTPUT, ← for “store this value”, IF … THEN … ELSE … END IF for decisions and WHILE … DO … END WHILE for repetition. The keywords stay in English in every language, because they become real code later.

نیمچەکۆد ئەلگۆریزمێک بە دێڕی کورت و ڕێکخراو دەنووسێت کە کەمێک لە کۆد دەچن بەڵام بۆ مرۆڤن، نەک بۆ کۆمپیوتەر. هیچ ستانداردێکی فەرمیی تاکی نییە، بەڵام زۆربەی کتێبەکان وشەی هاوشێوە بەکار دەهێنن: INPUT و OUTPUT، ← بۆ «ئەم نرخە (Value) هەڵبگرە»، IF … THEN … ELSE … END IF بۆ بڕیار و WHILE … DO … END WHILE بۆ دووبارەکردنەوە. وشە کلیلەییەکان (Keyword) لە هەموو زمانێکدا بە ئینگلیزی دەمێننەوە، چونکە دواتر دەبن بە کۆدی ڕاستەقینە.

Pseudocode lets you think about the steps without worrying about one language's punctuation. The same lines can later be written in Python, Java or C#. AI books use their own pseudocode conventions; those are explained in Reading AI pseudocode.

نیمچەکۆد ڕێگەت پێ دەدات بیر لە هەنگاوەکان بکەیتەوە بەبێ نیگەرانی لە خاڵبەندیی زمانێکی دیاریکراو. هەمان دێڕەکان دواتر دەکرێت بە Python، Java یان ⁦C#⁩ بنووسرێن. کتێبەکانی ژیریی دەستکرد (Artificial intelligence) ڕێکەوتنی نیمچەکۆدی تایبەت بە خۆیان هەیە؛ ئەوانە لە خوێندنەوەی نیمچەکۆدی ژیریی دەستکرد ڕوون کراونەتەوە.

A flowchart draws an algorithm as shapes joined by arrows. Each shape has a fixed meaning, so anyone can read a flowchart. Flow diagrams for work processes were introduced by the engineers Frank and Lillian Gilbreth in 1921; the symbols programmers use today are set in the international standard ISO 5807 (1985).

هێڵکاریی ڕەوت ئەلگۆریزمێک وەک شێوەی بەیەکەوە بەستراو بە تیر دەکێشێت. هەر شێوەیەک واتایەکی دیاریکراوی هەیە، بۆیە هەموو کەسێک دەتوانێت هێڵکاریی ڕەوت بخوێنێتەوە. هێڵکارییەکانی ڕەوتی کار لە ساڵی ⁦1921⁩دا لەلایەن هەردوو ئەندازیار Frank و ⁦Lillian Gilbreth⁩ـەوە ناسێنران؛ ئەو هێمایانەی بەرنامەسازەکان ئەمڕۆ بەکاریان دەهێنن لە ستانداردی نێودەوڵەتیی ⁦ISO 5807 (1985)⁩دا دیاری کراون.

Every algorithm, however large, is built from only three control structures:

هەموو ئەلگۆریزمێک، هەرچەند گەورە بێت، تەنها لە سێ پێکهاتەی کۆنترۆڵ (Control structure) دروست دەکرێت:

In 1966 the computer scientists Corrado Böhm and Giuseppe Jacopini showed that these three are enough to express any algorithm a computer can carry out. Every language in this course — Python today, Java or C# tomorrow — has its own words for them, but the ideas are the same.

لە ساڵی ⁦1966⁩دا زانایانی کۆمپیوتەر ⁦Corrado B⁩öhm و ⁦Giuseppe Jacopini⁩ سەلماندیان کە ئەم سێیانە بەسن بۆ دەربڕینی هەر ئەلگۆریزمێک کە کۆمپیوتەر بتوانێت جێبەجێی بکات. هەموو زمانێکی ئەم کۆرسە (ئەمڕۆ Python، سبەی Java یان ⁦C#⁩) وشەی خۆی بۆیان هەیە، بەڵام بیرۆکەکان وەک یەکن.

Here is the algorithm from the start of this lesson as a flowchart. It uses sequence (the first three steps) and selection (the two diamonds). The idea: keep the “largest so far” in largest, and replace it whenever you find a bigger number. The same algorithm in pseudocode is on the pseudocode screen.

ئەمە ئەو ئەلگۆریزمەیە لە سەرەتای ئەم وانەیەدا هات، وەک هێڵکاریی ڕەوت. ڕیزبەندی (سێ هەنگاوی یەکەم) و هەڵبژاردن (دوو شێوە ئەڵماسییەکە) بەکار دەهێنێت. بیرۆکەکە: «گەورەترینی تا ئێستا» لە largestـدا هەڵبگرە و هەر کاتێک ژمارەیەکی گەورەترت دۆزییەوە بیگۆڕە. هەمان ئەلگۆریزم بە نیمچەکۆد لە شاشەی نیمچەکۆددایە.

A mistake in a bank’s transfer program could send only half of the money; in hospital or aircraft software a mistake can hurt people. So an algorithm must be checked in every situation before anyone trusts it. How, before any code exists? You trace it: follow the steps by hand with real input and write every change in a trace table — one column per variable, one row per step.

هەڵەیەک لە بەرنامەی گواستنەوەی پارەی بانکێکدا دەکرێت تەنها نیوەی پارەکە بنێرێت؛ لە نەرمەواڵەی (Software) نەخۆشخانە یان فڕۆکەدا هەڵەیەک دەکرێت زیان بە خەڵک بگەیەنێت. بۆیە پێش ئەوەی کەس متمانەی پێ بکات، دەبێت ئەلگۆریزمێک لە هەموو بارێکدا بپشکنرێت. چۆن، پێش ئەوەی هیچ کۆدێک هەبێت؟ بەدوایدا دەچیت: بە دەست و بە نێوخستەیەکی ڕاستەقینە شوێن هەنگاوەکان دەکەویت و هەموو گۆڕانکارییەک لە خشتەیەکی بەدواداچوون دەنووسیت: ستوونێک بۆ هەر گۆڕاوێک (Variable) و ڕیزێک بۆ هەر هەنگاوێک.

Now trace a harder case, 5, 5, 3, where two numbers are equal: largest starts as 5; is $5 > 5$? No; is $3 > 5$? No; the output is 5. Correct. Good testers always try equal values, the smallest and largest values, and unusual inputs. In the Python track you use trace tables to find bugs in real code: Errors and debugging.

ئێستا بەدوای حاڵەتێکی قورستردا بچۆ، 5، 5، 3، کە دوو ژمارە یەکسانن: largest بە 5 دەست پێ دەکات؛ ئایا $5 > 5$؟ نەخێر؛ ئایا $3 > 5$؟ نەخێر؛ دەرخستەکە 5ـە. دروستە. تاقیکەرەوەی باش هەمیشە نرخە یەکسانەکان، بچووکترین و گەورەترین نرخەکان و نێوخستەی نائاسایی تاقی دەکاتەوە. لە ڕێڕەوی Pythonـدا خشتەکانی بەدواداچوون بۆ دۆزینەوەی باگەکان (Bug) لە کۆدی ڕاستەقینەدا بەکار دەهێنیت: هەڵەکان و کرمەکوژی.

Many students first write the largest-of-three algorithm like this. It looks right, and it works for 7, 12, 9. Trace it with 5, 5, 3 before you read on.

زۆر خوێندکار سەرەتا ئەلگۆریزمی گەورەترینی سێ ژمارە بەم شێوەیە دەنووسن. ڕاست دەردەکەوێت و بۆ 7، ⁦12⁩، 9 کار دەکات. پێش ئەوەی بەردەوام بیت، بە 5، 5، 3 بەدوایدا بچۆ.

The comparisons use >, so when the two biggest numbers are equal, neither of them wins and the algorithm falls through to c. Fix it with >= in both tests, or use the “largest so far” version from the flowchart, which handles ties naturally. This is exactly why we trace with unusual inputs.

بەراوردەکان > بەکار دەهێنن، بۆیە کاتێک دوو گەورەترین ژمارەکە یەکسان بن، هیچیان نابەنەوە و ئەلگۆریزمەکە دەگاتە c. بە >= لە هەردوو پشکنینەکەدا چاکی بکە، یان وەشانی «گەورەترینی تا ئێستا»ی ناو هێڵکاریی ڕەوتەکە بەکار بهێنە کە بە سروشتی ژمارەی یەکسان چارەسەر دەکات. ڕێک بۆ ئەمە بە نێوخستەی نائاسایی بەدوای ئەلگۆریزمدا دەچین.

A travel app adds the times of two bus trips. Its first algorithm added the hours and the minutes separately. Tested with 2 h 20 min + 1 h 30 min, it gave 3 h 50 min — correct. But for 1 h 15 min + 1 h 50 min it gave 2 h 65 min, and no clock shows 65 minutes. One test case was enough to break it. The highlighted lines fix it:

ئەپێکی (App) گەشت کاتی دوو گەشتی پاس کۆ دەکاتەوە. یەکەم ئەلگۆریزمەکەی کاتژمێرەکان و خولەکەکانی بە جیا کۆ دەکردەوە. بە 2 کاتژمێر و ⁦20⁩ خولەک لەگەڵ 1 کاتژمێر و ⁦30⁩ خولەک تاقی کرایەوە و 3 کاتژمێر و ⁦50⁩ خولەکی دا، کە دروستە. بەڵام بۆ 1 کاتژمێر و ⁦15⁩ خولەک لەگەڵ 1 کاتژمێر و ⁦50⁩ خولەک وەڵامەکەی 2 کاتژمێر و ⁦65⁩ خولەک بوو و هیچ کاتژمێرێک ⁦65⁩ خولەک پیشان نادات. یەک حاڵەتی تاقیکردنەوە بەس بوو بۆ شکاندنی. دێڕە ڕەنگکراوەکان چاکی دەکەن:

Now 1 h 15 min + 1 h 50 min gives 3 h 5 min. Test the border too: 0 h 45 min + 0 h 15 min must give exactly 1 h 0 min, which is why the test is minutes ≥ 60. One IF is enough: each input has fewer than 60 minutes, so their sum is at most 118.

ئێستا 1 کاتژمێر و ⁦15⁩ خولەک لەگەڵ 1 کاتژمێر و ⁦50⁩ خولەک دەدات 3 کاتژمێر و 5 خولەک. سنوورەکەش تاقی بکەرەوە: 0 کاتژمێر و ⁦45⁩ خولەک لەگەڵ 0 کاتژمێر و ⁦15⁩ خولەک دەبێت ڕێک 1 کاتژمێر و 0 خولەک بدات؛ بۆیە پشکنینەکە minutes ≥ 60ـە. یەک IF بەسە: هەر نێوخستەیەک کەمتر لە ⁦60⁩ خولەکی هەیە، بۆیە کۆکەیان لە ⁦118⁩ زیاتر نابێت.

This algorithm adds repetition. Two variables do the work: total adds up the marks (an accumulator) and count counts how many marks have been read (a counter). Both must start at 0. The loop repeats while count < 5; after the fifth mark the condition is false and the algorithm leaves the loop.

ئەم ئەلگۆریزمە دووبارەکردنەوە زیاد دەکات. دوو گۆڕاو کارەکە دەکەن: total نمرەکان کۆ دەکاتەوە (گۆڕاوی کۆکردنەوە (Accumulator)) و count دەژمێرێت چەند نمرە وەرگیراوە (ژمێرەر (Counter)). هەردووکیان دەبێت بە 0 دەست پێ بکەن. خولەکە دووبارە دەبێتەوە مادام count < 5؛ دوای نمرەی پێنجەم مەرجەکە هەڵە دەبێت و ئەلگۆریزمەکە لە خولەکە دەردەچێت.

Watch the same flowchart run with the marks 8, 6, 10, 7 and 9. The highlighted shape is the step running now, and the box on the right shows the variables after that step.

سەیر بکە هەمان هێڵکاریی ڕەوت بە نمرەکانی 8، 6، ⁦10⁩، 7 و 9 جێبەجێ دەبێت. شێوە ڕەنگکراوەکە ئەو هەنگاوەیە کە ئێستا جێبەجێ دەبێت و چوارگۆشەکەی لای ڕاست گۆڕاوەکان دوای ئەو هەنگاوە پیشان دەدات.

A problem often has more than one correct algorithm. Which one should you use? Take the question “Is n prime?”. A prime number is a whole number above 1 that only 1 and itself divide exactly. Here are four correct methods. Each tries divisors in order and answers “not prime” as soon as one divides n exactly; if none does, n is prime.

کێشەیەک زۆرجار زیاتر لە یەک ئەلگۆریزمی دروستی هەیە. کامیان بەکار بهێنیت؟ پرسیاری «ئایا n سەرەتاییە؟» وەربگرە. ژمارەی سەرەتایی ژمارەیەکی تەواوە (Integer) لە سەرووی 1 کە تەنها 1 و خودی خۆی بە تەواوی دابەشی دەکەن. ئەمە چوار ڕێگای دروستە. هەر یەکەیان دابەشکەرەکان بە ڕیز تاقی دەکاتەوە و هەر کە یەکێکیان n بە تەواوی دابەش بکات، وەڵام دەداتەوە «سەرەتایی نییە»؛ ئەگەر هیچیان نەیکرد، n سەرەتاییە.

All four give the same answer. For 97 they do 95, 47, 8 and 24 divisions: 97 is prime, so nothing divides it and every method must try its whole list. This is the worst case. For 91 every method stops at 7, because $91 = 7 \times 13$.

هەر چواریان هەمان وەڵام دەدەن. بۆ ⁦97⁩ بە ڕیز ⁦95⁩، ⁦47⁩، 8 و ⁦24⁩ دابەشکردن دەکەن: ⁦97⁩ سەرەتاییە، بۆیە هیچ ژمارەیەک دابەشی ناکات و هەر ڕێگایەک دەبێت هەموو لیستەکەی تاقی بکاتەوە. ئەمە خراپترین بارە (Worst case). بۆ ⁦91⁩ هەموو ڕێگاکان لە 7دا دەوەستن، چونکە $91 = 7 \times 13$.

Method 3 is the fastest of the four, and the gap grows with n: for 1009 it does 30 divisions instead of 1007. Method 4 does fewer divisions than methods 1 and 2, but its list of primes must first be stored in memory. Combine methods 3 and 4 — divide only by the stored primes up to $\sqrt{97}$, that is 2, 3, 5 and 7 — and 4 divisions are enough.

ڕێگای 3 خێراترینی هەر چوارەکەیە و جیاوازییەکە لەگەڵ گەورەبوونی n زیاد دەبێت: بۆ ⁦1009⁩ لە جیاتی ⁦1007⁩ دابەشکردن تەنها ⁦30⁩ دەکات. ڕێگای 4 لە ڕێگاکانی 1 و 2 دابەشکردنی کەمترە، بەڵام دەبێت سەرەتا لیستی ژمارە سەرەتاییەکان لە بیرگەدا هەڵبگیرێت. ڕێگاکانی 3 و 4 تێکەڵ بکە، واتە تەنها بەسەر ئەو ژمارە سەرەتاییە هەڵگیراوانەدا دابەش بکە کە تا $\sqrt{97}$ن (⁦2⁩، 3، 5 و ⁦7⁩)، ئەوسا 4 دابەشکردن بەسە.

So algorithms are compared in two ways: how the number of steps grows as the input grows — time complexity — and how much memory they need — space complexity. Often you can buy speed with memory, as method 4 does, or save memory by doing more work. The artificial-intelligence course measures both exactly with Big-O notation: Time and space complexity.

بۆیە ئەلگۆریزمەکان بە دوو ڕێگا بەراورد دەکرێن: ژمارەی هەنگاوەکان چۆن لەگەڵ گەورەبوونی نێوخستەدا زیاد دەبێت (ئاڵۆزیی کات (Time complexity)) و چەند بیرگەیان پێویستە (ئاڵۆزیی بیرگە (Space complexity)). زۆرجار دەتوانیت خێرایی بە بیرگە بکڕیت، وەک ڕێگای 4، یان بە کاری زیاتر بیرگە پاشەکەوت بکەیت. کۆرسی ژیریی دەستکرد هەردووکیان بە وردی بە نیشانەی ⁦Big-O⁩ دەپێوێت: ئاڵۆزیی کات و ئاڵۆزیی بیرگە.

For a mini project, the course used a simple plan in five parts. A first-year group followed it to build a binary-to-decimal converter, and you can use it for any program:

بۆ پڕۆژیلەیەک، کۆرسەکە پلانێکی سادەی پێنج بەشی بەکار هێنا. گرووپێکی قۆناغی یەکەم بۆ دروستکردنی گۆڕەرێکی دووانی (Binary) بۆ دەیی (Decimal) پەیڕەوی کرد و تۆش دەتوانیت بۆ هەر بەرنامەیەک بەکاری بهێنیت:

The scenario makes sure you solve the right problem. The flowchart and the algorithm let you find mistakes on paper, where fixing them is cheap. The examples prove the program works — and when one fails, you go back to the plan, not only to the code. The group's Kurdish report gave the parts Kurdish names, shown in the Kurdish version of this screen.

نەخشەنامە دڵنیات دەکاتەوە کە کێشە دروستەکە چارەسەر دەکەیت. هێڵکاریی ڕەوت و ئەلگۆریزم ڕێگەت پێ دەدەن هەڵەکان لەسەر کاغەز بدۆزیتەوە، کە چاککردنیان هەرزانە. نموونەکان دەیسەلمێنن کە بەرنامەکە کار دەکات و کاتێک یەکێکیان سەرنەکەوت، دەگەڕێیتەوە بۆ پلانەکە، نەک تەنها بۆ کۆدەکە. ڕاپۆرتە کوردییەکەی گرووپەکە ئەم ناوانەی بۆ بەشەکان بەکار هێنا: نەخشەنامە، «هێڵکاریی داڕژانی دراوەکان» (بۆ هێڵکاریی ڕەوت)، «هەنگاونامە» (بۆ ئەلگۆریزم)، «کۆدەکانی بەرنامەکە» و «چەند نموونەیەکی بەرنامەکە».

1. Scenario. The driver types the distance of the trip in kilometres. The program shows the fare: a starting fee of 2000 dinars plus 500 dinars per kilometre. If the distance is 0 or less, it says “Try again” and asks again.

1. نەخشەنامە. شۆفێرەکە دووریی گەشتەکە بە کیلۆمەتر دەنووسێت. بەرنامەکە کرێکە پیشان دەدات: ⁦2000⁩ دینار کرێی دەستپێک لەگەڵ ⁦500⁩ دینار بۆ هەر کیلۆمەترێک. ئەگەر دوورییەکە 0 یان کەمتر بوو، دەڵێت «⁦Try again⁩» و دووبارە دەپرسێتەوە.

4. Code. Each language track writes these eight lines in its own language — for example in the Python track.

4. کۆد. هەر ڕێڕەوێکی زمان ئەم هەشت دێڕە بە زمانی خۆی دەنووسێت، بۆ نموونە لە ڕێڕەوی Pythonـدا.

Some problems are too big to plan in one go: a whole app, a school event, a weather forecast. Break such a problem into sub-problems, and each sub-problem into smaller ones, until every piece is small enough for one short algorithm. Then put the pieces together. Here is a course-registration app broken down:

هەندێک کێشە ئەوەندە گەورەن کە بە یەک جار پلانیان بۆ دانانرێت: ئەپێکی تەواو، چالاکییەکی قوتابخانە، پێشبینیی کەشوهەوا. کێشەیەکی وەها بکە بە چەند کێشەیەکی بچووکتر و هەر یەکەشیان بکە بە بچووکتر، تا هەر پارچەیەک ئەوەندە بچووک دەبێت کە یەک ئەلگۆریزمی کورت بەسی بێت. پاشان پارچەکان پێکەوە دابنێ. ئەمە ئەپێکی ناونووسینی وانەکانە کە پارچە کراوە:

In code, each small piece usually becomes a function with one job; in the Python track see Small pieces, one job each. In a flowchart, a piece that is planned somewhere else is drawn as a predefined-process box.

لە کۆددا هەر پارچەیەکی بچووک زۆرجار دەبێت بە کردارێک (Function) کە یەک کاری هەیە؛ لە ڕێڕەوی Pythonـدا بڕوانە پارچەی بچووک، هەریەکە بۆ یەک کار. لە هێڵکارییەکی ڕەوتدا، پارچەیەک کە لە شوێنێکی تر پلانی بۆ دانراوە وەک چوارگۆشەی پرۆسەی ئامادە دەکێشرێت.

You can work through the pieces in two directions:

دەتوانیت بە دوو ئاراستە کار لەسەر پارچەکان بکەیت:

Real projects usually mix both. Either way, give every piece one clear job, a clear input and a clear output, so that the pieces fit together like bricks in a wall.

پڕۆژە ڕاستەقینەکان زۆرجار هەردووکیان تێکەڵ دەکەن. بە هەر ڕێگایەک بێت، یەک کاری ڕوون، نێوخستەیەکی ڕوون و دەرخستەیەکی ڕوون بدە بە هەر پارچەیەک، بۆ ئەوەی پارچەکان وەک خشت لە دیوارێکدا پێکەوە بگونجێن.

Decomposition also lets a team share the work: different people or groups take different sub-problems, ideally the ones they know best. Each piece is first tested on its own, then the pieces are joined and tested together — the unit and integration levels of testing. Big jobs such as a school’s open day, a delivery service or a weather forecast are organised this way.

پارچەکردن هەروەها ڕێگە بە تیمێک دەدات کارەکە دابەش بکات: کەس یان گرووپی جیاواز کێشە بچووکە جیاوازەکان وەردەگرن، باشتر وایە ئەوانەی کە باشتر دەیانناسن. سەرەتا هەر پارچەیەک بە تەنها تاقی دەکرێتەوە، پاشان پارچەکان پێکەوە دەبەسترێن و پێکەوە تاقی دەکرێنەوە: ئاستەکانی تاقیکردنەوەی یەکە (Unit test) و تاقیکردنەوەی پێکەوەبەستن (Integration testing) لە تاقیکردنەوە لە چوار ئاستدا. کاری گەورەی وەک ڕۆژی کراوەی قوتابخانەیەک، خزمەتگوزاریی گەیاندن یان پێشبینیی کەشوهەوا بەم شێوەیە ڕێک دەخرێن.