Loops Programming, Data Structures and Algorithms English Malayalam

LoopsYouTube↗ IA↗(long shot)
People & Blogs 2K views 6 likes 0 dislikes 30 Jan 2018

Programming, Data Structures and Algorithms 451 subscribers N/A YouTube↗

So, in module 3, we will look at reparative statements.

മൊഡ്യൂൾ (module) 3 ൽ, നമുക്ക് റെപ്റ്റിറ്റിവ് സ്റ്റേറ്റ്മെന്റുകൾ (repetitive statement) നോക്കും. ഇത് വരെ ഇഫ് (if) ഉം സ്വിച്ചും (switch) ഉപയോഗിച്ചുള്ള

So far we have seen conditional statements both if and select using switch statements.

കണ്ടീഷണൽ (conditional statement) സ്റ്റേറ്റ്‌മെന്റുകൾ ആണ് നമ്മൾ കണ്ടത്. ഇനി റെപ്റ്റിറ്റിവ് സ്റ്റേറ്റ്മെന്റുകൾ നോക്കാം (repetitive statement).

We will look at repetitive statements.

റെപ്റ്റിറ്റിവ് സ്റ്റേറ്റ്മെന്റുകളെ

So, repetitive statements are also called loops.

(Repetitive statement) ലൂപ്പുകൾ എന്നും വിളിക്കുന്നു.

It forms a very important class of statements, because you get to iterate or repeat over

ഇത് വളരെ പ്രധാനപ്പെട്ട ഒരു സ്റ്റേറ്റ്മെന്റ്

a set of operations. This is useful in lots of algorithms and it is a very basic construct.

(statement) ആണ്, കാരണം നിങ്ങൾ ഒരു കൂട്ടം പ്രവർത്തനങ്ങൾ

So, C offers three different kinds of repetitive statements namely for statement, the while

ആവർത്തിക്കുകയാണ് ചെയ്യുന്നത്. ഇത് ധാരാളം അൽ‌ഗോരിതങ്ങളിൽ (algorithm) ഉപയോഗപ്രദമാണ്,

statement and the do while statement.

മാത്രമല്ല ഇത് വളരെ അടിസ്ഥാനപരമായ ഒരു

We will see each one of them and see motivating examples for each one of them.

നിർമ്മിതിയാണ്. സി (C) യിൽ മൂന്ന് വ്യത്യസ്ത

So, in any loop construct, no matter what language you pick, there are two different

തരത്തിലുള്ള റെപ്റ്റിറ്റിവ് സ്റ്റെമെന്റുകൾ (Repetitive statement) ഉണ്ട്. ഫോർ സ്റ്റേറ്റ്മെന്റ്

kinds of loops that you can run. You can either have them counter controlled or what is called sentinel controlled. So, in counter controlled, what you have is you have a set of operations and you want to repeat that a certain number of times.

(for statement), വയിൽ സ്റ്റേറ്റ്മെന്റ് (while statement), ഡു വയിൽ സ്റ്റേറ്റ്മെന്റ് (do while statement). നമ്മൾ ഓരോന്നും അതിനുള്ള ഉദാഹരണങ്ങളും

And this number of times, you have to repeat; it is already known to you.

കാണും. നിങ്ങൾ ഏത് ഭാഷ തിരഞ്ഞെടുത്താലും, നിങ്ങൾക്ക് പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന രണ്ട് വ്യത്യസ്ത തരം ലൂപ്പുകൾ ഉണ്ട്.

Whereas, in sentinel controlled, you keep looping until a certain condition is met.

അവയെ കൗണ്ടർ കോൺട്രോൾഡ് (counter controlled) അല്ലെങ്കിൽ

So, for example, you may wait till the user inputs minus 1 and you want to do a repeated

സെന്റിനൽ കോൺട്രോൾഡ് (sentinel controlled) എന്ന് വിളിക്കാം. കൗണ്ടർ കൺ‌ട്രോൾഡിൽ (counter controlled), ഒരു കൂട്ടം

set of actions till the user inputs minus 1; maybe you want to find the factors of a

ഓപ്പറേഷനുകളുണ്ട് (operation) അത് ഒരു നിശ്ചിത തവണ ആവർത്തിക്കാൻ‌ താൽ‌പ്പര്യപ്പെടുന്നു.

number; but, the user could keep on giving these numbers.

എത്ര തവണ ആവർത്തിക്കണം എന്നത് നിങ്ങൾക്ക്

At some point of time, if the user inputs minus 1, you want to stop the program.

നേരത്തെ അറിയാം. അതേസമയം, സെന്റിനൽ കോൺട്രോൾഡിൽ (sentinel controlled), ഒരു നിശ്ചിത

So, if you want something like that, upfront you do not know how many inputs the user is

കണ്ടീഷൻ (condition) പാലിക്കുന്നതുവരെ നിങ്ങൾ ലൂപ്പ് (loop)

going to give. In such cases, the sentinel controlled structures are useful.

ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഉപയോക്താവ് -1 ഇൻപുട്ട് (input) ചെയ്യുന്നത് വരെ നിങ്ങൾക്ക് കാത്തിരിക്കാം,

And this structure is usually used when the number of iterations is dependent on the input

കൂടാതെ ഉപയോക്താവ് -1 ഇൻപുട്ട് (input) ചെയ്യുന്നത് വരെ ആവർത്തിച്ചുള്ള ഒരു കൂട്ടം ഓപ്പറേഷനുകൾ

and not on the problem being solved.

(operation) ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു;

So, let us start with the first one namely, the ‘for loops’.

ഒരു സംഖ്യയുടെ ഘടകങ്ങൾ കണ്ടെത്തുക എന്നതാവാം;

So, for loops is actually the…

പക്ഷേ, ഉപയോക്താവിന് ഈ നമ്പറുകൾ (number) നൽകുന്നത്

For loop construct is a counter controlled repetition structure.

തുടരാം. ഉപയോക്താവ് -1 ഇൻപുട്ട് (input) ചെയ്യുകയാണെങ്കിൽ,

What you have is you start with an initial value of some counter and you modify the counter

നിങ്ങൾ പ്രോഗ്രാം (program) നിർത്താൻ ആഗ്രഹിക്കുന്നു. നിങ്ങൾക്ക് അത്തരത്തിലുള്ള എന്തെങ്കിലും വേണമെങ്കിൽ,

as we go along till you reach a final value.

ഉപയോക്താവ് എത്ര ഇൻപുട്ടുകൾ (input) നൽകാൻ

So, maybe I start with number 1; go in steps of 2.

പോകുന്നുവെന്ന് മുൻ‌കൂട്ടി അറിയില്ല. അത്തരം സന്ദർഭങ്ങളിൽ, സെന്റിനൽ കോൺട്രോൾഡ്

And let us I stop at 43; in that case, I would be using all the odd numbers.

(sentinel controlled) ഘടനകൾ ഉപയോഗപ്രദമാണ്. ആവർത്തനങ്ങളുടെ എണ്ണം ഇൻപുട്ടിനെ (input) ആശ്രയിച്ചിരിക്കുമ്പോഴും പരിഹരിക്കപ്പെടുന്ന പ്രശ്‌നത്തെ ആശ്രയിക്കാതിരിക്കുമ്പോഴും

So, I am going in steps of two from 1.

ഈ ഘടന സാധാരണയായി ഉപയോഗിക്കുന്നു.

So, I would go 1, 3, 5, 7 and so on up till 43.

അതിനാൽ, ആദ്യത്തേതിൽ നിന്ന് ആരംഭിക്കാം,

Or I may say just for 20 times print hello.

അതായത് ‘ ഫ്രോർ ലൂപ്പ് (for loop)’. ഫോർ ലൂപ്പ് (for loop)’.കൺസ്ട്രക്റ്റ് (construct) ഒരു കൗണ്ടർ കോൺട്രോൾഡ്

In that case, I would start the initial value at 1; the counter would go by increments of

(counter controlled) ആവർത്തന ഘടനയാണ്. കൗണ്ടർ

1 and it stops at 20.

(counter) ഒരു പ്രാരംഭ മൂല്യത്തിൽ നിന്ന്

So, this for loop – the way C does; it lets the programmers specify an initial value,

ആരംഭിക്കുകയും ഒരു അന്തിമ മൂല്യത്തിലെത്തുന്നതുവരെ കൗണ്ടർ (counter) പരിഷ്കരിക്കുകയും ചെയ്യുക എന്നതാണ് ഇത് ചെയ്യുന്നത്. അതിനാൽ, ഞാൻ നമ്പർ

a modification to the counter as well as a final value; and on top of that, it also lets

1 ൽ നിന്ന് ആരംഭിക്കാം; 2 വെച്ച് കൂട്ടുകയാണ് 43 എത്തുമ്പോൾ നിർത്താം; അങ്ങനെയാണെങ്കിൽ,

you put in a body or what you would really want to do so many times. Say let us look at the basic expression. You have a for loop and it starts… it works like this.

എല്ലാ ഒറ്റസംഖ്യകളുമാണ് ഉപയോഗിക്കുന്നത്. അതിനാൽ, ഞാൻ 1, 3, 5, 7 എന്നിങ്ങനെ 43 വരെ പോകും. അല്ലെങ്കിൽ 20 തവണ പ്രിന്റ് ഹലോ (print hello) എന്ന് ഞാൻ പറഞ്ഞേക്കാം.

So, you have for, which is a key word. And you have these two parenthesis and you have three expressions: expression 1, expression 2, and expression 3.

അങ്ങനെയാണെങ്കിൽ, ഞാൻ പ്രാരംഭ മൂല്യം 1 ന് ആരംഭിക്കും; കൗണ്ടർ (counter) 1 ന്റെ ഇൻ‌ക്രിമെന്റുകൾ (increment) വഴി പോകുകയും അത് 20 ൽ‌ നിർ‌ത്തുകയും

And the body of the loop goes inside this statement here. So, the meaning of this is you evaluate expression 1.

ചെയ്യും. അതിനാൽ‌, ഇത് ഫോർ ലൂപ്പ് (for loop) ചെയ്യുന്ന രീതി; ഇത് ഒരു പ്രാരംഭ മൂല്യം, കൗണ്ടറിലെ (counter) ഒരു പരിഷ്ക്കരണം,

So, the expression 1 is just the initialization.

അന്തിമ മൂല്യം എന്നിവ വ്യക്തമാക്കാൻ പ്രോഗ്രാമർമാരെ

And you repeat something.

(programmer) അനുവദിക്കുന്നു; അതിനുള്ളിൽ ആവർത്തിച്ചു

And what you repeat?

ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കാര്യങ്ങൾ കൊടുക്കാൻ

You evaluate expression 2.

സാധിക്കും.

If it is true, you execute statement; if it is false, you exit the loop. So, when you execute the statement, you check if the expression 2 is true; if it is true,

അടിസ്ഥാന എക്സ്പ്രഷൻ (expression) നമുക്ക് നോക്കാം. നിങ്ങൾക്ക് ഒരു ഫോർ ലൂപ്പ് ഉണ്ട്. അതിനായി ഉള്ള കീവേഡ് (keyword) ഫോർ (for) എന്നാണ് രണ്ട് പരാൻതീസിസ് (paranthesis) ഉണ്ട്, മൂന്ന് എക്സ്പ്രഷനുകളുണ്ട്

(expression): എക്സ്പ്രഷൻ (expression) 1, എക്സ്പ്രഷൻ

you execute the statement and evaluate expression 3.

(expression) 2, എക്സ്പ്രഷൻ (expression) 3. കൂടാതെ ലൂപ്പിന്റെ

If it is false, exit from the loop. Typically, the statement that you have is a block of code.

(loop) ബോഡി (body) ഈ സ്റ്റേമെന്റിനുള്ളിൽ (statement) പോകുന്നു. അതിനാൽ,

Therefore, usually, you have to put this within braces.

ഇതിന്റെ അർത്ഥം നിങ്ങൾ എക്സ്പ്രഷൻ (expression) 1 വിലയിരുത്തുക എന്നതാണ്. അതിനാൽ, എക്സ്പ്രഷൻ

So, you need braces here and here typically, because that makes a code block.

(expression) 1 എന്നത് ഇനിഷ്യലൈസേഷൻ (initialization) മാത്രമാണ്. നിങ്ങൾ എന്തെങ്കിലും ആവർത്തിക്കുന്നു. നിങ്ങൾ എന്താണ് ആവർത്തിക്കുന്നത്? നിങ്ങൾ എക്സ്പ്രഷൻ (expression) 2 വിലയിരുത്തുന്നു. ഇത് ശരിയാണെങ്കിൽ,

So, let us take this small example computing the sum of first 20 odd numbers.

നിങ്ങൾ സ്റ്റേറ്റ്മെന്റ് (statement) എക്സിക്യൂട്ട് ചെയ്യുന്നു; അത് തെറ്റാണെങ്കിൽ, നിങ്ങൾ

So, to do so what we are going to do is we are going to have a variable called sum, which

ലൂപ്പിൽ (loop) നിന്ന് പുറത്തുകടക്കുക. സ്റ്റേറ്റ്മെന്റ് (statement) എക്സിക്യൂട്ട്

is initialized to 0; and to that, we are going to add k repeatedly; and k is just going to

(execute) ചെയ്യുമ്പോൾ, എക്സ്പ്രഷൻ (expression) 2 ശരിയാണോ എന്ന് നിങ്ങൾ പരിശോധിക്കുന്നു; അത് ശരിയാണെങ്കിൽ, നിങ്ങൾ സ്റ്റേറ്റ്മെന്റ്

be a sequence of odd numbers starting at 1.

(statement) എക്സിക്യൂട്ട് ചെയ്യുകയും (execute) എക്സ്പ്രഷൻ

So, let us see the loop structure in place.

(expression) 3 വിലയിരുത്തുകയും ചെയ്യുക. ഇത് തെറ്റാണെങ്കിൽ,

If you notice the structure of the for loop, the for loop runs from i equals 1; i less

ലൂപ്പിൽ (loop) നിന്ന് പുറത്തുകടക്കുക. സാധാരണയായി, സ്റ്റേറ്റ്മെന്റ് (statement) കോഡിന്റെ (code)

than or equal to 20 i plus plus; which means this body that you are seeing here is going

ഒരു ബ്ലോക്കാണ് (block) . അതിനാൽ, സാധാരണയായി, നിങ്ങൾ ഇത് ബ്രേസുകളിൽ (brace)ഇടണം.

to be executed exactly 20 times.

ആദ്യത്തെ 20 ഒറ്റ സംഖ്യകളുടെ ആകെത്തുക കണക്കുകൂട്ടുന്ന

So, let us check what the overall structure of the program is. We set k to be the first odd number, which is 1; and i is the loop iterator or the loop

ഈ ചെറിയ ഉദാഹരണം നോക്കാം. ഇതിനായി സം (sum) എന്ന വേരിയബിൾ (variable) ഉണ്ട്, അത് 0 എന്ന് ഇനിഷ്യലൈസ് (initialize) ചെയ്യുന്നു; അതിലേക്ക്, നമ്മൾ ആവർത്തിച്ച് k കൂട്ടാൻ പോകുന്നു;

control variable; and i less than or equal to 20 is the termination condition.

k എന്നത് 1 മുതൽ ആരംഭിക്കുന്ന ഒറ്റ സംഖ്യകളുടെ

Since we are incrementing i in terms of 1 using i plus plus (i++) , this loop will run

ഒരു ശ്രേണിയായി മാറുന്നു. ഫോർ ലൂപ്പിന്റെ (for

exactly 20 times. And the body of the loop is in such a way that, k tracks the i-th odd number; the very

loop) ഘടന നിങ്ങൾ ശ്രദ്ധിച്ചാൽ, ഫോർ ലൂപ്പ് (for loop) i എന്നത് 1 ൽ നിന്ന് റൺ ചെയ്യുന്നു. എന്നാൽ

first iteration k is 1; and the second iteration – k is supposed to be 3 and so on.

നിങ്ങൾ ഇവിടെ കാണുന്ന ഈ ബോഡി (body) കൃത്യമായി

It tracks the i-th odd number and we are adding that to sum.

20 തവണ നടപ്പിലാക്കാൻ പോകുന്നു എന്നാണ്. അതിനാൽ, പ്രോഗ്രാമിന്റെ (program) മൊത്തത്തിലുള്ള

And we are incrementing k in increments of 2; which means from 1 we will go 3, 5, 7, 9 and so on.

ഘടന എന്താണെന്ന് നമുക്ക് പരിശോധിക്കാം. ആദ്യത്തെ ഒറ്റസംഖ്യയായി നമ്മൾ k എടുത്തു അത് 1 ആണ്; i ആണ് ലൂപ്പ് അയ്‌ട്രേറ്റർ (loop

And this is the whole setup. Let us say we want to mentally simulate this; so Initially, sum is 0 and

iterator) അല്ലെങ്കിൽ ലൂപ്പ് കൺട്രോൾ വേരിയബിൾ (loop control variable); 20-ൽ കുറവോ തുല്യമോ എന്നതാണ് ടെർമിനേഷൻ കണ്ടീഷൻ (termination condition) . I പ്ലസ്

k is 1. We start the loop; when we start the loop i equals 1 and we are going to check if i

പ്ലസ് (i ++) ഉപയോഗിച്ച് 1 ന്റെ അടിസ്ഥാനത്തിൽ

is less than or equal to 20; this is actually true. So, therefore, sum plus equal to k.

i വർദ്ധിപ്പിക്കുന്നതിനാൽ, ഈ ലൂപ്പ് (loop) കൃത്യമായി

So, this plus equal to is essentially a shortcut for sum equals sum plus k. So, sum is 0. Now, we are adding 1 to it.

20 തവണ പ്രവർത്തിക്കും. ലൂപ്പിന്റെ (loop) ബോഡി (body), i-th ഒറ്റ സംഖ്യ ട്രാക്കു (track) ചെയ്യുന്ന

So, sum becomes 1. And k – we are adding 2 to it.

രീതിയിലാണ്; ആദ്യത്തെ ആവർത്തനം k 1 ആണ്; രണ്ടാമത്തെ

So, k becomes 3.

ആവർത്തനം - k 3 ഉം മറ്റും ആയിരിക്കണം. ഇത്

At the end of it, we go and evaluate expression 3, which is i plus plus.

i-th ഒറ്റ സംഖ്യ ട്രാക്കുചെയ്യുന്നു, എന്നിട്ട് അത് സം

So, now, i becomes 2. So, this is one body of the loop.

(sum) ന്റെ കൂടെ കൂട്ടുന്നു നമ്മൾ 2 ന്റെ വർദ്ധനവിൽ

At this point, we again go and check is i less than or equal to 20 or what; it is true.

k വർദ്ധിപ്പിക്കുകയാണ്; അതായത് 1 മുതൽ 3, 5, 7,

So, now, we add sum plus equal to k.

9 എന്നിങ്ങനെ പോകും. ഇതാണ് മുഴുവൻ സജ്ജീകരണം.

So, we add 1 and 3; sum becomes 4 and k is incremented by 2.

നമുക്ക് ഇത് മനസ്സിൽ ചെയ്തു നോക്കാം. അതിനാൽ തുടക്കത്തിൽ, സം (sum) 0 ഉം k 1 ഉം ആണ്.

So, k becomes 5.

നമ്മൾ ലൂപ്പ് (loop) ആരംഭിക്കുന്നു; നമ്മൾ

And finally, at the end of this iteration, i becomes 2 and so on.

ലൂപ്പ് (loop) ആരംഭിക്കുമ്പോൾ i 1 ന് തുല്യമാണ്, ഞാൻ

So, essentially, what we are doing is we are incrementing i and we will do this exactly

i 20 ൽ കുറവോ തുല്യമോ ആണോ എന്ന് പരിശോധിക്കാൻ പോകുന്നു; ഇത് യഥാർത്ഥത്തിൽ ശരിയാണ്. അതിനാൽ,

20 times. So, we will go from number 1, 3, 5, 7 and so on 20 times. So, it is a fairly simple program.

സം (sum) ന്റെ കൂടെ k കൂട്ടുന്നു. ‘+=’ sum=sum+k എന്നതിന്റെ ഒരു കുറുക്കുവഴിയാണ്. ആദ്യം തുക 0 ആണ്. ഇപ്പോൾ

But, it shows you the basic structure of a ‘for loop’.

നമ്മൾ ഇതിലേക്ക് 1 ചേർക്കുന്നു. അതിനാൽ,

So, let us take a small detour and look at what are the different kinds of operators

തുക 1 ആയി മാറുന്നു. K യുടെ കൂടെ 2 കൂട്ടുമ്പോൾ

that you can use. We already saw equal to equal to in an earlier lecture.

k 3 ആയി മാറുന്നു. അതിന്റെ അവസാനം, നമ്മൾ എക്സ്പ്രഷൻ

We also saw greater than in the lecture, where we are looking at a largest of the numbers

(expression) 3 വിലയിരുത്തുന്നു, അത് i++ ആണ്. അതിനാൽ,

and so on. There are other operators namely, not equal to or less than or equal to, greater than, and so on.

i ഇപ്പോൾ 2 ആയി മാറുന്നു.ഇത് ലൂപ്പിന്റെ (loop) ഒരു ബോഡിയാണ് (body). ഈ സമയത്ത്, നമ്മൾ വീണ്ടും പരിശോധിക്കുന്നത്

So, these are the six operators that you can use on numbers. So, you can use them on both integers and floating point numbers. But, more importantly, we also need to understand this notion of what are called logical operators.

i 20 ൽ കുറവോ തുല്യമോ ആണോ എന്നാണ്; ഇത് സത്യമാണ്. അതിനാൽ, ഇപ്പോൾ, സം ന്റെ കൂടെ k കൂട്ടുന്നു. അതിനാൽ, 1 ഉം 3 ഉം കൂട്ടുന്നു;

So, in all these things that we have seen so far, we have only one condition for the

സം 4 ആയി, k യുടെ കൂടെ 2 കൂട്ടുമ്പോൾ k 5 ആയി

expression that we are evaluating.

മാറുന്നു. ഒടുവിൽ, ഈ ആവർത്തനത്തിന്റെ

Sometimes we need more than a few conditions.

അവസാനത്തിൽ i 2 ആയി മാറുന്നു. അതിനാൽ,

So, let us look at this example; where, let us say if age is less than equal to 45 and

അടിസ്ഥാനപരമായി, നമ്മൾ ചെയ്യുന്നത് i വർദ്ധിപ്പിക്കുകയാണ്, ഇത് കൃത്യമായി 20 തവണ

salary is greater than or equal to 5000, I want to do some work.

ചെയ്യും. അതിനാൽ, 1, 3, 5, 7 എന്നിങ്ങനെ

So, I want to combine this into one condition and you can do this using this operator called

20 തവണ പോകും. ഇത് വളരെ ലളിതമായ ഒരു പ്രോഗ്രാമാണ് (program). പക്ഷേ, ഇത് ഒരു ‘ഫോർ ലൂപ്പിന്റെ’

AND.

(for loop) അടിസ്ഥാന ഘടന കാണിക്കുന്നു.

The AND operator when you type, you type ampersand ampersand (&&) ; and be careful; it is twice;

നമുക്ക് ഒരു ചെറിയ വഴിമാറി, നിങ്ങൾക്ക്

it is not a mistake.

ഉപയോഗിക്കാൻ കഴിയുന്ന വ്യത്യസ്ത തരം ഓപ്പറേറ്ററുകൾ

We have to type ampersand twice.

(operator) എന്തൊക്കെയാണെന്ന് നോക്കാം. മുമ്പത്തെ

That is a logical AND operation.

ഒരു പ്രഭാഷണത്തിൽ == കണ്ടു. ഏറ്റവും

Sometimes I may need something like a logical OR condition; either condition a is true or

വലിയ സംഖ്യകളും മറ്റും നോക്കിയപ്പോൾ ‘>’ കണ്ടു. മറ്റു ഓപ്പറേറ്ററുകൾ (operator) ഉണ്ട് - !=, <=, >=. നമ്പറുകളിൽ

condition b is true; in which case, we want logical OR operation.

ഉപയോഗിക്കാൻ കഴിയുന്ന 6 ഓപ്പറേറ്ററുകളുണ്ട്

And you get that using what is called the pipe ( || ) operator.

(operator) . അവ പൂർണ്ണസംഖ്യകളിലും ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകളിലും ഉപയോഗിക്കാം.

So, you press… you have this pipe twice; you usually see this pipe on top of the back

എന്നാൽ, അതിലും പ്രധാനമായി, ലോജിക്കൽ ഓപ്പറേറ്ററുകൾ (logical operator) എന്ന് വിളിക്കപ്പെടുന്ന ഓപ്പറേറ്ററുകളുണ്ട്

slash symbol.

(operator). ഇതുവരെ നാം കണ്ട ഈ കാര്യങ്ങളിലെല്ലാം,

So, back slash symbol and pipe are in the same key usually.

നമ്മൾ വിലയിരുത്തുന്ന എക്സ്പ്രഷന് (expression)

And for example, if I want to see if a number is a multiple of 2 or a multiple of 3; then

ഒരു കണ്ടീഷൻ (condition) മാത്രമേയുള്ളൂ. ചിലപ്പോൾ നമുക്ക് കുറച്ച് നിബന്ധനകളിൽ കൂടുതൽ ആവശ്യമാണ്. നമുക്ക് ഈ ഉദാഹരണം നോക്കാം;

I could use this condition num percentage 2 equals 0; checks whether it is a multiple

ഇവിടെ, പ്രായം 45 ന് തുല്യവും ശമ്പളം

of 2; num percentage three equal to equal to 0 checks whether the number is a multiple

5000 നേക്കാൾ കൂടുതലോ തുല്യമോ ആണെങ്കിൽ നമുക്ക് കുറച്ച് കാര്യം ചെയ്യണം.

of 3. And by sticking in this OR operator in between, I am checking if a number is either a multiple

അതിനാൽ, ഇത് ഒരു നിബന്ധനയായി സംയോജിപ്പിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, AND എന്ന ഈ ഓപ്പറേറ്റർ

of 2 or a multiple of 3. So, this is a very useful thing; and we may use it in the next few lectures.

(operator)ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും. AND ഓപ്പറേറ്റർ (operator) നിങ്ങൾ ടൈപ്പു (type)

So, I want to give another example of a for loop.

ചെയ്യുമ്പോൾ, നിങ്ങൾ ആമ്പർസാൻഡ് ആമ്പർസാൻഡ് (&&); എന്ന് രണ്ടുതവണ കൊടുക്കാൻ ശ്രദ്ധിക്കുക.

Let us say I want to print the n-th triangular number.

നമ്മൾ രണ്ടുതവണ ആമ്പർസാൻഡ് (&) ടൈപ്പ് (type) ചെയ്യണം.

So, in the previous example, the number of iterations was actually known in the program itself. So, we had i equal to 1; i less than or equal to 20.

അതൊരു ലോജിക്കൽ ഓപ്പറേറ്ററാണ് (logical operator). ചിലപ്പോൾ എനിക്ക് ഒരു ലോജിക്കൽ ഓർ കണ്ടീഷൻ (logical OR condition)

So, I said whenever we will know the number of iterations, it is better to use a for loop.

പോലുള്ള എന്തെങ്കിലും ആവശ്യമായി വന്നേക്കാം; ഒന്നുകിൽ കണ്ടീഷൻ (condition) എ (A) ശരിയാണ്

But, I want to show an example here; where, we really do not know the number of iterations,

അല്ലെങ്കിൽ കണ്ടീഷൻ (condition) ബി (B)ശരിയാണ്; അത്തരം സാഹചര്യങ്ങളിൽ, നമുക്ക് ലോജിക്കൽ

because the user is going to input it.

ഓർ (logical OR) ആവശ്യമാണ്. പൈപ്പ് (||) ഓപ്പറേറ്റർ

But, we still know that, once the number of iterations – once the user gives n, the

(pipe operator) എന്ന് വിളിക്കുന്നത്. ഈ പൈപ്പ് (pipe) രണ്ടുതവണയുണ്ട്;

number of iterations is fixed. So, let us see this small example.

ബാക്ക് സ്ലാഷ് (backslash) ചിഹ്നത്തിന് മുകളിൽ

Find the n-th triangular number; a triangular number is defined as a sum of integers from

സാധാരണയായി ഈ പൈപ്പ് (pipe) കാണും. അതിനാൽ, ബാക്ക് സ്ലാഷ് (backslash) ചിഹ്നവും പൈപ്പും

1 to n. So, I am showing a small segment of a code here.

(pipe) സാധാരണയായി ഒരേ കീയിലാണ് (key). ഉദാഹരണത്തിന്,

Let us say i as before is the iterator and number is the number of the n-th triangular

ഒരു സംഖ്യ 2 ന്റെ ഗുണിതമാണോ അതോ 3 ന്റെ ഗുണിതമാണോ എന്ന് കാണാൻ ഞാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ;

number that the user is asking for; and sum is the result that we want to give to the

അപ്പോൾ എനിക്ക് ഈ കണ്ടീഷൻ (condition) ഉപയോഗിക്കാം.

user. So, we start with prompting the user what is that triangular number that you want; and

num%2==0 ഇത് 2 ന്റെ ഗുണിതമാണോ എന്ന് പരിശോധിക്കുന്നു; num%3 == 0 സംഖ്യ 3 ന്റെ ഗുണിതമാണോയെന്ന്

we are going to scan it from the user; we will start with sum equal to zero.

എന്ന് പരിശോധിക്കുന്നു. ഓർ (OR) ഉപയോഗിച്ച്

So, at this point, I want to run it as many times as the number that the user wanted.

ഒരു സംഖ്യ 2 ന്റെ ഗുണിതമോ 3 ന്റെ ഗുണിതമോ ആണോ

So, now, what we have is we have for i equals 1, i less than or equal to number i plus plus.

എന്ന് ഞാൻ പരിശോധിക്കുന്നു. അതിനാൽ, ഇത് വളരെ ഉപയോഗപ്രദമായ കാര്യമാണ് ; അടുത്ത കുറച്ച് പ്രഭാഷണങ്ങളിൽ നമ്മൾ ഇത് ഉപയോഗിച്ചേക്കാം ഒരു ഫോർ ലൂപ്പിന് (for loop) മറ്റൊരു ഉദാഹരണം

The key thing that I want you to notice is that, this number is not a constant.

നൽകാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. N-th ത്രികോണ നമ്പർ

In the previous example, we had it as a constant; now, it is not a constant.

അച്ചടിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നുവെന്ന് നമുക്ക് പറയാം. അതിനാൽ, മുമ്പത്തെ ഉദാഹരണത്തിൽ,

But, the moment this is received from the user, the number of iterations is fixed and that makes it suitable for a for loop.

ആവർത്തനങ്ങളുടെ എണ്ണം യഥാർത്ഥത്തിൽ പ്രോഗ്രാമിൽ (program) തന്നെ അറിയപ്പെട്ടിരുന്നു. അതിനാൽ, എനിക്ക് i 1 ന് തുല്യമായിരുന്നു;

So, for i equals 1, i less than or equal to number; i plus plus – sum plus equals i.

i 20-ൽ കുറവോ തുല്യമോ ആണ്. അതിനാൽ, ആവർത്തനങ്ങളുടെ

So, the way this is going to work is you are going to check if i, which is equal to 1 is

എണ്ണം അറിയുമ്പോഴെല്ലാം ഒരു ഫോർ ലൂപ്പ് (for loop) ഉപയോഗിക്കുന്നതാണ് നല്ലത്. പക്ഷേ, ഞാൻ

less than or equal to the number or not.

ഇവിടെ ഒരു ഉദാഹരണം കാണിക്കാൻ ആഗ്രഹിക്കുന്നു.

Let us say the number that the user inputs is 5; 1 is less than or equal to 5; you will

ഇവിടെ, ആവർത്തനങ്ങളുടെ എണ്ണം നമുക്ക് ശരിക്കും അറിയില്ല, കാരണം ഉപയോക്താവ് ഇത് ഇൻപുട്ട്

add 1 to sum; then i gets incremented to 2; 2 is less than or equal to 5.

(input) ചെയ്യാൻ പോകുന്നു. പക്ഷേ, ആവർത്തനങ്ങളുടെ എണ്ണം ‘n’ ഉപയോക്താവ് നൽകി കഴിഞ്ഞാൽ, ആവർത്തനങ്ങളുടെ

Then 2 is added to sum and so on.

എണ്ണം നിശ്ചയിച്ചിട്ടുണ്ടെന്ന് നമുക്കറിയാം. ഈ ചെറിയ

So, you will add numbers 1, 2, 3, 4 and 5.

ഉദാഹരണം നോക്കാം. N-th ത്രികോണ നമ്പർ

And the result would be 15.

കണ്ടെത്തുക; 1 മുതൽ n വരെയുള്ള സംഖ്യകളുടെ

So, the fifth triangular number is 15; that would be the print out of this program.

ആകെത്തുകയാണ് ഒരു ത്രികോണ സംഖ്യയെ നിർവചിച്ചിരിക്കുന്നത്. ഞാൻ ഇവിടെ ഒരു കോഡിന്റെ

Let us look at another example, where the user is going to ask for this multiple times.

(code) ഒരു ചെറിയ ഭാഗം കാണിക്കുന്നു. മുമ്പത്തെപ്പോലെ i ആവർത്തനമാണെന്നും നമ്പർ (number) എന്നത്

So, the user is going to ask for sum n-th triangular number.

ഉപയോക്താവ് ആവശ്യപ്പെടുന്ന n-th ത്രികോണ സംഖ്യയുടെ സംഖ്യയാണെന്നും നമുക്ക് പറയാം; നമ്മൾ

But, he wants five such numbers.

ഉപയോക്താവിന് നൽകാൻ ആഗ്രഹിക്കുന്ന ഫലമാണ്

So, one way in which you can do this is you can ask the user to run the program five times.

സം (sum). അതിനാൽ, നിങ്ങൾ ആഗ്രഹിക്കുന്ന ആ

But, that is not the most desired way to do it.

ത്രികോണ നമ്പർ എന്താണെന്ന് ഉപയോക്താവിനോട് ആവശ്യപ്പെടുന്നതിലൂടെ നമ്മൾ ആരംഭിക്കുന്നു; നമ്മൾ ഇത് ഉപയോക്താവിൽ നിന്ന് സ്കാൻ (scan)

Instead, if we know upfront that, the user wants five triangular numbers; but, each time,

ചെയ്യാൻ പോകുന്നു; സം (sum) പൂജ്യത്തിൽ

the user may ask for a different triangular number.

നിന്ന് ആരംഭിക്കും. അതിനാൽ, ഈ സമയത്ത്,

And that is what we have here.

ഉപയോക്താവ് ആഗ്രഹിച്ച സംഖ്യയുടെ എത്രയോ

So, we have a for loop here and this for loop is going to take care of the fact that, we

മടങ്ങ് ഇത് പ്രവർത്തിപ്പിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. അതിനാൽ, ഇപ്പോൾ നമുക്കുള്ളത് for(i=1;i<=number;i++) ആണ്. നിങ്ങൾ ശ്രദ്ധിക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്ന

are going to ask for five numbers from the user.

പ്രധാന കാര്യം, ഈ നമ്പർ (number) ഒരു കോൺസ്റ്റന്റല്ല (constant). മുമ്പത്തെ ഉദാഹരണത്തിൽ‌, നമുക്ക് ഇത് ഒരു

And within each body of this loop outside, we have this finding the n-th triangular number.

കോൺസ്റ്റന്റ് (constant). ആയിരുന്നു; ഇപ്പോൾ, അത് കോൺസ്റ്റന്റല്ല (constant).. പക്ഷേ, ഇത് ഉപയോക്താവിൽ

So, we are doing five iterations of asking n from the user and finding the n-th triangular

നിന്ന് ലഭിച്ച നിമിഷം, ആവർത്തനങ്ങളുടെ എണ്ണം നിശ്ചയിച്ചിട്ടുണ്ട്, ഇത് ഒരു ലൂപ്പിനായി (loop)അനുയോജ്യമാക്കുന്നു. or(i=1;i<=number;i++) sum+=i;ഇത് പ്രവർത്തിക്കാൻ പോകുന്ന രീതി നിങ്ങൾ പരിശോധിക്കാൻ പോകുന്നു,

number and printing it.

i 1 എന്നത് നമ്പറിനെക്കാൾ കുറവോ തുല്യമോ ആണോ

And if you notice, we have this blue body, which is on this outer for loop; and this orange body, which is the inner for loop.

എന്ന് പരിശോധിക്കാൻ പോകുന്നു. ഇൻപുട്ട് 5 ആണെന്ന് നമുക്ക് പറയാം; 1 എന്നത് 5 നെക്കാൾ

So, what we have done is we have nested a for loop inside another for loop.

കുറവോ തുല്യമോ ആണ്; നിങ്ങൾ തുകയിലേക്ക്

And this is also a very useful thing to do.

1 ചേർക്കും; എന്നിട്ട് i 2 ആയി വർദ്ധിപ്പിക്കും;

So, we are having this outermost loop running on counter and the innermost loop running

2 എന്നത് 5-നേക്കാൾ കുറവോ തുല്യമോ ആണ്.

on i. So, we have two iterators.

തുടർന്ന് 2 തുകയിലേക്ക് ചേർക്കുന്നു. 1, 2, 3,

And what this program does is or what this code segment does is – it is going to ask

4, 5 സംഖ്യകൾ കൂട്ടും. ഫലം 15 ആയിരിക്കും.

the user five times for what is the triangular number that they want.

അതിനാൽ, അഞ്ചാമത്തെ ത്രികോണ സംഖ്യ 15 ആണ്; ഇതാണ് ഈ പ്രോഗ്രാമിന്റെ (program) ഔട്ട്പുട്ട്

And each time once the number is entered, it will find the triangular number and print

(output). ഉപയോക്താവ് ഇത് ഒന്നിലധികം തവണ ചോദിക്കാൻ പോകുന്ന

it out. So, I suggest that, you go and write this code and see what happens.

മറ്റൊരു ഉദാഹരണം നോക്കാം. ഉപയോക്താവ്

So, let us move on to the next construct, which is the while construct.

ആകെ n-th ത്രികോണ നമ്പർ ചോദിക്കാൻ പോകുന്നു. പക്ഷേ, അത്തരം അഞ്ച് അക്കങ്ങൾ അയാൾ ആഗ്രഹിക്കുന്നു.

So, the general form of the while construct is while expression statement.

നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയുന്ന ഒരു മാർഗം അഞ്ച് തവണ പ്രോഗ്രാം (program) പ്രവർത്തിപ്പിക്കാൻ

And as before, the statement is a block of code.

ഉപയോക്താവിനോട് ആവശ്യപ്പെടാം എന്നതാണ്.

So, typically, you put that within braces.

പക്ഷേ, അത് ചെയ്യാൻ ഏറ്റവും നല്ല മാർഗ്ഗമല്ല

The semantics is that, you repeat this following process; you evaluate the expression first;

അത്. പകരം, നമുക്ക് അത് മുൻ‌കൂട്ടി അറിയാമെങ്കിൽ, ഉപയോക്താവിന് അഞ്ച് ത്രികോണ സംഖ്യകൾ

if the expression is true, then you execute the statement; if the expression is false, you exit the loop.

വേണം; പക്ഷേ, ഓരോ തവണയും ഉപയോക്താവിന് മറ്റൊരു ത്രികോണ നമ്പർ ആവശ്യപ്പെടാം. അതാണ് നമുക്ക് ഇവിടെയുള്ളത്.

So, in the for loop, exiting the loop is known upfront; you run it for a certain number of

അതിനാൽ, നമുക്ക് ഇവിടെ ഒരു ഫോർ ലൂപ്പ്

iterations and you exit the loop; whereas, in while loop, you exit once the expression

ഉണ്ട്, ഇത് ഉപയോക്താവിൽ നിന്ന് അഞ്ച് നമ്പറുകൾ ചോദിക്കാൻ പോകുന്നു. ഈ ലൂപ്പിന്റെ (loop)

becomes false; which means the expression must change inside the loop.

ഓരോ ബോഡിയിലും (body), നമുക്ക് ഇത് n-th ത്രികോണ

If the expression does not change inside the loop, you would end up within infinite loop,

സംഖ്യ കണ്ടെത്തുന്നു. അതിനാൽ, ഉപയോക്താവിൽ നിന്ന് n ചോദിച്ച് n-th ത്രികോണ നമ്പർ

because the expression would always be true; we will keep executing the body of the loop

കണ്ടെത്തി അച്ചടിക്കുന്നതിനുള്ള അഞ്ച് ആവർത്തനങ്ങൾ ഞങ്ങൾ ചെയ്യുന്നു. ഈ നീല നിറത്തിലുള്ള

infinitely. Let us see a small example.

ബോഡി (body) ഔട്ടർ ഫോർ ലൂപ്പിലാണ് (outer for

Let us say I want to just print the 5 integers – the first 5 integers – the first 5 positive

loop). ഈ ഓറഞ്ച് ബോഡി (orange body), ഇന്നർ ഫോർ ലൂപ്പിലാണ്.

numbers. So, I can do this with a for loop running from 1 to 5 and printing it. I am showing a small code segment, which does something different.

(inner for loop) അതിനാൽ, നമ്മൾ ചെയ്തത് ഒരു ഫോർ ലൂപ്പ് (for loop) മറ്റൊന്നിനുള്ളിൽ നെസ്റ്റു (nest) ചെയ്‌തു എന്നതാണ്. ഇത് വളരെ ഉപയോഗപ്രദമായ കാര്യവുമാണ്.

So, I have int count equals 1. So, right then we declare the initialized count equal to 1.

അതിനാൽ, ഈ പുറം ലൂപ്പ് കൗണ്ടറിലും (counter) ഏറ്റവും

This is possible in C. Then while count is less than equal to 5; print count and count

ആന്തരിക ലൂപ്പ് (loop) i ലും പ്രവർത്തിക്കുന്നു. അതിനാൽ, നമുക്ക് രണ്ട് അയ്റ്റ്രേറ്ററുകൾ

plus plus. So, the key thing that you have to notice is that, this count that we have here is actually

(iterator) ഉണ്ട്. ഈ പ്രോഗ്രാം (program) എന്താണ് ചെയ്യുന്നത് അല്ലെങ്കിൽ ഈ കോഡ് സെഗ്മെന്റ് എന്താണ്

changing.

ചെയ്യുന്നത് - ഉപയോക്താവിന് അവർ ആഗ്രഹിക്കുന്ന

If we do not have this, count would be 1 forever while 1 is less than equal to 5; print count.

ത്രികോണ നമ്പർ (number) എന്താണെന്ന് അഞ്ച് തവണ ചോദിക്കാൻ പോകുന്നു. ഓരോ തവണയും നമ്പർ

We would be printing 1 in an infinite loop.

(number) നൽകി കഴിഞ്ഞാൽ, അത് ത്രികോണ നമ്പർ

However, this count plus plus is changing the value of count.

(number) കണ്ടെത്തി പ്രിന്റ് (print) ചെയ്യും. അതിനാൽ,

So, the next time you would check if 2 is less than or equal to 5; then you would check

നിങ്ങൾ പോയി ഈ കോഡ് (code) എഴുതി എന്താണ്

if 3 is less than or equal to 5 and so on.

സംഭവിക്കുന്നതെന്ന് കാണുക.

At some point, count would become 6; 6 less than or equal to 5 would become false.

ഇനി നമുക്ക് അടുത്ത കോൺസ്ട്രക്ടിലേക്ക് (construct) പോകാം, വയിൽ (while). ഇതിന്റെ പൊതുരൂപം

At that point, you exit the loop and you move to this location.

വയിൽ എക്സ്പ്രഷൻ സ്റ്റേറ്റ്മെന്റ് (while expression statement) എന്നാണ്. മുമ്പത്തെപ്പോലെ,

You exit the while loop.

സ്റ്റേറ്റ്മെന്റ് (statement) കോഡിന്റെ (code)

So, this is a natural use for a while loop.

ഒരു ബ്ലോക്കാണ് (block) . അതിനാൽ, സാധാരണയായി,

So, this can be returned using a for loop; but, this is a simple example to show how

നിങ്ങൾ അത് ബ്രേസുകളിൽ (brace) ഇടുന്നു. ഇനിപ്പറയുന്ന പ്രക്രിയ നിങ്ങൾ ആവർത്തിക്കുന്നു

the while loop works.

എന്നതാണ് അർത്ഥം. നിങ്ങൾ ആദ്യം എക്സ്പ്രഷൻ

Let us see a more concrete example; where, the number of iterations is actually not known.

(expression) വിലയിരുത്തുന്നു; എക്സ്പ്രഷൻ (expression) ശരിയാണെങ്കിൽ, നിങ്ങൾ സ്റ്റേറ്റ്മെന്റ്

So, the problem that I am going to pose is finding the greatest common divisor of two

(statement) നടപ്പിലാക്കുക; എക്സ്പ്രഷൻ (expression) തെറ്റാണെങ്കിൽ, നിങ്ങൾ ലൂപ്പിൽ (loop) നിന്ന്

positive numbers. Let us say the user gives two positive numbers.

പുറത്തുകടക്കുക. ഫോർ ലൂപ്പിൽ (for loop),

Let us also assume that, m is greater than n.

ലൂപ്പിൽ (loop) നിന്ന് പുറത്തുകടക്കുന്നത്

There are two numbers: m and n that are given to you.

മുൻ‌കൂട്ടി അറിയപ്പെടുന്നു; ഒരു നിശ്ചിത എണ്ണം

And let us assume that, m is actually greater than n.

ആവർത്തനങ്ങൾക്കായി നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിക്കുകയും

If it is not, you can ask the user to give it in that order or you could change m and

ലൂപ്പിൽ (loop) നിന്ന് പുറത്തുകടക്കുകയും ചെയ്യുന്നു; അതേസമയം, വയിൽ ലൂപ്പിൽ (while

n, so that m actually becomes greater than n.

loop) എക്സ്പ്രഷൻ (expression) തെറ്റായിക്കഴിഞ്ഞാൽ

That is not the crux, but I want you to look at this notion of GCD.

നിങ്ങൾ പുറത്തുകടക്കും; ഇതിനർത്ഥം എക്സ്പ്രഷൻ (expression) ലൂപ്പിനുള്ളിൽ (loop) മാറണം. എക്സ്പ്രഷൻ (expression) ലൂപ്പിനുള്ളിൽ (loop) മാറുന്നില്ലെങ്കിൽ, നിങ്ങൾ ഇൻഫിനിറ്റ് ലൂപ്പിനുള്ളിൽ (infinite

We are going to use an algorithm called the Euclid’s algorithm.

loop) അവസാനിക്കും, കാരണം എക്സ്പ്രഷൻ (expression)

And this dates back to 300 years before BC.

എല്ലായ്പ്പോഴും ശരിയായിരിക്കും; ലൂപ്പിന്റെ (loop) ബോഡി (body) അനന്തമായി എക്സിക്യൂട്ട്

So, it is a very old algorithm and it is a very neat algorithm.

(execute) ചെയ്യും. നമുക്ക് ഒരു ചെറിയ ഉദാഹരണം നോക്കാം.

So, if I want to find out GCD of two positive numbers, then GCD of m comma n is the same

ആദ്യത്തെ 5 പൂർണ്ണസംഖ്യകൾ - ആദ്യത്തെ 5 പോസിറ്റീവ്

as GCD of n comma m percentage n; where, percentage stands for modulo.

(positive) സംഖ്യകൾ അച്ചടിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നുവെന്ന് പറയാം. അതിനാൽ, 1 മുതൽ 5 വരെ പ്രവർത്തിക്കുന്ന

So, I have two examples below to show that. So, let us say I want to find out GCD of 43 and 13.

ഒരു ഫോർ ലൂപ്പ് (for loop) ഉപയോഗിച്ച് എനിക്ക്

See in this case, m is 43 and n is 13 and m is actually greater than 13; so the condition

ഇത് ചെയ്യാൻ കഴിയും. ഞാൻ ഒരു ചെറിയ കോഡ് സെഗ്മെന്റ് (code segment) കാണിക്കുന്നു. int

that we want to satisfy. We start with 43 percentage 13.

count 1 ന് തുല്യമാണ്. അതിനാൽ, ഇപ്പോൾ നമ്മൾ

So, 43 percentage 13 is 4, because 13 times 3 is 39.

കൗണ്ട് (count) 1 ആയി ഇനിഷ്യലൈസ് ചെയ്തു. ഇത് സി (C) യിൽ

So, 43 divided by 13 gives a reminder of 4.

സാധ്യമാണ്. നിങ്ങൾ ശ്രദ്ധിക്കേണ്ട പ്രധാന കാര്യം, ഇവിടെയുള്ള ഈ (count) യഥാർത്ഥത്തിൽ

And now, you take 13 and the reminder 4; you do 13 percentage 4; that is 1.

മാറുകയാണ്. ഇത് ഇല്ലെങ്കിൽ, (count) എന്നേക്കും 1 ആയിരിക്കും, 1<=5 ശരിയായതിനാൽ ഇൻഫിനിറ്റ് ലൂപ്പിൽ 1 അച്ചടിക്കുന്നു.

And then you take 4 percentage 1; this is 0.

എന്നാൽ ഈ കൗണ്ട് പ്ലസ് പ്ലസ് (count++)

So, at this point, you stop and you report this as the GCD.

എണ്ണത്തിന്റെ മൂല്യം മാറ്റുകയാണ്. അതിനാൽ, അടുത്ത തവണ നിങ്ങൾ 2 പരിശോധിക്കുന്നത് 5 നെക്കാൾ കുറവാണോ തുല്യമാണോ എന്നാണ്.

So, 43 and 13 are both prime numbers.

അതിനുശേഷം 3 എന്നത് 5-ൽ കുറവോ തുല്യമോ

There is no common factor.

ആണോ എന്ന് നിങ്ങൾ പരിശോധിക്കും. ഒരു

So, the common factor is indeed 1. Therefore, 1 is the GCD.

ഘട്ടത്തിൽ കൗണ്ട് (count) 6 ആകും; തെറ്റായി

Let us look at a difference example; let us say m equals 96 and n equals 28.

മാറും. ആ സമയത്ത്, നിങ്ങൾ ലൂപ്പിൽ (loop) നിന്ന് പുറത്തുകടന്ന് ഈ സ്ഥാനത്തേക്ക്

We start with 96 percentage 28.

നീങ്ങുന്നു. ഇതാണ് വയിൽ ലൂപ്പിൻറെ (while

So, 28 times 3 is 84. Therefore, 12 is the reminder.

loop) സ്വാഭാവിക ഉപയോഗം. ഇതേ കാര്യം ഫോർ ലൂപ്പ്

Then you take 28 modulo – the reminder that you got in the previous iteration.

(for loop) ഉപയോഗിച്ച് ചെയ്യാം; എന്നാൽ,

28 percentage 12 is 4; and 12 percentage 4 is 0.

വയിൽ ലൂപ്പ് (while loop) എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണിക്കുന്നതിനുള്ള ലളിതമായ ഉദാഹരണമാണിത്. നമുക്ക് കൂടുതൽ വ്യക്തമായ ഒരു ഉദാഹരണം നോക്കാം;

And therefore, 4 is the GCD. So, even though in both these examples, we do know that, the number of iterations is

ഇവിടെ, ആവർത്തനങ്ങളുടെ എണ്ണം യഥാർത്ഥത്തിൽ അറിയില്ല. അതിനാൽ, ഞാൻ നോക്കുന്ന പ്രശ്നം രണ്ട് പോസിറ്റീവ് (positive) സംഖ്യകളുടെ

3 because we have worked it out; upfront you may not know what is the number of iteration

ഏറ്റവും വലിയ പൊതുവായ ഹരണത്തെ കണ്ടെത്തുക എന്നതാണ്. ഉപയോക്താവ് രണ്ട് പോസിറ്റീവ്

that is required? So, given two numbers, you do not know the number of iterations that is required upfront.

നമ്പറുകൾ (positive number) m, n എന്നിവ നിങ്ങൾക്ക് നൽകിയിട്ടുണ്ട്. m യഥാർത്ഥത്തിൽ n നേക്കാൾ

In such cases, the while loop is a natural choice.

വലുതാണെന്ന് കരുതുക. അങ്ങനെയല്ലെങ്കിൽ,

So, let us see this basic code.

ആ ക്രമത്തിൽ നൽകാൻ ഉപയോക്താവിനോട്

We start with if m is greater than n; if m is greater than n, GCD of m comma n is GCD

ആവശ്യപ്പെടാം. അല്ലെങ്കിൽ നിങ്ങൾക്ക് m ഉം n ഉം മാറ്റാൻ കഴിയും, അങ്ങനെ m യഥാർത്ഥത്തിൽ

of n comma m percentage n.

n നേക്കാൾ വലുതായിത്തീരും. ജിസിഡി (GCD) എന്താണെന്ന്

This is what we wanted to do.

നോക്കാം. യൂക്ലിഡിന്റെ അൽഗോരിതം (Euclid’s algorithm)

And the code segment is as follows.

എന്ന് വിളിക്കുന്ന ഒരു അൽഗോരിതം (algorithm)

So, if v is already 0; then there is nothing to do; however, otherwise, what we do is we

ഉപയോഗിക്കാൻ പോകുന്നു. ഇത് ബിസി (BC) ക്ക് 300 വർഷം മുമ്പാണ്. അതിനാൽ, ഇത് വളരെ പഴയ അൽ‌ഗോരിതം

have a temporary variable called temp; we find out u percentage v, which is u modulo

(algorithm) ആണ്, മാത്രമല്ല ഇത് വളരെ വൃത്തിയായിട്ടുള്ള അൽ‌ഗോരിതം (algorithm) ആണ്. അതിനാൽ, രണ്ട് പോസിറ്റീവ് നമ്പറുകളുടെ (positive number) ജിസിഡി (GCD) കണ്ടെത്താൻ

v; that goes as temp.

ഞാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, n യുടെ ജിസിഡി (n, m) [GCD(n,

And once you do that, u becomes v itself and v becomes temp; which is what we did here.

m)] ജിസിഡി (n, m%n) [ (GCD(n, m%n)] എന്നതിന് തുല്യമാണ്; ഇവിടെ, ശതമാനം എന്നത് മൊഡ്യൂളോയെ (modulo) സൂചിപ്പിക്കുന്നു.

So, it is called m and n here; it is called u and v in the program.

അതിനാൽ, അത് കാണിക്കാൻ എനിക്ക് ചുവടെ രണ്ട്

So, what we did was we took the reminder and we will call it v. And take the previous divisor;

ഉദാഹരണങ്ങളുണ്ട്. 43, 13 എന്നിവയുടെ ജിസിഡി (GCD) കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നുവെന്ന് നമുക്ക് പറയാം. ഈ സാഹചര്യത്തിൽ, m 43 ഉം n 13 ഉം ആണ്. യഥാർത്ഥത്തിൽ 13 നേക്കാൾ വലുതുമാണ്;

call it u and we repeat this.

ഇതാണ് നമുക്ക് ആവശ്യമുള്ള കണ്ടീഷൻ (condition). നമ്മൾ

At the end of it, v will become 0 at some point of time and you report u as the GCD.

ആരംഭിക്കുന്നത് 43%13 ആണ്. അതിനാൽ, 43%13

So, now, let us pay attention to the construct itself and not the logic of the program. So, what we have is we have while v is not equal to 0.

എന്നത് 4 ആണ്, കാരണം 13 തവണ 3 എന്നത് 39 ആണ്. അതിനാൽ, 43 നെ 13 കൊണ്ട് ഹരിച്ചാൽ 4 റിമൈൻഡർ (remainder) കിട്ടുന്നു ഇപ്പോൾ നിങ്ങൾ 13 ഉം

So, we keep doing this till we violate this condition.

റിമൈൻഡർ (remainder) 4 ഉം എടുക്കുന്നു; 13% 4 ചെയ്യുന്നു; അതായത് 1. എന്നിട്ട് നിങ്ങൾ 4 % 1 എടുക്കും;

And we have two braces here indicating that, this is a body of the loop.

ഇത് 0 ആണ്. അതിനാൽ, ഈ സമയത്ത്, നിങ്ങൾ നിർത്തി ഇത് ജിസിഡി (GCD) ആയി റിപ്പോർട്ട്

And this body of the loop – upfront we do not know the number of iterations; we can

(report) ചെയ്യുന്നു. 43 ഉം 13 ഉം രണ്ടും പ്രൈം

see that, there is nothing, which is doing an iteration count; however, we are hoping

(prime) സംഖ്യകളാണ്. പൊതുവായ ഘടകങ്ങളൊന്നുമില്ല. അതിനാൽ, പൊതുവായ ഘടകം 1 ആണ്. അതിനാൽ

that, v will become 0 at some point of time.

1 ആണ് ജിസിഡി (GCD). നമുക്ക് മറ്റൊരു

So, v does not become 0 at any point of time.

ഉദാഹരണം നോക്കാം; m 96 ഉം n ന് 28 ഉം തുല്യമാണെന്ന്

This while loop will become an infinite loop; but, because of the property of the numbers

നമുക്ക് പറയാം. നമ്മൾ 96% 28 ൽ ആരംഭിക്കുന്നു.

and the operations that we are doing here, v will indeed become 0 at some point of time

അതിനാൽ, 28 * 3 എന്നത് 84 ആണ്. അതിനാൽ, 12 ആണ്

and u is the GCD of two numbers.

റിമൈൻഡർ (remainder). അതിനുശേഷം നിങ്ങൾ 28% എടുക്കുന്നു

So, again I suggest that, you go and try the different examples and ensure that, this is actually correct; we go and verify that, this algorithm is actually correct. So, finally, I give one last example for a while loop.

- മുമ്പത്തെ ആവർത്തനത്തിൽ നിങ്ങൾക്ക് ലഭിച്ച റിമൈൻഡർ (remainder) 12 ആണ്. 28%12 എന്നത് 4 ആണ്; കൂടാതെ 12 % 4 എന്നത് 0 ആണ്. അതിനാൽ 4 ആണ് ജിസിഡി. (GCD) അതിനാൽ, ഈ രണ്ട് ഉദാഹരണങ്ങളിലും, ആവർത്തനങ്ങളുടെ

So, again in this, at this point, we do not know the number of iterations that we are

എണ്ണം 3 ആണെന്ന് നമുക്കറിയാം, കാരണം നമ്മൾ ഇത്

going to execute.

പ്രവർത്തിച്ചിട്ടുണ്ട്; ആവശ്യമുള്ള ആവർത്തനത്തിന്റെ

So, the problem is finding the reverse of a positive number.

എണ്ണം എത്രയാണെന്ന് നിങ്ങൾക്ക് അറിയില്ലെങ്കിലോ?

So, if I want the reverse of the number 234, it is 432.

അതിനാൽ, രണ്ട് അക്കങ്ങൾ‌ നൽ‌കിയാൽ‌, മുൻ‌കൂട്ടി ആവശ്യമുള്ള ആവർത്തനങ്ങളുടെ എണ്ണം നിങ്ങൾ‌ക്കറിയില്ല.

So, I need three iterations to find out the reverse.

അത്തരം സാഹചര്യങ്ങളിൽ, വയിൽ ലൂപ്പ് (while loop)

But, I could give a number, which is 19574 and this would be a five digit number; you need five iterations.

ഉപയോഗിക്കാം. ഈ അടിസ്ഥാന കോഡ് (code) നമുക്ക് നോക്കാം. M എന്നത് n നെക്കാൾ വലുതാണെങ്കിൽ നമ്മൾ

In general, if I give you an n-digit number, you need n iterations; upfront you do not know the number of digits that the user is going to give. So, the algorithm that we are going to follow is as follows.

ആരംഭിക്കുന്നു; m n നേക്കാൾ വലുതാണെങ്കിൽ, m, n ന്റെ GCD n, m%n ന്റെ GCD ആണ്. ഇതാണ് നമ്മൾ ചെയ്യാൻ ആഗ്രഹിച്ചത്. കോഡ് സെഗ്മെന്റ്

So, till the number becomes 0, extract the last digit of the number by finding out the

(code segment) ഇപ്രകാരമാണ്. V ഇതിനകം 0 ആണെങ്കിൽ; പിന്നെ ഒന്നും ചെയ്യാനില്ല; അല്ലാത്തപക്ഷം, നമുക്ക്

number modulo 10. See you take a number; find number modulo 10; that gives you the last digit.

ടെംപ് (temp) എന്ന താൽക്കാലിക വേരിയബിൾ (variable) ഉണ്ട്;

Make it the next digit of the result by multiplying the result by 10 and adding the current digit.

നമ്മൾ u % v കണ്ടെത്തുന്നു, അത് u മൊഡ്യൂളോ (modulo)

So, I will show you simple example to make this clear.

v ആണ്; അത് ടെംപിലേക്ക് (temp) പോകുന്നു. അത്

Let x be the given number and y be the number that is being computed. Let us say the user input 56342 as the number, which has to be reversed. So, 2 is the first digit of the resultant number.

ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങൾ u v ആയിത്തീരുകയും v ടെംപ്‌ (temp) ആവുകയും ചെയ്യും; അതാണ് നമ്മൾ ഇവിടെ ചെയ്തത്. ഇതിനെ ഇവിടെ m, n എന്ന് വിളിക്കുന്നു; പ്രോഗ്രാമിൽ (program) ഇതിനെ u, v എന്ന് വിളിക്കുന്നു.

We want 2 to be the first digit of the resultant number.

അതിനാൽ, നമ്മൾ ചെയ്തത് റിമൈൻഡർ (remainder) എടുത്തതാണ്,

The way we do that is we take 56342 and do modulo 10; that will get the reminder 2 alone. It will extract only the last digit.

അതിനെ ഞങ്ങൾ വി (v) എന്ന് വിളിക്കും. മുമ്പത്തെ ഹരണത്തെ എടുക്കുക; അതിനെ യു (u) എന്ന് വിളിക്കുക, ഇത് ആവർത്തിക്കുന്നു.

You take that; multiply the previous one by 10 and add this to it; that will result in

അതിന്റെ അവസാനം, ഒരുഘട്ടത്തിൽ v 0 ആയിത്തീരുകയും u ജിസിഡിയായി (GCD) റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യും. അതിനാൽ, പ്രോഗ്രാമിന്റെ യുക്തിയിലല്ല, കോൺസ്ട്രറക്ട്

(construct) ശ്രദ്ധിക്കാം. വയിൽ v!=0 എന്നാണ് ഉള്ളത്.

And what you do is you take 56342; divide that by 10 to get 5634.

ഈ കണ്ടീഷൻ (condition) ലംഘിക്കുന്നതുവരെ നമ്മൾ ഇത് ചെയ്യുന്നു. നമുക്ക് ഇവിടെ രണ്ട് ബ്രേസുകൾ (brace) ഉണ്ട്,

What I mean by divide is you get only the quotient and not the fractional part.

ഇത് ലൂപ്പിന്റെ (loop) ഒരു ബോഡി (body) ആണെന്ന് സൂചിപ്പിക്കുന്നു. ലൂപ്പിന്റെ (loop) ആവർത്തനങ്ങളുടെ എണ്ണം നമുക്ക് മുൻ‌കൂട്ടി അറിയില്ല; അത് ഒരു

So, 56342 divided by 10; the quotient is 5634.

ആവർത്തന എണ്ണുകയാണ് ചെയ്യുന്നത്. എന്നിരുന്നാലും,

At this point, you do percentage 10 again; you will get only 4. You take 4 and add it to two times 10.

ഒരു ഘട്ടത്തിൽ v 0 ആയി മാറുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു. അതിനാൽ, ഏത് സമയത്തും v 0 ആയി മാറുന്നില്ല. ഈ ലൂപ്പ് (loop) അനന്തമായ ലൂപ്പായി (infinite loop) മാറും; പക്ഷേ, അക്കങ്ങളുടെ

The number is 24. So, so far, we have taken the last two digits and reversed it.

പ്രത്യേകതയും ഇവിടെ ചെയ്യുന്ന പ്രവർ‌ത്തനങ്ങളും കാരണം, v ഒരുഘട്ടത്തിൽ 0 ആയിത്തീരും, കൂടാതെ

Then you take 5634 itself and again divide it by 10 to get 563 and so on.

u എന്ന ജിസിഡി (GCD) ലഭിക്കും. അതിനാൽ, ഞാൻ വീണ്ടും നിർദ്ദേശിക്കുന്നു, നിങ്ങൾ പോയി വ്യത്യസ്ത

If you keeping doing this, at some point, you get 24365, which is the reverse of 56342.

ഉദാഹരണങ്ങൾ പരീക്ഷിച്ച് ഇത് ശരിയാണെന്ന് ഉറപ്പാക്കുക; നമുക്ക് ഈ അൽഗോരിതം (algorithm) യഥാർത്ഥത്തിൽ ശരിയാണോയെന്ന് നോക്കാം. അതിനാൽ, അവസാനമായി,

But, at that point, x becomes 0 and it is a termination condition.

വയിൽ ലൂപ്പിനായി (while loop) ഞാൻ ഒരു ഉദാഹരണം കൂടെ നൽകാം. വീണ്ടും, ഈ ഘട്ടത്തിൽ, നമുക്ക് എക്സിക്യൂട്ട്

So, you will keep doing this till x becomes 0; and this is a natural way of using a while

(execute) ചെയ്യാൻ പോകുന്ന ആവർത്തനങ്ങളുടെ എണ്ണം അറിയില്ല. ഒരു പോസിറ്റീവ് (positive) സംഖ്യയുടെ റിവേഴ്‌സ് (reverse) കണ്ടെത്തുന്നതാണ്

loop.

പ്രശ്നം. 234 എന്ന സംഖ്യയുടെ റിവേഴ്‌സ് (reverse) 432

So, let us look at the program itself. We have x equals 0 and y equals 0; and you expect the user to give an input number.

ആണ്. അതിനാൽ, റിവേഴ്‌സ് (reverse) കണ്ടെത്താൻ എനിക്ക് മൂന്ന് ആവർത്തനങ്ങൾ ആവശ്യമാണ്. പക്ഷേ, എനിക്ക് ഒരു നമ്പർ (number) നൽകാൻ കഴിയും,

So, input an integer and you scan it from the user.

അത് 19574 ആണ്, ഇത് അഞ്ച് അക്ക സംഖ്യയായിരിക്കും; ഇവിടെ അഞ്ച് ആവർത്തനങ്ങൾ ആവശ്യമാണ്. പൊതുവേ,

If the user inputs 0 itself, you check the condition while x is greater than 0.

ഞാൻ നിങ്ങൾക്ക് ഒരു n- അക്ക നമ്പർ നൽകിയാൽ, n ആവർത്തനങ്ങൾ ആവശ്യമാണ്; ഉപയോക്താവ് നൽകാൻ

Let us say the user gives 0 as the input; then the while loop is not even executed once;

പോകുന്ന അക്കങ്ങളുടെ എണ്ണം നിങ്ങൾക്ക് അറിയില്ല. അതിനാൽ, നമ്മൾ ചെയ്യാൻ പോകുന്ന

you can directly go and print y equals 0.

അൽഗോരിതം (algorithm) ഇനിപ്പറയുന്നതാണ്. നമ്പർ 0 ആകുന്നതുവരെ,

So, we also assume that, the user inputs only positive numbers or 0. So, if the user inputs 0, this while will not be executed.

നമ്പർ (number) മൊഡ്യൂളോ (modulo) കണ്ടെത്തി നമ്പറിന്റെ (number) അവസാന അക്കം എക്‌സ്‌ട്രാക്റ്റു (extract) ചെയ്യുക. നമ്പർ (number) മൊഡ്യൂളോ (modulo) 10 (%10)കണ്ടെത്തുക; അത്

Therefore, the reverse number is 0 itself.

നിങ്ങൾക്ക് അവസാന അക്കം നൽകുന്നു.

However, if the user inputs any number greater than 0; then we have y equals 10 times y plus

ഫലത്തെ 10 കൊണ്ട് ഗുണിച്ച് നിലവിലെ അക്കം ചേർത്തുകൊണ്ട് ഫലത്തിന്റെ അടുത്ത അക്കമാക്കുക. ഇത് വ്യക്തമാക്കുന്നതിനുള്ള ലളിതമായ ഉദാഹരണം

x mod 10.

ഞാൻ കാണിച്ചുതരാം.

So, you remember the evaluation order; we have parenthesis here; this will be evaluated first; and that is doing modulo 10 of x; that extracts the last digit, but it adds it to

X തന്നിരിക്കുന്ന സംഖ്യയും y കണക്കുകൂട്ടുന്ന സംഖ്യയും ആകട്ടെ. 56342 എന്ന ഇൻപുട്ട് നമ്പറായി (input number) നമുക്ക് പറയാം, അത് ഇത് റിവേഴ്‌സ് (reverse) ചെയ്യേണ്ടതുണ്ട്. റിസൾട്ട് (result) ആയി

കിട്ടേണ്ട സംഖ്യയുടെ ആദ്യ അക്കമാണ് 2. അത്

10 times y. And x itself is diminished by a factor of 10. Remember – x being an integer – the integer division, you have integer divided by integer;

ചെയ്യുന്ന രീതി 56342 എടുത്ത് മൊഡ്യൂളോ (modulo) 10 ചെയ്യുക എന്നതാണ്; അതിന് റിമൈൻഡർ (remainder) 2 മാത്രം ലഭിക്കും. അങ്ങനെ അവസാന അക്കം

that gives you only the quotient and it truncates the fractional part.

മാത്രം എക്‌സ്‌ട്രാക്റ്റു (extract)ചെയ്യും. അത് എടുക്കുക; മുമ്പത്തെ ഒന്നിനെ 10 കൊണ്ട്

So, x keeps diminishing by a factor of 10 every time.

ഗുണിച്ച് ഇതിലേക്ക് ചേർക്കുക; കിട്ടുന്ന റിസൾട്ട് (result) 2 ആണ്. ഇനി 5634 ലഭിക്കാൻ 5634

At the end of it, you have x equals 0. At that point, this while condition is not true anymore; when it becomes false, you come

നെ 10 കൊണ്ട് ഹരിക്കുക. വിഭജനം കൊണ്ട് നിങ്ങൾക്ക് ലഭിക്കുന്നത് ഘടകഭാഗമാണ്, ഭിന്ന ഭാഗമല്ല. അതിനാൽ,

to the end of the loop and you print the reverse number. So, this is a full program segment.

56342 നെ 10 കൊണ്ട് ഹരിക്കുന്നു; അതിന്റെ കോഷ്യന്റ് (quotient) 5634 ആണ്. ഈ സമയത്ത്, നിങ്ങൾ വീണ്ടും മൊഡ്യൂളോ

If you type it in your editor and compile, it should work.

(modulo) 10 ചെയ്യുന്നു; നിങ്ങൾക്ക് 4 മാത്രമേ

Let us move to the third construct, which is a do-while construct. And the general form is do statement – while expression.

ലഭിക്കൂ. 4 എടുത്ത് 2 *10 ന്റെ കൂടെ ചേർക്കുക. നമ്പർ 24 ആണ്. അതിനാൽ, ഇതുവരെ നമ്മൾ അവസാന രണ്ട് അക്കങ്ങൾ എടുത്ത് റിവേഴ്‌സ് ചെയ്തു.

The semantics is as follows. Execute the statements and then evaluate the expression.

5634 എടുത്ത് വീണ്ടും 10 കൊണ്ട് ഹരിച്ചാൽ

So, the key concept is that, you execute it once and then you evaluate the expression.

563 ലഭിക്കും. നിങ്ങൾ ഇത് ചെയ്യുന്നത് തുടരുകയാണെങ്കിൽ, ഒരു ഘട്ടത്തിൽ നിങ്ങൾക്ക് 24365 ലഭിക്കും, അത് 56342 ന്റെ റിവേഴ്‌സ്

If the expression is true, you re-execute the statement; otherwise, exit the loop.

(reverse) ആണ് . പക്ഷേ, ആ സമയത്ത്, x 0 ആയി മാറുന്നു,

So, this do-while construct is different from the for and while construct.

ഇത് ഒരു ടെർമിനേഷൻ കണ്ടീഷൻ (termination condition)

The for and while constructs – both check the condition once even before executing the

ആണ്. അതിനാൽ, x 0 ആകുന്നതുവരെ നിങ്ങൾ ഇത് തുടരും;

body of the loop even once. However, in do while, you execute the loop body at least once before you go into checking

ഇങ്ങനെയാണ് വയിൽ ലൂപ്പ് (while loop) ഉപയോഗിക്കുന്നത്. നമുക്ക് പ്രോഗ്രാം (program) നോക്കാം. x =0 y =0 ആണ്; ഉപയോക്താവ് ഒരു നമ്പർ (number) നൽകുമെന്ന്

the condition. So, let us look at a specific example, where do while is natural.

നിങ്ങൾ പ്രതീക്ഷിക്കുന്നു. അതിനാൽ, ഒരു സംഖ്യ ഇൻപുട്ട് (input) ചെയ്യുക, നിങ്ങൾ അത് ഉപയോക്താവിൽ

Let us say I want the input numbers to be of a specific kind. So, I showed you an example earlier; where, we were checking if the number that is input by the user is a multiple of 3 or not.

നിന്ന് സ്കാൻ (scan) ചെയ്യുക. ഉപയോക്താവ് 0 ഇൻപുട്ട് (input) ചെയ്യുകയാണെങ്കിൽ, x 0 നെക്കാൾ വലുതാണെങ്കിൽ

If it is not, we prompted the user to give this input once more and we scanned it.

നിങ്ങൾ അവസ്ഥ പരിശോധിക്കുക. ഉപയോക്താവ് ഇൻപുട്ടായി 0 നൽകുന്നുവെന്ന് നമുക്ക് പറയാം; അപ്പോൾ

But, we had no guarantee that, the user actually input a number, which is a multiple of 3; which means we have to repeatedly keep asking the user till the user actually inputs a multiple

ലൂപ്പ് (loop) ഒരുതവണ പോലും നടപ്പിലാക്കില്ല; നിങ്ങൾക്ക് നേരിട്ട് പോയി y 0 എന്ന് അച്ചടിക്കാൻ കഴിയും. ഉപയോക്താവ് പോസിറ്റീവ് നമ്പറുകൾ

of 3. So, this is a natural thing to do with a do-while construct.

(positive number) അല്ലെങ്കിൽ 0 മാത്രമേ ഇൻപുട്ട്

So, let us see what is happening in this setup here.

(input) ചെയ്യുന്നുള്ളൂ എന്നും നമ്മൾ അനുമാനിക്കുന്നു.

Let us as before, look at the logic first and then we look at the structure itself.

ഉപയോക്താവ് ഇൻപുട്ട് (input) ചെയ്യുന്നത് 0 ആണെങ്കിൽ, ഇത് നടപ്പിലാക്കില്ല. അതിനാൽ, റിവേഴ്‌സ്

So, the very first time you have a do, there is nothing to check; you prompt the user by

നമ്പർ (reverse number) 0 തന്നെ. എന്നിരുന്നാലും, ഉപയോക്താവ് 0 ൽ കൂടുതലുള്ള ഏതെങ്കിലും നമ്പർ

printing this on the screen; and the user is expected to enter a number. Let us say the user inputs minus 5; then after this, you go and check the loop.

(number) ഇൻപുട്ട് (input) ചെയ്യുകയാണെങ്കിൽ; അപ്പോൾ y =10*y+(x %10) ചെയ്യുക. നിങ്ങൾ മൂല്യനിർണ്ണയ ക്രമം ഓർക്കുക; ഇവിടെ പരാൻതീസിസ് (paranthesis)

So, now, we see an example of ampersand ampersand or the logical AND.

ഉണ്ട്; ഇത് ആദ്യം വിലയിരുത്തപ്പെടും; അത് x%10 ചെയ്യുന്നു; അവസാന അക്കത്തെ വേർതിരിച്ചെടുക്കുന്നു,

So, while x is greater than 0 and x percentage 3 not equal to 0; so the user let us say entered

ഇത് 10 * y ലേക്ക് കൂട്ടുന്നു. X തന്നെ 10 ന്റെ ഒരു ഘടകത്താൽ കുറയുന്നു. ഓർക്കുക - x ഒരു പൂർണ്ണസംഖ്യ ആണ് അതിനെ പൂർണ്ണസംഖ്യ കൊണ്ട് ഹരിക്കുന്നു;

minus 5; minus 5 is not greater than 0.

അത് ഘടകഭാഗം മാത്രം നൽകുന്നു, ഭിന്ന

So, this condition evaluates to false and this condition also is actually true.

ഭാഗത്തെ വെട്ടിച്ചുരുക്കുന്നു. അതിനാൽ, x ഓരോ തവണയും 10 എന്ന ഘടകം കുറയുന്നു. ഇ തിന്റെ അവസാനം,

So, minus 5 mod 3 is not equal to 0; however, since this evaluate to false and that evaluates

x = 0 ആണ്. ആ സമയത്ത്, ഈ വയിൽ കണ്ടീഷൻ (while condition) ഇനി ശരിയല്ല; അത് തെറ്റായിത്തീരുമ്പോൾ,

to true, the overall expression evaluates to false.

നിങ്ങൾ ലൂപ്പിന്റെ (loop) അവസാനത്തിലെത്തി

Therefore, the user has to enter another number.

റിവേഴ്‌സ് നമ്പർ (reverse number) പ്രിന്റു (print) ചെയ്യുന്നു. ഇതൊരു പൂർണ്ണ പ്രോഗ്രാം

At this point, you go back here and there is nothing to check; you go and print this

(program) വിഭാഗമാണ്. നിങ്ങളുടെ എഡിറ്ററിൽ (editor) ഇത് ടൈപ്പു (type) ചെയ്ത് കംപൈൽ (compile) ചെയ്യുകയാണെങ്കിൽ,

on the screen once more; you scan the user input once more. Let us say the user now input 9.

അത് പ്രവർത്തിക്കും. നമുക്ക് മൂന്നാമത്തെ കൺസ്ട്രക്ടിലേക്ക് (construct) പോകാം, ടു വയിൽ. (do while). പൊതുവായ രൂപം

If the input is 9, x greater than 0 would be true; however, x mod 3 would still be 0.

ടു സ്റ്റേറ്റ്മെന്റ് വയിൽ എക്സ്പ്രഷൻ (do statement while expression) എന്നാണ്. സെമാന്റിക്‌സ് ഇപ്രകാരമാണ്. സ്റ്റേറ്റ്മെന്റുകൾ (statement) നടപ്പിലാക്കുക, തുടർന്ന് എക്സ്പ്രഷൻ (expression) വിലയിരുത്തുക.

Therefore, this while condition is still false; you would go back and do the print f statement.

അതിനാൽ, പ്രധാന ആശയം, നിങ്ങൾ അത് ഒരിക്കൽ എക്സിക്യൂട്ട് (execute) ചെയ്യുകയും എക്സ്പ്രഷൻ

Let us say now the user inputs 5.

(expression) വിലയിരുത്തുകയും ചെയ്യുന്നു എന്നതാണ്.

So, we did minus 5 first; we did 9 next.

എക്സ്പ്രഷൻ (expression) ശരിയാണെങ്കിൽ, സ്റ്റേറ്റ്മെന്റുകൾ (statement) വീണ്ടും നടപ്പിലാക്കുക; അല്ലെങ്കിൽ, ലൂപ്പിൽ

Let us say the user inputs 5 now.

(loop) നിന്ന് പുറത്തുകടക്കുക. അതിനാൽ, ടു വയിൽ (do

And at this point, 5 is greater than 0 is true and 5 mod 3 is not equal to 0, is also

while) ഫോർ (for), വയിൽ (while) കൺസ്ട്രക്റ്റിൽ (construct) നിന്ന് വ്യത്യസ്തമാണ്. ഫോർ (for), വയിൽ (while) കൺസ്ട്രക്റ്റുകൾ

true. Therefore, 5 is a valid user input.

(construct) - രണ്ടും ലൂപ്പിന്റെ ബോഡി (loop body) എക്സിക്യൂട്ട്

At this point, the condition evaluates to true; and therefore, you stop here. So, you keep doing this till a certain condition is satisfied.

(execute) ചെയ്യുന്നതിന് മുമ്പായി ഒരു തവണ എങ്കിലും കണ്ടീഷൻ(condition) പരിശോധിക്കുന്നു. എന്നാൽ ടു വയിൽ (do while) ചെയ്യേണ്ട സമയത്ത്, കണ്ടീഷൻ (condition) പരിശോധിക്കുന്നതിന് മുമ്പായി ഒരു തവണയെങ്കിലും

So, let us look at the construct itself; we have the key word do followed by a block of

ലൂപ്പ് ബോഡി (loop body) എക്സിക്യൂട്ട് (execute) ചെയ്യുന്നു. ഒരു ഉദാഹരണം നോക്കാം, ഇൻപുട്ട് (input) നമ്പറുകൾ (number) ഒരു പ്രത്യേക തരത്തിലുള്ളതായിരിക്കണമെന്ന്

code; and the body of the loop is this one.

ഞാൻ ആഗ്രഹിക്കുന്നു. അതിനാൽ, ഞാൻ നേരത്തെ ഒരു ഉദാഹരണം കാണിച്ചുതന്നു; ഇവിടെ, ഉപയോക്താവ്

So, that is the overall structure for the setup here.

ഇൻപുട്ട് (input) ചെയ്യുന്ന നമ്പർ (number)3 ന്റെ ഗുണിതമാണോ അല്ലയോ എന്ന് പരിശോധിക്കുന്നു. അങ്ങനെയല്ലെങ്കിൽ,

So, let us look at this in summary.

ഈ ഇൻപുട്ട് (input) ഒരിക്കൽ കൂടി നൽകാൻ ഉപയോക്താവിനോട് ആവശ്യപ്പെടുകയും അത് സ്കാൻ (scan) ചെയ്യുകയും

In the for loop, what we have is we start with an initialization condition; we first

ചെയ്തു. പക്ഷേ, ഉപയോക്താവ് യഥാർത്ഥത്തിൽ ഇൻപുട്ട് (input) ചെയ്യുന്ന സംഖ്യ 3 ന്റെ ഗുണിതമാണ് എന്ന് നമുക്ക് ഉറപ്പില്ല; അതിനർ‌ത്ഥം ഉപയോക്താവ്

check an expression; if it is true, you evaluate the body; you do some loop increment and go

3 ന്റെ ഗുണിതം ഇൻ‌പുട്ട് (input) ചെയ്യുന്നതുവരെ നമ്മൾ ആവർത്തിച്ച് ഉപയോക്താവിനോട് ചോദിച്ചുകൊണ്ടിരിക്കണം. ടു വയിൽ (do while) ഉപയോഗിച്ച്

back.

ചെയ്യേണ്ട ഒരു സ്വാഭാവിക കാര്യമാണിത്. അതിനാൽ,

And when you go back, you have to evaluate the expression once more.

ഈ സജ്ജീകരണത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന്

At some point, this loop increment that you are doing will violate the expression; at

നമുക്ക് നോക്കാം. മുമ്പത്തെപ്പോലെ നമുക്ക് ആദ്യം ലോജിക് (logic) നോക്കാം, തുടർന്ന് ഘടന നോക്കാം. നിങ്ങൾ ആദ്യമായി ഒരു കാര്യം

that point, you exit; and that is the false branch. If you look at the while loop, the while loop starts with some body and it checks the expression

ചെയ്യുമ്പോൾ, പരിശോധിക്കാൻ ഒന്നുമില്ല; ഇത് സ്ക്രീനിൽ (screen) ഉപയോക്താവിനോട് ഒരു നമ്പർ (number) നല്കാൻ ആവശ്യപെടുന്നു. യൂസർ (user) ഇൻപുട്ട് (input) -5 എന്ന് നമുക്ക് പറയാം; അതിനുശേഷം, ലൂപ്പ്

first; if it is true, you execute the loop body and comeback and evaluate the expression;

(loop) പരിശോധിക്കുക. ഇപ്പോൾ, ആമ്പർസാൻഡ് ആമ്പർസാൻഡിന്റെ (&&) അല്ലെങ്കിൽ ലോജിക്കൽ AND ന്റെ (logical AND) ഒരു ഉദാഹരണം നമ്മൾ കാണുന്നു.

if it is false, you exit the loop.

അതിനാൽ, x 0 നെക്കാൾ വലുതാണെങ്കിൽ x%3 0

So, the key thing to notice is that, this body that you have here must contain something

ന് തുല്യമല്ല; അതിനാൽ -5 നൽകിയാൽ ; -5 0 നെക്കാൾ

that will change the evaluation of the expression.

വലുതല്ല. അതിനാൽ, ഈ കണ്ടീഷൻ (condition) തെറ്റാണെന്ന്

If it does not change the evaluation of expression, you will keep doing this loop forever, which

വിലയിരുത്തുന്നു, ഈ അവസ്ഥയും യഥാർത്ഥത്തിൽ ശരിയാണ്. അതിനാൽ, - 5%3 0 ന് തുല്യമല്ല;

we want to avoid.

ഒരു കണ്ടീഷൻ (condition) തെറ്റായി വിലയിരുത്തുകയും

And this picture clearly shows how do while is different from both these.

മറ്റൊന്ന് സത്യമായി വിലയിരുത്തുകയും ചെയ്യുന്നതിനാൽ, മൊത്തത്തിലുള്ള എക്സ്പ്രഷൻ (expression) തെറ്റായി വിലയിരുത്തുന്നു.

We have a body of the loop that is executed even before the expression is checked once.

അതിനാൽ, ഉപയോക്താവ് മറ്റൊരു നമ്പർ (number) നൽകണം. ഈ സമയത്ത്, നിങ്ങൾ ഇവിടെ തിരികെ

So, once you execute the body, you then check expression; if it is true, you go back and

പോകുന്നു, പരിശോധിക്കാൻ ഒന്നുമില്ല; വീണ്ടും സ്ക്രീനിൽ (screen) പ്രിന്റു p(ചെയ്യുക; ഇൻപുട്ട് (input) വീണ്ടും സ്കാൻ (scan) ചെയ്യുന്നു.

execute the body once more; if it is false, you exit the loop.

ഉപയോക്താവ് ഇപ്പോൾ ഇൻപുട്ട് (input) 9 കൊടുത്തു എന്നിരിക്കട്ടെ. ഇൻപുട്ട് (input) 9 ആണെങ്കിൽ,

And these are the three basic constructs that is available in C. And depending on the problem,

0 നേക്കാൾ വലുത് x ശരിയാകും; എന്നിരുന്നാലും, x%3 ഇപ്പോഴും 0 ആയിരിക്കും. അതിനാൽ, ഈ കണ്ടീഷൻ

you need to pick one appropriately.

(condition) ഇപ്പോഴും തെറ്റാണ്; നിങ്ങൾ തിരികെ പോയി പ്രിന്റ് എഫ് സ്റ്റേറ്റ്മെന്റ് (printf statement) ചെയ്യും.

So, in summary, for loops are used whenever you know the number of iterations that you

ഉപയോക്തൃ ഇൻപുട്ടുകൾ (input) 5 എന്ന് ഇപ്പോൾ പറയാം. നമ്മൾ ആദ്യം -5 ചെയ്തു; അടുത്തത് 9 ചെയ്തു. ഇപ്പോൾ 5 ചെയ്തു. ഈ സമയത്ത്, 5 എന്നത് 0 നേക്കാൾ വലുതാണ്, 5 %3 0 ന് തുല്യമല്ല,

have to run the body of the loop; a while loop is used if you want to check on a condition

ഇത് ശരിയാണ്. അതിനാൽ, 5 ഒരു സാധുവായ ഉപയോക്തൃ ഇൻപുട്ടാണ് (input). ഈ സമയത്ത്, കണ്ടീഷൻ (condition) ശരിയാണെന്ന് വിലയിരുത്തുന്നു; അതിനാൽ നിങ്ങൾ ഇവിടെ നിർത്തുക. ഒരു പ്രത്യേക

കണ്ടീഷൻ (condition) ശരിയാവുന്നതുവരെ നിങ്ങൾ ഇത് ചെയ്യുന്നത് തുടരുക. കൺസ്ട്രക്ടിനെക്കുറിച്ച് (construct) നമുക്ക് നോക്കാം;

at least once even before you get to the body, but you do not know the number of iterations

ടു (do) എന്ന ഒരു കീവേഡ് (keyword) ഉണ്ട്, അതിനുശേഷം ഒരു കോഡ് ബ്ലോക്ക് (code block); പിന്നെ ലൂപ്പിന്റെ ബോഡി (loop body). ഇതാണ് മൊത്തത്തിലുള്ള

that you need upfront; and do while is used if you want to execute a body at least once

ഘടന. ഇത് ചുരുക്കത്തിൽ നോക്കാം. ഫോർ ലൂപ്പിൽ, ഒരു ഇനിഷ്യലായ്സേഷൻ കണ്ടീഷനിൽ (initalization condition) നിന്നാണ് ആരംഭിക്കുന്നത്; നമ്മൾ ആദ്യം ഒരു

എക്സ്പ്രഷൻ (expression) പരിശോധിക്കുന്നു; അത് ശരിയാണെങ്കിൽ, നിങ്ങൾ ബോഡി (body) വിലയിരുത്തുന്നു; അതിനുശേഷം ലൂപ്പ് ഇൻക്രിമെന്റ് (loop

even before you check the expression, but you do not know the number of times the body

increment) നടത്തി തിരികെ പോകുക. തിരികെ പോകുമ്പോൾ, ഒരിക്കൽ കൂടി എക്സ്പ്രഷൻ (expression) വിലയിരുത്തണം. ചില ഘട്ടങ്ങളിൽ, നിങ്ങൾ ചെയ്യുന്ന ഈ ലൂപ്പ് ഇൻക്രിമെന്റ് (loop increment) എക്സ്പ്രഷനെ

(expression) ലംഘിക്കും; ആ സമയത്ത്, ലൂപ്പിൽ

is supposed to be executed.

(loop) നിന്ന് പുറത്തുകടക്കുന്നു. വയിൽ ലൂപ്പ് (while loop) ബോഡിയിൽ (body) ആരംഭിക്കുകയും അത് ആദ്യം എക്സ്പ്രഷൻ

So, there are two ways to change the loop behavior.

(expression) പരിശോധിക്കുകയും ചെയ്യുന്നു; ഇത് ശരിയാണെങ്കിൽ, ലൂപ്പ് ബോഡി (loop body) എക്സിക്യൂട്ട്ചെയ്യുകയും (execute) എക്സ്പ്രഷൻ (expression) വിലയിരുത്തുകയും

There are two key words namely, break and continue.

ചെയ്യുന്നു; അത് തെറ്റാണെങ്കിൽ, നിങ്ങൾ ലൂപ്പിൽ നി (loop) ന്ന് പുറത്തുകടക്കുക. അതിനാൽ, ശ്രദ്ധിക്കേണ്ട പ്രധാന കാര്യം, ബോഡിയിൽ

I am not talking about this in this module; we will see this later as we see the need

(body) എക്സ്പ്രഷന്റെ (expression) വിലയിരുത്തലിനെ മാറ്റുന്ന എന്തെങ്കിലും അടങ്ങിയിരിക്കണം. ഇത് എക്സ്പ്രഷന്റെ (expression) മൂല്യനിർണ്ണയത്തെ മാറ്റിയില്ലെങ്കിൽ, ലൂപ്പ് (loop) എന്നെന്നേക്കുമായി

തുടരും. ഇവ രണ്ടിൽ നിന്നും

for them.

ടു വയിൽ (do while) എങ്ങനെ വ്യത്യസ്‌തമായിരിക്കുന്നു എന്ന് ഈ ചിത്രം വ്യക്തമാക്കുന്നു. എക്‌സ്‌പ്രഷൻ‌ (expression) ഒരിക്കൽ‌ പരിശോധിക്കുന്നതിനുമുമ്പുതന്നെ എക്സിക്യൂട്ട് (execute)

So far, I have been using dev C plus plus to show you program segments; I promised earlier

ചെയ്യുന്ന ലൂപ്പിന്റെ (loop) ഒരു ബോഡി (body) നമ്മുടെ പക്കലുണ്ട്. അതിനാൽ, ബോഡി എക്സിക്യൂട്ട്(execute) ചെയ്തുകഴിഞ്ഞാൽ, എക്സ്പ്രഷൻ (expression) പരിശോധിക്കുക; അത് ശരിയാണെങ്കിൽ, തിരികെ

പോയി ബോഡി ഒരിക്കൽ കൂടി എക്സിക്യൂട്ട്(execute) ചെയ്യുക; അത് തെറ്റാണെങ്കിൽ, ലൂപ്പിൽ (loop) നിന്ന് പുറത്തുകടക്കുക. സി (C) യിൽ ലഭ്യമായ

that, I will actually point out where you can get this dev C plus plus.

മൂന്ന് അടിസ്ഥാന നിർമിതികളാണിവ. പ്രശ്‌നത്തെ ആശ്രയിച്ച് നിങ്ങൾ ഉചിതമായ ഒന്ന് തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. അതിനാൽ, ചുരുക്കത്തിൽ, നിങ്ങൾ ലൂപ്പിന്റെ

It can be found at sourceforge website – at sourceforge dot net slash projects slash orwelldevcpp.

(loop) ബോഡി (body) പ്രവർത്തിപ്പിക്കേണ്ട ആവർത്തനങ്ങളുടെ എണ്ണം അറിയുമ്പോഴെല്ലാം ഫോർ ലൂപ്പുകൾ (loop) ഉപയോഗിക്കുന്നു; ബോഡിയിലേക്ക് (nഎത്തുന്നതിനുമുമ്പുതന്നെ ഒരു കണ്ടീഷൻ (condition) എങ്കിലും പരിശോധിക്കണമെങ്കിൽ

വയിൽ ലൂപ്പ് (while loop) ഉപയോഗിക്കുന്നു, എന്നാൽ ആവശ്യമുള്ള ആവർത്തനങ്ങളുടെ എണ്ണം നിങ്ങൾക്കറിയില്ല; എക്സ്പ്രഷൻ (expression) പരിശോധിക്കുന്നതിന് മുമ്പായി ഒരു തവണയെങ്കിലും

It is roughly about 42 mega bytes in size; you need to download the compiler, the debugger,

ഒരു ബോഡി (body) എക്സിക്യൂട്ട് (execute) ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ടു വയിൽ ഉപയോഗിക്കുന്നു, എന്നാൽ ബോഡി (body) എത്ര തവണ എക്സിക്യൂട്ട് (execute) ചെയ്യണമെന്ന് നിങ്ങൾക്കറിയില്ല.

അതിനാൽ, ലൂപ്പ് (loop) സ്വഭാവം മാറ്റാൻ

the graphical environment and so on.

രണ്ട് വഴികളുണ്ട്. രണ്ട് പ്രധാന പദങ്ങളുണ്ട്, ബ്രേക്ക് (break), കണ്ടിന്യൂ (continue). ഈ മൊഡ്യൂളിൽ (module) ഞാൻ ഇതിനെക്കുറിച്ച് സംസാരിക്കുന്നില്ല;

It takes about 42 MB in size.

ഇതുവരെ, പ്രോഗ്രാം സെഗ്‌മെന്റുകൾ (program

I suggest that, you download and start using that.

segment) കാണിക്കാൻ ഞാൻ ഡേവ് സി പ്ലസ് പ്ലസ് (Dev C++) ആണ് ഉപയോഗിച്ചത്; ദേവ് സി പ്ലസ് പ്ലസ്

And it takes a few minutes to set up and not more.

(Dev C++) എവിടെ നിന്ന് ലഭിക്കും എന്ന് ഞാൻ കാണിച്ചു തരും. ഇത് സോഴ്സ്ഫോർജ് വെബ്സൈറ്റിൽ (sourceforge

So, that is a very useful thing to download.

website) കാണാം. (http://sourceforge.net/projects/orwelldevcpp). ഏകദേശം 42 മെഗാ ബൈറ്റുകളുടെ (megabyte) വലിപ്പമുണ്ട്; നിങ്ങൾ കംപൈലർ (compiler),

So, of course, there are several other development environments; if you are already using some

ഡീബഗ്ഗർ, (debugger) ഗ്രാഫിക്കൽ എൻവയൺമെൻറ് (graphical environment) തുടങ്ങിയവ ഡൗൺലോഡ് (download) ചെയ്യേണ്ടതുണ്ട്. ഇതിന് ഏകദേശം 42 MB വലുപ്പം ആവശ്യമാണ്. സജ്ജീകരിക്കാൻ കുറച്ച് മിനിറ്റ് എടുക്കും. ഇത് വളരെ

ഉപയോഗപ്രദമാണ്. മറ്റ് നിരവധി ഡെവലപ്മെന്റ്

IDE, go ahead and use it.

എൻവയൺമെന്റുകൾ (development environment) ഉണ്ട്. നിങ്ങൾ വേറെ IDE ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ, അത് തന്നെ തുടരുക.

If you are coming from the Linux world, you are probably used to the shell and you very

നിങ്ങൾ ലിനക്സ് (Linux) ആണ് ഉപയോഗിക്കുന്നതെങ്കിൽ ഒരുപക്ഷേ ഷെല്ലിലേക്ക് (shell) ഉപയോഗിച്ചിരിക്കാം,

likely have a GCC or some such compiler installed already; you can go ahead and use those also

കൂടാതെ നിങ്ങൾ ഇതിനകം ഒരു ജിസിസിയോ (GCC) അല്ലെങ്കിൽ അത്തരം ചില കംപൈലറോ (compiler) ഇൻസ്റ്റാൾ (install)

if you are familiar with them.

ചെയ്തിരിക്കാം; നിങ്ങൾക്ക് പരിചയമുണ്ടെങ്കിൽ

But, since I am showing a demo using dev C plus plus, it may make sense to actually use

മുന്നോട്ട് പോകാനും അവ ഉപയോഗിക്കാനും കഴിയും. പക്ഷേ, ഞാൻ ഡേവ് സി പ്ലസ് പ്ലസ്

it, so that you can track what you are doing. So, this is especially useful if you are new to programming.

(Dev C++) ഉപയോഗിച്ച് ഒരു ഡെമോ (demo) കാണിക്കുന്നതിനാൽ,

I suggest that, you actually practice the problems that I have given so for.

നിങ്ങൾ ഇത് ഉപയോഗിച്ചാൽ എന്താണ് ചെയ്യുന്നതെന്ന് ട്രാക്ക് (track) ചെയ്യാനാകും. നിങ്ങൾ പ്രോഗ്രാമിംഗിൽ

At times, I have given complete problem statements; at times I am giving only code segments; but,

(programming) പുതിയ ആളാണെങ്കിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഞാൻ നൽകിയിട്ടുള്ള പ്രശ്നങ്ങൾ നിങ്ങൾ പരിശീലിkkക്കുക. ചില

you have to go and write a complete program.

സമയങ്ങളിൽ, ഞാൻ പൂർണ്ണമായ പ്രശ്ന പ്രസ്താവനകൾ

You write complete programs whenever you can.

നൽകിയിട്ടുണ്ട്; ചില സമയങ്ങളിൽ ഞാൻ

And whenever it is needed, run the programs; test with your own inputs and ensure that,

കോഡ് സെഗ്‌മെന്റുകൾ (code segment) മാത്രമാണ് നൽകുന്നത്; പക്ഷേ, നിങ്ങൾ ഒരു പൂർണ്ണ

the programs that I have return so far are indeed correct.

പ്രോഗ്രാം (program) എഴുതണം. ആവശ്യമുള്ളപ്പോഴെല്ലാം

So, it is possible that, I have made some mistakes somewhere along.

പ്രോഗ്രാമുകൾ (program) പ്രവർത്തിപ്പിക്കുക; നിങ്ങളുടെ സ്വന്തം ഇൻ‌പുട്ടുകൾ‌ (input)

So, it is better that, you go and check these answers once before you move on to the next

ഉപയോഗിച്ച് പരിശോധിച്ച് ഞാൻ‌ ഇതുവരെ നൽ‌കിയ പ്രോഗ്രാമുകൾ‌ (program) ശരിയാണെന്ന് ഉറപ്പുവരുത്തുക. ഞാൻ എവിടെയോ ചില തെറ്റുകൾ വരുത്തിയിരിക്കാം.

lecture. So far, in this week, we have seen basics of programming in C; we saw the notions of

അതിനാൽ, അടുത്ത പ്രഭാഷണത്തിലേക്ക് പോകുന്നതിന് മുമ്പായി നിങ്ങൾ ഈ ഉത്തരങ്ങൾ പരിശോധിക്കുക എന്നതാണ്

variables; we saw the if statement; we saw the switch statement; and we saw for while

നല്ലത്. ഇതുവരെ, ഈ ആഴ്ചയിൽ, സി (C) യിലെ പ്രോഗ്രാമിംഗിന്റെ (programming) അടിസ്ഥാനകാര്യങ്ങൾ

and do while statements. We also saw basic operators and how to print and scan inputs.

നമ്മൾ കണ്ടു; വേരിയബിളുകൾ (variable) കണ്ടു; ഇഫ് സ്റ്റേറ്റ്മെന്റ്, സ്വിച്ച്, വയിൽ, ടു വയിൽ സ്റ്റേറ്റ്മെന്റ്

From next week onwards, we will see more sophisticate uses of these constructs in solving different

(if, while, do while statement) അടിസ്ഥാന ഓപ്പറേറ്ററുകളും (operator) ഇൻപുട്ടുകൾ (input) എങ്ങനെ പ്രിന്റു (print) ചെയ്യാമെന്നും സ്‌കാൻ (scan) ചെയ്യാമെന്നും കണ്ടു. അടുത്ത ആഴ്ച മുതൽ‌, വ്യത്യസ്‌ത

kinds of problems.

തരത്തിലുള്ള പ്രശ്‌നങ്ങൾ‌ പരിഹരിക്കുന്നതിന്

So, we are at the end of lecture 2.

ഈ കോൺസ്ട്രക്ടുകളുടെ (construct) കൂടുതൽ‌ സങ്കീർ‌ണ്ണമായ

Thank you.

ഉപയോഗങ്ങൾ‌ കാണും. ഇതോടെ പ്രഭാഷണം 2 അവസാനിക്കുകയാണ് . നന്ദി.