The derivation system was chosen for explanation.

விளக்கத்திற்காக இந்த வழித்தோன்றல் முறை தேர்ந்தெடுக்கப்பட்டது.


In practice, derivation systems are used for describing computational relations.

நடைமுறையில், கணக்கீட்டு உறவுகளை விவரிக்க வழித்தோன்றல் அமைப்புகள் பயன்படுத்தப்படுகின்றன.


Typing and evaluation of expressions are examples for such relations.

உருவாக்கம் மற்றும் வெளிப்பாடுகளின் மதிப்பீடு ஆகியவை இதுபோன்ற உறவுகளுக்கு எடுத்துக்காட்டுகளாகும்.


We are going to use derivation systems for this purpose.

இந்த நோக்கத்திற்காக வழித்தோன்றல் அமைப்புகளைப் பயன்படுத்தப் போகிறோம்.


5 < 9க்கான அனைத்து வழித்தோன்றல்களையும் கொடுங்கள்.


Give two inference rules for judgments x < y.

x < y தீர்ப்புகளுக்கான இரண்டு அனுமான விதிகளை கொடுங்கள்.


Your rules derive the same judgments the rules given above derive.

உங்கள் விதிகள் மேலே கொடுக்கப்பட்ட விதிகள் பெறக்கூடிய அதே தீர்ப்புகளைப் பெறுகின்றன.


No judgments has more than one derivation.

எந்தத் தீர்ப்பும் ஒன்றுக்கு மேற்பட்ட வழித்தோன்றலைக் கொண்டிருக்கவில்லை.


Give two inference rules for judgments x < y such that a judgment x < y is derivable if and only if x + k * 5 = y for some k ≥ 1.

x < y தீர்ப்புகளுக்கான இரண்டு அனுமான விதிகளை கொடுங்கள், இதனால் x < y என்ற தீர்ப்பு பெறப்பட்டால், சில k ≥ 1 க்கு x + k * 5 = y ஆக இருக்கும்.


The semantic layers of a language see the phrases of the language as abstract syntactic objects.

ஒரு மொழியின் சொற்பொருள் அடுக்குகள் மொழியின் சொற்றொடர்களை சுருக்கமான தொடரியல் பொருள்களாகப் பார்க்கின்றன.


சொல் விவரங்கள் ஒரு பங்கை வகிக்காது.


This brings us back to the philosophy of Chapter 1.

இது நம்மை முதல் அத்தியாயத்தின் தத்துவத்திற்கு கொண்டு செல்கிறது.


We explained OCaml with abstract syntactic notions.

OCaml ஐ சுருக்கமான தொடரியல் கருத்துகளுடன் விளக்கினோம்.


For the discussion of the semantic layers, we switch to a language of abstract expressions.

சொற்பொருள் அடுக்குகளின் விவாதத்திற்காக, சுருக்கமான வெளிப்பாடுகளின் மொழிக்கு மாறுகிறோம்.


The new language has types as considered before.

புதிய மொழி முன்பு கருதிய வகைகளைக் கொண்டுள்ளது.


Constants are values of the types int, bool, and string.

நிலையானவை int, bool மற்றும் string வகைகளின் மதிப்புகளாகும்.


For simplicity, we just have binary operator applications.

எளிமைக்காக, எங்களிடம் இருமச் செயற்குறி பயன்பாடுகள் மட்டுமே உள்ளன.


The variables introduced by lambda expressions and let expressions are called local variables.

லாம்ப்டா வெளிப்பாடுகள் மற்றும் லெட் வெளிப்பாடுகளால் அறிமுகப்படுத்தப்பட்ட மாறிகள் உள்ளூர் மாறிகள் என்று அழைக்கப்படுகின்றன.


Tuple patterns are replaced by projections.

துகள் வடிவங்கள் ப்ரொஜெக்ஷன்களால் மாற்றப்படுகின்றன.


It is possible to translate concrete expressions into equivalent abstract expressions.

உண்மையான வெளிப்பாடுகளை சமமான சுருக்கமான வெளிப்பாடுகளாக மொழிபெயர்க்க முடியும்.


Tail recursion is more efficient than general recursion.

பொதுவான மறுபயன்பாட்டை விட வால் மறுபயன்பாடு மிகவும் திறமையானது.


Recursive function applications can only appear in tail positions.

மறுபயன்பாட்டு செயல்பாடு பயன்பாடுகள் வால் நிலைகளில் மட்டுமே தோன்ற முடியும்.


Typical examples of tail recursive functions include gcd and my_mod.

வால் மறுபயன்பாட்டு செயல்பாடுகளுக்கு வழக்கமான எடுத்துக்காட்டுகள் gcd மற்றும் my_mod ஆகியவை அடங்கும்.


Functions like pow are not tail recursive.

pow போன்ற செயல்பாடுகள் வால் மறுபயன்பாடு அல்ல.


Tail recursive functions can be traced in a simple way.

வால் மறுபயன்பாட்டு செயல்பாடுகளை எளிமையான முறையில் கண்காணிக்க முடியும்.


For non-tail recursive functions, traces look more complicated.

வால் அல்லாத மறுபயன்பாட்டு செயல்பாடுகளுக்கு, தடயங்கள் மிகவும் சிக்கலானதாக இருக்கும்.


Tail recursive functions can be expressed with loops in imperative programming.

கட்டாய நிரலாக்கத்தில் வால் மறுபயன்பாட்டு செயல்பாடுகளை சுழல்களுடன் வெளிப்படுத்தலாம்.


Functional programming languages prefer tail recursive functions over loops.

செயல்பாட்டு நிரலாக்க மொழிகள் சுழல்களை விட வால் மறுபயன்பாட்டு செயல்பாடுகளை விரும்புகின்றன.


Non-tail recursive functions can be reformulated as tail recursive functions.

வால் அல்லாத மறுபயன்பாட்டு செயல்பாடுகளை வால் மறுபயன்பாட்டு செயல்பாடுகளாக மீண்டும் உருவாக்கலாம்.


An extra argument can serve as an accumulator.

ஒரு கூடுதல் வாதம் ஒரு திரட்டியாக செயல்பட முடியும்.


The factorial of a positive integer n is the product of all positive integers less than or equal to n.

ஒரு நேர்மறை முழு எண் n இன் காரணி என்பது n க்கு சமமான அல்லது குறைவான அனைத்து நேர்மறை முழு எண்களின் பெருக்கமாகும்.


Tuples can represent collections of values.

மதிப்புகளின் தொகுப்புகளை டியூப்பிள்கள் குறிக்க முடியும்.


The marathon time of Eliud Kipchoge's world record was 2:01:39.

எலியுட் கிப்சோகேயின் உலக சாதனை மராத்தான் நேரம் 2:01:39 ஆகும்.


OCaml has tuples to represent collections of values.

மதிப்புகளின் தொகுப்புகளைப் பிரதிநிதித்துவப்படுத்த OCaml டியூப்பிள்களைக் கொண்டுள்ளது.


The component types of a tuple are not restricted to int.

ஒரு டியூப்பிளின் கூறு வகைகள் int க்கு மட்டுப்படுத்தப்படவில்லை.


நீளம் 2 கொண்ட டியூப்பிள்கள் ஜோடிகள் என்று அழைக்கப்படுகின்றன.


We can write functions to translate between times.

நேரங்களுக்கு இடையில் மொழிபெயர்க்கும் செயல்பாடுகளை நாம் எழுதலாம்.


Execution is aborted and an exception is reported.

செயல்படுத்துதல் நிறுத்தப்பட்டு ஒரு விதிவிலக்கு அறிவிக்கப்படுகிறது.


Exceptions can be useful when debugging erroneous programs.

தவறான நிரல்களை பிழைத்திருத்தம் செய்யும் போது விதிவிலக்குகள் பயனுள்ளதாக இருக்கும்.


The program binds the identifier 'a' to the integer 8.

அந்த நிரல் 'a' என்ற அடையாளங்காட்டியினை 8 என்ற எண்ணுக்குக் கட்டுப்படுத்துகிறது.


After execution, the interpreter will show the values it has computed.

செயல்படுத்திய பிறகு, மொழிபெயர்ப்பாளர் கணக்கிடப்பட்ட மதிப்புகளைக் காண்பிக்கும்.


The course is designed to take about one third of the study time.

இந்த பாடத்திட்டம் படிப்பு நேரத்தில் மூன்றில் ஒரு பகுதியை எடுத்துக் கொள்ள வடிவமைக்கப்பட்டுள்ளது.


We assume that incoming students are familiar with mathematical thinking.

உள்வரும் மாணவர்கள் கணித சிந்தனையுடன் நன்கு அறிந்திருப்பார்கள் என்று நாங்கள் கருதுகிறோம்.


The interpreter checks that the given text can be interpreted as a program.

கொடுக்கப்பட்ட உரை ஒரு நிரலாக விளக்கப்பட முடியுமா என்பதை மொழிபெயர்ப்பாளர் சரிபார்க்கிறார்.


முக்கிய வார்த்தைகளை அடையாளங்காட்டிகளாகப் பயன்படுத்த முடியாது.


ஒவ்வொரு வெளிப்பாட்டிற்கும் ஒரு வகை உண்டு.


The values of the type int are integers.

int வகையின் மதிப்புகள் முழு எண்களாகும்.


In contrast to the infinite mathematical type Z, OCaml’s type int provides only a finite interval.

முடிவற்ற கணித வகைக்கு மாறாக Z, OCaml இன் வகை int ஒரு வரையறுக்கப்பட்ட இடைவெளியை மட்டுமே வழங்குகிறது.


The endpoints of the interval can be obtained with the predefined identifiers min_int and max_int.

இடைவெளியின் இறுதிப் புள்ளிகளை முன் வரையறுக்கப்பட்ட அடையாளங்காட்டிகளான min_int மற்றும் max_int மூலம் பெறலாம்.


All machine operations respect this interval.

அனைத்து இயந்திர செயல்பாடுகளும் இந்த இடைவெளியை மதிக்கின்றன.


We will usually ignore the machine integers and just assume that all integers are available.

நாம் பொதுவாக இயந்திர முழு எண்களை புறக்கணிப்போம், மேலும் அனைத்து முழு எண்களும் கிடைக்கும் என்று கருதுவோம்.


As long as the machine integers are not exceeded, the programs will work as expected.

இயந்திர முழு எண்கள் மீறப்படாத வரை, நிரல்கள் எதிர்பார்த்தபடி செயல்படும்.


The new English text realizes some substantial changes.

புதிய ஆங்கில உரை சில குறிப்பிடத்தக்க மாற்றங்களை உணர்த்துகிறது.


More basic explanations with more examples could be helpful in many places.

மேலும் பல எடுத்துக்காட்டுகளுடன் கூடிய அடிப்படை விளக்கங்கள் பல இடங்களில் உதவியாக இருக்கும்.


The course spans 15 weeks of teaching in the winter semester.

இந்தப் பாடநெறி குளிர்கால பருவத்தில் 15 வாரங்கள் கற்பித்தலை உள்ளடக்கியது.


Each week comes with two lectures, an exercises assignment, office hours, tutorials, and a test.

ஒவ்வொரு வாரமும் இரண்டு விரிவுரைகள், பயிற்சி ஒதுக்கீடு, அலுவலக நேரம், பயிற்சி வகுப்புகள் மற்றும் ஒரு தேர்வு ஆகியவை அடங்கும்.


There is a midterm exam in December and a final exam after the lecture period has finished.

டிசம்பரில் ஒரு இடைக்காலத் தேர்வும், விரிவுரை காலம் முடிந்த பிறகு இறுதித் தேர்வும் உள்ளது.


The take home project should be considered an important part of the course.

வீட்டிற்கு எடுத்துச் செல்லும் திட்டம் பாடத்தின் ஒரு முக்கிய பகுதியாகக் கருதப்பட வேண்டும்.


The interpreter will show an error message indicating which rule of the language is violated.

மொழியின் எந்த விதி மீறப்படுகிறது என்பதைக் காட்டும் பிழை செய்தியை மொழிபெயர்ப்பாளர் காண்பிப்பார்.


When we program, expressions are written as sequences of characters.

நாம் நிரல் எழுதும் போது, வெளிப்பாடுகள் எழுத்துக்களின் வரிசையாக எழுதப்படுகின்றன.


The rules for the conversion of character sequences into abstract expressions are fixed by the concrete syntax of a language.

எழுத்து வரிசைகளை அருவ வெளிப்பாடுகளாக மாற்றுவதற்கான விதிகள் ஒரு மொழியின் உறுதியான சொற்றொடரால் சரி செய்யப்படுகின்றன.


In the lexical representation of an expression, subexpressions can be indicated with parentheses.

ஒரு வெளிப்பாட்டின் லெக்சிகல் பிரதிநிதித்துவத்தில், துணை வெளிப்பாடுகளை அடைப்புக்குறிகளுடன் குறிக்கலாம்.


To reduce the number of parentheses needed for the textual representation of expressions, the concrete syntax of a language fixes operator precedences.

வெளிப்பாடுகளின் உரை பிரதிநிதித்துவத்திற்குத் தேவையான அடைப்புக்குறிகளின் எண்ணிக்கையைக் குறைக்க, ஒரு மொழியின் உறுதியான சொற்றொடர் ஆபரேட்டர் முன்னுரிமைகளை சரி செய்கிறது.


We also have types as abstract syntactic objects.

அருவமான சொற்றொடரியல் பொருள்களாகவும் நாம் வகைகளைக் கொண்டுள்ளோம்.


Given the abstract syntax of a language, we can define the static semantics and the dynamic semantics of the language.

ஒரு மொழியின் அருவ சொற்றொடரியல் கொடுக்கப்பட்டால், மொழியின் நிலையான சொற்பொருள் மற்றும் இயக்கவியல் சொற்பொருளை நாம் வரையறுக்கலாம்.


The dynamic semantics is concerned with the evaluation of expressions and does not make use of types.

இயக்கவியல் சொற்பொருள் வெளிப்பாடுகளின் மதிப்பீட்டைப் பற்றியது மற்றும் வகைகளைப் பயன்படுத்துவதில்லை.


The static semantics defines a type discipline such that the evaluation of well-typed expressions doesn’t lead to obviously erroneous situations.

நிலையான சொற்பொருள் ஒரு வகை ஒழுக்கத்தை வரையறுக்கிறது, இதனால் நன்கு தட்டச்சு செய்யப்பட்ட வெளிப்பாடுகளின் மதிப்பீடு வெளிப்படையாக தவறான சூழ்நிலைகளுக்கு வழிவகுக்காது.


Both semantics employ environments mapping free variables to either types or values.

இரண்டு சொற்பொருள்களும் இலவச மாறிகளை வகைகளுக்கோ அல்லது மதிப்புகளுக்கோ மேப்பிங் செய்யும் சூழல்களைப் பயன்படுத்துகின்றன.


The semantic systems of a language are described as so-called derivation systems consisting of inference rules for syntactic objects called judgments.

ஒரு மொழியின் சொற்பொருள் அமைப்புகள், தீர்ப்புகள் எனப்படும் சொற்றொடரியல் பொருள்களுக்கான அனுமான விதிகளால் ஆன வழித்தோன்றல் அமைப்புகளாக விவரிக்கப்படுகின்றன.


We speak of typing judgments and typing rules for the static semantics, and of evaluation judgments and evaluation rules for the dynamic semantics.

நிலையான சொற்பொருளுக்கான தட்டச்சு தீர்ப்புகள் மற்றும் தட்டச்சு விதிகள், மற்றும் இயக்கவியல் சொற்பொருளுக்கான மதிப்பீட்டு தீர்ப்புகள் மற்றும் மதிப்பீட்டு விதிகள் பற்றி நாம் பேசுகிறோம்.


The algorithmic reading of the inference rules gives us abstract algorithms that given an expression and an environment compute either the type or the value of the expression provided it exists.

அனுமான விதிகளின் அல்காரிதமிக் வாசிப்பு, ஒரு வெளிப்பாடு மற்றும் ஒரு சூழல் கொடுக்கப்பட்டால், வெளிப்பாட்டின் வகையையோ அல்லது மதிப்பையோ கணக்கிடும் அருவ அல்காரிதம்களை நமக்கு வழங்குகிறது.


The type checking algorithm given by the typing rules needs to guess the types of the argument variables of lambda expressions.

தட்டச்சு விதிகள் மூலம் கொடுக்கப்பட்ட வகை சரிபார்ப்பு அல்காரிதம், லாம்ப்டா வெளிப்பாடுகளின் வாத மாறிகளின் வகைகளை யூகிக்க வேண்டும்.


For recursive function declarations we need an argument type and a result type to avoid guessing.

மீண்டும் மீண்டும் வரும் செயல்பாடு அறிவிப்புகளுக்கு, யூகத்தைத் தவிர்க்க ஒரு வாத வகையும், முடிவு வகையும் தேவை.


A good way to think about type checking sees type checking as abstract evaluation of an expression.

வகை சரிபார்ப்பைப் பற்றிச் சிந்திப்பதற்கான ஒரு நல்ல வழி, வகை சரிபார்ப்பை ஒரு வெளிப்பாட்டின் அருவ மதிப்பீடாகப் பார்ப்பதாகும்.


While evaluation computes values, type checking computes types.

மதிப்பீடு மதிப்புகளைக் கணக்கிடும்போது, வகை சரிபார்ப்பு வகைகளைக் கணக்கிடுகிறது.


There is the connection that an expression of a type evaluate to a value of type t.

ஒரு வகையின் வெளிப்பாடு t வகையின் மதிப்பிற்கு மதிப்பிடும் என்ற தொடர்பு உள்ளது.


The type checking algorithm given by the typing rules always terminates.

தட்டச்சு விதிகள் மூலம் கொடுக்கப்பட்ட வகை சரிபார்ப்பு அல்காரிதம் எப்போதும் முடிவடையும்.


In later chapters we will implement in OCaml a type checker and an evaluator for the language considered here following the algorithmic reading of the typing and evaluation rules.

பிற்கால அத்தியாயங்களில், தட்டச்சு மற்றும் மதிப்பீட்டு விதிகளைப் பற்றிய அல்காரிதமிக் வாசிப்பைப் பின்பற்றி, இங்கு கருதப்படும் மொழிக்கான ஒரு வகை சரிபார்ப்பையும், மதிப்பீட்டையும் OCaml இல் செயல்படுத்துவோம்.


One speaks of static typing to emphasize the fact that evaluation does not rely on type information.

மதிப்பீடு வகை தகவல்களைச் சார்ந்து இல்லை என்பதை வலியுறுத்த நிலையான தட்டச்சு பற்றி பேசப்படுகிறது.


The OCaml interpreter realizes a maximum integer of 4611686018427387903.

OCaml மொழிபெயர்ப்பாளர் 4611686018427387903 என்ற அதிகபட்ச முழு எண்ணை உணர்த்துகிறார்.


Every programming language provides machine integers for efficiency.

எல்லா நிரலாக்க மொழிகளும் திறனுக்காக இயந்திர முழு எண்களை வழங்குகின்றன.


There are techniques for realizing much larger intervals of integers based on machine integers in programming languages.

நிரலாக்க மொழிகளில் இயந்திர முழு எண்களை அடிப்படையாகக் கொண்டு பெரிய இடைவெளிகளை உருவாக்குவதற்கான நுட்பங்கள் உள்ளன.


Things become interesting once we declare functions.

நாம் செயல்பாடுகளை அறிவித்தவுடன் விஷயங்கள் சுவாரஸ்யமாகின்றன.


The declaration `let square x = x * x` declares a function `square:int→int` squaring its argument.

`let square x = x * x` என்ற அறிவிப்பு அதன் வாதத்தை சதுரமாக்கும் `square:int→int` என்ற செயல்பாட்டை அறிவிக்கிறது.


Given the declaration of `square`, execution of the declaration `let a = square 5` binds the identifier `a` to the integer 25.

`square` இன் அறிவிப்பைக் கருத்தில் கொண்டு, `let a = square 5` என்ற அறிவிப்பை செயல்படுத்துவது, `a` என்ற அடையாளங்காட்டியைக் கொண்டு முழு எண் 25 உடன் இணைக்கிறது.


Can we compute a power x^8 with just three multiplications?

மூன்று பெருக்கல்களுடன் x^8 இன் சக்தியை கணக்கிட முடியுமா?


Easy, we just square the integer x three times.

எளிதாக, நாம் முழு எண் x ஐ மூன்று முறை சதுரமாக்குகிறோம்.


This declaration gives us a function `pow8:int→int`.

இந்த அறிவிப்பு நமக்கு `pow8:int→int` என்ற செயல்பாட்டை வழங்குகிறது.


Local declarations are obtained with `let` expressions.

`let` வெளிப்பாடுகளுடன் உள்ளூர் அறிவிப்புகள் பெறப்படுகின்றன.


The declaration `let abs x = if x < 0 then -x else x` declares a function `abs:int→int` returning the absolute value of an integer.

`let abs x = if x < 0 then -x else x` என்ற அறிவிப்பு ஒரு முழு எண்ணின் முழுமையான மதிப்பைக் கொடுக்கும் `abs:int→int` என்ற செயல்பாட்டை அறிவிக்கிறது.


The declaration `let max x y :int= if x <= y then y else x` declares a function `max:int→int→int` computing the maximum of two numbers.

`let max x y :int= if x <= y then y else x` என்ற அறிவிப்பு இரண்டு எண்களின் அதிகபட்சத்தை கணக்கிடும் `max:int→int→int` என்ற செயல்பாட்டை அறிவிக்கிறது.


This is the first function we see taking two arguments.

இரண்டு வாதங்களை எடுக்கும் முதல் செயல்பாடு இது.


There is an explicit return type specification in the declaration (appearing as “ :int”), which is needed so that `max` receives the correct type.

அறிவிப்பில் ஒரு வெளிப்படையான திரும்பும் வகை விவரக்குறிப்பு உள்ளது (“ :int” எனத் தோன்றும்), இது `max` சரியான வகையைப் பெறத் தேவைப்படுகிறது.


Given `max`, we can declare a function `let max3 x y z = max (max x y) z` returning the maximum of three numbers.

`max` கொடுக்கப்பட்டால், மூன்று எண்களின் அதிகபட்சத்தை வழங்கும் `let max3 x y z = max (max x y) z` என்ற செயல்பாட்டை அறிவிக்கலாம்.


There is a type `bool` having two values `true` and `false` called booleans.

`true` மற்றும் `false` என்ற இரண்டு மதிப்புகளைக் கொண்ட `bool` என்ற வகை உள்ளது, இது பூலியன்கள் என்று அழைக்கப்படுகிறது.


The comparison operator “≤” used for `max` (written “<=” in OCaml) is used with the functional type `int→int→bool` saying that an expression `e1 ≤ e2` where both subexpressions `e1` and `e2` have type `int` has type `bool`.

`max`-க்கு பயன்படுத்தப்படும் ஒப்பீட்டு ஆபரேட்டர் “≤” (OCaml-ல் “<=” என எழுதப்பட்டது) செயல் வகை `int→int→bool`-உடன் பயன்படுத்தப்படுகிறது, அதாவது `e1 ≤ e2` என்ற வெளிப்பாடு, இதில் `e1` மற்றும் `e2` ஆகிய இரண்டு துணை வெளிப்பாடுகளும் `int` வகையைக் கொண்டுள்ளன, `bool` வகையைக் கொண்டுள்ளது.


The declaration `let test (x :int) y z = if x <= y then y <= z else false` declares a function `test:int→int→int→bool` testing whether its three arguments appear in order.

`let test (x :int) y z = if x <= y then y <= z else false` என்ற அறிவிப்பு, அதன் மூன்று வாதங்கள் வரிசையில் தோன்றுமா என்பதைச் சோதிக்கும் `test:int→int→int→bool` என்ற செயல்பாட்டை அறிவிக்கிறது.


We recall that powers satisfy the equations x^0 = 1 and x^(n+1) = x * x^n.

அடுக்குகள் சமன்பாடுகளை பூர்த்தி செய்கின்றன என்பதை நாம் நினைவு கூர்கிறோம்: x^0 = 1 மற்றும் x^(n+1) = x * x^n.


Recursive computations can be captured with recursive functions.

மீண்டும் மீண்டும் நிகழும் கணக்கீடுகளை மீண்டும் மீண்டும் வரும் செயல்பாடுகளுடன் கைப்பற்ற முடியும்.


மாறிகள் சரங்களாகப் பிரதிநிதித்துவப்படுத்தப்படுகின்றன.


Constants are represented as the values of a constructor type.

நிலையானவை ஒரு கட்டுநர் வகையின் மதிப்புகளாகப் பிரதிநிதித்துவப்படுத்தப்படுகின்றன.


Expressions are represented as the values of a constructor type.

வெளிப்பாடுகள் ஒரு கட்டுநர் வகையின் மதிப்புகளாகப் பிரதிநிதித்துவப்படுத்தப்படுகின்றன.


The grammar follows the conventions of OCaml.

இலக்கணம் OCaml இன் மரபுகளைப் பின்பற்றுகிறது.


Conditionals, lambda expressions, and let expressions take their arguments after operator and function applications.

நிபந்தனைகள், லாம்ப்டா வெளிப்பாடுகள் மற்றும் லெட் வெளிப்பாடுகள் தங்கள் வாதங்களை ஆபரேட்டர் மற்றும் செயல்பாடு பயன்பாடுகளுக்குப் பிறகு எடுத்துக்கொள்கின்றன.


Function applications take their arguments before operator applications.

செயல்பாட்டு பயன்பாடுகள் தங்கள் வாதங்களை ஆபரேட்டர் பயன்பாடுகளுக்கு முன் எடுத்துக்கொள்கின்றன.


Multiplication takes its arguments before addition and subtraction.

பெருக்கல் கூட்டல் மற்றும் கழித்தலுக்கு முன் அதன் வாதங்களை எடுத்துக்கொள்கிறது.


Addition and subtraction are at the same level.

கூட்டல் மற்றும் கழித்தல் ஒரே மட்டத்தில் உள்ளன.


இலக்கணத்தில் 6 நிலைகள் உள்ளன.


The top level accommodates prefix constructs.

மேல் நிலை முன்னொட்டு கட்டமைப்புகளை உள்ளடக்கியது.


The bottom level accommodates primitive expressions.

கீழ் நிலை அடிப்படை வெளிப்பாடுகளை உள்ளடக்கியது.


The linearization functions for the linearization grammar for expressions must put white space characters between the words.

வெளிப்பாடுகளுக்கான நேரியல்மயமாக்கல் இலக்கணத்திற்கான நேரியல்மயமாக்கல் செயல்பாடுகள் சொற்களுக்கு இடையில் வெற்று இட எழுத்துக்களை வைக்க வேண்டும்.


OCaml’s concrete syntax doesn’t have constants for negative integers.

OCaml இன் கான்கிரீட் தொடரியல் எதிர்மறை முழு எண்களுக்கான மாறிலிகளைக் கொண்டிருக்கவில்லை.


Another feature of OCaml’s concrete syntax is the requirement that identifiers used for values must start with lower case letters.

OCaml இன் கான்கிரீட் தொடரியலின் மற்றொரு அம்சம் என்னவென்றால், மதிப்புகளுக்குப் பயன்படுத்தப்படும் அடையாளங்காட்டிகள் சிறிய எழுத்துக்களுடன் தொடங்க வேண்டும்.


கட்டுநர் வகை nat ஐக் கவனியுங்கள்.


We can now easily define addition and multiplication as functions.

நாம் இப்போது கூட்டல் மற்றும் பெருக்கலை செயல்பாடுகளாக எளிதாக வரையறுக்கலாம்.


Defining the natural numbers with a constructor type is logically of great importance.

இயற்கை எண்களை ஒரு கட்டுநர் வகையுடன் வரையறுப்பது தர்க்கரீதியாக மிகவும் முக்கியமானது.


The process of translating string representations of syntactic objects into tree representations is known as parsing.

சொற்றொடரியல் பொருள்களின் சரப் பிரதிநிதித்துவங்களை மரப் பிரதிநிதித்துவங்களாக மொழிபெயர்க்கும் செயல்முறை பகுப்பாய்வு என்று அழைக்கப்படுகிறது.


We will focus on a parsing method called recursive descent.

மீண்டும் மீண்டும் இறங்குதல் எனப்படும் பகுப்பாய்வு முறையில் கவனம் செலுத்துவோம்.


The first step in parsing a string translates the string into a list of tokens representing words.

ஒரு சரத்தை பகுப்பாய்வு செய்வதில் முதல் படி, சரத்தை சொற்களைப் பிரதிநிதித்துவப்படுத்தும் டோக்கன்களின் பட்டியலாக மொழிபெயர்க்கிறது.


The list [1,2,3] may be depicted as the tree.

[1,2,3] என்ற பட்டியல் மரமாக சித்தரிக்கப்படலாம்.


பட்டியல்களை மரங்களாகப் பார்ப்பது முக்கியம்.


For instance, the list [1,2,3] may be depicted as the tree.

உதாரணமாக, [1,2,3] பட்டியல் மரமாக சித்தரிக்கப்படலாம்.


Given a list [x1,...,xn], we call the values x1,..., xn the elements or the members of the list.

[x1,...,xn] என்ற பட்டியல் கொடுக்கப்பட்டால், x1,..., xn மதிப்புகளைப் பட்டியலின் உறுப்புகள் அல்லது உறுப்பினர்கள் என்று அழைக்கிறோம்.


Despite the fact that tuples and lists both represent sequences, tuple types and list types are quite different.

துணுக்குகளும் பட்டியல்களும் வரிசைகளை பிரதிநிதித்துவப்படுத்தினாலும், துணுக்கு வகைகள் மற்றும் பட்டியல் வகைகள் முற்றிலும் வேறுபட்டவை.


A tuple type t1 ×···× tn admits only tuples of length n, but may fix different types for different components.

ஒரு துணுக்கு வகை t1 ×···× tn ஆனது நீளம் n கொண்ட துணுக்குகளை மட்டுமே அனுமதிக்கிறது, ஆனால் வெவ்வேறு கூறுகளுக்கு வெவ்வேறு வகைகளை சரிசெய்யலாம்.


A list type L(t) admits lists [x1,..., xn] of any length but fixes a single type t for all elements.

ஒரு பட்டியல் வகை L(t) எந்த நீளத்திலும் பட்டியல்களை [x1,..., xn] அனுமதிக்கிறது, ஆனால் அனைத்து கூறுகளுக்கும் ஒரே வகையை t சரிசெய்கிறது.


We start with the definition of a polymorphic function length: ∀α. L(α)→N

ஒரு பலவடிவ செயல்பாடு நீளத்தின் வரையறையுடன் தொடங்குகிறோம்: ∀α. L(α)→N


Another prominent list operation is concatenation.

மற்றொரு முக்கிய பட்டியல் செயல்பாடு இணைப்பு ஆகும்.


We call l1 @ l2 the concatenation of l1 and l2.

l1 @ l2 ஐ l1 மற்றும் l2 இன் இணைப்பு என்று அழைக்கிறோம்.


How can we define an operation reversing lists?

பட்டியல்களை தலைகீழாக மாற்றும் ஒரு செயல்பாட்டை எவ்வாறு வரையறுப்பது?


This brings us to the following definition of list reversal.

இது பட்டியலை தலைகீழாக மாற்றுவதற்கான பின்வரும் வரையறைக்கு நம்மை அழைத்துச் செல்கிறது.


We can also define a tail recursive list reversal function.

வால் மறுநிகழ்வு பட்டியல் தலைகீழ் செயல்பாட்டையும் நாம் வரையறுக்கலாம்.


The functions defined so far are all defined by list recursion.

இதுவரை வரையறுக்கப்பட்ட செயல்பாடுகள் அனைத்தும் பட்டியல் மறுநிகழ்வு மூலம் வரையறுக்கப்பட்டுள்ளன.


List recursion means that there is no recursion for the empty list, and that for every nonempty list x::l the recursion is on the tail l of the list.

பட்டியல் மறுநிகழ்வு என்பது வெற்று பட்டியலுக்கு மறுநிகழ்வு இல்லை, மேலும் ஒவ்வொரு காலியாகாத பட்டியல் x::l க்கும் மறுநிகழ்வு பட்டியலின் வால் l இல் உள்ளது என்று பொருள்.


Another prominent list operation is map.

மற்றொரு முக்கிய பட்டியல் செயல்பாடு மேப் ஆகும்.


We say that map applies the function f pointwise to a list.

மேப், செயல்பாட்டை ஒரு பட்டியலுக்கு புள்ளி வாரியாகப் பயன்படுத்துகிறது என்று கூறுகிறோம்.


Finally, we define a function that yields the list of all integers between two numbers m and n (including m and n).

இறுதியாக, இரண்டு எண்களுக்கு (m மற்றும் n உட்பட) இடையேயான அனைத்து முழு எண்களின் பட்டியலை வழங்கும் ஒரு செயல்பாட்டை வரையறுக்கிறோம்.


Sorting a list is easy: We start with the empty list, which is sorted, and insert the elements one by one.

ஒரு பட்டியலை வரிசைப்படுத்துவது எளிது: வரிசைப்படுத்தப்பட்ட காலியான பட்டியலுடன் தொடங்கி, ஒவ்வொன்றாக உறுப்புகளைச் செருகுகிறோம்.


Once all elements are inserted, we have a sorted rearrangement of the original list.

எல்லா கூறுகளும் செருகப்பட்டதும், அசல் பட்டியலின் வரிசைப்படுத்தப்பட்ட மறுசீரமைப்பு நம்மிடம் உள்ளது.


Make sure you understand every detail of the definition.

வரையறையின் ஒவ்வொரு விவரத்தையும் நீங்கள் புரிந்து கொண்டீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.


We offer a trace: isort[3,2] = insert3 (isort[2]) = insert3 (insert2 (isort[])) = insert3 (insert2 []) = insert3 [2] = 2 ::insert3 [] = 2 :: [3] = [2,3]

நாங்கள் ஒரு தடயத்தை வழங்குகிறோம்: isort[3,2] = insert3 (isort[2]) = insert3 (insert2 (isort[])) = insert3 (insert2 []) = insert3 [2] = 2 ::insert3 [] = 2 :: [3] = [2,3]


Note that isort inserts the elements of the input list reversing the order they appear in the input list.

isort உள்ளீட்டுப் பட்டியலில் உள்ள உறுப்புகளை உள்ளீட்டுப் பட்டியலில் தோன்றும் வரிசையை மாற்றிச் செருகுகிறது என்பதை நினைவில் கொள்க.


More elegantly, we may say that the insertion function preserves sortedness.

மேலும் நேர்த்தியாக, செருகுதல் செயல்பாடு வரிசைப்படுத்தலைத் தக்க வைத்துக் கொள்கிறது என்று நாம் கூறலாம்.


Declaring the functions insert and isort in OCaml is now routine.

OCaml இல் insert மற்றும் isort செயல்பாடுகளை அறிவிப்பது இப்போது வழக்கமானது.


There is, however, the surprise that OCaml derives polymorphic types for insert and isort if no type specification is given.

இருப்பினும், எந்த வகை விவரக்குறிப்பும் கொடுக்கப்படாவிட்டால், OCaml insert மற்றும் isort க்கான பலவகை வகைகளை உருவாக்குகிறது என்பது ஆச்சரியமாக இருக்கிறது.


This follows from the fact that OCaml accommodates comparisons with the polymorphic type.

OCaml பலவகை வகைகளுடன் ஒப்பீடுகளை ஏற்றுக்கொள்கிறது என்ற உண்மையிலிருந்து இது பின்பற்றப்படுகிறது.


We will explain later how comparisons behave on tuples and lists.

டூப்பிள்கள் மற்றும் பட்டியல்களில் ஒப்பீடுகள் எவ்வாறு செயல்படுகின்றன என்பதைப் பற்றிப் பிறகு விளக்குவோம்.


For boolean values, OCaml realizes the order false < true.

பூலியன் மதிப்புகளுக்கு, OCaml false < true என்ற வரிசையை உணர்த்துகிறது.


Thus we have isort[true,false,false,true] = [false,false,true,true]

எனவே, isort[true,false,false,true] = [false,false,true,true] உள்ளது.


Declare a function that tests whether a list is sorted.

ஒரு பட்டியல் வரிசைப்படுத்தப்பட்டுள்ளதா என்பதைச் சோதிக்கும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


வால் மறுசுழற்சியைப் பயன்படுத்தவும்.


Write the function with a generalized match and show how the generalized match translates into simple matches.

ஒரு பொதுவான பொருத்தத்துடன் செயல்பாட்டை எழுதி, பொதுவான பொருத்தம் எவ்வாறு எளிய பொருத்தங்களாக மொழிபெயர்க்கப்படுகிறது என்பதைக் காட்டுங்கள்.


Declare a function that tests whether two lists are equal up to reordering.

இரண்டு பட்டியல்கள் மறுவரிசைப்படுத்துதல் வரை சமமாக உள்ளதா என்பதைச் சோதிக்கும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


Declare a function that reorders a list such that the elements appear in descending order.

உறுப்புகள் இறங்கு வரிசையில் தோன்றும் வகையில் ஒரு பட்டியலை மறுவரிசைப்படுத்தும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


Declare a function that sorts a list and removes all duplicates.

ஒரு பட்டியலை வரிசைப்படுத்தி, அனைத்து நகல்களையும் நீக்கும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


The trees in the forest swayed gently in the breeze.

காட்டில் இருந்த மரங்கள் மெதுவாகக் காற்றில் அசைந்தன.


உப்பு கொஞ்சம் கொடுங்களேன்.


The company announced record profits this quarter.

நிறுவனம் இந்த காலாண்டில் சாதனை லாபம் ஈட்டியதாக அறிவித்தது.


The algorithm efficiently sorts the data.

அல்காரிதம் தரவை திறமையாக வரிசைப்படுத்துகிறது.


She is a talented musician and plays the veena beautifully.

அவள் ஒரு திறமையான இசைக்கலைஞர் மற்றும் வீணையை அழகாக வாசிக்கிறாள்.


The government is implementing new policies to boost the economy.

பொருளாதாரத்தை மேம்படுத்த அரசு புதிய கொள்கைகளை அமல்படுத்துகிறது.


The research paper explores the impact of climate change on agriculture.

இந்த ஆராய்ச்சி கட்டுரை காலநிலை மாற்றம் விவசாயத்தில் ஏற்படுத்தும் தாக்கத்தை ஆராய்கிறது.


Despite the challenges, the team persevered and achieved their goals.

சவால்கள் இருந்தபோதிலும், குழு விடாமுயற்சியுடன் செயல்பட்டு தங்கள் இலக்குகளை அடைந்தது.


The complex equation requires advanced mathematical techniques to solve.

சிக்கலான சமன்பாட்டைத் தீர்க்க மேம்பட்ட கணித நுட்பங்கள் தேவை.


The ancient temple is a testament to the rich cultural heritage of the region.

பண்டைய கோயில் இப்பகுதியின் வளமான கலாச்சார பாரம்பரியத்திற்கு ஒரு சான்றாகும்.


The software update includes several bug fixes and performance improvements.

மென்பொருள் புதுப்பிப்பில் பல பிழை திருத்தங்களும், செயல்திறன் மேம்பாடுகளும் அடங்கும்.


The artist's unique style is characterized by vibrant colors and bold brushstrokes.

கலைஞரின் தனித்துவமான பாணி துடிப்பான வண்ணங்கள் மற்றும் தைரியமான தூரிகை இயக்கங்களால் வகைப்படுத்தப்படுகிறது.


The economic forecast predicts a period of sustained growth.

பொருளாதார முன்னறிவிப்பு நிலையான வளர்ச்சியின் காலகட்டத்தை முன்னறிவிக்கிறது.


The detective meticulously examined the evidence at the crime scene.

துப்பறியும் நபர் குற்ற இடத்தில் ஆதாரங்களை நுணுக்கமாக ஆய்வு செய்தார்.


The company's innovative approach has disrupted the industry.

நிறுவனத்தின் புதுமையான அணுகுமுறை தொழில்துறையை சீர்குலைத்துள்ளது.


The philosophical debate centered on the nature of consciousness.

தத்துவ விவாதம் உணர்வுபூர்வமான தன்மையை மையமாகக் கொண்டிருந்தது.


The scientist conducted experiments to test the hypothesis.

அறிவியல் அறிஞர் கருதுகோளை சோதிக்க பரிசோதனைகளை நடத்தினார்.


The ancient civilization left behind a legacy of art and architecture.

பண்டைய நாகரிகம் கலை மற்றும் கட்டிடக்கலையின் பாரம்பரியத்தை விட்டுச் சென்றது.


The political situation remains volatile and unpredictable.

அரசியல் நிலைமை நிலையற்றதாகவும், கணிக்க முடியாததாகவும் உள்ளது.


The team collaborated effectively to complete the project ahead of schedule.

திட்டத்தை திட்டமிட்டபடி முடிக்க குழுவினர் திறம்பட ஒத்துழைத்தனர்.


The type checker matches on the given expression and for each variant follows the algorithmic reading of the respective typing rule.

வகை சரிபார்ப்பவர் கொடுக்கப்பட்ட வெளிப்பாட்டில் பொருந்தி, ஒவ்வொரு வகையிலும் தொடர்புடைய தட்டச்சு விதியின் வழிமுறைகளைப் பின்பற்றுகிறார்.


Note that we are using helper functions for operator and function applications for better readability.

செயல்பாட்டாளர் மற்றும் செயல்பாட்டு பயன்பாடுகளுக்கு சிறந்த புரிதலுக்காக உதவி செயல்பாடுகளைப் பயன்படுத்துகிறோம் என்பதை நினைவில் கொள்க.


We realize the evaluator with a function eval:env var value→exp→value that evaluates an expression in an environment.

ஒரு சூழலில் ஒரு வெளிப்பாட்டை மதிப்பிடும் eval:env var value→exp→value என்ற செயல்பாட்டின் மூலம் மதிப்பீட்டாளரை உணர்கிறோம்.


As with the type checker, we use helper functions for operator and function applications for better readability.

வகை சரிபார்ப்பதைப் போலவே, சிறந்த புரிதலுக்காக ஆபரேட்டர் மற்றும் செயல்பாட்டு பயன்பாடுகளுக்கு உதவி செயல்பாடுகளைப் பயன்படுத்துகிறோம்.


The lexer for Mini-OCaml needs work, mainly because it needs to recognize identifiers (i.e., variables) and number constants.

Mini-OCamlக்கான லெக்சருக்கு வேலை தேவை, முக்கியமாக அடையாளங்காட்டிகள் (அதாவது, மாறிகள்) மற்றும் எண் மாறிலிகளை அங்கீகரிக்க வேண்டும்.


We avoid considering auxiliary strings by accessing the given string by position using String.get and by using String.sub to extract an identifier identified by its starting position and length.

String.get ஐப் பயன்படுத்தி நிலையின் மூலம் கொடுக்கப்பட்ட சரத்தை அணுகுவதன் மூலமும், அதன் தொடக்க நிலை மற்றும் நீளத்தால் அடையாளம் காணப்பட்ட அடையாளங்காட்டியைப் பிரித்தெடுக்க String.sub ஐப் பயன்படுத்துவதன் மூலமும் துணை சரங்களை நாங்கள் கருத்தில் கொள்வதைத் தவிர்க்கிறோம்.


The constant true and false and keywords like if are first recognized as identifiers and then transformed into the respective constant or keyword tokens.

உண்மை மற்றும் பொய் போன்ற மாறிலிகள் மற்றும் என்றால் போன்ற முக்கிய வார்த்தைகள் முதலில் அடையாளங்காட்டிகளாக அங்கீகரிக்கப்பட்டு, பின்னர் அந்தந்த மாறிலி அல்லது முக்கிய வார்த்தை டோக்கன்களாக மாற்றப்படுகின்றன.


Digits and letters are recognized by using the function Char.code and exploiting the fact that the codes of the respective characters follow each other continuously in a canonical order.

Char.code செயல்பாட்டைப் பயன்படுத்துவதன் மூலமும், அந்தந்த எழுத்துகளின் குறியீடுகள் ஒருவருக்கொருவர் தொடர்ந்து ஒரு நியம வரிசையில் பின்பற்றுகின்றன என்ற உண்மையைச் சுரண்டுவதன் மூலமும் இலக்கங்களும் எழுத்துகளும் அங்கீகரிக்கப்படுகின்றன.


Following OCaml, an identifier must start with a lower case letter and can then continue with digits, lower and upper case letters, and the special characters ‘_’ (underline) and ‘'’ (quote).

OCaml ஐப் பின்பற்றி, ஒரு அடையாளங்காட்டி சிறிய எழுத்தில் தொடங்க வேண்டும், பின்னர் இலக்கங்கள், சிறிய மற்றும் பெரிய எழுத்துக்கள் மற்றும் சிறப்பு எழுத்துக்கள் ‘_’ (கீழே கோடு) மற்றும் ‘'’ (மேற்கோள்) ஆகியவற்றுடன் தொடரலாம்.


We remark that the lexer follows the longest munch rule when it reads identifiers and numbers; that is, it reads as many characters as are possible for an identifier or number.

அடையாளங்காட்டிகள் மற்றும் எண்களைப் படிக்கும்போது லெக்சர் மிக நீண்ட மன்ச் விதியைப் பின்பற்றுகிறது என்பதை நாங்கள் கவனிக்கிறோம்; அதாவது, ஒரு அடையாளங்காட்டி அல்லது எண்ணுக்கு எவ்வளவு எழுத்துகள் சாத்தியமோ அவ்வளவு எழுத்துகளைப் படிக்கிறது.


The parsing grammar for Mini-OCaml consists of a grammar for types and a grammar for expressions building on the grammar for types.

Mini-OCamlக்கான பகுப்பாய்வு இலக்கணம் வகைகளுக்கான இலக்கணத்தையும், வகைகளுக்கான இலக்கணத்தின் அடிப்படையில் வெளிப்பாடுகளுக்கான இலக்கணத்தையும் கொண்டுள்ளது.


The top level takes care of the prefix phrases, which recurse to the top level.

மேல் நிலை முன்னொட்டு சொற்றொடர்களை கவனித்துக்கொள்கிறது, இது மேல் நிலைக்கு மீண்டும் நிகழ்கிறது.


We now come to the parsing grammar for Mini-OCaml types: ty::=pty ty’ ty’::=”->”ty|[] pty::=”bool”|”int”|”(”ty”)”

இப்போது Mini-OCaml வகைகளுக்கான பகுப்பாய்வு இலக்கணத்திற்கு வருகிறோம்: ty::=pty ty’ ty’::=”->”ty|[] pty::=”bool”|”int”|”(”ty”)”


The project counts as the test for this week.

இந்த வாரம் சோதனைக்கு இந்த திட்டம் கணக்கிடப்படுகிறது.


நீங்கள் திட்டத்தை ரசிப்பீர்கள் என்று நம்புகிறோம்.


Often there are several algorithms solving a given computational task, and these algorithm may differ significantly in their running times.

பெரும்பாலும் கொடுக்கப்பட்ட கணக்கீட்டு பணியை தீர்க்கும் பல வழிமுறைகள் உள்ளன, மேலும் இந்த வழிமுறைகள் அவற்றின் இயங்கும் நேரங்களில் கணிசமாக வேறுபடலாம்.


ஒரு பொதுவான உதாரணம் பட்டியல்களை வரிசைப்படுத்துவதாகும்.


Insertion sort, the sorting algorithm we have already seen, requires quadratic worst-case time.

செருகு வரிசை, நாம் ஏற்கனவே பார்த்த வரிசைப்படுத்தும் வழிமுறை, இருபடி மோசமான நேரத்தை தேவைப்படுகிறது.


It turns out that we can define the running time of an expression as the number of function calls needed for its execution.

ஒரு வெளிப்பாட்டின் இயங்கும் நேரத்தை அதன் செயல்படுத்தலுக்குத் தேவையான செயல்பாட்டு அழைப்புகளின் எண்ணிக்கையாக வரையறுக்க முடியும் என்பது தெரியவந்துள்ளது.


This abstract and technology-independent notion of running time provides an excellent tool for distinguishing between faster and slower algorithms.

இயங்கும் நேரத்தின் இந்த சுருக்கமான மற்றும் தொழில்நுட்பம் சாராத கருத்து, வேகமான மற்றும் மெதுவான வழிமுறைகளுக்கு இடையே வேறுபடுத்துவதற்கான சிறந்த கருவியை வழங்குகிறது.


The algorithm's running time assumes constant field access, which is true for arrays.

அல்காரிதத்தின் இயங்கும் நேரம் நிலையான புல அணுகலை அனுமானிக்கிறது, இது வரிசைகளுக்கு உண்மை.


Binary search is used to distinguish it from linear search, which has linear running time.

நேரியல் தேடலில் இருந்து வேறுபடுத்திக் காட்ட இரும தேடல் பயன்படுத்தப்படுகிறது, இது நேரியல் இயங்கும் நேரத்தைக் கொண்டுள்ளது.


Binary search usually returns an index where the element searched for occurs.

இருபடி தேடல் பொதுவாக தேடப்பட்ட உறுப்பு நிகழும் ஒரு குறியீட்டை வழங்குகிறது.


The binary search function can be declared as follows.

இருபடி தேடல் செயல்பாட்டை பின்வருமாறு அறிவிக்கலாம்.


The worker function is tail-recursive and the array segment is halved upon recursion.

வேலை செய்யும் செயல்பாடு வால்-மீண்டும்-மீண்டும் வருகிறது, மேலும் வரிசைப் பிரிவு மீண்டும் மீண்டும் வரும்போது பாதியாகிறது.


இருபடி தேடல் இரண்டு மாறிலிகளை நிறைவு செய்கிறது.


The state of the array agrees with the initial state.

வரிசையின் நிலை ஆரம்ப நிலைக்கு இணங்குகிறது.


All elements to the left of l are smaller than x and all elements to the right of r are greater than x.

l இன் இடதுபுறத்தில் உள்ள அனைத்து கூறுகளும் x ஐ விட சிறியவை, மேலும் r இன் வலதுபுறத்தில் உள்ள அனைத்து கூறுகளும் x ஐ விட பெரியவை.


Linear search generalizes binary search.

நேரியல் தேடல் இருபடி தேடலை பொதுமைப்படுத்துகிறது.


Declare a function that checks whether a value occurs in an array.

ஒரு மதிப்பை ஒரு வரிசையில் காண்கிறதா என்பதை சரிபார்க்கும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


The running time of linear search should be O(n).

நேரியல் தேடலின் இயங்கும் நேரம் O(n) ஆக இருக்க வேண்டும்.


Declare a function that checks whether there is some i ≤ n such that f(i) = x.

f(i) = x போன்ற சில i ≤ n உள்ளதா என்பதை சரிபார்க்கும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


A function f is increasing if f(i) ≤ f(j) whenever i ≤ j.

i ≤ j ஆக இருக்கும்போது ஒரு செயல்பாடு f(i) ≤ f(j) என்றால் அது அதிகரிக்கும்.


There is an elegant algorithm reversing the elements of an array.

ஒரு வரிசையின் கூறுகளை தலைகீழாக மாற்றும் ஒரு நேர்த்தியான வழிமுறை உள்ளது.


The algorithm is based on a function swapping values.

இந்த வழிமுறை மதிப்புகளைப் பரிமாறும் ஒரு செயல்பாட்டை அடிப்படையாகக் கொண்டது.


The algorithm now reverses a segment i < j in an array.

இந்த வழிமுறை இப்போது ஒரு வரிசையில் i < j என்ற பகுதியை தலைகீழாக்குகிறது.


Function reverse satisfies two invariants.

தலைகீழ் செயல்பாடு இரண்டு மாறிலிகளை நிறைவு செய்கிறது.


The state of the array agrees with the initial state up to repeated swapping.

வரிசையின் நிலை மீண்டும் மீண்டும் பரிமாற்றம் வரை ஆரம்ப நிலைக்கு இணங்குகிறது.


The segments l ≤ i and j ≤ r agree with the reversed initial state.

l ≤ i மற்றும் j ≤ r பிரிவுகள் தலைகீழாக மாற்றப்பட்ட ஆரம்ப நிலைக்கு இணங்குகின்றன.


Declare a function rotating the elements of an array.

ஒரு வரிசையின் கூறுகளை சுழற்றும் ஒரு செயல்பாட்டை அறிவிக்கவும்.


The algorithm is based on two straightforward rules.

இந்த வழிமுறை இரண்டு நேரடியான விதிகளின் அடிப்படையில் அமைந்துள்ளது.


If one of the numbers is 0, the other number is the greatest common divisor of the two numbers.

எண்களில் ஒன்று 0 ஆக இருந்தால், மற்ற எண் அந்த இரண்டு எண்களின் மிகப்பெரிய பொது வகுத்தியாகும்.


We now recall that x%y is obtained by subtracting y from x as long as y ≤ x.

y ≤ x ஆக இருக்கும் வரை, x இலிருந்து y ஐக் கழிப்பதன் மூலம் x%y பெறப்படுகிறது என்பதை இப்போது நினைவு கூர்கிறோம்.


The function terminates since recursion decreases the second argument.

மீண்டும் மீண்டும் செயல்படுத்துதல் இரண்டாவது வாதத்தை குறைப்பதால் இந்த செயல்பாடு முடிகிறது.


Our goal here is to carefully explain how the algorithm can be derived from basic principles.

இந்த இடத்தில், அடிப்படை கொள்கைகளில் இருந்து வழிமுறையை எவ்வாறு பெறலாம் என்பதை கவனமாக விளக்குவதே எங்கள் குறிக்கோள்.


We first define the divides relation for numbers.

முதலில் எண்களுக்கான வகுத்தல் உறவை வரையறுக்கிறோம்.


When we have k|x, we say that k is a divisor or a factor of x.

k|x ஆக இருக்கும்போது, k என்பது x இன் வகுத்தி அல்லது காரணி என்று கூறுகிறோம்.


Moreover, when we say that k is a common divisor of x and y we mean that k is a divisor of both x and y.

மேலும், k என்பது x மற்றும் y இன் பொது வகுத்தி என்று நாம் கூறும்போது, k என்பது x மற்றும் y இரண்டின் வகுத்தியாகும் என்று பொருள்.


We observe that every number x has 1 and x as divisors.

ஒவ்வொரு எண்ணும் x க்கு 1 மற்றும் x வகுத்திகளாக இருப்பதைக் காண்கிறோம்.


It follows that two numbers have a greatest common divisor if and only if not both numbers are zero.

இரண்டு எண்களும் பூஜ்ஜியமாக இல்லாவிட்டால் மட்டுமே, இரண்டு எண்களும் மிகப்பெரிய பொது வகுத்தியைக் கொண்டிருக்கும்.


We call a number z the GCD of two numbers x and y if the divisors of z are exactly the common divisors of x and y.

z இன் வகுத்திகள் x மற்றும் y இன் பொது வகுத்திகளாக இருந்தால், z என்ற எண்ணை x மற்றும் y ஆகிய இரண்டு எண்களின் GCD என்று அழைக்கிறோம்.


15 மற்றும் 63 இன் GCD 3 ஆகும்.


Our goal is to find an algorithm that computes the GCD of two numbers.

இரண்டு எண்களின் GCD ஐக் கணக்கிடும் ஒரு வழிமுறையைக் கண்டுபிடிப்பதே எங்கள் குறிக்கோள்.


If one of the two numbers is 0, we are done since the other number is the GCD of the two numbers.

இரண்டு எண்களில் ஒன்று 0 ஆக இருந்தால், மற்ற எண் அந்த இரண்டு எண்களின் GCD என்பதால் நாம் முடித்துவிட்டோம்.


It remains to find a rule that given two positive numbers x and y yields two numbers x' and y' that have the same GCD and whose sum is smaller.

இரண்டு நேர்மறை எண்களான x மற்றும் y கொடுக்கப்பட்டால், அதே GCD ஐக் கொண்ட x' மற்றும் y' என்ற இரண்டு எண்களைக் கொடுக்கும் ஒரு விதியைக் கண்டுபிடிப்பது இன்னும் உள்ளது, மேலும் அவற்றின் கூட்டுத்தொகை சிறியதாக இருக்கும்.


If x ≥ y, then the common divisors of x and y are exactly the common divisors of x-y and y.

x ≥ y என்றால், x மற்றும் y இன் பொது வகுத்திகள் x-y மற்றும் y இன் பொது வகுத்திகளாகும்.


Euclid’s algorithm now simply applies the modulo rule until the zero rule applies, using the symmetry rule when needed.

யூக்லிட்டின் வழிமுறை இப்போது பூஜ்ஜிய விதி பொருந்தும் வரை மட்டு விதியைப் பயன்படுத்துகிறது, தேவைப்படும்போது சமச்சீர் விதியைப் பயன்படுத்துகிறது.


Recall that gcd terminates since recursion decreases the second argument.

மீண்டும் மீண்டும் செயல்படுத்துதல் இரண்டாவது வாதத்தை குறைப்பதால் gcd முடிகிறது என்பதை நினைவில் கொள்க.


The running time of gcd x y is at most y since each recursion step decreases y.

ஒவ்வொரு மீண்டும் மீண்டும் செயல்படுத்துதல் படியும் y ஐக் குறைப்பதால், gcd x y இன் இயங்கும் நேரம் அதிகபட்சம் y ஆகும்.


In fact, one can show that the asymptotic running time of gcd x y is logarithmic in y.

உண்மையில், gcd x y இன் ஏசிம்டோடிக் இயங்கும் நேரம் y இல் மடக்கையாகும் என்பதை ஒருவர் காட்ட முடியும்.


The list [10,11,12] may be stored with three blocks connected through links.

[10,11,12] என்ற பட்டியல் மூன்று தொகுதிகளுடன் இணைக்கப்பட்டு சேமிக்கப்படலாம்.


Each of the 3 blocks has two fields, where the first field represents a number in the list and the second field holds a link.

3 தொகுதிகளில் ஒவ்வொன்றும் இரண்டு புலங்களைக் கொண்டுள்ளன, முதல் புலம் பட்டியலில் உள்ள எண்ணையும், இரண்டாவது புலம் ஒரு இணைப்பையும் குறிக்கிறது.


Links always point to blocks and are represented through the addresses of the blocks.

இணைப்புகள் எப்போதும் தொகுதிகளை நோக்கிச் செல்கின்றன, மேலும் அவை தொகுதிகளின் முகவரிகள் மூலம் குறிப்பிடப்படுகின்றன.


Thus the above linked block representation of the list [10,11,12] is represented with the following segment in the heap.

எனவே, [10,11,12] பட்டியலின் மேலே உள்ள இணைக்கப்பட்ட தொகுதி பிரதிநிதித்துவம் குவியலில் பின்வரும் பகுதியுடன் குறிப்பிடப்படுகிறது.


Note that the representation of the empty list as -1 is safe since the addresses of blocks are nonnegative numbers.

காலி பட்டியலை -1 ஆகக் குறிப்பது பாதுகாப்பானது, ஏனெனில் தொகுதிகளின் முகவரிகள் எதிர்மறையற்ற எண்களாகும்.


Given a linked block representation of a list we can freely choose where the blocks are allocated in the heap.

ஒரு பட்டியலின் இணைக்கப்பட்ட தொகுதி பிரதிநிதித்துவம் கொடுக்கப்பட்டால், தொகுதிகள் எங்கு குவியலில் ஒதுக்கப்படுகின்றன என்பதை நாம் சுதந்திரமாகத் தேர்ந்தெடுக்கலாம்.


There is no particular order to observe, except that the fields of a block must be allocated consecutively.

கவனிக்க எந்த குறிப்பிட்ட வரிசையும் இல்லை, ஒரு தொகுதியின் புலங்கள் தொடர்ச்சியாக ஒதுக்கப்பட வேண்டும் என்பதைத் தவிர.


It is also perfectly possible to represent circular lists.

சுற்றுப் பட்டியல்களைக் குறிப்பதும் முற்றிலும் சாத்தியமாகும்.


We emphasize that mathematical lists cannot be circular.

கணிதப் பட்டியல்கள் வட்டமாக இருக்க முடியாது என்பதை நாங்கள் வலியுறுத்துகிறோம்.


Lists as they appear with the block representation are commonly called linked lists.

தொகுதி பிரதிநிதித்துவத்துடன் தோன்றும் பட்டியல்கள் பொதுவாக இணைக்கப்பட்ட பட்டியல்கள் என்று அழைக்கப்படுகின்றன.


How many blocks and how many fields are required to store the list [1,2,3,4] in a heap using the linked block representation?

இணைக்கப்பட்ட தொகுதி பிரதிநிதித்துவத்தைப் பயன்படுத்தி, [1,2,3,4] பட்டியலை ஒரு குவியலில் சேமிக்க எத்தனை தொகுதிகள் மற்றும் எத்தனை புலங்கள் தேவை?


The function alloc allocates a new block of the given length in the heap and returns the address of the block.

alloc செயல்பாடு குவியலில் கொடுக்கப்பட்ட நீளத்தின் புதிய தொகுதியை ஒதுக்குகிறது மற்றும் தொகுதியின் முகவரியை வழங்குகிறது.


Blocks must have at least length 1 (that is, at least one field).

தொகுதிகள் குறைந்தபட்சம் 1 நீளம் கொண்டிருக்க வேண்டும் (அதாவது, குறைந்தபட்சம் ஒரு புலம்).


The function get yields the value in the field of a block, where the field is given by its index in the block.

get செயல்பாடு ஒரு தொகுதியின் புலத்தில் உள்ள மதிப்பை அளிக்கிறது, அங்கு புலம் தொகுதியில் அதன் குறியீட்டால் வழங்கப்படுகிறது.


The function set replaces the value in the field of a block.

set செயல்பாடு ஒரு தொகுதியின் புலத்தில் உள்ள மதிப்பை மாற்றுகிறது.


Thus we may think of blocks as mutable objects.

எனவே, தொகுதிகளை மாற்றக்கூடிய பொருள்களாக நாம் நினைக்கலாம்.


The function release is given the address of an allocated block and deallocates this block and all blocks allocated after this block.

release செயல்பாடு ஒதுக்கப்பட்ட தொகுதியின் முகவரியை வழங்குகிறது மற்றும் இந்த தொகுதியையும், இந்த தொகுதிக்குப் பிறகு ஒதுக்கப்பட்ட அனைத்து தொகுதிகளையும் விடுவிக்கிறது.


We implement the heap with the following structure:

பின்வரும் கட்டமைப்பைக் கொண்டு குவியலை செயல்படுத்துகிறோம்:


Note that we use the helper function check to ensure that only allocated addresses are used by set, get, and release.

set, get மற்றும் release ஆகியவற்றால் ஒதுக்கப்பட்ட முகவரிகள் மட்டுமே பயன்படுத்தப்படுவதை உறுதிசெய்ய, check என்ற உதவிச் செயல்பாட்டைப் பயன்படுத்துகிறோம் என்பதை நினைவில் கொள்க.


The exception address signals an address error that has occurred while allocating or accessing a block.

ஒரு தொகுதியை ஒதுக்கும்போது அல்லது அணுகும் போது ஏற்பட்ட முகவரிப் பிழையை முகவரி விதிவிலக்குக் குறிக்கிறது.