Introduction to arrays Programming, Data Structures and Algorithms English Malayalam

Introduction to arraysYouTube↗ IA↗(long shot)
People & Blogs 3K views 9 likes 0 dislikes 30 Jan 2018

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

Welcome to lecture three. So, in the last two lectures, we saw basics of C programming; and we also saw basic notions

മൂന്നാമത്തെ പ്രഭാഷണത്തിലേക്ക് സ്വാഗതം. കഴിഞ്ഞ രണ്ട് പ്രഭാഷണങ്ങളിൽ, സി പ്രോഗ്രാമിംഗിന്റെ (C programming) അടിസ്ഥാനകാര്യങ്ങൾ നമ്മൾ കണ്ടു; വേരിയബിളുകളുടെയും (variable) മറ്റും അടിസ്ഥാന ധാരണകളും കണ്ടു.

കൺട്രോൾ സ്ട്രക്ച്ചറുകളും (control structure) ലൂപ്പുകളും

of variables and so on.

(loop) പരിശോധിച്ചു.

We looked at control structures; we also looked at the notion of loops.

ഈ പ്രഭാഷണത്തിൽ, സി (C) നമുക്ക് നൽകുന്ന

So, in this lecture, we will see something really important that C provides us, and that

വളരെ പ്രധാനപ്പെട്ട ഒന്ന് കാണും, അതാണ് അറേകളുടെ (array) ആശയം.

is the notion of arrays.

പൂർണ്ണസംഖ്യകൾ, ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ

So, we have seen basic data types like integers, float pointing numbers and characters.

(floating point numbers), കാരക്ടറുകൾ (character) എന്നിവ പോലുള്ള

And these are basic data types. So, you can get numbers or letters using that.

അടിസ്ഥാന ഡാറ്റാ ടൈപ്പുകൾ (data types) നമ്മൾ കണ്ടു.

But sometimes we also need a logical collection of these values; it is not that, just one

ഇവ അടിസ്ഥാന ഡാറ്റാ ടൈപ്പുകളാണ് (data types).

value is sufficient; we need a logical collection of values.

ഇത് ഉപയോഗിച്ച് അക്കങ്ങളോ അക്ഷരങ്ങളോ ലഭിക്കും.

And this is where arrays come in.

എന്നാൽ ചിലപ്പോൾ ഈ മൂല്യങ്ങളുടെ ലോജിക്കൽ

So, arrays are what are called aggregate data types. So, it is an aggregate data type of a specific ((Refer Time: 01:03).

(logical) ശേഖരം ആവശ്യമാണ്; ഒരു മൂല്യം മാത്രം

It aggregates data of the same type of elements.

അല്ല; മൂല്യങ്ങളുടെ ഒരു ലോജിക്കൽ (logical)

You can also aggregate data of different types together; we will see that later.

ശേഖരം ആവശ്യമാണ്. ഇവിടെയാണ് അറേകൾ (array) വരുന്നത്.

These are called structures. We will see them later.

അതിനാൽ, അറേകളെ (array) അഗ്ഗ്രിഗേറ്റ് ഡാറ്റ

But arrays are aggregate elements of the same data type.

ടൈപ്പുകൾ (aggregate data types) എന്ന് വിളിക്കുന്നു.

So, there are lots of examples, where you need this.

ഇത് ഒരു നിർദ്ദിഷ്ട ഡാറ്റയുടെ (data) ആകെ

One primary thing is these arrays are usually fixed size and they are also sequentially

ഡാറ്റ ടൈപ്പാണ് (data types) ((Refer Time: 01:03). ഇത് ഒരേ തരത്തിലുള്ള മൂലകങ്ങളുടെ ഡാറ്റ

indexed.

സമാഹരിക്കുന്നു (data).

So, we will see all these things as we go along. So, arrays are logical collections of the same type.

നിങ്ങൾക്ക് വിവിധ തരം ഡാറ്റയും (data)

For instance, it could be list of marks of a student, it could be temperature that you

ഒരുമിച്ച് സമാഹരിക്കാം; അവ പിന്നീട് കാണും. ഇവയെ സ്ട്രക്ച്ചർ (structure) എന്ന് വിളിക്കുന്നു

are recording over a year or you want to save matrices and do operations on matrices, and

എന്നാൽ‌, ഒരേ ഡാറ്റാ (data) തരത്തിന്റെ ആകെ

so on.

ഘടകങ്ങളാണ്.

So, these are all examples of arrays.

അറേകൾ‌ (array). നിങ്ങൾക്ക് എവിടെയാണ് ആവശ്യമുള്ളത് എന്നതിന്

And on these arrays, you want to do operations like find minimum, find maximum or you want

ധാരാളം ഉദാഹരണങ്ങളുണ്ട്. ഒരു പ്രധാന കാര്യം ഈ അറേകൾ (array) സാധാരണയായി

to order all of the elements in such a way that, the names of students come in alphabetical

നിശ്ചിത വലുപ്പമുള്ളവയാണ്, അവ തുടർച്ചയായി ഇൻഡക്സ് (index) ചെയ്യപ്പെടുന്നു.

order or you may want to search for a particular temperature of the day and so on.

അറേകൾ ഒരേ തരത്തിലുള്ള ലോജിക്കൽ (logical) ശേഖരങ്ങളാണ്. ഉദാഹരണത്തിന്, ഇത് ഒരു വിദ്യാർത്ഥിയുടെ

So, these are common operations.

മാർക്കിന്റെ (mark) പട്ടികയായിരിക്കാം, നിങ്ങൾ ഒരു വർഷത്തിൽ

You want to be able to read entries into an array; you want to do operations on an array,

റെക്കോർഡ് (record) ചെയ്യുന്ന താപനിലയായിരിക്കാം അല്ലെങ്കിൽ മെട്രിക്സ് (matrix) സംരക്ഷിക്കാനും

and so on.

മെട്രിക്സിൽ (matrix) പ്രവർത്തനങ്ങൾ നടത്താനും

And that is exactly what we will do in this lecture.

നിങ്ങൾ ആഗ്രഹിക്കുന്നു.

So, let us do a little thought experiment.

ഇവയെല്ലാം അറേകളുടെ (array) ഉദാഹരണങ്ങളാണ്.

I want to find out average temperature of the year.

ഈ ശ്രേണികളിൽ, കുറഞ്ഞത് കണ്ടെത്തുക, പരമാവധി

So, I have 365 days.

കണ്ടെത്തുക അല്ലെങ്കിൽ എല്ലാ എലെമെന്റുകളും

And if I did not have support for these aggregate data types called arrays, my program would

(element) ക്രമീകരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, വിദ്യാർത്ഥികളുടെ പേരുകൾ അക്ഷരമാലാക്രമത്തിൽ

look something like this.

വരുന്നു അല്ലെങ്കിൽ ഒരു ദിവസത്തെ താപനില

So, I show only the code segment here.

തിരയാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം.

Let us see what it has.

ഇവ സാധാരണ പ്രവർത്തനങ്ങളാണ്.

So, there is first of all 365 days; I will need 365 variables; float, temperature 1,

ഒരു അറേയിലേക്ക് (array) എൻ‌ട്രികൾ‌ (entry) റീഡ് (read) ചെയ്യാനും; ഓപ്പറേഷനുകൾ (operation)

temperature 2, and so on up till temperature 365.

നടത്താനും കഴിയും. ഈ പ്രഭാഷണത്തിൽ നമ്മൾ അത് ചെയ്യും.

I will need all these declarations.

നമുക്ക് ഒരു ചെറിയ പരീക്ഷണം നടത്താം.

So, even though I showed dot dot dot, you really need so many declarations.

വർഷത്തിലെ ശരാശരി താപനില കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

And then I am going to find out the sum and the average – find the sum and therefore, find the average.

എനിക്ക് 365 ദിവസമുണ്ട്. അറേകൾ (array) എന്ന് വിളിക്കുന്ന ഈ അഗ്ഗ്രിഗേറ്റ് ഡാറ്റ (aggregate data) തരങ്ങൾ ഇല്ലെങ്കിൽ, എന്റെ

So, one thing that I have to do is take all the variables one at a time and read through

പ്രോഗ്രാം (program) ഇതുപോലെയായി കാണപ്പെടും., ഞാൻ ഇവിടെ കോഡ് സെഗ്മെന്റ് (code segment) മാത്രം കാണിക്കുന്നു.

them.

അതിലെന്താണ് എന്ന് നമുക്ക് നോക്കാം.

So, I have so many declarations and then I go on and scan all of them. And finally, I need a huge expression, which takes each of these variables; and add them

ആദ്യം 365 ദിവസമുണ്ട്; എനിക്ക് 365 വേരിയബിളുകൾ (variable) ആവശ്യമാണ്; ഫ്ലോട്ട്, (float) താപനില 1, താപനില 2, എന്നിങ്ങനെ താപനില 365 വരെ. എനിക്ക് ഈ ഡിക്ലറേഷനുകളെല്ലാം

up and give sum.

(declaration) ആവശ്യമാണ്.

So, what we have is something really cumbersome.

ഞാൻ ഡോട്ട് ഡോട്ട് ഡോട്ട് (dot) കാണിച്ചിട്ടുണ്ടെങ്കിലും,

So, we have 365 variable names; we will have to scan each one of them; and we will have

ശരിക്കും ധാരാളം ഡിക്ലറേഷനുകൾ (declaration) ആവശ്യമാണ്.

365 lines in which we will scan them.

എന്നിട്ട് ഞാൻ തുകയും ശരാശരിയും കണ്ടെത്താൻ

So, that is what you will do in this block here.

പോകുന്നു.

And finally, this one, where you are adding up all the values is also rather cumbersome,

ഞാൻ ചെയ്യേണ്ട ഒരു കാര്യം എല്ലാ വേരിയബിളുകളും (variable) റീഡ് (read) ചെയ്യുക എന്നതാണ്.

because if you forget something, you have no way to go back and check which one is missed

അതിനാൽ, എനിക്ക് വളരെയധികം ഡിക്ലറേഷനുകൾ (declaration) ഉണ്ട്, തുടർന്ന് അവയെല്ലാം സ്കാൻ

out.

(scan) ചെയ്യുന്നു.

So, this is not a nice way to do things.

അവസാനമായി, എനിക്ക് ഒരു വലിയ എക്സ്പ്രഷൻ

And programming languages give support for the same data type; temperature being floating

(expression) ആവശ്യമാണ്, അത് ഈ ഓരോ വേരിയബിളുകളും

point and have many of those aggregated into something called an array.

(variable) എടുക്കുന്നു; അവ ചേർത്ത് തുക നൽകുക.

So, let us see the same thing done using arrays.

അതിനാൽ, നമുക്കുള്ളത് ശരിക്കും ബുദ്ധിമുട്ടുള്ള

It is much more elegant if we use arrays.

കാര്യമാണ്. 365 വേരിയബിൾ (variable) പേരുകൾ ഉണ്ട്; നമുക്ക് അവ

So, the first thing you will notice is that, there is float temp of 365.

ഓരോന്നും സ്കാൻ (scan) ചെയ്യേണ്ടിവരും; 365 ലൈനുകൾ ഉണ്ടാകും, അതിൽ സ്കാൻ (scan) ചെയ്യും.

So, what you see here is you see that, there is a declaration here; which goes like open

അവസാനമായി, നിങ്ങൾ എല്ലാ മൂല്യങ്ങളും ചേർക്കുന്നിടത്ത് ഇത് വളരെ ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്, കാരണം നിങ്ങൾ എന്തെങ്കിലും

bracket 365 close bracket.

മറന്നാൽ, തിരികെ പോകാനും ഏതാണ് നഷ്‌ടമായതെന്ന്

All it says is I do not want a single floating point number; I need 365 floating point numbers.

പരിശോധിക്കാനും മാർഗമില്ല. അതിനാൽ, കാര്യങ്ങൾ ചെയ്യാനുള്ള നല്ലൊരു മാർഗമല്ല ഇത്. പ്രോഗ്രാമിംഗ് (programming) ഭാഷകൾ ഒരേ ഡാറ്റ

So, that has to be allocated somewhere.

തരത്തിന് പിന്തുണ നൽകുന്നു; താപനില

As before, we have float sum equals 0 and average.

ഫ്ലോട്ടിംഗ് പോയിന്റായതിനാൽ (floating point) അവയെ ഒരു അറേ

And now, I want to scan the elements one-by-one.

(array) യിൽ വെക്കാം. അതിനാൽ, അറേ (array) ഉപയോഗിച്ച ഇതേ കാര്യം നമുക്ക്

This whole thing becomes very nice and simple; you have seen the for loop before.

നോക്കാം. നമ്മൾ അറേകൾ (array) ഉപയോഗിക്കുകയാണെങ്കിൽ ഇത് കൂടുതൽ ഗംഭീരമാണ്.

For i equals 0; i less than 365 i plus plus scanf ampersand temp of i.

നിങ്ങൾ ആദ്യം ശ്രദ്ധിക്കുന്നത്, 365 ന്റെ ഫ്ലോട്ട് (float) ടെംപ് (temp) ഉണ്ട് എന്നതാണ്.

So, what this loop does is it scans the elements one-by-one and it stores it in what is called

ഇവിടെ ഒരു ഡിക്ലറേഷൻ (declaration) ഉണ്ട്; അത് ഓപ്പൺ

temp of i.

ബ്രാക്കറ്റ് 365 ക്ലോസ് ബ്രാക്കറ്റ് പോലെ

We will see what temp of i means in a little while.

പോകുന്നു. ([365]) അതിൽ പറയുന്നത് എനിക്ക് ഒരു ഫ്ലോട്ടിംഗ്

But, the first thing I want you to do observe is that, let us become much more elegant.

പോയിൻറ് നമ്പർ (floating point number) ആവശ്യമില്ല;

Instead of 365 lines that you had earlier, now, you have three lines of code, which is

എനിക്ക് 365 ഫ്ലോട്ടിംഗ് പോയിൻറ് നമ്പറുകൾ

scanning 365 elements.

(floating point number) ആവശ്യമാണ്.

The other thing that we have very nice is just the addition itself.

അതിനാൽ, അത് എവിടെയെങ്കിലും അനുവദിക്കണം. മുമ്പത്തെപ്പോലെ, ഫ്ലോട്ട് സം (sum) 0 ഉം

So, as before, we iterate over all the elements from i equal to 0 to i equals 364 – both

ആവറേജും (average) ഉണ്ട്. ഇപ്പോൾ, എലെമെന്റുകൾ (element) ഓരോന്നായി സ്കാൻ (scan) ചെയ്യാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

inclusive; and we add the temperature to sum. So, you add one temperature at a time and the result goes back to sum.

ഫോർ ലൂപ്പ് (for loop) നിങ്ങൾ മുമ്പ് കണ്ടു. for (i= 0; i < 365 i++) scanf (“&temp[ i]”).

At the end of this loop, you have the sum, which is the sum of all the temperatures over

ഈ ലൂപ്പ് (loop)ചെയ്യുന്നത് എലെമെന്റുകളെ ഓരോന്നായി

365 days. So, if you divide by 365, you get average.

സ്കാൻ (scan) ചെയ്യുകയും അത് ടെംപ് ഓഫ് ഐ (temp[i[)

So, one thing that you have to notice here is that, the sum is actually initialized to

എന്ന് വിളിക്കുകയും ചെയ്യുന്നു. മുമ്പ് ഉണ്ടായിരുന്ന 365 വരികൾക്ക് പകരമായി,

0 here. Therefore, you start with 0 as the temperature and then you add on temperature of each of

ഇപ്പോൾ മൂന്ന് വരി കോഡ് ഉണ്ട്, അത് 365

the days to give temperatures of 365 days; and then you divide by 365.

എലെമെന്റുകൾ (element) സ്കാൻ (scan) ചെയ്യുന്നു. നമുക്ക് വളരെ മനോഹരമായിട്ടുള്ള മറ്റൊരു കാര്യം അഡിഷൻ

So, the nice thing about this whole thing is it fits into one screen.

ആണ്. മുമ്പത്തെപ്പോലെ, i 0 മുതൽ 365 വരെയുള്ള

So, if I want 5 years, all I have to do is ensure that, I iterate over 365 into 5 iterations.

എല്ലാ എലെമെന്റുകളെയും (element) ആവർത്തിക്കുന്നു - രണ്ടും ഉൾപ്പെടുന്നു; ഒരു സമയം ഒരു താപനില

So, that piece of code is still going to be something very very small.

ചേർക്കുന്നു, ഫലം ആകെത്തുകയിലേക്ക്

So, I do not have to declare so many variables; and the program does not get clumsy; and there is less scope for errors when you have arrays than when you have individual variables.

പോകുന്നു. ഈ ലൂപ്പിന്റെ (loop) അവസാനം, നിങ്ങൾക്ക് സം (sum) ഉണ്ട്, ഇത് 365 ദിവസത്തിലെ എല്ലാ താപനിലകളുടെയും ആകെത്തുകയാണ്.

ഇതിനെ 365 കൊണ്ട് ഹരിച്ചാൽ ശരാശരി ലഭിക്കും.

So, let us go and look at arrays in more detail now.

ഇവിടെ ശ്രദ്ധിക്കേണ്ട ഒരു കാര്യം, തുക യഥാർത്ഥത്തിൽ

The first thing is – as before, we need to declare arrays before we use them. So, the syntax is as follows.

0 ആയി ആരംഭിക്കുന്നു എന്നതാണ്. നിങ്ങൾ 0 ആയി താപനില ആരംഭിച്ച് 365 ദിവസത്തെ

So, you start with type and then you give an array name and then you give number of

താപനില നൽകുന്നതിന് ഓരോ ദിവസത്തെയും താപനില ചേർക്കുന്നു; എന്നിട്ട് 365 കൊണ്ട് ഹരിക്കുന്നു.

elements.

എനിക്ക് 5 വർഷം വേണമെങ്കിൽ, ഞാൻ ചെയ്യേണ്ടത്

So, just like this – you specify the type; you specify the array name; and you want the

365-ൽ 5 ആവർത്തനങ്ങളായി ആവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക മാത്രമാണ്.

number of elements. So, in this case, marks is an array of size 7 and they are all integers.

ആ കോഡ് (code) ഇപ്പോഴും വളരെ ചെറുതായിരിക്കും. അതിനാൽ, എനിക്ക് വളരെയധികം വേരിയബിളുകൾ (variable) ഡിക്ലയർ (declare) ചെയ്യേണ്ടതില്ല;

So, the key thing is – remember – this is an aggregate data type of type integer

വ്യക്തിഗത വേരിയബിളുകളുള്ളതിനേക്കാൾ (variable) അറേകളുള്ളപ്പോൾ

here.

(array) പിശകുകൾക്ക് സാധ്യത കുറവാണ്.

Similarly, in this line, we have temperature, which is an array of 365 elements; and the

കൂടുതൽ വിശദമായി അറേകൾ (array) നോക്കാം. ആദ്യത്തേത് - മുമ്പത്തെപ്പോലെ, അറേകൾ (array) ഉപയോഗിക്കുന്നതിന്

values that it can contain are floating point values.

മുമ്പ് അവ ഡിക്ലയർ (declare) ചെയ്യേണ്ടതുണ്ട്.

So, one important thing that you have to remember is that, when you say int marks of 7 for example, you get something, which is contiguous in nature; as in, these are locations, which

സിന്റാക്സ് (syntax) ഇപ്രകാരമാണ്. നിങ്ങൾ ടൈപ്പ് (type) ഉപയോഗിച്ച് ആരംഭിക്കുക, തുടർന്ന് ഒരു അറേ (array) നാമം നൽകുകയും തുടർന്ന് എലെമെന്റുകളുടെ (element) എണ്ണം നൽകുകയും

are continuous in your memory.

ചെയ്യുന്നു. ഈ സാഹചര്യത്തിൽ, മാർക്ക് (mark) 7 വലുപ്പത്തിന്റെ

And the individual elements of the array can be indexed as marks of 0, marks of 1, and

ഒരു ശ്രേണിയാണ്, അവയെല്ലാം പൂർണ്ണസംഖ്യകളാണ്. അതിനാൽ, പ്രധാന കാര്യം - ഓർമ്മിക്കുക - ഇത്

so on up till marks of 6.

ഇവിടെ ഇൻറിജറിന്റെ അഗ്ഗ്രിഗേറ്റ് ഡാറ്റാ

So, anything which is of the form marks of i, where 0 less than or equal to i, less than

ടൈപ്പ് (type) ആണ്. അതുപോലെ, ഈ വരിയിൽ, നമുക്ക്

or equal to 6 is valid.

താപനിലയുണ്ട്, അത് 365 മൂലകങ്ങളുടെ ഒരു

Let us see what happens from the memory point of view.

നിരയാണ്; അതിൽ അടങ്ങിയിരിക്കുന്ന മൂല്യങ്ങൾ ഫ്ലോട്ടിംഗ്

So, earlier, we saw what happens to variables from the memory point of view.

പോയിന്റ് (floating point ) മൂല്യങ്ങളാണ്.

Let us see what happens to arrays from a memory point of view.

അതിനാൽ, നിങ്ങൾ ഓർത്തിരിക്കേണ്ട ഒരു പ്രധാന കാര്യം,

So, when you see a declaration like int marks of 7, what you are really seeing is an array.

ഉദാഹരണത്തിന് int mark[7] എന്ന് നിങ്ങൾ പറയുമ്പോൾ, മെമ്മറിയിൽ (memory) തുടർച്ചയായ ലൊക്കേഷനുകളാണ്

So, you see memory locations here; I am showing only a segment of the memory. And instead of one variable called marks, we are going to have 7 variables named marks of 0 to marks of 6.

(location) ലഭിക്കുന്നത് അറേയുടെ വ്യക്തിഗത എലെമെന്റുകളെ (element) 0, 1 മാർക്ക്, എന്നിങ്ങനെ 6 മാർക്ക് വരെ ഇൻഡക്സ് ചെയ്യാം. മെമ്മറി (memory) കാഴ്ചപ്പാടിൽ നിന്ന് എന്ത് സംഭവിക്കുമെന്ന്

So, this is not a mistake; it is marks of 0 to six, and not 1 to 7.

നമുക്ക് നോക്കാം. മെമ്മറി (memory) കാഴ്ചപ്പാടിൽ നിന്ന് വേരിയബിളുകൾക്ക്

So, some languages start indexing arrays at 1; but C indices start at 0.

എന്ത് സംഭവിക്കുമെന്ന് നേരത്തെ കണ്ടു. ഒരു മെമ്മറി (memory) കാഴ്ചപ്പാടിൽ നിന്ന് അറേകൾക്ക് (array) എന്ത് സംഭവിക്കുമെന്ന് നമുക്ക് നോക്കാം.

So, you can think of it as 7 variables namely, marks of 0 to marks of 6.

int mark[7] പോലുള്ള ഒരു ഡിക്ലറേഷൻ (declaration)

And as we did earlier, if you do not have any initialization, the values in the array

കാണുമ്പോൾ, നിങ്ങൾ ശരിക്കും കാണുന്നത് ഒരു ശ്രേണിയാണ്. നിങ്ങൾ ഇവിടെ മെമ്മറി ലൊക്കേഷനുകൾ കാണുന്നു; ഞാൻ മെമ്മറിയുടെ (memory) ഒരു ഭാഗം മാത്രമാണ്

are unknown.

കാണിക്കുന്നത്.

You should assume that, these values are unknown.

മാർക്ക് എന്ന് വിളിക്കുന്ന ഒരു വേരിയബിളിന്

And this could get laid out anywhere in the memory just like variables do.

(variable) പകരം, നമുക്ക് 0 മുതൽ 6 വരെ മാർക്ക്

The only thing is that, these are going to be 7 contiguous locations.

(mark) എന്ന് പേരുള്ള 7 വേരിയബിളുകൾ (variable)

So, for instance, let us assume that, marks of 0 was allocated address 2731; then marks

ലഭിക്കും. അതിനാൽ, ഇത് ഒരു തെറ്റല്ല; ഇത് 0 മുതൽ ആറ് വരെയാണ്,

of 1 would be at address 2732 and so on; marks of 6 would be at address 2737.

1 മുതൽ 7 വരെ അല്ല. ചില ഭാഷകൾ 1 മുതൽ ഇൻഡെക്‌സിംഗ്

So, this is what I meant by arrays are going to have contiguous set of locations.

(indexing) ആരംഭിക്കുന്നു; എന്നാൽ സി ഇൻഡക്സ് (index) 0 ൽ ആരംഭിക്കുന്നു.

So, as I said, each element can be thought of as a variable.

അതിനാൽ, നിങ്ങൾക്ക് ഇത് 7 വേരിയബിളുകളായി

Just like individual variables, they start out to uninitialized.

(variable) ചിന്തിക്കാം, അതായത് 0 മുതൽ 6 വരെ

One nice thing is once you have declared an array; just like in variables, you can assign

മാർക്ക്. നമ്മൾ നേരത്തെ ചെയ്തതുപോലെ, ഒരു ഇനിഷ്യലായ്സേഷനും (initialization) ഇല്ലെങ്കിൽ, അറേയിലെ (array) മൂല്യങ്ങൾ

values to these variables.

അജ്ഞാതമാണ്.

So, we saw that, we can have left-hand side variable name, right-hand side value or expressions

ഈ മൂല്യങ്ങൾ അജ്ഞാതമാണെന്ന് നിങ്ങൾ അനുമാനിക്കണം. വേരിയബിളുകൾ (variable) ചെയ്യുന്നതുപോലെ മെമ്മറിയിൽ എവിടെയും ഇത് സ്ഥാപിക്കപ്പെടാം.

for variables. The same thing applies for arrays.

ഒരേയൊരു കാര്യം, ഇവ 7 തുടർച്ചയായ സ്ഥലങ്ങളായിരിക്കും.

So, in the left-hand side, you have an individual variable – marks of 3; and on the right-hand

ഉദാഹരണത്തിന്, 0 ന്റെ മാർക്ക് അഡ്രസ്സ്

side, we have a value 36. So, if you do this in your program, then the value will go to 36. So, at this point, you know the contents of the location marks of 3.

(address) 2731 എന്ന് അനുവദിച്ചുവെന്ന് കരുതുക; 1 ന്റെ മാർക്ക് അഡ്രസ്സ് (address) 2732 ൽ ആയിരിക്കും; 6 ന്റെ മാർ‌ക്ക് അഡ്രസ്സ് (address) 2737 ആയിരിക്കും.

As before, we can use ampersand to get the location of the memory.

അതിനാൽ‌, അറേകൾ‌ (array) തുടർച്ചയായി ഒരു കൂട്ടം ലൊക്കേഷനുകൾ‌ (location) ആയിരിക്കും.

So, for instance, if I want let us say address of marks of 2, then I do ampersand of marks of 2; and ampersand of marks of 2 would give me 2733 as the value; ampersand of marks of

ഓരോ എലെമെന്റിനെയും (element) ഒരു വേരിയബിളായി (variable) കണക്കാക്കാം. വ്യക്തിഗത വേരിയബിളുകൾ (variable) പോലെ, അവ ഇനിഷ്യലായിസ് ചെയ്യാതെ തുടങ്ങുന്നു.

നിങ്ങൾ ഒരു അറേ പ്രഖ്യാപിച്ചുകഴിഞ്ഞാൽ വേരിയബിളുകളിലെന്നപോലെ

1 would give me 2732 as the value, and so on. So, the addresses are going from 2731 down to 2737 in increasing values.

(variable), മൂല്യങ്ങൾ നൽകാം. ഇടത് വശത്തുള്ള വേരിയബിൾ (variable) നാമം, വ ലതുവശത്തെ മൂല്യം അല്ലെങ്കിൽ വേരിയബിളുകൾക്കുള്ള (v ariable) എക്സ്പ്രഷനുകൾ (expression) ഉണ്ട്.

So, they are contiguous and they are increasing from 0 to array index 6.

അറേകൾക്കും (array) ഇത് ബാധകമാണ്. ഇടത് വശത്ത്, ഒരു വ്യക്തിഗത വേരിയബിൾ

So, let us revisit the example that we did earlier.

(variable) ഉണ്ട് - മാർക്ക്[3]; വലതുവശത്ത്, 36 എന്ന

So, we have float temp of 365; say we have an array of type float and 365 values. At this point, we do not care about where it is getting laid out in the memory, because

മൂല്യം ഉണ്ട്. അതിനാൽ, നിങ്ങളുടെ പ്രോഗ്രാമിൽ (program) നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ, മൂല്യം 36 ലേക്ക് പോകും. ഈ സമയത്ത്, 3 ന്റെ ലൊക്കേഷൻ (location) മാർക്ക്[3]

that is something that, your run time system should do.

യുടെ ഉള്ളടക്കങ്ങൾ നിങ്ങൾക്കറിയാം. മെമ്മറിയുടെ (memory) സ്ഥാനം ലഭിക്കുന്നതിന്

So, as a programmer, we do not care about where it is in the memory location; just like

നമുക്ക് ആമ്പർസാൻഡ്(& )(ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, മാർക്ക്[2] ന്റെ അഡ്രസ്സ് പറയാൻ

for variables, we do not care where they are in the memory.

ഞാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, &മാർക്ക്[2] ചെയ്യുന്നു;

Then this is something that, I did not draw attention to earlier.

&മാർക്ക്[3] എനിക്ക് 2733 മൂല്യമായി നൽകും;

Now, let us see what it is doing.

&മാർക്ക്[1] എനിക്ക് 2732 മൂല്യമായി നൽകും,

If it is an individual variable, we saw that scanf takes the format and the address of

അങ്ങനെ. അതിനാൽ, അഡ്രസ്സുകൾ 2731 ൽ നിന്ന് വർദ്ധിച്ചു 2737 ലേക്ക് പോകുന്നു.

a variable; the same thing is happening here. We have the format here and we have the address of a variable; only that, the variable is

അവ തുടർച്ചയായവയാണ്, 0 മുതൽ 6 വരെ അറേ ഇൻഡക്സ് (array index) വർദ്ധിക്കുന്നു.

not an individual variable; it is actually an array location.

നമ്മൾ മുമ്പ് ചെയ്ത ഉദാഹരണം വീണ്ടും

So, temp of i is temp of 0, temp of 1, temp of 2, so on till temp of 364.

സന്ദർശിക്കാം. ഫ്ലോട്ട് ടെംപ്[365] (float temp[365]) ഉണ്ട്; ടൈപ്പ് (type) ഫ്ലോട്ടും (float) 365 മൂല്യങ്ങളും ഉണ്ടെന്നിരിക്കട്ടെ.

And when finally, when you look at this loop, it runs from 0 to 364; so it actually runs

ഈ സമയത്ത്, മെമ്മറിയിൽ (memory) എവിടെയാണ് ഇത് സ്ഥാപിക്കുന്നതെന്ന് നമ്മൾ ശ്രദ്ധിക്കുന്നില്ല,

365 times. So, your array is indexed from 0 to 364; the loop also runs from 0 to 364. We are actually scanning 365 elements.

കാരണം ഇത് നിങ്ങളുടെ റൺ ടൈം സിസ്റ്റം (run time system) ചെയ്യേണ്ട ഒന്നാണ്. അതിനാൽ, ഒരു പ്രോഗ്രാമർ (programmer) എന്ന നിലയിൽ,

And in this loop, we are adding all the 365 elements into sum and you average at the end

മെമ്മറി (memory) സ്ഥാനത്ത് അത് എവിടെയാണെന്ന് നമ്മൾ ശ്രദ്ധിക്കുന്നില്ല; വേരിയബിളുകളെപ്പോലെ, (variable) അവ മെമ്മറിയിൽ (memory) എവിടെയാണെന്ന്

of it.

നമ്മൾ ശ്രദ്ധിക്കുന്നില്ല.

So, it is as simple as that.

ഇപ്പോൾ, അത് എന്താണ് ചെയ്യുന്നതെന്ന്

So, from arrays, we get contiguous locations and we have a same data type; but we have

നമുക്ക് നോക്കാം. ഇത് ഒരു വ്യക്തിഗത വേരിയബിളാണെങ്കിൽ (variable), സ്കാൻഫ് (scanf) ഒരു വേരിയബിളിന്റെ

many elements of the same data type one after the other.

(variable) ഫോർമാറ്റും (format) അഡ്രസ്സും (address)

There are various ways to initialize arrays; you can do something like this. Let us say I want marks of 7 students and I could have it as int marks of 7 and read

എടുക്കുന്നതായി നമ്മൾ കണ്ടു; ഇവിടെയും ഇതുതന്നെ സംഭവിക്കുന്നു. നമുക്ക് ഇവിടെ ഫോർമാറ്റ് (format) ഉണ്ട്, ഒരു വേരിയബിളിന്റെ (variable) അഡ്രസ്സ് (address) ഉണ്ട്; വേരിയബിൾ

it from the user. Or, sometimes I know what these values are.

(variable) ഒരു വ്യക്തിഗത വേരിയബിൾ (variable) അല്ല;

So, I could initialize it right away; I could do this.

ഇത് യഥാർത്ഥത്തിൽ ഒരു അറേ ലൊക്കേഷനാണ്

So, int marks of 7.

(array location).

So, I am declaring marks to be an integer array of 7 elements. And you can specify the list of values on the right-hand side using a curly braces.

അതിനാൽ, ടെംപ് [i] ടെം‌പ്[1], ടെം‌പ്[2], ടെം‌പ്[3], അങ്ങനെ ടെം‌പ്[364] വരെ (temp[1], temp[2], tem[3]...tem[[364]. ഒടുവിൽ, നിങ്ങൾ ഈ ലൂപ്പ് (loop) നോക്കുമ്പോൾ

So, in this case, marks of 0 would be 22; marks of 2 would be 75; marks of 6 would be

അത് 0 മുതൽ 364 വരെ പ്രവർത്തിക്കുന്നു; ഇത് യഥാർത്ഥത്തിൽ 365 തവണ പ്രവർത്തിക്കുന്നു.

45 and so on. So, the locations on the left side can be seen as 0 to 7; and the values can be seen

അതിനാൽ, നിങ്ങളുടെ ശ്രേണി 0 മുതൽ 364 വരെ ഇൻഡക്സ് (index) ചെയ്തിരിക്കുന്നു; ലൂപ്പും 0 മുതൽ 364 വരെ

from left to right.

പ്രവർത്തിക്കുന്നു.

So, you get a one-to-one mapping from left side to the right side.

യഥാർത്ഥത്തിൽ 365 എലെമെന്റുകൾ (element) സ്കാൻ (scan) ചെയ്യുന്നു.

So, when you do this, let us say these are locations 0 to 6 and the values are 22 for

ഈ ലൂപ്പിൽ (loop), എല്ലാ 365 എലെമെന്റുകളും (element) ആകെ ചേർക്കുന്നു, അതിന്റെ അവസാനം ആവറേജ്

0, 15 for 1, and so on till 45 for marks of 6.

(average) കണ്ടുപിടിക്കുന്നു. അതിനാൽ, അറേകളിൽ (array) നിന്ന്, തുടർച്ചയായ സ്ഥാനങ്ങൾ ലഭിക്കുന്നു, ഒന്നിനുപുറകെ ഒന്നായി

It is not just that you can initialize and leave it at that; you can change the values

ഒരേ ഡാറ്റാ ടൈപ്പിന്റെ (datatype) നിരവധി എലെമെന്റുകൾ

just like you do for other variables.

(element) നമ്മുടെ പക്കലുണ്ട്.

So, you can do something of this effect.

അറേ (array) ഇനിഷ്യലായസ് (initialize) ചെയ്യുന്നതിന്

Even though you have initialized, mark of 3 to 56, we can do some assignment like this

വിവിധ മാർഗങ്ങളുണ്ട്; എനിക്ക് 7 വിദ്യാർത്ഥികളുടെ മാർക്ക് (mark) വേണമെന്ന് പറയട്ടെ, എനിക്ക്

– marks of 3 equal to 36; and that will change the value to 36.

ഇന്റ മാർക്ക്[7] (int mark[7]) എന്ന് കൊടുത്ത്

So, we saw that, the value changed from 56 to 36.

ഉപയോക്താവിൽ നിന്ന് റീഡ് (read) ചെയ്യാൻ

So, there are a few fine points that you have to remember.

കഴിയും. അല്ലെങ്കിൽ, ചിലപ്പോൾ ഈ മൂല്യങ്ങൾ എന്താണെന്ന്

Array indices always start at 0 in C. If you come from other programming languages, some languages start at 1. So, be aware of this.

എനിക്കറിയാം. അതിനാൽ, എനിക്ക് ഉടൻ തന്നെ ഇത് ഇനിഷ്യലായസ് (initialize) ചെയ്യാം; ഞാൻ മാർക്‌സ് (marks) എന്നത്

This is a common mistake and lot of people get trapped in this thing that, the indices start at 1 and not at 0.

7 എലെമെന്റുകളുടെ (element) ഒരു ഇന്റിജർ അറേ (integer array) ആയി ഡിക്ലയർ (declare) ചെയ്യുന്നു.

So, in C, they do start at 0.

കർലി ബ്രേസുകൾ (curly brace) ഉപയോഗിച്ച് വലതുവശത്തുള്ള

And when you do marks of 7, marks of 0 to 6 – all are valid; marks of 7 is invalid

മൂല്യങ്ങളുടെ പട്ടിക വ്യക്തമാക്കാൻ കഴിയും. അതിനാൽ, ഈ സാഹചര്യത്തിൽ, മാർക്ക്[0] (mark[0]) 22 ആയിരിക്കും;

as well as marks of minus 1 or minus 2 and so on. So, you will never have indices, which are negative; nor, you will have an index, which

മാർക്ക്[2] (mark[2]) 75 ആയിരിക്കും; മാർക്ക്[6] (mark[6]) 45 ആയിരിക്കും. ഇടതുവശത്തുള്ള സ്ഥാനങ്ങൾ 0 മുതൽ 7 വരെ കാണാം;

is greater than and equal to the declaration that you had.

മൂല്യങ്ങൾ ഇടത്തുനിന്ന് വലത്തോട്ട് കാണാൻ

So, for example, in the float that you showed earlier, so we have 365.

കഴിയും. അതിനാൽ, ഇടത് വശത്ത് നിന്ന് വലതുവശത്തേക്ക് നിങ്ങൾക്ക് ഒരു വൺ ടു വൺ മാപ്പിംഗ്

So, temp of 365 would be invalid, because we have only temp of 0 to temp of 364.

(one-to-one mapping) ലഭിക്കും. നിങ്ങൾ ഇത് ചെയ്യുമ്പോൾ, ഇവ 0 മുതൽ 6 വരെയുള്ള സ്ഥാനങ്ങളാണെന്നും മൂല്യങ്ങൾ 0 ന് 22, 1 ന് 15 എന്നിങ്ങനെയാണെന്നും 6 മാർക്കിന് 45 വരെ

ആണെന്നും പറയാം.

So, I want to talk about another small example, which is along the lines of finding the hottest

ഇത് നിങ്ങൾക്ക് ഇനിഷ്യലായസ് (initialize) ചെയ്യുക മാത്രമല്ല മറ്റ് വേരിയബിളുകൾ (variable) പോലെ മൂല്യങ്ങൾ മാറ്റാനും കഴിയും. നിങ്ങൾ ഇനിഷ്യലായസ് (initialize) ചെയ്തിട്ടുണ്ടെങ്കിലും

, 3 മുതൽ 56 വരെ ചില അസൈൻമെന്റുകൾ (assignment) ചെയ്യാൻ കഴിയും - 3 ന് 36 ന് തുല്യമായ മാർക്ക്; അത് മൂല്യം

day.

36 ആയി മാറ്റും.

So, I have read 365 temperatures into an array called temp; but I want to find out the maximum

അതിനാൽ, മൂല്യം 56 ൽ നിന്ന് 36 ആക്കി. അതിനാൽ, നിങ്ങൾ ഓർമ്മിക്കേണ്ട ചില പോയിൻറുകൾ (point) ഉണ്ട്. അറേ ഇൻഡെക്സുകൾ (array index) എല്ലായ്പ്പോഴും

സി (C) യിൽ 0 ൽ ആരംഭിക്കുന്നു.

temperature or which day was the hottest day.

നിങ്ങൾ മറ്റ് പ്രോഗ്രാമിംഗ് (programming) ഭാഷകളിൽ നിന്നാണെങ്കിൽ, ചില ഭാഷകൾ 1 ൽ ആരംഭിക്കുന്നു.

So, what I want the user to print is print the day in which the day was the hottest as

അതിനാൽ, ഇതിനെക്കുറിച്ച് അറിഞ്ഞിരിക്കുക. ഇത് ഒരു സാധാരണ തെറ്റാണ്, കൂടാതെ ധാരാളം ആളുകൾ ഈ വിഷയത്തിൽ കുടുങ്ങുകയും ചെയ്യുന്നു, ഇൻഡെക്സുകൾ 1 ലാണ് ആരംഭിക്കുന്നത്, 0 അല്ല. സി (C) യില് അവ

well as a temperature of that day.

0 ൽ ആരംഭിക്കുന്നു. കൂടാതെ മാർക്ക് [7] (mark[7]) ചെയ്യുമ്പോൾ

So, as before, we have float temp of 365; and I have two arrays – two variables namely,

0 മുതൽ 6 വരെ - എല്ലാം സാധുവാണ്; മാർക്ക് [7] (mark[7]) അസാധുവാണ്, അതുപോലെ തന്നെ മാർക്ക് [-1], (mark[-1]) മാർക്ക് [-2] (mark[-2]) എന്നിവയും. ഒരിക്കലും നെഗറ്റീവ് (negative) ആയ ഇൻഡെക്സുകൾ

(index) ഉണ്ടാകില്ല; കൂടാതെ, നിങ്ങൾക്ക് ഉണ്ടായിരുന്ന ഒരു ഡിക്ലറേഷനെക്കാൾ (declaration) വലുതും തുല്യവുമായ

hottest day and i.

ഒരു ഇൻഡക്സ് (index) ഉണ്ടാവുകയില്ല. ഉദാഹരണത്തിന്, നിങ്ങൾ മുമ്പ് കാണിച്ച ഫ്ലോട്ടിൽ

I am going to use hottest day to find out which day is the hottest.

(float), 365 ഉണ്ട്. അതിനാൽ, 365 ന്റെ ടെം‌പ്[365] (temp[365])അസാധുവാണ്, കാരണം ടെംപ് [0] മുതൽ ടെം‌പ് [364] വരെ മാത്രമേ ഉള്ളൂ.

And I am going to use i to iterate over all the locations.

മറ്റൊരു ചെറിയ ഉദാഹരണത്തെക്കുറിച്ച് സംസാരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, അത് ഏറ്റവും ചൂടേറിയ ദിവസം കണ്ടെത്തുന്നതിനുള്ള വഴിയാണ്.

So, initially, what I am going to assume is day 0 is the hottest.

അതിനാൽ, ഞാൻ 365 താപനിലയെ ടെംപ് (temp) എന്ന അറേയിലേക്ക് (array) റീഡ് (read) ചെയ്തു; പക്ഷെ പരമാവധി താപനില

So, let us say this is January 1; I assume that, January 1 is the hottest and it is day

അല്ലെങ്കിൽ ഏറ്റവും ചൂടേറിയ ദിവസം ഏതെന്ന് കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു. അതിനാൽ, ഉപയോക്താവ് അച്ചടിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നത് ആ ദിവസത്തെ ഏറ്റവും

ചൂടേറിയതും ആ ദിവസത്തെ താപനിലയും അച്ചടിക്കുക എന്നതാണ്. അതിനാൽ, മുമ്പത്തെപ്പോലെ, ഞങ്ങൾക്ക് ഫ്ലോട്ട്

ടെംപ്[365] (float temp[365]) ഉണ്ട്; എനിക്ക് രണ്ട് അറേകളുണ്ട്

So, temp of hottest day, which is temp of 0 goes to max.

(array) - രണ്ട് വേരിയബിളുകൾ (variable), അതായത് ഹോട്ടെസ്റ് ഡേ (hottest day), i. ഏത് ദിവസമാണ് ഏറ്റവും ചൂടേറിയതെന്ന് കണ്ടെത്താൻ ഞാൻ ഏറ്റവും ഹോട്ടെസ്റ് ഡേ (hottest

Now, I run a loop from 1 to 364.

day) ഉപയോഗിക്കാൻ പോകുന്നു. എല്ലാ ലൊക്കേഷനുകളിലും (location) ആവർത്തിക്കാൻ ഞാൻ i ഉപയോഗിക്കാൻ പോകുന്നു.

So, this goes from January 2 till December 31.

തുടക്കത്തിൽ, ഞാൻ അനുമാനിക്കാൻ പോകുന്നത് ദിവസം 0 ആണ് ഏറ്റവും ചൂടേറിയത്.

And what I am going to do is I am going to see if the current temperature is less than the…

ഇത് ജനുവരി 1 ആണെന്ന് നമുക്ക് പറയാം; ജനുവരി 1 ഏറ്റവും ചൂടേറിയതും അത് ദിവസം 0 ഉം ആണെന്ന്

The current maximum temperature that I have in record is less than temperature of day

ഞാൻ അനുമാനിക്കുന്നു. അതിനാൽ, ടെംപ് [ഹോട്ടെസ്റ് ഡേ] (temp[hottest day] എന്നത്

i. So, if it is less, then max is that I have is not the actual max; some other day became hotter.

ടെംപ് [0 ] (temp[0]) മാക്സ് (max) ആയി മാറുന്നു. ഇപ്പോൾ, ഞാൻ 1 മുതൽ 364 വരെ ഒരു ലൂപ്പ്

So, I have to update it.

(loop) പ്രവർത്തിപ്പിക്കുന്നു.

So, I have hottest day equal to i updated. I not only update the day in which the temperature was very high; I also record the actual temperature,

അതിനാൽ, ഇത് ജനുവരി 2 മുതൽ ഡിസംബർ 31 വരെ പോകുന്നു. ഞാൻ ചെയ്യാൻ പോകുന്നത് നിലവിലെ താപനിലയേക്കാൾ കുറവാണോ എന്ന് ഞാൻ കാണാൻ പോകുന്നു…

because that is what you are actually tracking. So, what this loop really does is this.

നിലവിലെ പരമാവധി താപനില ഞാൻ രേഖപ്പെടുത്തുന്നത് ദിവസത്തെ താപനിലയേക്കാൾ കുറവാണ്.

So, you go from day 1 to day 364.

അതിനാൽ, അത് കുറവാണെങ്കിൽ, പരമാവധി എന്നത് എനിക്ക്

So, we start at day 0; we go from day 1 to day 364.

യഥാർത്ഥ മാക്സ് (max) അല്ല എന്നതാണ്; മറ്റു

And if some other day becomes hotter, we update it and we move forward.

ചില ദിവസം ചൂടായി. അതിനാൽ, ഞാൻ ഇത് അപ്‌ഡേറ്റ് (update) ചെയ്യണം. അതിനാൽ, ഞാൻ അപ്‌ഡേറ്റുചെയ്‌തതിന് (update) തുല്യമായ ഏറ്റവും

And since I have to find out the hottest day in the year, I have to go all the way till

ചൂടേറിയ ദിവസം എനിക്കുണ്ട്. താപനില വളരെ കൂടുതലുള്ള ദിവസം ഞാൻ അപ്‌ഡേറ്റ്

364 days or day 0 to day 364 – 365 days.

(update) ചെയ്യുക മാത്രമല്ല; യഥാർത്ഥ താപനിലയും

At the end of it, hottest day will have the index of the day and max will contain the

രേഖപ്പെടുത്തുന്നു, കാരണം അതാണ് നിങ്ങൾ യഥാർത്ഥത്തിൽ ട്രാക്കു (track)ചെയ്യുന്നത്. അതിനാൽ, ഈ ലൂപ്പ് (loop) ശരിക്കും ചെയ്യുന്നത്

actual temperature.

ഇതാണ്.

So, I can print that, the hottest day was day number hottest day with temperature max.

നിങ്ങൾ ദിവസം 1 മുതൽ 364 ദിവസം വരെ പോകുന്നു. മറ്റേതെങ്കിലും ദിവസം കൂടുതൽ ചൂടാകുകയാണെങ്കിൽ,

So, this is a very simple loop.

അത് അപ്‌ഡേറ്റ് (update) ചെയ്യുകയും മുന്നോട്ട്

I did not show code for reading in temperature of the 365 days, but we only see the code

പോകുകയും ചെയ്യുന്നു. വർഷത്തിലെ ഏറ്റവും ചൂടേറിയ ദിവസം ഞാൻ കണ്ടെത്തേണ്ടതിനാൽ, 364 ദിവസം വരെ അല്ലെങ്കിൽ

for finding out the maximum. So, this is the very simple and common example of how arrays are used.

ദിവസം 0 മുതൽ 364 - 365 ദിവസം വരെ പോകണം. അതിന്റെ അവസാനം, ഏറ്റവും ചൂടേറിയ

I want to find out the maximum. So, it could be marks of 100 students or so.

ദിവസത്തിന് ദിവസത്തെ ഇൻഡക്സും (index) പരമാവധി താപനിലയും അടങ്ങിയിരിക്കും.

And I want to find out which student got the highest mark.

അതിനാൽ, എനിക്ക് അത് അച്ചടിക്കാൻ

So, I may have to just iterate over this and find out the largest value.

കഴിയും, ഇത് വളരെ ലളിതമായ ഒരു ലൂപ്പാണ് (loop). 365 ദിവസത്തെ താപനിലയിൽ വായിക്കുന്നതിനുള്ള

So, we start with day 0 being the hottest.

കോഡ് (code) ഞാൻ കാണിച്ചില്ല, പക്ഷേ പരമാവധി കണ്ടെത്തുന്നതിനുള്ള

And if i-th day is hotter than the current record, update it.

കോഡ് മാത്രമാണ് കാണുന്നത്. അറേകൾ (array) എങ്ങനെ ഉപയോഗിക്കുന്നു എന്നതിന്റെ വളരെ ലളിതവും സാധാരണവുമായ

There are also multidimensional arrays that are possible; so not everything in practical uses 1-dimensional.

ഉദാഹരണമാണിത്. എനിക്ക് പരമാവധി കണ്ടെത്താൻ ആഗ്രഹമുണ്ട്. ഇത് 100 വിദ്യാർത്ഥികളുടെ മാർക്ക് (mark) ആകാം.

So, even though I have; So, I have things like matrices and so on.

ഏത് വിദ്യാർത്ഥിയാണ് ഏറ്റവും കൂടുതൽ മാർക്ക് (mark) നേടിയതെന്ന് കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

Naturally, they are multidimensional or in this, matrices are actually 2-dimensional;

അതിനാൽ, എനിക്ക് ഇതിലൂടെ ആവർത്തിച്ച് ഏറ്റവും വലിയ മൂല്യം കണ്ടെത്തേണ്ടി വന്നേക്കാം.

you could also have 3-dimensional structures and so on.

ദിവസം 0 ഏറ്റവും ചൂടേറിയതായി ഞങ്ങൾ ആരംഭിക്കുന്നു.

So, C gives you flexibility to have arrays of multiple dimensions.

നിലവിലെ റെക്കോർഡിനേക്കാൾ i-th ദിവസം ചൂടുള്ളതാണെങ്കിൽ,

So, for instance, let us see something of this kind.

അത് അപ്‌ഡേറ്റു (update) ചെയ്യുക.

If I have a declaration int A square bracket 4 square bracket 3; it means that, we have

മൾട്ടി-ഡൈമെൻഷണൽ അറേകളും (multidimensional array) ഉണ്ട്; എല്ലാം 1-ഡൈമൻഷണൽ (1 dimensional) ഉപയോഗിക്കുന്നില്ല. മെട്രിക്സ് (matrix) മുതലായവ ഉണ്ട്.

four rows numbered 0, 1, 2, 3.

സ്വാഭാവികമായും, അവ മൾട്ടി-ഡൈമെൻഷണൽ

So, that comes from this.

(multidimensional) ആണ്. മെട്രിക്സ് (matrix) യഥാർത്ഥത്തിൽ

And number of columns being 3 numbered from 0 to 2.

2-ഡൈമെൻഷനാണ് (2-dimension); നിങ്ങൾക്ക് ത്രിമാന ഘടനകളും മറ്റും ഉണ്ടായിരിക്കാം.

So, we have four rows by three columns.

അതിനാൽ, ഒന്നിലധികം അളവുകളുടെ ശ്രേണികൾ സി (C) യിൽ ലഭ്യമാണ്.

I can also have something, which is 3-dimensional.

ഉദാഹരണത്തിന്, എനിക്ക് ഒരു ഡിക്ലറേഷൻ (declaration)

So, in this case, I have a floating point array called B. And there are three dimensions

int [4] [3]; ഉണ്ടെങ്കിൽ അതിനർത്ഥം, നമുക്ക് 0, 1, 2, 3 അക്കങ്ങളുള്ള നാല് റോകളാണുള്ളത് (row). 0 മുതൽ 2 വരെ 3 അക്കങ്ങളുള്ള കോളം (column) ഉണ്ട്.

അതിനാൽ, നമുക്ക് മൂന്ന് കോളങ്ങളും

to it.

(column) നാല് റോകളും (row) ഉണ്ട്.

So, you can think of it as x, y and z dimension.

ത്രിമാനവും ഉണ്ടയിരിക്കുന്നതാണ്. ഈ സാഹചര്യത്തിൽ, എനിക്ക് ബി എന്ന് വിളിക്കുന്ന ഒരു ഫ്ലോട്ടിംഗ് പോയിൻറ്

So, in the x dimension, there is 2; you can think of it as two planes: plane 0, and plane

അറേ (floating point array) ഉണ്ട്, അതിന് മൂന്ന് മാനങ്ങളുണ്ട്. അതിനാൽ, നിങ്ങൾക്ക് ഇത് x, y, z അളവുകളായി കണക്കാക്കാം. അതിനാൽ, x അളവിൽ 2 ഉണ്ട്; നിങ്ങൾക്ക് ഇത് രണ്ട്

പ്ലെയ്നുകളായി (plane) കണക്കാക്കാം: തലം 0, തലം 1.

1. In each plane, I have four rows and three columns.

ഓരോ പ്ലെയ്നുകളിലും (plane) എനിക്ക് നാല് വരികളും മൂന്ന് നിരകളും ഉണ്ട്.

That is what you see here.

അതാണ് നിങ്ങൾ ഇവിടെ കാണുന്നത്.

So, in each plane, I have four rows and three columns.

മെട്രിക്സും (matrix) ഗ്രാഫിക്സും (graphics)

So, this comes in very handy for handling matrices and graphics and so on.

കൈകാര്യം ചെയ്യുന്നതിന് ഇത് വളരെ സഹായകരമാണ്. കുറച്ച് സമയത്തിനുള്ളിൽ മൾട്ടി-ഡൈമെൻഷണൽ

We will look at these examples in a little later.

അറേകളുടെ (multidimensional) ഉദാഹരണങ്ങൾ നമ്മൾ കാണും. ഈ മൊഡ്യൂളിന്റെ (module) അവസാനം, നമുക്ക്

In a little while, we will see examples of multidimensional arrays.

ഉള്ളത് അറേകളുടെ (array) അടിസ്ഥാന ധാരണയാണ്;

So, at the end of this module, what we have is basic notion of arrays; how we can use

നമുക്ക് എങ്ങനെ അറേകൾ (array) ഉപയോഗിക്കാം, അവ എങ്ങനെ ഇൻഡെക്സ് (index) ചെയ്യാം, മെമ്മറിയിൽ

the arrays, how we can index them, and what happens inside memory.

(memory) എന്ത് സംഭവിക്കും.

So, in the next two modules, we will see more details about arrays.

അടുത്ത രണ്ട് മൊഡ്യൂളുകളിൽ (module), അറേകളെക്കുറിച്ചുള്ള (array) കൂടുതൽ വിശദാംശങ്ങൾ കാണും.