algorithms and programming: simple gcd

Summary

This script is a detailed tutorial on the concepts of algorithms and data structures in the context of programming, specifically in Python. It introduces algorithms as a set of steps to solve problems efficiently, like a recipe for cooking. The tutorial explains the importance of algorithms in programming, how they are used to execute tasks in a step-by-step manner, and their implementation in computers. It also delves into the basics of programming languages, the role of functions, and the process of creating a program. The script further discusses the Great Common Divisor (GCD) as an algorithmic example, illustrating how to calculate it and emphasizing the significance of algorithms in everyday computational tasks.

Takeaways

• 😀 The course introduces the basics of programming, data structures, and algorithms, starting with the fundamental concept of an algorithm.
• 🎓 An algorithm is a set of steps that can be followed to solve a problem or perform a computation, akin to a recipe in cooking.
• 💡 Programming languages allow us to write instructions for a computer to execute, with the goal of making tasks automated and efficient.
• 👨‍🏫 The course emphasizes that algorithms can be executed by a human or a machine, but the expectation is that a computer will carry out the steps defined by the programmer.
• 🔍 The example of planning an event like a function in a hall illustrates how an algorithm can involve multiple steps and considerations.
• 📚 The script discusses the importance of detailing an algorithm at various levels of detail depending on the experience of the audience or team executing it.
• 🔢 The concept of the greatest common divisor (GCD) is used to demonstrate how algorithms can be used to find the largest common factor between two numbers, showcasing a practical application.
• 🛠️ The script introduces a simple algorithm to calculate the GCD by listing the factors of two numbers and finding the largest common one.
• 💻 The course will cover how to implement algorithms in the context of computer programming, emphasizing the practical application of algorithms to solve computational problems.
• 🌐 The script highlights the ubiquity of algorithms in everyday life, from booking flights to solving puzzles like Sudoku, emphasizing their role in optimization and data processing.

Q & A

What is the primary focus of the course mentioned in the script?

The primary focus of the course is on algorithms, data structures, and the basics of programming, starting with an introduction to algorithms.

What is the definition of an algorithm according to the script?

An algorithm is defined as a set of steps or instructions to perform a specific task or solve a particular problem, much like a recipe in cooking.

How are algorithms related to programming languages?

Algorithms are the logical procedures that programming languages use to execute tasks. The script explains that programming languages allow us to write programs that detail the order of necessary steps and handle different scenarios.

What is the significance of steps in an algorithm?

The steps in an algorithm are significant because they represent the sequence of actions that must be executable by a machine, such as a computer, to perform a specific task.

Why is it necessary for a program to be executable by a machine?

A program must be executable by a machine so that the machine can carry out the instructions as intended by the programmer, which is the common context for programming.

What is the role of a function in the context of the script?

In the context of the script, a function represents a set of instructions that perform a specific task, such as arranging chairs in a hall, and is a fundamental building block in programming.

Why is it important to detail the steps of an algorithm?

Detailing the steps of an algorithm is important to ensure that it can be understood and executed by different people or machines, and to handle any complexity or variations in the task at hand.

What is the purpose of discussing the greatest common divisor (GCD) in the script?

The purpose of discussing the GCD is to illustrate how algorithms can be used to solve mathematical problems, specifically by finding the largest common factor between two numbers.

How does the script describe the process of finding the GCD of two numbers?

The script describes the process of finding the GCD by listing the factors of the two numbers and identifying the largest factor that both numbers share.

What is the significance of the Euclidean algorithm in the context of the script?

The Euclidean algorithm is significant as it is a classic example of an efficient algorithm used to compute the GCD of two numbers, which is a fundamental concept in number theory and computer science.

How does the script explain the concept of data structures in relation to algorithms?

The script explains that data structures are used to organize and store data in a way that can be efficiently accessed and manipulated by algorithms, highlighting their importance in programming.

Outlines

00:00

💡 Introduction to Algorithms and Programming

The paragraph introduces the concept of algorithms and programming, emphasizing the importance of algorithms in defining the logic behind tasks. It explains that an algorithm is a set of steps that can be executed to achieve a desired outcome, akin to a recipe. The paragraph also touches on the basic idea of programming languages, which are used to write programs that instruct computers on how to perform tasks. The concept of executing an algorithm step by step is introduced, and the expectation that a computer or a person should be able to execute a program is set. The paragraph concludes by discussing how the course will focus on computer algorithms, starting from basic mathematical operations.

05:01

🔢 Computational Thinking and Practical Examples

This paragraph delves into computational thinking, illustrating how algorithms can be used to solve practical problems like organizing events or rearranging numbers in a spreadsheet. It mentions optimization problems, such as booking flights or solving puzzles like Sudoku, which require computational algorithms to find the best solution. The paragraph also highlights the importance of data structures in organizing information efficiently, setting the stage for a deeper exploration of algorithms and their applications in various computational tasks.

10:02

🧩 The Process of Algorithm Design and Function

The paragraph discusses the process of designing algorithms, focusing on the need for a clear and limited set of instructions. It emphasizes the importance of defining what needs to be done in a way that can be understood and executed without knowing the exact values of the input. The paragraph introduces the concept of functions and how they can be used to organize and simplify complex tasks. It uses the example of calculating the greatest common divisor (GCD) to illustrate the algorithmic process and the importance of identifying and utilizing common factors between numbers.

15:06

🔍 Detailed Explanation of GCD Algorithm

This paragraph provides a detailed explanation of the algorithm used to calculate the greatest common divisor (GCD) of two numbers. It describes the process of listing the factors of the numbers and identifying the largest common factor. The paragraph uses examples to demonstrate how the algorithm works, showing the step-by-step method of factor listing and comparison. It also discusses the practicality and efficiency of the algorithm, ensuring that the process is reliable and can be applied to any pair of positive integers.

20:06

📝 Implementing the GCD Algorithm in Python

The paragraph outlines the implementation of the GCD algorithm in Python, starting with the definition of a function to calculate the GCD. It explains how to create lists to store the factors of the numbers and how to use loops to iterate through these factors. The paragraph also covers how to check for divisibility and append factors to the list if they are common to both numbers. It concludes with the process of extracting the greatest common factor from the combined list of factors, demonstrating the practical application of the algorithm in a programming context.

25:07

💻 Deep Dive into Python Programming Constructs

This paragraph provides an in-depth look at various programming constructs in Python, such as loops, conditional statements, and data structures. It discusses how these constructs are used to build algorithms and solve problems efficiently. The paragraph emphasizes the importance of understanding how to assign and manipulate values, as well as how to use built-in functions like 'append' to modify data structures. It also touches on the significance of indentation and syntax in Python, highlighting the language's readability and ease of use for programming.

Keywords

💡Algorithm

An algorithm is a set of step-by-step instructions designed to accomplish a specific task or solve a particular problem. In the context of the video, algorithms are the foundation of programming, used to efficiently organize and execute a series of operations, such as calculating the greatest common divisor (GCD) of two numbers. The script mentions algorithms in relation to their execution by a machine and how they are fundamental to programming, exemplified by the process of calculating the GCD.

💡Programming

Programming refers to the process of writing, testing, debugging, and maintaining the source code of computer programs. The video script discusses programming as a means to give instructions to a computer in a certain order and to handle different operations using programming languages. It ties into the broader theme of the video by illustrating how programming allows the execution of algorithms to perform tasks like data organization and optimization.

💡Data Structures

Data structures are specialized formats for organizing, processing, and storing data. The script touches on data structures as a way to efficiently store and manage the data required for algorithms to function. In the video, lists are used as a simple data structure to store and manipulate the factors of numbers, showcasing the importance of data structures in programming and algorithm design.

💡Greatest Common Divisor (GCD)

The GCD of two or more integers is the largest positive integer that divides each of the integers without leaving a remainder. The video script uses the GCD as a practical example to demonstrate how algorithms work. It explains the process of finding the GCD of two numbers through a step-by-step algorithm, highlighting its relevance in computational mathematics and problem-solving.

💡Function

In programming, a function is a reusable block of code that performs a specific task and returns a result. The script mentions functions in the context of executing a set of instructions to achieve a goal, such as building a hall or calculating mathematical operations. Functions are a fundamental concept in the video, illustrating how they encapsulate logic within a program, making it reusable and modular.

💡Machine

A machine, as referenced in the script, is a device that executes instructions, particularly in the context of computers executing programs. The video discusses how machines carry out the steps outlined by algorithms, emphasizing the role of machines in the field of computer science and programming, and how they are essential for algorithm execution.

💡List

A list, in the context of the video, is a data structure that stores an ordered collection of items, which can be elements of any data type. The script uses lists to demonstrate how data can be organized and iterated over, such as when generating and storing the factors of a number. Lists are a simple yet powerful tool in programming, allowing for the collection and management of data points.

💡Execution

Execution in programming refers to the process of running a program or algorithm, where the machine follows the instructions step by step. The video script explains execution in the context of how a computer follows the steps of an algorithm to perform a task, like calculating the GCD. It highlights the importance of execution in bringing algorithms to life within a programming environment.

💡Optimization

Optimization in the video script refers to the process of making a program or algorithm as efficient or functional as possible. It is discussed in the context of solving problems like finding the minimum time or cost for flights, which involves organizing and selecting data to achieve the best outcome. Optimization is a key theme in the video, showcasing its importance in algorithm design and problem-solving.

💡Spreadsheet

A spreadsheet is a type of computer application for data organization, analysis, and storage. The script mentions spreadsheets as an example of a tool used for computational tasks, such as organizing and reordering data. It illustrates how spreadsheets can be utilized to perform algorithmic tasks, like sorting numbers in ascending or descending order, which is a common operation in data processing.

💡Variable

A variable in programming is a storage location paired with an associated symbolic name, which contains some known or unknown quantity of information referred to as a value. The video script discusses variables in the context of storing and manipulating data, such as the factors of numbers during the calculation of the GCD. Variables are crucial for holding intermediate results and allowing for dynamic data manipulation within a program.

Highlights

Welcome to the course on Python programming, data structures, and algorithms.

An algorithm is a set of steps to perform a task efficiently.

Programming is about writing instructions for a computer to follow.

Algorithms can be executed step by step to achieve a desired outcome.

The course will focus on computer algorithms and their practical applications.

Functions are a fundamental concept in programming, used to perform specific tasks.

Data structures are used to organize and store data efficiently.

The greatest common divisor (GCD) is an important concept in number theory.

The Euclidean algorithm is a method for finding the GCD of two numbers.

The course will explore various algorithms for sorting and optimization.

Understanding algorithms is crucial for solving computational problems.

The course will cover the implementation of algorithms in Python.

The importance of loops and conditional statements in programming will be discussed.

The course will teach how to write clean and efficient code.

Data structures like lists and their operations will be explained.

The concept of variables and assignment in programming will be covered.

The course will also delve into functions and how to define them in Python.

Error handling and debugging techniques will be an essential part of the course.

The practical applications of algorithms in everyday life will be highlighted.

The course aims to bridge the gap between theoretical concepts and practical programming.

Transcripts

പൈത്തണിലെ(phython) പ്രോഗ്രാമിംഗ്(programming), ഡാറ്റാ സ്ട്രക്ചറുകൾ(data

structures), അൽഗോരിതം(algorithm) എന്നിവയെക്കുറിച്ചുള്ള

കോഴ്സിലെ(course) ആദ്യ പ്രഭാഷണത്തിലേക്ക്

സ്വാഗതം.

ഒരു അൽ‌ഗോരിതം(algorithm) എന്താണ് അർത്ഥമാക്കുന്നത്,

എന്താണ് പ്രോഗ്രാമിംഗ്(programming) എന്നതിന്റെ അടിസ്ഥാന

നിർവചനത്തിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം.

നിങ്ങളിൽ മിക്കവർക്കും അറിയാവുന്നതുപോലെ,

ചില ജോലികൾ എങ്ങനെ ചിട്ടയായി നിർവഹിക്കാം

എന്നതിന്റെ വിവരണമാണ് അൽഗോരിതം(algorithm). ഒരു

അൽ‌ഗോരിതം(algorithm) എന്തെങ്കിലും നേടുന്നതിനായി ഉള്ള

ഘട്ടങ്ങളുടെ ഒരു ശ്രേണി ഉൾക്കൊള്ളുന്നു,

അത് ഒരു പാചകക്കുറിപ്പായി കണക്കാക്കാം. അതിനാൽ,

തീർച്ചയായും പാചകക്കുറിപ്പ് എന്ന പദം പാചകത്തിൽ

നിന്നാണ് വരുന്നത്, അവിടെ നമുക്ക് ചേരുവകളുടെ

ലിസ്റ്റും(list) തുടർന്ന് ഒരു വിഭവം തയ്യാറാക്കുന്നതിനുള്ള

ഘട്ടങ്ങളും ഉണ്ട്. അതുപോലെ തന്നെ, എന്തെങ്കിലും

തയ്യാറാക്കുന്നതിനോ അല്ലെങ്കിൽ നൽകിയ

ചുമതല നേടുന്നതിനോ ഉള്ള ഒരു മാർഗമാണ്

അൽഗോരിതം(algorithm). ഈ കാര്യത്തിന്റെ പശ്ചാത്തലത്തിൽ,

ഒരു പാചകക്കുറിപ്പിനെയാണ് നമ്മൾ ഒരു പ്രോഗ്രാം(program)

എന്ന് വിളിക്കുന്നത്. ഒരു പ്രോഗ്രാമിംഗ്(programming)

ഭാഷ ഉപയോഗിച്ച് നമ്മൾ ഒരു പ്രോഗ്രാം(program)

എഴുതുന്നു. അതിനാൽ, ആവശ്യമുള്ള ഘട്ടങ്ങളുടെ

ക്രമം വിവരിക്കാനും അതിനിടയിൽ വ്യത്യസ്ത

കാര്യങ്ങൾ സംഭവിക്കുകയാണെങ്കിൽ വ്യത്യസ്ത ഘട്ടങ്ങൾ

എങ്ങനെ പിന്തുടരാമെന്നും വിവരിക്കുക എന്നതാണ്

പ്രോഗ്രാമിംഗ്(programming) ഭാഷയുടെ ലക്ഷ്യം.

അൽ‌ഗോരിതം(algorithm) എക്സിക്യൂട്ട്(execute) ചെയ്യുന്നതെന്തും

ചെയ്യാൻ‌ കഴിയുന്ന ഒന്നാണ് സ്റ്റെപ്പ്(step)

എന്ന ആശയം. ഇപ്പോൾ ഒരു മെഷീൻ(machine) ഒരു

പ്രോഗ്രാം(program) എക്സിക്യൂട്ട്(execute) ചെയ്യേണ്ടതില്ല,

എന്നിരുന്നാലും കമ്പ്യൂട്ടർ(computer)

നമ്മുടെ ഘട്ടങ്ങൾ നടപ്പിലാക്കുമെന്ന്

നമ്മൾ പ്രതീക്ഷിക്കുന്ന കമ്പ്യൂട്ടർ(computer)

പ്രോഗ്രാമിംഗിന്റെ(programming) സാധാരണ സന്ദർഭമാണിത്.

ഒരു വ്യക്തിക്കും ഒരു പ്രോഗ്രാം(program)

എക്സിക്യൂട്ട്(execute) ചെയ്യാൻ കഴിയും.

ഉദാഹരണത്തിന്, ഒരു ഫംഗ്ഷനായി(function) ഒരു

ഹാൾ(hall) തയ്യാറാക്കുക എന്നതാണ് കയ്യിലുള്ള

ചുമതലയെന്ന് കരുതുക. അതിനാൽ, മുറി വൃത്തിയാക്കൽ,

സ്റ്റേജ്(stage) തയ്യാറാക്കൽ, അലങ്കാരം ഉണ്ടെന്ന്

ഉറപ്പുവരുത്തുക, കസേരകൾ ക്രമീകരിക്കുക

തുടങ്ങി വിവിധ ഘട്ടങ്ങൾ ഇതിൽ ഉൾപ്പെടും.

ഒരു കൂട്ടം ആളുകൾ ഇത് നിർവ്വഹിക്കും.

ഇപ്പോൾ ഈ ഗ്രൂപ്പിന്റെ(group) വൈദഗ്ധ്യവും അനുഭവവും

അനുസരിച്ച്, നിങ്ങൾക്ക് ഈ അൽഗോരിതം(algorithm) വിവിധ

തലങ്ങളിൽ വിശദമായി വിവരിക്കാൻ കഴിയും.

ഉദാഹരണത്തിന്, കസേര ക്രമീകരിക്കുക പോലുള്ള

ഒരു നിർദ്ദേശം, ആളുകൾക്ക് പ്രതീക്ഷിക്കേണ്ടതെന്താണെന്ന്

കൃത്യമായി അറിയാമെങ്കിൽ അർത്ഥമുണ്ട്. മറുവശത്ത്,

ഇത് മുമ്പൊരിക്കലും ചെയ്യാത്ത ഒരു പുതിയ

കൂട്ടം ആളുകളാണെങ്കിൽ; നിങ്ങൾ ഘട്ടം കൂടുതൽ

വിശദമായി വിവരിക്കേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, നിങ്ങൾ

അത് പറയണം, 8 വരികളിൽ കസേരകൾ ക്രമീകരിക്കുക,

ഓരോ വരിയിലും 10 കസേരകൾ ഇടുക. അതിനാൽ, ഒരു

ഘട്ടത്തിന്റെ ആശയം ആത്മനിഷ്ഠമാണ്, അത്

വ്യക്തിയിൽ നിന്നോ അൽഗോരിതം(algorithm) നടപ്പിലാക്കുന്ന

യന്ത്രത്തിൽ നിന്നോ നമ്മൾ പ്രതീക്ഷിക്കുന്നതിനെ

ആശ്രയിച്ചിരിക്കുന്നു. ആ ശേഷിയുടെ അടിസ്ഥാനത്തിൽ,

നമ്മൾ അൽഗോരിതം(algorithm) തന്നെ വിവരിക്കുന്നു.

ഈ കോഴ്സിലെ(course) നമ്മുടെ ശ്രദ്ധ കമ്പ്യൂട്ടർ(computer)

അൽ‌ഗോരിതംസിലായിരിക്കും(algorithm), സാധാരണയായി, ഈ അൽ‌ഗോരിതംസ്(algorithm)

വിവരങ്ങൾ കൈകാര്യം ചെയ്യുന്നു. ഹൈസ്കൂളിൽ(highschool)

നിന്ന് തുടങ്ങി നമുക്കെല്ലാവർക്കും പരിചിതമായ ഏറ്റവും

അടിസ്ഥാനപരമായ അൽഗോരിതം(algorithm), സംഖ്യാ പ്രവർത്തനങ്ങൾ

കണക്കാക്കുന്ന ഒരു അൽഗോരിതം(algorithm) ആണ്.

ഉദാഹരണത്തിന്, നമുക്ക് x, y എന്നീ രണ്ട് അക്കങ്ങൾ

എടുത്ത് x പവർ(power) y കണക്കാക്കുന്ന ഒരു

അൽഗോരിതം(algorithm) ഉണ്ടായിരിക്കാം. അതിനാൽ, സ്കൂളിൽ(school)

അത്തരം നിരവധി ഫംഗ്ഷനുകൾ(function) നമ്മൾ കണ്ടു.

ഉദാഹരണത്തിന്, x- ന്റെ സ്‌ക്വയർ റൂട്ട്(square

root) കണക്കുകൂട്ടാൻ, സ്കൂളിൽ(school) നമ്മൾ

ചെയ്യുന്നത് x- ന്റെ സ്‌ക്വയർ റൂട്ട്(square

root) കണക്കുകൂട്ടുന്നതിനുള്ള സങ്കീർണ്ണമായ മാർഗ്ഗമാണ്

അല്ലെങ്കിൽ x- നെ y കൊണ്ട് ഹരണം നടത്തുന്നു.

ഇവയെല്ലാം മൂല്യങ്ങൾ കണക്കുകൂട്ടുന്ന

അൽ‌ഗോരിതം(algorithm) ആണ്, ഒന്നോ അതിലധികമോ

സംഖ്യകൾ നൽകിയാൽ ഈ ഫംഗ്ഷന്റെ(function)

ഔട്ട്‌പുട്ട്(output) കണക്കാക്കുന്നു.

എന്നാൽ കമ്പ്യൂട്ടർ(computer) ഉപയോഗിച്ച നമുക്കെല്ലാവർക്കും

മറ്റ് പല കാര്യങ്ങളും കണക്കുകൂട്ടലിന്റെ

പരിധിയിൽ വരുന്നതായി അറിയാം. ഉദാഹരണത്തിന്,

വിവരങ്ങൾ ക്രമീകരിക്കുന്നതിന് നമ്മൾ ഒരു സ്പ്രെഡ്ഷീറ്റ്(spreadsheet)

ഉപയോഗിക്കുന്നു, അതിൽ ഒരു നിര അടുക്കാൻ

നമ്മൾ ആഗ്രഹിക്കുന്നു. അതിനാൽ, നിരയിലെ

ഇനങ്ങൾ‌ ആരോഹണ ക്രമത്തിലോ അവരോഹണ ക്രമത്തിലോ

പുനഃക്രമീകരിക്കുന്നത് ഇതിൽ ഉൾപ്പെടുന്നു.

അതിനാൽ, വിവരങ്ങൾ പുനഃക്രമീകരിക്കുക

എന്നത് ഒരു കമ്പ്യൂട്ടേഷണൽ(computational) ചുമതലയാണ്, അൽഗോരിതം(algorithm)

ഉപയോഗിച്ച് ഇത് എങ്ങനെ ചെയ്യണമെന്ന് നമ്മൾ

അറിയേണ്ടതുണ്ട്. ഇന്നത്തെ ജീവിതത്തിൽ

നമുക്ക് ചുറ്റും കണക്കുകൂട്ടലുകൾ

കാണുന്നു. ഉദാഹരണത്തിന്, നമ്മൾ ഒരു ട്രാവൽ

ബുക്കിംഗ്(travel booking) സൈറ്റിലേക്ക്(site)

പോയി, ഒരു നഗരത്തിൽ നിന്ന് മറ്റൊരു നഗരത്തിലേക്ക്

ഒരു ഫ്ലൈറ്റ്(flight) ബുക്ക്(book) ചെയ്യാൻ

നമ്മൾ ശ്രമിക്കുമ്പോൾ, മിനിമം(minimum) സമയം അല്ലെങ്കിൽ

കുറഞ്ഞ ചെലവ് കണക്കിലെടുത്ത് ഫ്ലൈറ്റുകൾ(flight) ക്രമീകരിക്കാൻ

ഇത് വാഗ്ദാനം ചെയ്യും. അതിനാൽ, ഇവ ഒപ്റ്റിമൈസേഷൻ(optimization)

പ്രശ്നങ്ങളാണ്. ഒരു പ്രത്യേക രീതിയിൽ

വിവരങ്ങൾ ക്രമീകരിക്കുന്നതും നമ്മൾ ആഗ്രഹിക്കുന്ന

അളവ് കണക്കാക്കുന്നതും ഇതിൽ ഉൾപ്പെടുന്നു.

ഈ സാഹചര്യത്തിൽ, നമുക്ക് a മുതൽ b വരെ

എങ്ങനെ പോകാമെന്ന് അറിയാൻ നമ്മൾ ആഗ്രഹിക്കുന്നു,

കൂടാതെ a മുതൽ b വരെ പോകാൻ കഴിയുന്ന എല്ലാ

വഴികളിലും, നമുക്ക് ഒപ്റ്റിമൽ(optimal) ആയ

ഒന്ന് വേണം. തീർച്ചയായും, കമ്പ്യൂട്ടർ(computer)

പ്രോഗ്രാമുകൾ(program) നടപ്പിലാക്കുന്ന

നിരവധി കാര്യങ്ങൾ ഇന്ന് നാം കാണുന്നു.

നമുക്ക് ഗെയിമുകൾ(game) കളിക്കാൻ കഴിയും.

ഉദാഹരണത്തിന്, നമുക്ക് സുഡോകു(sudoku) പരിഹരിക്കാനാകും

അല്ലെങ്കിൽ ഒരു പ്രോഗ്രാമിനെതിരെ(program) ചെസ്സ്(chess) കളിക്കാം.

ഒരു പ്രമാണം ടൈപ്പു(type) ചെയ്യാൻ നമ്മൾ വേഡ്

പ്രോസസർ(word processor) ഉപയോഗിക്കുമ്പോൾ അല്ലെങ്കിൽ sms സന്ദേശങ്ങൾ

ടൈപ്പുചെയ്യാൻ നമ്മുടെ സെൽ ഫോണുകൾ(cell phone) ഉപയോഗിക്കുമ്പോഴും,

കമ്പ്യൂട്ടർ(computer) നമ്മുടെ അക്ഷരവിന്യാസത്തിൽ

തിരുത്തൽ നിർദ്ദേശിക്കുന്നു. ഈ കോഴ്‌സിൽ(course) ഇവയിൽ

ചിലത് നമ്മൾ പരിശോധിക്കും, പക്ഷേ നമ്മുടെ സന്ദർഭത്തിലെ

ഒരു പ്രോഗ്രാം(program) വിവരങ്ങൾ നോക്കുകയും

അത് ഒരു നിർദ്ദിഷ്ട ആവശ്യകതയിലേക്ക്

കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്ന ഒന്നാണ്.

അതിനാൽ, ഇത് ഒരു നമ്പർ(number) എടുത്ത് നമ്പർ(number)

പുറത്തെടുക്കുന്നതിനുള്ള ഒരു ചോദ്യം മാത്രമല്ല.

അതിൽ കാര്യങ്ങൾ പുനഃക്രമീകരിക്കുന്നതിൽ ഉൾപ്പെടാം. കൂടുതൽ

സങ്കീർണ്ണമായ കാര്യങ്ങൾ കമ്പ്യൂട്ടിംഗ്(computing)

ചെയ്യുന്നത് ഇതിൽ ഉൾപ്പെടാം. ഒരു പ്രത്യേക

രീതിയിൽ വിവരങ്ങൾ ഓർഗനൈസു(organise) ചെയ്യുന്നത്

ഇതിൽ ഉൾപ്പെടാം, അതിനാൽ ഈ കണക്കുകൂട്ടലുകൾ

കൂടുതൽ ലഘുലേഖയായിത്തീരുന്നു, അതിനെയാണ് നമ്മൾ

ഒരു ഡാറ്റാ(data) ഘടന എന്ന് വിളിക്കുന്നത്.

അതിനാൽ ഇത് വിശദീകരിക്കുന്നതിന്, നമ്മളിൽ ഭൂരിഭാഗവും

കണ്ടതും അൽഗോരിതം(algorithm) മനസിലാക്കാൻ ശ്രമിച്ചതുമായ

ഫംഗ്ഷൻ(function) നോക്കാം. m, n എന്നീ രണ്ട് പോസിറ്റീവ്(positive)

സംഖ്യകളുടെ ഏറ്റവും വലിയ പൊതു ഹാരകമാണ്

ഞാൻ കണക്കാക്കാൻ ആഗ്രഹിക്കുന്ന പ്രോപ്പർട്ടി(property).

നമുക്കറിയാവുന്നതുപോലെ, വിഭജിക്കുന്ന ഒരു

സംഖ്യയാണ് ഹാരകം. എനിക്ക് m കൊണ്ട്

k യെ ഹരിക്കാൻ കഴിയുകയും മിച്ചം ലഭിക്കുന്നില്ലെങ്കിൽ,

k എന്നത് m ന്റെ ഹാരകമാണ്.അതിനാൽ, m, n എന്നിവയുടെ ഏറ്റവും

വലിയ പൊതുവായ ഹാരകമായിരിക്കണം. അതിനാൽ, പൊതുവായ

എന്നതിൻറെ അർത്ഥം ഇത് ഇവ രണ്ടിനെയും

ഹരിക്കണം, ഇത് ഇവയിൽ ഏറ്റവും വലുതുമായിരിക്കണം.

ഏറ്റവും വലിയ k എന്നത് k , m നെയും k , n നെയും

ഹരിക്കുന്നതായിരിക്കണം. ഉദാഹരണത്തിന്, നമ്മൾ

8 ഉം 12 ഉം നോക്കുകയാണെങ്കിൽ, 4 എന്നത് 8 ന്റെ ഘടകമാണെന്നും

4 എന്നത് 8 ന്റെ ഹാരകമാണെന്നും 4 എന്നത് 12 ന്റെ ഹാരകമാണെന്നും

12 ന്റെ മറ്റൊരു ഹാരകം 6 ആണെന്നും എന്നാൽ

6 എന്നത് 8 ന്റെ ഹാരകം അല്ലെന്നും കാണാം.

അതിനാൽ, 8, 12 എന്നിവയുടെ ഹാരകങ്ങളിലൂടെ കടന്നുപോകുകയാണെങ്കിൽ,

8 നെയും 12 നെയും ഹരിക്കുന്ന ഏറ്റവും വലിയ സംഖ്യ

4 ആണെന്ന് പരിശോധിക്കുന്നത് എളുപ്പമാണ്. അതിനാൽ,

8, 12 എന്നിവയുടെ gcd 4 ആണ്. 18 ഉം 25 ഉം ആണെങ്കിൽ

എങ്ങനെയാണ്. 25 എന്നത് 5 ഗുണം 5 ആണ്. അതിനാൽ,

ഇതിന് 1 ഉം 25 ഉം ഒഴികെയുള്ള ഒരു ഹാരകം മാത്രമേയുള്ളൂ,

അത് 5 ആണ്. കൂടാതെ 5 എന്നത് 18 ന്റെ ഹാരകമല്ല,

പക്ഷേ ഭാഗ്യവശാൽ 1 എന്നത് 18 ന്റെ ഹാരകമാണ്.

അതിനാൽ, നമുക്ക് പറയാൻ കഴിയും, 18 ൻറെയും

25 ൻറെയും gcd 1 ആണ്; 18 നെയും 25 നെയും ഹരിക്കുന്ന

1 നെക്കാൾ വലിയ സംഖ്യ ഒന്നുമില്ല. 1 എല്ലാ

സംഖ്യകളെയും ഹരിക്കുന്നതിനാൽ, 18, 25 എന്നീ കാര്യങ്ങളിൽ

നമ്മൾ കണ്ടതുപോലെ, രണ്ട് സംഖ്യകളിൽ

എല്ലായ്പ്പോഴും ഒരു പൊതു ഹാരകമെങ്കിലും

ഉണ്ടായിരിക്കും. gcd എല്ലായ്പ്പോഴും

നന്നായി നിർവചിക്കപ്പെടും; പൊതുവായ ഹാരകത്തെ

കണ്ടെത്താൻ നമുക്ക് ഒരിക്കലും കഴിയില്ല

എന്നു വരില്ല എന്നു മാത്രമല്ല എല്ലാ

പൊതു ഹാരകങ്ങളും അക്കങ്ങളായിരിക്കുമെന്നതിനാൽ,

നമുക്ക് അവയെ ചെറുത് മുതൽ വലുത് വരെ ക്രമീകരിക്കാനും

ഏറ്റവും വലിയവയെ ഏറ്റവും വലിയ പൊതുവായ

ഹാരകം ആയി തിരഞ്ഞെടുക്കാനും കഴിയും. അതിനാൽ, m,

n എന്നീ ഏതെങ്കിലും പോസിറ്റീവ്(positive) സംഖ്യകൾ

നൽകിയാൽ, നമുക്ക് തീർച്ചയായും ഈ രണ്ട്

അക്കങ്ങളുടെ gcd കണക്കാക്കാം.

അപ്പോൾ m, n എന്നിവയുടെ gcd എങ്ങനെ കണക്കു

കൂട്ടാം? ഇവിടെയാണ് നമ്മൾ അൽഗോരിതം(algorithm)

വഴിയിലേക്ക് വരുന്നത്, ഏത് m അല്ലെങ്കിൽ

ഏതെങ്കിലും n നായി m n ന്റെ gcd വ്യവസ്ഥാപിതമായി

കണക്കുകൂട്ടുന്നതിനുള്ള ഏകീകൃത മാർഗം വിവരിക്കാൻ

നമ്മൾ ആഗ്രഹിക്കുന്നു. വളരെ ലളിതമായ ഒരു

നടപടിക്രമമുണ്ട്. ഇത് ഏറ്റവും കാര്യക്ഷമമല്ല;

മുന്നോട്ടുപോകുന്നതിന് അനുസരിച്ച് നമുക്ക്

നന്നായി മനസ്സിലാക്കാൻ കഴിയും. എന്നാൽ gcdയുടെ

നിർവചനം നോക്കുകയാണെങ്കിൽ, അത് പറയുന്നു, m ന്റെ

എല്ലാ ഘടകങ്ങളും നോക്കുക, n ന്റെ എല്ലാ

ഘടകങ്ങളും നോക്കുക, രണ്ടിന്റെയും ഘടകമായ

ഏറ്റവും വലിയ ഘടകം കണ്ടെത്തുക. അതിനാൽ,

ഇത് ചെയ്യുന്നതിനുള്ള നിഷ്കളങ്കമായ മാർഗ്ഗം,

ആദ്യം m ന്റെ ഘടകങ്ങൾ പട്ടികപ്പെടുത്തുക,

തുടർന്ന് രണ്ടാമത്തെ സംഖ്യ n ന്റെ എല്ലാ

ഘടകങ്ങളും പട്ടികപ്പെടുത്തുക, തുടർന്ന് ഈ രണ്ട്

ലിസ്റ്റുകളിൽ(list), രണ്ട് ലിസ്റ്റുകളിലും(list)

ദൃശ്യമാകുന്ന ഏറ്റവും വലിയ സംഖ്യ റിപ്പോർട്ടുചെയ്യുക.

ഇത് മിക്കവാറും അക്ഷരാർത്ഥത്തിൽ gcdയുടെ നിർവചനമാണ്.

ഇത് ഒരു അൽഗോരിതം(algorithm) ഉൾക്കൊള്ളുന്നുണ്ടോ

എന്നതാണ് ഇവിടുത്തെ ചോദ്യം. ഉയർന്ന തലത്തിൽ,

ഘടകങ്ങളെ ഒരൊറ്റ ഘട്ടമായി ലിസ്റ്റ്

ഔട്ട്(list out) ചെയ്യുന്നതിനെക്കുറിച്ച് ചിന്തിക്കുകയാണെങ്കിൽ,

ഒരു അൽഗോരിതത്തിൽ(algorithm) നിന്ന് നമുക്ക് വേണ്ടത്

രണ്ട് കാര്യങ്ങളാണ്. ഒന്ന്, എന്തുചെയ്യണമെന്നതിന്റെ

വിവരണം പരിമിതമായ രീതിയിൽ എഴുതിയിരിക്കണം.

ആ അർത്ഥത്തിൽ, m, n എന്നിവയുടെ മൂല്യം കണക്കിലെടുക്കാതെ

തന്നെ അത് വായിക്കാനും മനസിലാക്കാനും കഴിയുന്ന

തരത്തിൽ നിർദ്ദേശങ്ങൾ എഴുതാൻ എനിക്ക് കഴിയണം.

ഇവിടെ വളരെ വ്യക്തമാണ്, നമുക്ക് കൃത്യമായി

മൂന്ന് ഘട്ടങ്ങളുണ്ട്. അതിനാൽ, അൽ‌ഗോരിതം(algorithm)

രൂപീകരിക്കുന്നതിന് നമുക്ക് മൂന്ന് ഘട്ടങ്ങളുണ്ട്,

അതുവഴി ഇത് ഒരു പരിമിത രീതിയിൽ അവതരിപ്പിക്കാൻ

കഴിയും. ഒരു അൽ‌ഗോരിതത്തിന്റെ(algorithm) മറ്റൊരു ആവശ്യകത,

പരിമിതമായ എണ്ണം ഘട്ടങ്ങൾക്ക് ശേഷം

നമുക്ക് ഉത്തരം ലഭിക്കണം എന്നതാണ്. ഇതിൽ, m,

n എന്നിവയുടെ വ്യത്യസ്ത മൂല്യങ്ങൾക്ക് പരിമിതമായ

എണ്ണം ഘട്ടങ്ങൾ വ്യത്യസ്തമായിരിക്കാം, നിങ്ങൾക്ക് n- ന് വളരെ

ചെറിയ സംഖ്യയുണ്ടെങ്കിൽ ധാരാളം ഘടകങ്ങളില്ലെന്ന്

നിങ്ങൾക്ക് ഊഹിക്കാനാകും, n ഒരു വളരെ വലിയ സംഖ്യയാണെങ്കിൽ

നിങ്ങൾക്ക് നിരവധി ഘടകങ്ങളുണ്ടാകാം.

അതിനാൽ, m, n എന്നിവയുടെ ഘടകങ്ങൾ ലിസ്റ്റു(list)

ചെയ്യുന്നതിന് വളരെയധികം സമയമെടുക്കും; എന്നിരുന്നാലും,

ഈ പ്രക്രിയ എല്ലായ്പ്പോഴും അവസാനിക്കുമെന്ന്

നമ്മൾ ഉറപ്പുനൽകാൻ ആഗ്രഹിക്കുന്നു,

തുടർന്ന് ഇത് ചെയ്തുകഴിഞ്ഞാൽ രണ്ട് ലിസ്റ്റുകളിലും(list)

ദൃശ്യമാകുന്ന ഏറ്റവും വലിയ സംഖ്യ കണ്ടെത്താൻ

നമുക്ക് കഴിയും.

ഈ പ്രക്രിയ നന്നായി നിർവചിക്കപ്പെട്ടിട്ടുണ്ടെന്ന്

വാദിക്കാൻ, നമ്മൾ തിരിച്ചറിയേണ്ടത്

m ന്റെ ഘടകങ്ങൾ 1 നും m നും ഇടയിലായിരിക്കണം

എന്നതാണ്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ,

ഘടകങ്ങളായി അനന്തമായ വ്യത്യസ്ത സാധ്യതകളുണ്ടെങ്കിലും,

m നെക്കാൾ വലിയ ഒരു സംഖ്യയും നാം നോക്കേണ്ടതില്ല,

അതിനാൽ, m ന്റെ ഘടകങ്ങൾ കണക്കുകൂട്ടാൻ നമ്മൾ

ചെയ്യേണ്ടത്, ഒന്ന് മുതൽ m വരെയുള്ള ശ്രേണിയിലെ

ഓരോ സംഖ്യയും പരിശോധിക്കുക എന്നതാണ്, കൂടാതെ

ശിഷ്ടം ഇല്ലാതെ m നെ ഹരിക്കാൻ പറ്റുകയാണെങ്കിൽ,

നമ്മൾ അതിനെ ഘടകങ്ങളുടെ പട്ടികയിലേക്ക്

ചേർക്കുന്നു. ഘടകങ്ങളുടെ ശൂന്യമായ ലിസ്റ്റിൽ(list)

നിന്നാണ് നമ്മൾ ആരംഭിക്കുന്നത്, അത് 1, 2, 3, 4 മുതൽ m വരെ

പരിഗണിക്കുന്നു, അത്തരം ഓരോ സംഖ്യയ്ക്കും,

ഈ സംഖ്യയെ m കൊണ്ട് ഹരിച്ചാൽ നമുക്ക്

0 ശിഷ്ടം ആയി ലഭിക്കുന്നുണ്ടോ എന്ന് നമ്മൾ പരിശോധിക്കുന്നു,

നമുക്ക് 0 ശിഷ്ടം ലഭിക്കുകയാണെങ്കിൽ

നമ്മൾ അത് പട്ടികയിലേക്ക് ചേർക്കുന്നു.

നമുക്ക് വ്യക്തമായ ഉദാഹരണം നോക്കാം,

നമുക്ക് 14, 63 എന്നിവയുടെ gcd കണക്കുകൂട്ടാൻ

ശ്രമിക്കാം. അതിനാൽ, നമ്മുടെ അൽഗോരിതത്തിന്റെ(algorithm)

ആദ്യ ഘട്ടം 14 ന്റെ ഘടകങ്ങൾ കണക്കുകൂട്ടാൻ

പറയുന്നു. മുകളിലുള്ള നമ്മുടെ നിരീക്ഷണത്തിലൂടെ,

14 ന്റെ ഘടകങ്ങൾ ഒന്നിനും 14 നും ഇടയിൽ ഉണ്ടാവണം,

14 നെക്കാൾ വലുതായ ഒന്നും ഒരു ഘടകമാകില്ല.

അതിനാൽ, ഒന്ന് മുതൽ 14 വരെ സാധ്യമായ എല്ലാ

ഘടകങ്ങളും ലിസ്റ്റു(list) ചെയ്യാനും അവ പരീക്ഷിക്കാനും

നമ്മൾ ആരംഭിക്കുന്നു. 1 എല്ലായ്പ്പോഴും

ഹരിക്കുമെന്ന് നമുക്കറിയാം; ഈ സാഹചര്യത്തിൽ 14

നെ 2 ഹരിക്കുന്നു, കാരണം 14 നെ 2 കൊണ്ട്

ഹരിച്ചാൽ ശിഷ്ടം ഇല്ലാതെ 7 ശേഷിക്കുന്നു.

ഇപ്പോൾ 3 ഹരിക്കുന്നില്ല, 4 ഹരിക്കുന്നില്ല,

5 ഹരിക്കുന്നില്ല, 6 ഹരിക്കുന്നില്ല;

എന്നാൽ 7 ചെയ്യുന്നു, കാരണം 14 നെ 7 കൊണ്ട്

ഹരിച്ചാൽ നമുക്ക് 0 ശിഷ്ടം ആയി ലഭിക്കും.

പിന്നീട് 8 ഹരിക്കപ്പെടുന്നില്ല, ഒമ്പത് ഹരിക്കുന്നില്ല,

അങ്ങനെ. അവസാനമായി, അവശേഷിക്കുന്ന

മറ്റൊരു ഘടകം 14 തന്നെയാണെന്ന് നമ്മൾ കണ്ടെത്തി.

അതിനാൽ m എന്ന ഓരോ സംഖ്യയ്ക്കും, 1, m

എന്നിവ ഘടകങ്ങളായിരിക്കും, അതിനിടയിൽ ഘടകങ്ങൾ

ഉണ്ടാകാം.

അതിനാൽ, ഇത് ചെയ്തുകഴിഞ്ഞാൽ, 14 ന്റെ ഘടകങ്ങൾ നമ്മൾ

തിരിച്ചറിഞ്ഞു, ഈ ഘടകങ്ങൾ കൃത്യമായി

1, 2, 7, 14 എന്നിവയാണ്.

14, 63 എന്നിവയുടെ gcd കണക്കുകൂട്ടുന്നതിനുള്ള

അടുത്ത ഘട്ടം 63 ന്റെ ഘടകങ്ങൾ കണക്കുകൂട്ടുക

എന്നതാണ്. അതിനാൽ, അതുപോലെ തന്നെ, 1 മുതൽ

63 വരെയുള്ള എല്ലാ അക്കങ്ങളും നമ്മൾ

എഴുതുകയും ഏതെല്ലാം സംഖ്യകൾ ഇവയെ ഹരിക്കുന്നുവെന്ന്

പരിശോധിക്കുകയും ചെയ്യുന്നു. വീണ്ടും,

1 ഹരിക്കുന്നു, ഇവിടെ 2 ഹരിക്കുന്നില്ല;

63 എന്നത് ഇരട്ട സംഖ്യയല്ല, 3 ഹരിക്കുന്നു, എന്നിട്ട്

ഹരിക്കാത്ത ഒരു കൂട്ടം സംഖ്യകൾ ഇവിടെ കാണാം.

അപ്പോൾ 7 ഹരിക്കുന്നു, കാരണം 7 ഗുണം 9, 63 ആണ്.

വീണ്ടും 8 ഹരിക്കുന്നില്ല, പക്ഷേ 9 ഹരിക്കുന്നു.

പിന്നീട് വീണ്ടും വലിയ സംഖ്യകളുണ്ട്,

അവ ഹരിക്കുന്നില്ല. എന്നിട്ട് 21 ഹരിക്കുന്നു,

കാരണം 21 ഗുണം 3, 63 ആണ്. ഒടുവിൽ, നമ്മുടെ

അവസാനത്തെ ഘടകം 63 ആണെന്ന് നമ്മൾ കണ്ടെത്തുന്നു.

ഒന്ന് മുതൽ 63 വരെ നമ്മൾ യഥാക്രമം ആയി

കടന്നുപോകുന്നു, ഒരു ഘടകമല്ലാത്ത

ഓരോ സംഖ്യയും മറികടന്ന്, നമ്മൾ 1, 3, 7, 9, 21, 63 പട്ടികയിൽ

അവസാനിക്കുന്നു. 14, 63 എന്നീ രണ്ട് അക്കങ്ങളുടെ

ഘടകങ്ങൾ കണക്കുകൂട്ടിയ ശേഷം, നമ്മുടെ അൽഗോരിതത്തിന്റെ(algorithm)

അടുത്ത ഘട്ടം പറയുന്നു, രണ്ട് ലിസ്റ്റിലും(list)

ദൃശ്യമാകുന്ന ഏറ്റവും വലിയ ഘടകം നമ്മൾ

കണ്ടെത്തണം. അതിനാൽ, നമ്മൾ ഇത് എങ്ങനെ

ചെയ്യും, പൊതുവായ ഘടകങ്ങളുടെ ഒരു പട്ടിക

എങ്ങനെ നിർമ്മിക്കും. ഇപ്പോൾ ഇത് ചെയ്യാൻ

കൂടുതൽ ബുദ്ധിപരമായ വഴികളുണ്ട്, എന്നാൽ

ഇവിടെ വളരെ ലളിതമായ ഒരു മാർഗമുണ്ട്.

നമ്മൾ ഒരു ലിസ്റ്റിലൂടെ(list) കടന്നുപോകുന്നു,

അതായത്, 14 ന്റെ ഘടകങ്ങളുടെ പട്ടിക, പട്ടികയിലെ

ഓരോ ഇനവും 63 ന്റെ ഘടകമാണോ എന്ന് നമ്മൾ

പരിശോധിക്കുന്നു. അതിനാൽ, നമ്മൾ 1 ൽ

നിന്ന് ആരംഭിക്കുന്നു, 1 എന്നത് 63 ന്റെ ഘടകമായി

കാണപ്പെടുന്നുണ്ടോ എന്ന് നോക്കുന്നു.

ഇത് കാണപ്പെടുന്നുണ്ട്, അതിനാൽ നമ്മൾ ഇത്

പൊതു ഘടകങ്ങളുടെ പട്ടികയിലേക്ക്

ചേർക്കുന്നു. അപ്പോൾ ഇനി നമ്മൾ 2 നോക്കുന്നു,

എന്നിട്ട് അത് ദൃശ്യമാകുമോ എന്ന് നമ്മൾ ചോദിക്കുന്നു;

അത് ദൃശ്യമാകാത്തതിനാൽ നമ്മൾ അത് ഒഴിവാക്കുന്നു.

എന്നിട്ട് നമ്മൾ 3 നോക്കുകയും 7 നോക്കുകയും

ചെയ്യുന്നു, എന്നാൽ 7 ദൃശ്യമാകുന്നതിനാൽ

നമ്മൾ 7 ചേർക്കുകയും ചെയ്യുന്നു. ഒടുവിൽ,

നമ്മൾ 14 നോക്കുകയും 14 ദൃശ്യമാകുന്നില്ലെന്ന്

കണ്ടെത്തുകയും അതിനാൽ അത് ഒഴിവാക്കുകയും

ചെയ്യുന്നു. ഈ രീതിയിൽ നമ്മൾ യഥാക്രമം ആയി

1, 2, 7, 14 എന്നിവയിലൂടെ കടന്നുപോയി, ഇവയിൽ

1, 7 എന്നിവ മാത്രമേ രണ്ട് ലിസ്റ്റിലും(list)

ദൃശ്യമാകൂ എന്ന് നിഗമനം ചെയ്തു.

ഇപ്പോൾ ഇത് ചെയ്തുകഴിഞ്ഞാൽ, ചെറിയതിൽ നിന്ന്

വലിയതിലേക്ക് നമ്മൾ കണക്കാക്കിയ പൊതുവായ

എല്ലാ ഘടകങ്ങളുടെയും ഒരു ലിസ്റ്റ്(list) നമ്മുടെ

പക്കലുണ്ട്, കാരണം ആരോഹണ ക്രമത്തിൽ

14 ന്റെ ഘടകങ്ങളിലേക്ക് നമ്മൾ പോയി. അതിനാൽ,

ഈ ലിസ്റ്റും(list) ആരോഹണ ക്രമത്തിലായിരിക്കും.

വലിയ ഘടകം റിട്ടേൺ(return) ചെയ്യുക എന്ന് പറയുന്നത്,

ഈ ലിസ്റ്റിലെ(list) ഏറ്റവും വലതുവശത്തെ ഘടകം

റിട്ടേൺ(return) ചെയ്യുക എന്നുള്ളതാണ്, അതായത്

7. അപ്പോൾ ഇതാണ് നമ്മുടെ ഫംഗ്ഷന്റെ(function) ഔട്ട്‌പുട്ട്(output).

നമ്മൾ 14 ന്റെ ഘടകങ്ങൾ കണക്കുകൂട്ടി, 63 ന്റെ

ഘടകങ്ങൾ കണക്കുകൂട്ടി, 14 ന്റെ ഓരോ ഘടകങ്ങളും

യഥാക്രമം ആയി പരിശോധിച്ചു, ഇത് 63 ന്റെ ഒരു ഘടകമാണോ

എന്ന് പരിശോധിക്കുകയും ഇവിടെയുള്ള പൊതു

ഘടകങ്ങളുടെ പട്ടിക കണക്കുകൂട്ടുകയും,

തുടർന്ന് ഈ പട്ടികയിൽ നിന്ന് നമ്മൾ ഏറ്റവും

വലുത് എക്‌സ്‌ട്രാക്റ്റു(extract) ചെയ്യുകയും ചെയ്തു,

ഇത് വാസ്തവത്തിൽ, നമ്മുടെ gcd ആണ്. ഈ അൽഗോരിതം(algorithm)

എങ്ങനെ പ്രവർത്തിപ്പിക്കും എന്നതിന്റെ ഒരു ഉദാഹരണമാണിത്.

നിങ്ങൾ‌ക്കത് കുറച്ചുകൂടി വിശദമായി എഴുതേണ്ടിവന്നാൽ‌,

ഈ ലിസ്റ്റുകൾ‌(list) നമ്മൾ ഓർത്തിരിക്കേണ്ടതുണ്ടെന്ന്

നമ്മൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്, തുടർന്ന്‌ അവയിലേക്ക്

മടങ്ങുക. അതിനാൽ, നമ്മൾ 14 ന്റെ ഘടകങ്ങൾ

കണക്കുകൂട്ടേണ്ടതുണ്ട്, അത് ഒരു വശത്ത് വയ്ക്കുക,

അത് എവിടെയെങ്കിലും എഴുതുക, 63 ന്റെ ഘടകം

കണക്കുകൂട്ടേണ്ടതുണ്ട്, അത് എവിടെയെങ്കിലും

എഴുതുക, തുടർന്ന് ഈ രണ്ട് ലിസ്റ്റുകളും(list)

താരതമ്യം ചെയ്യുക. അതിനാൽ, മറ്റൊരു

വിധത്തിൽ പറഞ്ഞാൽ ഇവ സംഭരിക്കുന്നതിന്

നമ്മൾ ചില പേരുകൾ നൽകേണ്ടതുണ്ട്. m

ന്റെ ഘടകങ്ങൾക്ക് fm എന്നും n ന്റെ ഘടകങ്ങൾക്ക്

fn എന്നും ഈ ലിസ്റ്റുകൾക്ക്(list) പേരുകൾ നൽകാം. അതിനാൽ,

നമ്മൾ ചെയ്യുന്നത് ഒന്ന് മുതൽ m വരെയുള്ള

അക്കങ്ങളിലൂടെ കടന്നുപോകുക എന്നതാണ്. ഓരോ i നും,

ഈ പട്ടിക 1 മുതൽ m വരെ, i m ഹരിക്കുന്നുണ്ടോ,

i m കൊണ്ട് ഹരിച്ചാൽ എനിക്ക് ശിഷ്ടം 0

ലഭിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്നു,

അങ്ങനെയാണെങ്കിൽ m അല്ലെങ്കിൽ fm ന്റെ

ലിസ്റ്റ്(list) ഘടകങ്ങളിലേക്ക് നമ്മൾ ഇത് ചേർക്കുന്നു.

അതുപോലെ, 1 മുതൽ n വരെ ഉള്ള ഓരോ j നും, j n നെ

ഹരിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു,

അങ്ങനെയാണെങ്കിൽ നമ്മൾ അത് fn പട്ടികയിലേക്ക്

ചേർക്കുന്നു. ഇപ്പോൾ നമുക്ക് fm,

fn എന്നീ രണ്ട് ലിസ്റ്റുകൾ(list) ഉണ്ട്, അവ m ന്റെ ഘടകങ്ങളും

n ന്റെ ഘടകങ്ങളുമാണ്. ഇപ്പോൾ നമ്മൾ പൊതു

ഘടകങ്ങളുടെ പട്ടിക കണക്കുകൂട്ടാൻ ആഗ്രഹിക്കുന്നു,

അതിനെ നമ്മൾ cf എന്ന് വിളിക്കും. അതിനാൽ,

നമ്മൾ ചെയ്യുന്നത്, ആദ്യത്തെ സംഖ്യയുടെ

ഘടകമായ ഓരോ f നും, നമ്മുടെ കാര്യത്തിൽ

14 ആയിരുന്നു എന്ന് ഓർക്കുക, അവിടെ ഓരോ

f നും 1, 2, 7, 14 എന്നിവയിലൂടെ കടന്നുപോകാം. അതിനാൽ,

ഓരോ f നും, മറ്റ് ലിസ്റ്റിലും(list) ഉണ്ടെങ്കിൽ, പൊതു

ഘടകങ്ങളുടെ പട്ടികയിലേക്ക് നമ്മൾ f ചേർക്കുന്നു.

അതിനാൽ, മറ്റ് പട്ടികയിൽ‌, നിങ്ങളുടെ നമ്പർ‌(number)

1, 3, 7, 9, 21, 63 ആണെങ്കിൽ‌, അതിനാൽ‌, നമ്മൾ ഈ

പട്ടികയുമായി f നെ താരതമ്യം ചെയ്യുന്നു,

നമ്മൾ അത് കണ്ടെത്തിയാൽ‌ അത് cf ലേക്ക് ചേർ‌ക്കുന്നു.

ഇപ്പോൾ ഇത് ചെയ്തുകഴിഞ്ഞാൽ, പൊതു ഘടകങ്ങളുടെ

പട്ടികയുടെ ഏറ്റവും വലിയ മൂല്യം തിരികെ

നൽകാൻ നമ്മൾ ആഗ്രഹിക്കുന്നു. ഒന്ന് എല്ലായ്പ്പോഴും

ഒരു പൊതു ഘടകമായിരിക്കുമെന്ന് ഓർമ്മിക്കുക. അതിനാൽ,

cf ലിസ്റ്റ്(list) ശൂന്യമായിരിക്കില്ല. കുറഞ്ഞത് ഒരു മൂല്യമെങ്കിലും

ഉണ്ടാകും, പക്ഷേ നമ്മൾ അവയെ ആരോഹണ

ക്രമത്തിൽ ചേർത്തതിനാൽ, fm ലിസ്റ്റ്(list) 1 മുതൽ

m വരെയും fn ലിസ്റ്റ്(list) 1 മുതൽ n വരെയും നിർമ്മിച്ചതിനാൽ,

ഏറ്റവും വലിയ മൂല്യം ഏറ്റവും വലതുവശത്തെ

മൂല്യമായിരിക്കും. ഇത് gcdക്ക് കുറച്ചുകൂടി

വിശദമായ അൽഗോരിതം(algorithm) നൽകുന്നു. m ന്റെ ഘടകങ്ങളുടെ

പട്ടിക എങ്ങനെ കണക്കാക്കാം, n ന്റെ ഘടകങ്ങളുടെ

പട്ടിക എങ്ങനെ കണക്കാക്കാം, ഈ രണ്ട് ലിസ്റ്റുകൾക്കിടയിലെ(list)

ഏറ്റവും വലിയ ഘടകത്തെ എങ്ങനെ കണക്കാക്കാം

എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ

നൽകുന്നത് ഒഴികെ ഇത് മുൻപത്തേതു പോലെ

തന്നെയാണ്. അതിനാൽ, നേരത്തെ നമുക്ക്

മൂന്ന് സംഗ്രഹ പ്രസ്താവനകൾ ഉണ്ടായിരുന്നു, ഇപ്പോൾ

നമ്മൾ 6 കുറച്ചുകൂടി വിശദമായ പ്രസ്താവനകൾ

ആയി വികസിപ്പിച്ചു.

നമ്മുടെ ആദ്യത്തെ പൈത്തൺ(python) പ്രോഗ്രാം(program)

എഴുതാൻ ഇത് ഇതിനകം തന്നെ മതിയായ വിവരങ്ങൾ

നൽകുന്നു. തീർച്ചയായും, ഇത് എങ്ങനെ എഴുതണമെന്ന്

അറിയുന്നതിനുമുമ്പ് നമ്മൾ കുറച്ചുകൂടി

പഠിക്കേണ്ടതുണ്ട്, പക്ഷേ അത് എങ്ങനെ

വായിക്കാമെന്ന് നമുക്ക് തീർച്ചയായും

കണ്ടെത്താനാകും. അതിനാൽ, ഈ പൈത്തൺ

പ്രോഗ്രാമിംഗ്(python programming) ചെയ്യുന്നത്

നമ്മൾ മുമ്പത്തെ ഘട്ടത്തിൽ അനൗപചാരികമായി

വിവരിച്ചതാണ്. പൈത്തൺ പ്രോഗ്രാമിലെ(python

program) ആദ്യ കാര്യം ഫംഗ്ഷനെ(function) നിർവചിക്കുന്ന ഒരു

വരിയാണ്. അതിനാൽ, m, n ന്റെ gcd എന്ന ഫംഗ്ഷൻ(function)

നമ്മൾ നിർവചിക്കുന്നു. അതിനാൽ, ഏതൊരു ഫംഗ്ഷനും(function)

പോലെ ഏത് സംഖ്യയും ആകാവുന്ന രണ്ട് ആർഗ്യുമെന്റുകളാണ്(argument)

m, n എന്നിവ. ഗണിതശാസ്ത്രത്തിൽ നമ്മൾ f (x, y) എന്ന് വായിക്കുന്നത്

പോലെയാണ്, ഇതിനർത്ഥം x, y എന്നിവ മദ്ധ്യസ്ഥ

മൂല്യങ്ങളാണെന്നും, ഓരോ x, y എന്നിവയ്‌ക്കും,

നമ്മൾ ഫംഗ്ഷൻ(function) വിളിക്കാൻ ഉപയോഗിക്കുന്ന

മൂല്യങ്ങളെ ആശ്രയിച്ച് എന്തെങ്കിലും ചെയ്യുക.

അതിനാൽ, ഇത് ഒരു നിർവചനമാണെന്ന് ഇത് പറയുന്നു, അതിനാൽ

gcd (m, n) എന്ന ഫംഗ്ഷന്റെ(function) നിർവചനത്തിനായി

def. ഇപ്പോൾ ആദ്യപടിയായി

m ന്റെ ഘടകങ്ങളുടെ പട്ടിക കണക്കുകൂട്ടുക.

പൈത്തണിൽ(python) ചതുര ബ്രാക്കറ്റുകൾ(bracket)

ഉപയോഗിച്ച് നമ്മൾ ഒരു ലിസ്റ്റ്(list) എഴുതുന്നു.

അതിനാൽ, പട്ടിക [x, y, z] എന്നിങ്ങനെ എഴുതിയിരിക്കുന്നു.

അതിനാൽ, ശൂന്യമായ പട്ടിക രണ്ടു സ്ക്വയർ

ബ്രാക്കറ്റുകൾ (bracket) മാത്രമാണ്. അതിനാൽ,

ഘടകങ്ങളുടെ ശൂന്യമായ ഒരു പട്ടിക ഉപയോഗിച്ച്

നമ്മൾ ആരംഭിക്കുന്നു. ഈ സമത്വം അർത്ഥമാക്കുന്നത്

ഒരു മൂല്യം നൽകുക എന്നാണ്. അതിനാൽ,

fm എന്ന m ന്റെ ഘടകങ്ങളുടെ പട്ടിക ശൂന്യമായ

പട്ടികയായി നൽകുന്നു. 1 മുതൽ n വരെയുള്ള

ശ്രേണിയിലെ എല്ലാ മൂല്യങ്ങളും ഇപ്പോൾ

പരിശോധിക്കേണ്ടതുണ്ട്. ഇപ്പോൾ പൈത്തണിന്(python)

റേഞ്ച്(range) എന്ന് വിളിക്കുന്ന ഒരു

ബിൽറ്റ് ഇൻ ഫംഗ്ഷൻ(built in function) ഉണ്ട്, എന്നാൽ

പൈത്തണിന്റെ(python) പ്രത്യേകത കാരണം

ഇത് നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന ശ്രേണി നൽകില്ല,

പക്ഷേ അതിൽ ഒന്ന് കുറവാണ് നൽകുന്നത്.

അതിനാൽ, 1 മുതൽ n +1 വരെയുള്ള ശ്രേണിയിലെ സംഖ്യകൾ

നൽകുക, അത് എനിക്ക് ഒന്ന് മുതൽ m വരെയുള്ള

ശ്രേണിയിൽ ഒന്ന് നൽകുന്നു, ഒന്ന്

മുതൽ മുകളിലെ പരിധി വരെ, എന്നാൽ ഉയർന്ന

പരിധി ഉൾപ്പെടുന്നില്ല. അതിനാൽ, ഞാൻ 1,2,3 മുതൽ

m വരെ ഉള്ള മൂല്യങ്ങൾ എടുക്കുന്നുവെന്ന്

ഇത് പറയും. i ന്റെ ഈ ഓരോ മൂല്യങ്ങൾക്കും,

ഇത് ശരിയാണോ എന്ന് പരിശോധിക്കുന്നു.

ഇവിടെ ശിഷ്ടത്തിൻറെ ചിഹ്നമാണ് %.

i m നെ ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ കിട്ടുന്നത്

എന്ന് പരിശോധിക്കുക. i m നെ ഹരിച്ചാൽ ശിഷ്ടം

0 ആണെങ്കിൽ, അതിനുശേഷം നമ്മൾ fn ലിസ്റ്റിലേക്ക്(list)

i കൂട്ടിച്ചേർക്കും, നമ്മൾ അത് വലതുവശത്ത്

ചേർക്കും, ലിസ്റ്റിന്റെ(list) അവസാനത്തിൽ ചേർക്കുക

എന്ന് അർത്ഥം വരുന്ന ഇംഗ്ലീഷ്(English) പദമാണ്

അപ്പൻഡ്(append). അതിനാൽ, നമ്മൾ i n ലേക്ക് കൂട്ടിച്ചേർക്കുന്നു.

അതിനാൽ, ഈ ഘട്ടത്തിൽ, നമ്മൾ fm കണക്കുകൂട്ടി.

മുമ്പത്തെ ഉദാഹരണത്തിൽ‌ നമ്മൾ അനൗപചാരികമായി

എഴുതിയത് ഇതാണ്, 1 മുതൽ m വരെ ഓരോ i നും,

i m നെ ഹരിച്ചാൽ i fm ലേക്ക് ചേർക്കുക, ഇപ്പോൾ

നമ്മൾ അത് പൈത്തൺ(python) വാക്യഘടനയിൽ ചെയ്തു.

നമ്മൾ ഘടകങ്ങളുടെ ഒരു ശൂന്യമായ ലിസ്റ്റ്(list)

നിർ‌വ്വചിച്ചു, ആ ശ്രേണിയിലെ ഓരോ നമ്പറിനെയും(number)

ഇത് ഒരു ഹാരകമാണോയെന്ന് പരിശോധിച്ച് അത്

ചേർക്കുക. ഇപ്പോൾ ഇവിടെ നമ്മൾ

n നും ഇതു പോലെ തന്നെ ചെയ്യുന്നു. അതിനാൽ,

n ന്റെ ഘടകങ്ങളുടെ ശൂന്യമായ പട്ടികയിൽ‌

നിന്നാണ് നമ്മൾ ആരംഭിക്കുന്നത്, ഈ ശ്രേണിയിലെ ഓരോ

j യും ഹരിച്ചാൽ‌ നമ്മൾ അതിനെ കൂട്ടിച്ചേർക്കുന്നു.

ഇപ്പോൾ, ഈ സമയത്ത് നമുക്ക് രണ്ട് പട്ടിക

fm ഉം fn ഉം ഉണ്ട്. ഇപ്പോൾ, പൊതു ഘടകങ്ങളുടെ

പട്ടിക കണക്കാക്കാൻ നമ്മൾ ആഗ്രഹിക്കുന്നു.

അതിനാൽ, പൊതു ഘടകങ്ങളുടെ പട്ടിക സൂചിപ്പിക്കാൻ

നമ്മൾ cf ഉപയോഗിക്കുന്നു. തുടക്കത്തിൽ പൊതു

ഘടകങ്ങളൊന്നുമില്ല. ഇപ്പോൾ, ആദ്യ പട്ടികയിലെ

ഓരോ ഘടകത്തിനും രണ്ടാമത്തെ പട്ടികയിൽ‌ ഘടകം

പ്രത്യക്ഷപ്പെടുകയാണെങ്കിൽ‌ നമ്മൾ അതിനെ cf ലേക്ക്

കൂട്ടിച്ചേർക്കുന്നു. അതിനാൽ, അപ്പൻഡ്(append)

എന്ന അതേ ഫംഗ്ഷൻ(function) ഉടനീളം ഉപയോഗിക്കുന്നു.

ഒരു ലിസ്റ്റ്(list) എടുത്ത് ഒരു മൂല്യം ചേർക്കുക.

ഏത് മൂല്യം? നിബന്ധനകളെ തൃപ്തിപ്പെടുത്തുന്നുവെങ്കിൽ,

നമ്മൾ ഇപ്പോൾ നോക്കുന്ന മൂല്യം നമ്മൾ ചേർക്കുന്നു.

അതിനാൽ, നേരത്തെ നമ്മൾ ശിഷ്ടം 0 ആണെങ്കിൽ

ചേർക്കുകയായിരുന്നു, ഇപ്പോൾ ഇത് രണ്ട്

ലിസ്റ്റിലും(list) ദൃശ്യമാകുമ്പോൾ നമ്മൾ ഇത് ചേർക്കുന്നു.

ആദ്യ പട്ടികയിലെ ഓരോ f ഉം രണ്ടാമത്തെ

പട്ടികയിലും പ്രത്യക്ഷപ്പെടുകയാണെങ്കിൽ, അത് ചേർക്കുക.

ഇതിനുശേഷം നമ്മൾ fm, cf കണക്കുകൂട്ടി.

ഇപ്പോൾ നമുക്ക് ഏറ്റവും വലതുവശത്തെ ഘടകം

വേണം. അതിനാൽ, ഇത് ചില പൈത്തൺ(python) വാക്യഘടന

മാത്രമാണ്, പകരം ഇടതുവശത്ത് നിന്ന്

എണ്ണാൻ തുടങ്ങിയാൽ പട്ടികയിലെ സ്ഥാനങ്ങളുടെ

നമ്പർ(number) 0, 1, 2, 3, 4 എന്നിങ്ങനെയാണ്. എന്നാൽ പൈത്തണിന്(python)

ഒരു കുറുക്കുവഴി ഉണ്ട് നിങ്ങൾക്ക്

വലതുവശത്ത് നിന്ന് എണ്ണാൻ താൽപ്പര്യമുണ്ട്,

തുടർന്ന് നമ്മൾ അക്കങ്ങളെ മൈനസ്(minus) 1, മൈനസ്(minus)

2 എന്നിങ്ങനെ കണക്കാക്കുന്നു. അതിനാൽ, cfന്റെ മൈനസ്(minus)

ഒന്നാമത്തെ ഘടകം റിട്ടേൺ(return) ചെയ്യുക,

പൈത്തൺ(python) പദപ്രയോഗത്തിൽ ഏറ്റവും വലതുവശത്തെ

മൂലകം റിട്ടേൺ(return) ചെയ്യുക. അതിനാൽ,

ഇത് ഏറ്റവും വലതുവശത്തെ ഘടകമാണ്.

ഈ സമയത്ത്, ചില സ്ഥലങ്ങളിൽ നമ്മൾ കോളൻ(colon) ഉപയോഗിക്കുന്നത്

എന്തുകൊണ്ടാണെന്നും, എന്തുകൊണ്ടാണ് നമ്മൾ

എന്തെങ്കിലും പുഷ്(push) ചെയ്യുന്നതെന്നും

കൃത്യമായി മനസ്സിലായില്ലെങ്കിലും ഈ കോഡ്(code), ഈ പ്രോഗ്രാം(program)

ഡീകോഡ്(decode) ചെയ്യാൻ നമുക്ക് ശ്രമിക്കാമെന്ന്

മനസിലാക്കാൻ ഇത് മതിയാകും. ഇവിടെ

മറ്റ് വാക്യഘടനാപരമായ കാര്യങ്ങളുണ്ടെന്ന്

ശ്രദ്ധിക്കുക, അതിനാൽ ഉദാഹരണത്തിന്, നിങ്ങൾക്ക്

ഈ വിരാമചിഹ്നങ്ങളുണ്ട്, അവ ഈ കോളനുകളെപ്പോലെ(colon)

അൽപ്പം വിചിത്രമാണ്. ഈ വരിയുമായി ബന്ധപ്പെട്ട്

ഈ വരി ഇൻഡന്റ്(intend) ചെയ്‌തിരിക്കുന്നു

എന്ന വസ്തുത നിങ്ങൾക്കുണ്ട്, ഈ വരി ഈ വരിയിലേക്ക്

ഇൻഡന്റ്(intend) ചെയ്‌തിരിക്കുന്നു. മറ്റ് ഭാഷകളിലെ പ്രോഗ്രാമുകളേക്കാൾ(program)

പൈത്തൺ പ്രോഗ്രാമുകൾ(python program) വായിക്കാനും

എഴുതാനും അൽപ്പം എളുപ്പമാക്കുന്ന

സവിശേഷതകളാണ് ഇവയെല്ലാം. അതിനാൽ, പൈത്തൺ(python)

വാക്യഘടന കൂടുതൽ ഔപചാരികമായി പഠിക്കുമ്പോൾ

നമ്മൾ ഇവയിലേക്ക് വരും. മുമ്പത്തെ

സ്ലൈഡിൽ(slide) നമ്മൾ എഴുതിയ അനൗപചാരിക

അൽഗോരിതത്തിന്റെ(algorithm) വളരെ വിശ്വസ്തമായ

റെൻഡറിംഗാണ്(rendering) ഈ പൈത്തൺ(python) ഘട്ടങ്ങൾ

എന്ന് ഈ ഘട്ടത്തിൽ നിങ്ങൾക്ക് സ്വയം

ബോധ്യപ്പെടുത്താൻ കഴിയും.

ഈ പ്രത്യേക ഉദാഹരണത്തിൽ നിന്ന് ഇതിനകം തന്നെ

ഒഴിവാക്കാൻ കഴിയുന്ന ചില പോയിന്റുകൾ(point)

നമുക്ക് ശ്രദ്ധിക്കാം. അതിനാൽ, ഇന്റർമീഡിയറ്റ്(intermediate)

മൂല്യങ്ങളുടെ വിവരങ്ങൾ സൂക്ഷിക്കാൻ നമുക്ക്

ഒരു മാർഗം ആവശ്യമാണ് എന്നതാണ് ആദ്യത്തെ

പ്രധാന കാര്യം. അതിനാൽ, നമുക്ക് ആരംഭിക്കാൻ

രണ്ട് പേരുകളുണ്ട്, നമ്മുടെ ആർഗ്യുമെന്റുകളുടെ(argument)

പേരുകൾ m, n. ഈ ഘടകങ്ങളുടെയും പൊതുവായ ഘടകങ്ങളുടെയും

പട്ടിക കണക്കാക്കാൻ നമ്മൾ ഈ മൂന്ന് പേരുകൾ

ഉപയോഗിക്കുന്നു, കൂടാതെ i, j, f പോലുള്ള

മറ്റ് പേരുകളും നമ്മൾ ഉപയോഗിക്കുന്നു.

നമുക്ക് i 1 മുതൽ n വരെ പ്രവർത്തിക്കേണ്ടത്

ആവശ്യമാണ്. നമുക്ക് j 1 മുതൽ n വരെ പ്രവർത്തിക്കേണ്ടത്

ആവശ്യമാണ്. തീർച്ചയായും, നമുക്ക് വീണ്ടും

ഉപയോഗിക്കാം. പക്ഷെ കുഴപ്പമില്ല. cf ലെ

എല്ലാ ഘടകങ്ങളിലൂടെയും പ്രവർത്തിക്കാൻ

നമ്മൾ f ഉപയോഗിക്കുന്നു. അതിനാൽ, ഇന്റർമീഡിയറ്റ്(intermediate)

മൂല്യങ്ങളുടെ വിവരങ്ങൾ സൂക്ഷിക്കുന്നതിനുള്ള

വഴികളാണ് ഇവ. ശ്രദ്ധിക്കേണ്ട രണ്ടാമത്തെ കാര്യം,

ഒരു മൂല്യം ഒരൊറ്റ ഇനമാകാം എന്നതാണ്.

ഉദാഹരണത്തിന്, m n എന്നത് അക്കങ്ങളാണ്,

അതുപോലെ തന്നെ ഓരോ ഘട്ടത്തിലും i, j, f

എന്നിവ അക്കങ്ങളാണ്. അതിനാൽ, ഇവ ഒരൊറ്റ

മൂല്യങ്ങളായിരിക്കും അല്ലെങ്കിൽ അവ ശേഖരങ്ങളാകാം.

ലിസ്റ്റുകൾ(list) ഉണ്ട്. അതിനാൽ fm ഒരു പട്ടികയാണ്,

fn ഒരു പട്ടികയാണ്. ഇത് മൂല്യങ്ങളുടെ

ശേഖരം സൂചിപ്പിക്കുന്ന ഒരൊറ്റ പേരാണ്, ഈ

സാഹചര്യത്തിൽ, ഒരു പട്ടിക എന്നത് ഒരു

സ്ഥാനവും ആദ്യ സ്ഥാനവും അവസാന സ്ഥാനവും ഉള്ള

ഒരു ശ്രേണിയാണ്. ഇവ അക്കങ്ങളുടെ പട്ടികയാണ്.

ഒരാൾ‌ക്ക് മറ്റ് ശേഖരങ്ങൾ‌ സങ്കൽപ്പിക്കാൻ‌

കഴിയും, ഒപ്പം മുന്നോട്ട് പോകുന്നതിനനുസരിച്ച്

ഇവയെ കാണുകയും ചെയ്യാം. അതിനാൽ, ശേഖരങ്ങൾ

പ്രധാനമാണ്, കാരണം m ന്റെ ഓരോ ഘടകങ്ങൾക്കും

വെവ്വേറെ പേര് നിർമ്മിക്കുന്നത് തുടരുകയാണെങ്കിൽ

ഒരു പ്രോഗ്രാം(program) എഴുതുന്നത് വളരെ

ബുദ്ധിമുട്ടാണ്. m എത്ര വലുതാണെന്നത്

പരിഗണിക്കാതെ തന്നെ m ന്റെ എല്ലാ ഘടകങ്ങൾക്കും

നമുക്ക് ഒരു പേര് ആവശ്യമാണ്. ഈ പേരുകൾക്ക്

ഒരൊറ്റ മൂല്യത്തെയോ മൂല്യങ്ങളുടെ ശേഖരത്തെയോ

സൂചിപ്പിക്കാൻ കഴിയും. പ്രത്യേക ഘടനയുള്ള

മൂല്യങ്ങളുടെ ശേഖരത്തെയാണ് നമ്മൾ ഡാറ്റാ സ്ട്രക്ചർ(data

structure) എന്ന് വിളിക്കുന്നത്. അതിനാൽ, ഇവയെ സാധാരണയായി

ഡാറ്റാ സ്ട്രക്ചറുകൾ(data structures) എന്ന് വിളിക്കുന്നു.

അതിനാൽ, ഈ സാഹചര്യത്തിൽ നമ്മുടെ ഡാറ്റാ ഘടന

ഒരു പട്ടികയാണ്.

ഈ പേരുകളും മൂല്യങ്ങളും ഉപയോഗിച്ച് നമുക്ക്

എന്തുചെയ്യാൻ കഴിയും, ഒരു പേരിന് ഒരു മൂല്യം

നൽകാമെന്നതാണ് ഒരു കാര്യം. അതിനാൽ, ഉദാഹരണത്തിന്,

നമ്മൾ fn = ശൂന്യമായ ലിസ്റ്റ്(list) എന്ന്

എഴുതുമ്പോൾ, fn ന്റെ മൂല്യം ശൂന്യമായ

പട്ടികയായി നമ്മൾ സജ്ജമാക്കുന്നു.

ഇത് രണ്ട് കാര്യങ്ങൾ പറയുന്നു, മൂല്യം

ശൂന്യമായ പട്ടികയാണെന്ന് ഇത് പറയുന്നു, ഇത്

fn ലിസ്റ്റുകളെ(list) സൂചിപ്പിക്കുന്നു

എന്ന് പൈത്തണിനോട്(python) പറയുന്നു, ഇത് നമ്മൾ

കാണുന്നതുപോലെ ഇവിടെ നടക്കുന്ന രണ്ട്

ഘട്ടങ്ങളാണ്. മറ്റൊരു ഭാഗം, നമ്മൾ

cf പട്ടികയിലെ ഓരോ f നും വേണ്ടി എന്തെങ്കിലും

എഴുതുമ്പോൾ, cf ലെ എല്ലാ മൂല്യങ്ങളും

എടുത്ത് f എന്ന പേരിന് f എന്ന മൂല്യങ്ങളിലേക്ക്

ഓരോന്നായി നൽകണമെന്ന് ഇത് സൂചിപ്പിക്കുന്നു.

അവർക്ക് ഈ സമത്വ ചിഹ്നം സ്പഷ്ടമായി

ഇല്ലെങ്കിലും, നമ്മൾ cf പട്ടികയിലേക്ക്

ചുവടുവെക്കുമ്പോൾ ഇത് f നായി പുതിയ മൂല്യങ്ങൾ

നൽകുന്നു. അതിനാൽ, ഒരു പൈത്തൺ പ്രോഗ്രാമിൽ(python

program) നമ്മൾ ചെയ്യുന്ന പ്രധാന കാര്യം പേരുകൾക്ക്

മൂല്യങ്ങൾ നൽകുക എന്നതാണ്.

ഒരു മൂല്യം നിർണ്ണയിച്ചാൽ നമുക്ക് മൂല്യം പരിഷ്കരിക്കാനാകും.

ഉദാഹരണത്തിന്, n ന്റെ ഒരു പുതിയ ഘടകം കണ്ടെത്തുമ്പോഴെല്ലാം,

പഴയ ഘടകങ്ങളൊന്നും നമ്മൾ ആഗ്രഹിക്കുന്നില്ല,

നിലവിലുള്ള ലിസ്റ്റ്(list) fm എടുക്കാൻ നമ്മൾ

ആഗ്രഹിക്കുന്നു, അത് ചേർക്കാൻ നമ്മൾ

ആഗ്രഹിക്കുന്നു. അതിനാൽ, അപ്പൻഡ്(append)

എന്ന ഈ ഫംഗ്ഷൻ(function), ഉദാഹരണത്തിന്, fn എന്ന

പേരിന്റെ മൂല്യം ഒരു പുതിയ പേരിലേക്ക്

പരിഷ്കരിക്കുന്നു, അത് പഴയ പേര് എടുക്കുകയും

അതിന്റെ അവസാനം ഒരു i ഘടിപ്പിക്കുകയും

ചെയ്യുന്നു. സാധാരണയായി, നിങ്ങൾക്ക്

ഒരു സംഖ്യ ഉണ്ടായിരിക്കാം, അത് രണ്ട് ഇരട്ടി

സംഖ്യ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ

നമ്മൾ ആഗ്രഹിക്കുന്നു. അതിനാൽ, നമുക്ക്

i = 2 * i പോലുള്ള എന്തെങ്കിലും ഉണ്ടായിരിക്കാം.

അതിനാൽ, നക്ഷത്രം ഗുണനത്തെ സൂചിപ്പിക്കുന്നു,

ഇതിനർത്ഥം ഗണിതപരമായി i = 2 * i എന്നത് അർത്ഥമാക്കുന്നില്ല,

കാരണം; വ്യക്തമായും, i 0 അല്ലാത്തിടത്തോളം,

i, 2 * i ന് തുല്യമാകരുത്. അതിന്റെ അർത്ഥം i

യുടെ നിലവിലെ മൂല്യം എടുത്ത് അതിനെ രണ്ടായി

ഗുണിച്ച് i ലേക്ക് നിയോഗിക്കുക എന്നതാണ്.

നമ്മൾ മുന്നോട്ട് പോകുന്നതിനനുസരിച്ച്

നമുക്ക് അത് കാണാൻ സാധിക്കും, പക്ഷേ

അസൈൻമെന്റ്(assignment) ഉപയോഗിച്ച് പൂർണ്ണമായും

പുതിയ മൂല്യം നൽകാം അല്ലെങ്കിൽ പഴയ മൂല്യം

ഉപയോഗിച്ച് നിങ്ങൾക്ക് മൂല്യം അപ്‌ഡേറ്റ്(update)

ചെയ്യാൻ കഴിയും. അതിനാൽ, ഇവിടെ നമ്മൾ

fn ലിസ്റ്റിന്റെ(list) ഫംഗ്ഷന്റെ(function) പഴയ

മൂല്യം എടുക്കുന്നു, നമ്മൾ ഒരു മൂല്യം

കൂട്ടിച്ചേർക്കുന്നു, അതിന് fn ന്റെ ഒരു

പുതിയ മൂല്യം ലഭിക്കും.

നമ്മൾ ശ്രദ്ധിക്കേണ്ട മറ്റൊരു ഭാഗം നമ്മൾ

എങ്ങനെ ഘട്ടങ്ങൾ നിർവ്വഹിക്കുന്നു

എന്നതാണ്. അതിനാൽ, ഇന്നത്തെ പ്രഭാഷണത്തിന്റെ

തുടക്കത്തിൽ നമ്മൾ പറഞ്ഞു, ഒരു പ്രോഗ്രാം(program)

ഘട്ടങ്ങളുടെ ഒരു ശ്രേണിയാണ്. എന്നാൽ

നമ്മൾ തുടക്കം മുതൽ അവസാനം വരെയുള്ള

ഘട്ടങ്ങളുടെ ക്രമം അന്ധമായി നടപ്പിലാക്കുന്നില്ല.

ചിലപ്പോൾ നമ്മൾ വീണ്ടും വീണ്ടും അതേ കാര്യം

ചെയ്യേണ്ടിവരും. ഉദാഹരണത്തിന്, 1 മുതൽ

m വരെയുള്ള എല്ലാ ഘടകങ്ങളും m നെ ഹരിക്കുന്നുണ്ടോ

എന്ന് പരിശോധിക്കുക, അങ്ങനെയാണെങ്കിൽ

അവയെ പട്ടികയിൽ ഇടുക. അതിനാൽ, ചില ഘട്ടങ്ങൾ

ആവർത്തിക്കുന്നു, ഉദാഹരണങ്ങൾക്കായി,

ഒരു ലിസ്റ്റിലെ(list) ഓരോ ഇനത്തിനും ഇവിടെ

നമ്മൾ എന്തെങ്കിലും ചെയ്യുന്നു.

നമ്മൾ നോക്കുന്ന മൂല്യം പ്രത്യേക

നിബന്ധനകൾ പാലിക്കുന്നുണ്ടെങ്കിൽ മാത്രമേ ചില ഘട്ടങ്ങൾ

നടപ്പിലാക്കുകയുള്ളൂ. m നെ i കൊണ്ട് ഹരിച്ചാൽ

ശിഷ്ടം 0 ആണെങ്കിൽ, m % i എന്നത് 0 പറയാം,

ഇതിനെ കൂട്ടി ചേർക്കുക. അതിനാൽ, m ന്റെ ഘടകങ്ങൾ

fm ലേക്ക് i കൂട്ടിച്ചേർക്കുക എന്ന ഘട്ടം,ഇത് സംഭവിക്കുന്നത്

i എന്നത് m ന്റെ ഘടകമാണെന്ന അവസ്ഥയുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ

മാത്രമായിരിക്കും. ഒരേ കാര്യം വീണ്ടും

വീണ്ടും ചെയ്യുന്ന ആവർത്തന ഘട്ടങ്ങൾ

ഉണ്ട്. അവർക്ക് കണ്ടീഷണൽ‌(conditional) ഘട്ടങ്ങളുണ്ട്, ഒരു

പ്രത്യേക നിബന്ധന ഉണ്ടെങ്കിൽ‌ മാത്രമേ

ഇത് ചെയ്യൂ. അതിനാൽ, നമുക്ക്

ഇവിടെ നിർത്തും. പ്രോഗ്രാമുകൾ(program)

നമുക്ക് അവബോധപരമായി അറിയുന്നതിൽ നിന്ന്

വളരെ വ്യത്യസ്തമല്ലെന്ന് ഈ ഉദാഹരണങ്ങൾ നിങ്ങളെ

കാണിക്കും, അത് ശരിയായി എഴുതുക, മാത്രമല്ല

നമുക്ക് ആവശ്യമുള്ള എല്ലാ ഇന്റർമീഡിയറ്റ്(intermediate)

മൂല്യങ്ങളുടെയും ഘട്ടങ്ങളുടെയും

വിവരങ്ങൾ സൂക്ഷിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്തുക,

അങ്ങനെ നമുക്ക് കാര്യങ്ങൾ നഷ്ടപ്പെടുന്നില്ല.

നമ്മൾ പിന്നീട് ഈ ഉദാഹരണം കൂടുതൽ വിശദമായി

നോക്കും, കൂടാതെ ഇത് എഴുതുന്നതിനുള്ള

മറ്റ് മാർഗ്ഗങ്ങൾ കണ്ടെത്താനും മറ്റ്

സവിശേഷതകൾ പരിശോധിക്കാനും ശ്രമിക്കും, പക്ഷേ

ഇത് പ്രോഗ്രാമിംഗ്(programming) ചിത്രീകരിക്കുന്നതിനുള്ള

ഒരു നല്ല മാർഗമാണ്.