What's an algorithm? - David J. Malan

המוח שלכם יכול לפתור אלגוריתמים - דייויד מלן

Translator: Andrea McDonough Reviewer: Jessica Ruby

תרגום: Ido Dekkers עריכה: eviatar edlerman

What's an algorithm?

מה הוא אלגוריתם?

In computer science,

במדעי המחשב,

an algorithm is a set of instructions

אלגוריתם הוא סט של הוראות

for solving some problem, step-by-step.

לפתירת בעיה, שלב אחרי שלב.

Typically, algorithms are executed by computers,

בדרך כלל, אלגוריתמים מופעלים על מחשבים,

but we humans have algorithms as well.

אבל לנו האנשים יש גם אלגוריתמים.

For instance, how would you go about counting

לדוגמה, איך הייתם סופרים

the number of people in a room?

את מספר האנשים בחדר?

Well, if you're like me,

ובכן, אם הייתם כמוני,

you probably point at each person,

אתם כנראה הייתם מצביעים על כל אדם,

one at a time,

אחד אחרי השני,

and count up from 0:

וסופרים מ 0:

1, 2, 3, 4 and so forth.

1,2,3,4 וכך הלאה.

Well, that's an algorithm.

ובכן, זה אלגוריתם.

In fact, let's try to express it

למעשה, בואו ננסה לבטא אותו

a bit more formally in pseudocode,

בצורה קצת יותר פורמלית בפסואודו קוד,

English-like syntax

that resembles a programming language.

בדומה לשפת דיבור

שמדמה שפת תכנות.

Let n equal 0.

ניצור n ששווה ל 0.

For each person in room, set n = n + 1.

לכל אדם בחדר, נציב n=n+1.

How to interpret this pseudocode?

איך נתרגם את זה בפסואודו קוד?

Well, line 1 declares, so to speak,

ובכן, שורה 1 מגדירה אפשר להגיד,

a variable called n

משתנה שנקרא n

and initializes its value to zero.

ומאתחלת אותו עם הערך 0.

This just means that at the beginning of our algorithm,

זה רק אומר שבהתחלה של האלגוריתם שלנו,

the thing with which we're counting

הדבר שאיתו אנחנו סופרים

has a value of zero.

יש לו ערך של 0.

After all, before we start counting,

אחרי הכל, לפני שהתחלנו לספור,

we haven't counted anything yet.

לא ספרנו כלום עדיין.

Calling this variable n is just a convention.

לקרוא למשתנה הזה n זו פשוט מוסכמה.

I could have called it almost anything.

הייתי יכול לקרוא לו כמעט בכל שם.

Now, line 2 demarks the start of loop,

עכשיו, שורה 2 מסמנת את תחילתה של הלולאה,

a sequence of steps that will repeat some number of times.

רצף של צעדים שיחזרו מספר פעמים.

So, in our example, the step we're taking

אז, בדוגמה שלנו, הצעד שאנחנו עושים

is counting people in the room.

הוא לספור אנשים בחדר.

Beneath line 2 is line 3,

מתחת לשורה 2 בשורה 3,

which describes exactly how we'll go about counting.

שמתארת בדיוק איך אנחנו נספור.

The indentation implies that it's line 3

ההזחה מציינת שזו שורה 3

that will repeat.

שתחזור על עצמה.

So, what the pseudocode is saying

אז, מה שהפסואודו קוד אומר

is that after starting at zero,

זה שאחרי שמתחילים באפס,

for each person in the room,

לכל אדם בחדר,

we'll increase n by 1.

אנחנו נגדיל את n ב 1.

Now, is this algorithm correct?

עכשיו, האם האלגוריתם נכון?

Well, let's bang on it a bit.

ובכן, בואו נחשוב על זה קצת.

Does it work if there are 2 people in the room?

האם זה עובד אם יש שני אנשים בחדר?

Let's see.

בואו נראה.

In line 1, we initialize n to zero.

בשורה 1, אנחנו מאתחלים את n באפס.

For each of these two people,

לכל אחד משני האנשים האלה,

we then increment n by 1.

אנחנו נגדיל את n ב 1.

So, in the first trip through the loop,

אז, במעבר הראשון בלולאה,

we update n from zero to 1,

אנחנו מעדכנים את n מ 0 ל 1,

on the second trip through that same loop,

במעבר השני באותה לולאה,

we update n from 1 to 2.

אנחנו מעדכנים את n מ 1 ל 2.

And so, by this algorithm's end, n is 2,

וכך, בסיום האלגוריתם, n הוא 2,

which indeed matches the number of people in the room.

שבאמת תואם את מספר האנשים בחדר.

So far, so good.

עד עכשיו, הכל טוב.

How about a corner case, though?

אבל מה עם מקרי קצה?

Suppose that there are zero people in the room,

נניח שיש אפס אנשים בחדר,

besides me, who's doing the counting.

חוץ ממני, שסופר.

In line 1, we again initialize n to zero.

בשורה 1 אנחנו מאתחלים את n לאפס.

This time, though, line 3 doesn't execute at all

הפעם, עם זאת, שורה 3 לא מתבצעת בכלל

since there isn't a person in the room,

מאחר ואין אנשים בחדר,

and so, n remains zero,

וכך, n נשאר אפס,

which indeed matches the number of people in the room.

שזו באמת תואם למספר האנשים בחדר.

Pretty simple, right?

די פשוט, נכון?

But counting people one a time is pretty inefficient, too, no?

אבל לספור אנשים אחד אחד זה די לא יעיל, נכון?

Surely, we can do better!

בטוח שאפשר להצליח יותר!

Why not count two people at a time?

למה לא לספור שני אנשים כל פעם?

Instead of counting 1, 2, 3, 4, 5, 6, 7, 8, and so forth,

במקום לספור 1,2,3,4,5,6,7,8 וכך הלאה,

why not count

למה לא לספור

2, 4, 6, 8, and so on?

2,4,6,8 וכך הלאה?

It even sounds faster, and it surely is.

זה אפילו נשמע מהיר יותר, וזה בטוח כך.

Let's express this optimization in pseudocode.

בואו נבטא את הטיוב הזה בפסואודו קוד

Let n equal zero.

נצהיר על n שווה אפס.

For each pair of people in room,

לכל זוג אנשים בחדר,

set n = n + 2.

נציב n=n+2.

Pretty simple change, right?

שינוי די פשוט, נכון?

Rather than count people one at a time,

במקום לספור אנשים אחד אחד,

we instead count them two at a time.

אנחנו סופרים במקום שניים כל פעם.

This algorithm's thus twice as fast as the last.

האלגוריתם הזה מהיר לכן פי שניים מהקודם.

But is it correct?

אבל האם הוא נכון?

Let's see.

בואו נראה.

Does it work if there are 2 people in the room?

האם זה עובד כשיש שני אנשים בחדר?

In line 1, we initialize n to zero.

בשורה 1, אנחנו מאתחלים את n ל 0.

For that one pair of people, we then increment n by 2.

לזוג האנשים הזה, אנחנו מגדילים את n ב 2.

And so, by this algorithm's end, n is 2,

וכך, בסוף האלגוריתם הזה, n הוא 2,

which indeed matches the number of people in the room.

שזו באמת מתאים למספר האנשים בחדר.

Suppose next that there are zero people in the room.

נניח אז שיש אפס אנשים בחדר.

In line 1, we initialize n to zero.

בשורה 1, אנחנו מאתחלים את n לאפס.

As before, line 3 doesn't execute at all

כמו קודם, שורה 3 לא מתבצעת בכלל

since there aren't any pairs of people in the room,

מאחר ואין זוגות אנשים בחדר,

and so, n remains zero,

וכך, n נשאר אפס,

which indeed matches the number of people in the room.

שבאמת תואם את מספר האנשים בחדר.

But what if there are 3 people in the room?

אבל מה אם היו 3 אנשים בחדר?

How does this algorithm fair?

איך האלגוריתם הזה מצליח?

Let's see.

בואו נראה.

In line 1, we initialize n to zero.

בשורה 1 מאתחלים את n לאפס.

For a pair of those people,

לזוג מהאנשים האלה,

we then increment n by 2,

אנחנו מעלים את n ב 2,

but then what?

אבל אז מה?

There isn't another full pair of people in the room,

אין עוד זוג מלא של אנשים בחדר,

so line 2 no longer applies.

אז שורה 2 לא רלוונטית יותר.

And so, by this algorithm's end,

וכך, בסופו אל האלגוריתם הזה,

n is still 2, which isn't correct.

n הוא עדיין 2, מה שלא נכון.

Indeed this algorithm is said to be buggy

באמת האלגוריתם הזה לא תקין

because it has a mistake.

מפני שיש לו שגיאה.

Let's redress with some new pseudocode.

בואו נתקן עם פסואודו קוד נוסף.

Let n equal zero.

נצהיר על n שווה לאפס.

For each pair of people in room,

לכל זוג של אנשים בחדר,

set n = n + 2.

נציב n=n+2

If 1 person remains unpaired,

אם אדם אחד נשאר ללא זוג,

set n = n + 1.

נציב n=n+1.

To solve this particular problem,

כדי לפתור את הבעיה הזו,

we've introduced in line 4 a condition,

אנחנו מציגים בשורה 4 תנאי,

otherwise known as a branch,

שידוע אחרת כענף,

that only executes if there is one person

שמבוצע רק אם יש אדם אחד

we could not pair with another.

שאי אפשר לחבר לאחר.

So now, whether there's 1 or 3

אז עכשיו, בין אם יש 1 או 3

or any odd number of people in the room,

או כל מספר אי זוגי של אנשים בחדר,

this algorithm will now count them.

האלגוריתם הזה יספור אותם עכשיו.

Can we do even better?

האם אנחנו יכולים להצליח יותר?

Well, we could count in 3's or 4's or even 5's and 10's,

ובכן, אנחנו יכולים לספור בקפיצות של 3, 4 או אפילו 5 ו 10,

but beyond that it's going to get

אבל מעבר לזה זה יעשה

a little bit difficult to point.

מעט קשה יותר להצביע.

At the end of the day,

בסופו של יום,

whether executed by computers or humans,

בין אם יופעל על ידי מחשב או אדם,

algorithms are just a set of instructions

אלגוריתמים הם רק סט של הוראות

with which to solve problems.

איתם ניתן לפתור את הבעיות.

These were just three.

אלה היו רק שלושה.

What problem would you solve with an algorithm?

איזה בעיה אתם הייתם פותרים עם אלגוריתם?