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 second declaration of the identifier 'a' shadows the first declaration of 'a'.

'a' എന്ന ഐഡൻ്റിഫയറിൻ്റെ രണ്ടാമത്തെ പ്രഖ്യാപനം 'a'യുടെ ആദ്യ പ്രഖ്യാപനത്തെ മറയ്ക്കുന്നു.


We emphasize the role of correctness statements and practice inductive correctness proofs.

ശരിയായ പ്രസ്താവനകളുടെ പങ്കിന് ഞങ്ങൾ ഊന്നൽ നൽകുന്നു, കൂടാതെ ഇൻഡക്റ്റീവ് ശരിയായ തെളിവുകൾ പരിശീലിക്കുന്നു.


As it comes to functional programming, we cover higher-order recursive functions.

ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിലേക്ക് വരുമ്പോൾ, ഉയർന്ന-ഓർഡർ റിcursive ഫംഗ്ഷനുകൾ ഞങ്ങൾ ഉൾക്കൊള്ളുന്നു.


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

ഇടവേളയുടെ അവസാന പോയിന്റുകൾ മുൻകൂട്ടി നിർവചിക്കപ്പെട്ട ഐഡൻ്റിഫയറുകൾ ഉപയോഗിച്ച് നേടാനാകും.


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

വിൻ്റർ സെമസ്റ്ററിൽ 15 ആഴ്ചത്തെ പഠനമാണ് കോഴ്സിനുള്ളത്.


Students perceive the course as challenging and exciting.

വിദ്യാർത്ഥികൾ കോഴ്സിനെ വെല്ലുവിളിയും ആവേശകരവുമാണ് എന്ന് കരുതുന്നു.


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

ഏത് ഭാഷാ നിയമമാണ് ലംഘിക്കപ്പെട്ടതെന്ന് സൂചിപ്പിക്കുന്ന ഒരു പിശക് സന്ദേശം ഇന്റർപ്രെറ്റർ കാണിക്കും.


We also cover asymptotic running time considering binary search.

ബൈനറി തിരയൽ പരിഗണിച്ച് അസിംപ്‌റ്റോട്ടിക് റണ്ണിംഗ് സമയവും ഞങ്ങൾ ഉൾക്കൊള്ളുന്നു.


The new English text realizes some substantial changes.

പുതിയ ഇംഗ്ലീഷ് പാഠം ചില കാര്യമായ മാറ്റങ്ങൾ ഉൾക്കൊള്ളുന്നു.


This text teaches functional programming and the structure of programming languages.

ഈ പാഠപുസ്തകം ഫങ്ഷണൽ പ്രോഗ്രാമിംഗും പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഘടനയും പഠിപ്പിക്കുന്നു.


We concentrate on recursive functions on integers computing things like powers.

ശക്തികൾ പോലുള്ള കാര്യങ്ങൾ കണക്കാക്കുന്ന പൂർണ്ണസംഖ്യകളിലെ റിcursive ഫംഗ്ഷനുകളിൽ ഞങ്ങൾ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.


The bodies of declarations are expressions.

പ്രഖ്യാപനങ്ങളുടെ ഭാഗങ്ങൾ എക്സ്പ്രഷനുകളാണ്.


We follow an approach known as functional programming.

ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് എന്നറിയപ്പെടുന്ന ഒരു സമീപനമാണ് ഞങ്ങൾ പിന്തുടരുന്നത്.


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

വീട്ടിലിരുന്ന് ചെയ്യാനുള്ള പ്രോജക്റ്റ് കോഴ്സിൻ്റെ ഒരു പ്രധാന ഭാഗമായി കണക്കാക്കണം.


Tail recursion is often more efficient than general recursion.

സാധാരണ റിcursഷനെക്കാൾ കൂടുതൽ കാര്യക്ഷമമാണ് ടെയിൽ റിcursഷൻ.


The function `gcd` is a typical example of tail recursion.

`gcd` എന്ന ഫംഗ്ഷൻ ടെയിൽ റിcursഷന്റെ ഒരു സാധാരണ ഉദാഹരണമാണ്.


In imperative programming, tail recursive functions can be expressed with loops.

ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗിൽ, ടെയിൽ റിcursഷൻ ഫംഗ്ഷനുകൾ ലൂപ്പുകൾ ഉപയോഗിച്ച് പ്രകടിപ്പിക്കാൻ കഴിയും.


Functional programming languages often prefer tail recursive functions over loops.

ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകൾ പലപ്പോഴും ലൂപ്പുകളേക്കാൾ ടെയിൽ റിcursഷൻ ഫംഗ്ഷനുകൾക്ക് മുൻഗണന നൽകുന്നു.


Tail recursive functions can be reformulated by introducing an extra argument.

ഒരു അധിക ആർഗ്യുമെന്റ് അവതരിപ്പിക്കുന്നതിലൂടെ ടെയിൽ റിcursഷൻ ഫംഗ്ഷനുകൾ പുനർരൂപകൽപ്പന ചെയ്യാൻ കഴിയും.


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

ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യയായ n-ന്റെ ഫാക്ടോറിയൽ, n-ൽ കുറവോ തുല്യമോ ആയ എല്ലാ പോസിറ്റീവ് പൂർണ്ണസംഖ്യകളുടെയും ഗുണനഫലമാണ്.


The time for a marathon may be given in the format h:m:s.

ഒരു മാരത്തണിന്റെ സമയം h:m:s എന്ന ഫോർമാറ്റിൽ നൽകാം.


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

ബെർലിനിൽ എലിയുഡ് കിപ്ചോഗെയുടെ ലോക റെക്കോർഡ് സമയം 2:01:39 ആയിരുന്നു.


OCaml has tuples to represent collections of values as single values.

ഒറ്റ മൂല്യങ്ങളായി മൂല്യങ്ങളുടെ ശേഖരം പ്രതിനിധീകരിക്കുന്നതിന് OCaml-ൽ ട്യൂപ്പിളുകൾ ഉണ്ട്.


We can use the tuple (2, 1, 39) : int * int * int to represent the marathon time.

മാരത്തൺ സമയം പ്രതിനിധീകരിക്കുന്നതിന് നമുക്ക് (2, 1, 39) : int * int * int എന്ന ട്യൂപ്പിൾ ഉപയോഗിക്കാം.


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

ഒരു ട്യൂപ്പിളിന്റെ ഘടക തരങ്ങൾ int-ൽ മാത്രം ഒതുങ്ങുന്നില്ല.


Tuples of length 2 are called pairs, and tuples of length 3 are called triples.

2 എന്ന നീളമുള്ള ട്യൂപ്പിളുകളെ ജോഡികൾ എന്നും, 3 എന്ന നീളമുള്ള ട്യൂപ്പിളുകളെ ട്രിപ്പിളുകൾ എന്നും വിളിക്കുന്നു.


We can write functions to translate between times given in total seconds and times given as (h, m, s) tuples.

മൊത്തം സെക്കൻഡിൽ നൽകിയിട്ടുള്ള സമയവും (h, m, s) ട്യൂപ്പിളുകളായി നൽകിയിട്ടുള്ള സമയവും തമ്മിൽ വിവർത്തനം ചെയ്യുന്നതിന് നമുക്ക് ഫംഗ്ഷനുകൾ എഴുതാം.


What happens when we execute the native operation 5/0 in OCaml?

OCaml-ൽ 5/0 എന്ന നേറ്റീവ് പ്രവർത്തനം നടപ്പിലാക്കുമ്പോൾ എന്താണ് സംഭവിക്കുക?


Execution is aborted and an exception is reported.

പ്രവർത്തനം റദ്ദാക്കുകയും ഒരു ഒഴിവാക്കൽ റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു.


Exceptions can be useful when debugging erroneous programs.

തെറ്റായ പ്രോഗ്രാമുകൾ ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ ഒഴിവാക്കലുകൾ ഉപയോഗപ്രദമാകും.


At the mathematical level we use types like N+ or side conditions like y != 0 to exclude undefined applications like x/0.

ഗണിതശാസ്ത്രപരമായ തലത്തിൽ, നിർവചിക്കാത്ത പ്രയോഗങ്ങൾ ഒഴിവാക്കാൻ N+ പോലുള്ള തരങ്ങളും y != 0 പോലുള്ള നിബന്ധനകളും നമ്മൾ ഉപയോഗിക്കുന്നു.


When coding a mathematical function in OCaml, we need to replace mathematical types like N with the OCaml type int.

OCaml-ൽ ഒരു ഗണിതശാസ്ത്ര ഫംഗ്ഷൻ കോഡ് ചെയ്യുമ്പോൾ, N പോലുള്ള ഗണിതശാസ്ത്ര തരങ്ങളെ OCaml തരം int-മായി മാറ്റേണ്ടതുണ്ട്.


Strings are values like integers and booleans and have type string.

സ്ട്രിംഗുകൾ പൂർണ്ണസംഖ്യകളും ബൂളിയൻ മൂല്യങ്ങളും പോലെ മൂല്യങ്ങളാണ്, കൂടാതെ സ്ട്രിംഗ് തരം ഉണ്ട്.


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 എന്ന പൂർണ്ണസംഖ്യയെ മൂന്ന് തവണ സ്ക്വയർ ചെയ്യുന്നു.


Local declarations are obtained with `let` expressions combining a declaration with an expression using the keywords `let` and `in`.

`let` ഉം `in` ഉം എന്നീ കീവേഡുകൾ ഉപയോഗിച്ച് ഒരു പ്രഖ്യാപനത്തെ ഒരു എക്സ്പ്രഷനുമായി സംയോജിപ്പിച്ച് `let` എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് പ്രാദേശിക പ്രഖ്യാപനങ്ങൾ ലഭിക്കും.


Let expressions must not be confused with top-level declarations (which don’t use the keyword `in`).

ലെറ്റ് എക്സ്പ്രഷനുകൾ ടോപ് ലെവൽ പ്രഖ്യാപനങ്ങളുമായി ആശയക്കുഴപ്പത്തിലാകരുത് (അവ `in` എന്ന കീവേഡ് ഉപയോഗിക്കില്ല).


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 of `abs` uses a comparison `x < 0` and a conditional formed with the keywords `if`, `then`, and `else`.

`abs` ൻ്റെ പ്രഖ്യാപനം `x < 0` എന്ന താരതമ്യവും `if`, `then`, `else` എന്നീ കീവേഡുകൾ ഉപയോഗിച്ച് രൂപീകരിച്ച ഒരു വ്യവസ്ഥയും ഉപയോഗിക്കുന്നു.


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` ശരിയായ ടൈപ്പ് സ്വീകരിക്കുന്നതിന് ആവശ്യമാണ്.


Next we declare a three-argument maximum function using a local declaration.

അടുത്തതായി, ഒരു പ്രാദേശിക പ്രഖ്യാപനം ഉപയോഗിച്ച് ഒരു മൂന്ന് ആർഗ്യുമെൻ്റ് പരമാവധി ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുന്നു.


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` എന്ന ടൈപ്പ് ഉണ്ട്.


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.

റിcursive ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് റിcursive കണക്കുകൂട്ടലുകൾ ഉൾക്കൊള്ളാൻ കഴിയും.


We now declare a recursive function implementing this equation: `let rec pow x n = if n < 1 then 1 else x * pow x (n - 1)`

ഈ സമവാക്യം നടപ്പിലാക്കുന്ന ഒരു റിcursive ഫംഗ്ഷൻ ഇപ്പോൾ പ്രഖ്യാപിക്കുന്നു: `let rec pow x n = if n < 1 then 1 else x * pow x (n - 1)`


We say that the function `pow` applies itself.

`pow` എന്ന ഫംഗ്ഷൻ സ്വയം ബാധകമാക്കുന്നു എന്ന് നമ്മൾ പറയുന്നു.


The example derivation system considered here was chosen for the purpose of explanation.

വിശദീകരണത്തിനായി ഇവിടെ പരിഗണിക്കുന്ന ഉദാഹരണ ഡെറിവേഷൻ സിസ്റ്റം തിരഞ്ഞെടുത്തു.


In practice, derivation systems are used for describing computational relations that cannot be described otherwise.

പ്രായോഗികമായി, മറ്റ് വിധത്തിൽ വിവരിക്കാൻ കഴിയാത്ത കമ്പ്യൂട്ടേഷണൽ ബന്ധങ്ങൾ വിവരിക്കാൻ ഡെറിവേഷൻ സിസ്റ്റങ്ങൾ ഉപയോഗിക്കുന്നു.


Typing and evaluation of expressions are examples for such relations, and we are going to use derivation systems for this purpose.

എക്സ്പ്രഷനുകളുടെ ടൈപ്പിംഗും മൂല്യനിർണ്ണയവും അത്തരം ബന്ധങ്ങൾക്കുള്ള ഉദാഹരണങ്ങളാണ്, ഈ ആവശ്യത്തിനായി ഞങ്ങൾ ഡെറിവേഷൻ സിസ്റ്റങ്ങൾ ഉപയോഗിക്കാൻ പോകുന്നു.


5 ̇ <9-നുള്ള എല്ലാ ഡെറിവേഷനുകളും നൽകുക.


Give two inference rules for judgments x ̇ < y such that your rules derive the same judgments the rules given above derive, but have the additional property that no judgments has more than one derivation.

x ̇ < y എന്ന വിധിക്കായി രണ്ട് ഇൻഫറൻസ് നിയമങ്ങൾ നൽകുക, അതുവഴി നിങ്ങളുടെ നിയമങ്ങൾ മുകളിൽ നൽകിയിട്ടുള്ള നിയമങ്ങൾ ഉണ്ടാക്കുന്ന അതേ വിധികൾ ഉണ്ടാക്കുന്നു, എന്നാൽ ഒരു വിധിക്ക് ഒന്നിൽ കൂടുതൽ ഡെറിവേഷൻ ഉണ്ടാകില്ലെന്ന അധിക സ്വത്തും ഉണ്ട്.


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 എന്ന വിധി x+k·5 = y ആണെങ്കിൽ k≥1 ആകുമ്പോൾ മാത്രം ഉണ്ടാക്കാവുന്നതാണ്.


The semantic layers of a language see the phrases of the language as abstract syntactic objects where lexical details don’t play a role.

ഒരു ഭാഷയുടെ അർത്ഥപരമായ പാളികൾ, പദപരമായ വിശദാംശങ്ങൾ ഒരു പങ്കും വഹിക്കാത്ത അമൂർത്തമായ ശൈലീപരമായ വസ്തുക്കളായി ഭാഷയിലെ ശൈലികൾ കാണുന്നു.


This brings us back to the philosophy of Chapter 1 where we explained OCaml with abstract syntactic notions such as expressions, types, and declarations and lexical details where conveyed tacitly through the code for mathematically motivated examples.

ഗണിതപരമായി പ്രചോദിതരായ ഉദാഹരണങ്ങൾക്കായി കോഡിലൂടെ വ്യക്തമാക്കാത്ത പദപരമായ വിശദാംശങ്ങളും, എക്സ്പ്രഷനുകൾ, തരങ്ങൾ, പ്രഖ്യാപനങ്ങൾ തുടങ്ങിയ അമൂർത്തമായ ശൈലീപരമായ ആശയങ്ങൾ ഉപയോഗിച്ച് OCaml വിശദീകരിച്ച ഒന്നാം അധ്യായത്തിലെ തത്ത്വചിന്തയിലേക്ക് ഇത് നമ്മെ തിരികെ കൊണ്ടുവരുന്നു.


For the discussion of the semantic layers, we switch to a language of abstract expressions differing from the sublanguage considered for the syntactic layers.

അർത്ഥപരമായ പാളികളെക്കുറിച്ചുള്ള ചർച്ചയ്ക്കായി, ശൈലീപരമായ പാളികൾക്കായി പരിഗണിക്കുന്ന ഉപഭാഷയിൽ നിന്ന് വ്യത്യസ്തമായ അമൂർത്തമായ പദപ്രയോഗങ്ങളുടെ ഒരു ഭാഷയിലേക്ക് നമ്മൾ മാറുന്നു.


The new language has types as considered before t::=int|bool|string|t 1 →t 2 |t 1 ×···×t n n≥2 35 2 Syntax and Semantics and abstract expressions as described by the following grammar:

പുതിയ ഭാഷയ്ക്ക് മുമ്പ് പരിഗണിച്ച തരങ്ങൾ ഉണ്ട് t::=int|bool|string|t 1 →t 2 |t 1 ×···×t n n≥2 35 2 ശൈലിയും അർത്ഥവും കൂടാതെ താഴെ പറയുന്ന വ്യാകരണത്തിലൂടെ വിവരിക്കുന്ന അമൂർത്തമായ പദപ്രയോഗങ്ങളും:


The letter c ranges over constants (lexically represented as literals), the letters x and f range over variables (lexically represented as identifiers), and the letter o ranges over operators.

c എന്ന അക്ഷരം സ്ഥിരമായവയെ (പദപരമായി ലിറ്ററലുകളായി പ്രതിനിധീകരിക്കുന്നു), x, f എന്നീ അക്ഷരങ്ങൾ വേരിയബിളുകളെയും (പദപരമായി ഐഡന്റിഫയറുകളായി പ്രതിനിധീകരിക്കുന്നു), o എന്ന അക്ഷരം ഓപ്പറേറ്റർമാരെയും സൂചിപ്പിക്കുന്നു.


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.

ലാംഡാ എക്സ്പ്രഷനുകളും ലെറ്റ് എക്സ്പ്രഷനുകളും അവതരിപ്പിക്കുന്ന വേരിയബിളുകളെ ലോക്കൽ വേരിയബിളുകൾ എന്ന് വിളിക്കുന്നു.


Lambda expressions are written in mathematical notation and take only one argument variable.

ലാംഡാ എക്സ്പ്രഷനുകൾ ഗണിതശാസ്ത്രപരമായ രൂപത്തിൽ എഴുതിയിരിക്കുന്നു, കൂടാതെ ഒരു ആർഗ്യുമെന്റ് വേരിയബിൾ മാത്രമേ എടുക്കൂ.


Similarly, let expressions bind only one or two variables.

അതുപോലെ, ലെറ്റ് എക്സ്പ്രഷനുകൾ ഒന്നോ രണ്ടോ വേരിയബിളുകളെ മാത്രം ബന്ധിപ്പിക്കുന്നു.


Tuple patterns are replaced by projections π n, yielding the nth component of a tuple.

ട്യൂപ്പിൾ പാറ്റേണുകൾ പ്രൊജക്ഷനുകൾ π n ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു, ഇത് ഒരു ട്യൂപ്പിളിന്റെ n-ാം ഘടകം നൽകുന്നു.


We will refer to the expressions identified by the phrasal syntax as concrete expressions.

വാക്യഘടനയാൽ തിരിച്ചറിയപ്പെടുന്ന പദപ്രയോഗങ്ങളെ നമ്മൾ കോൺക്രീറ്റ് എക്സ്പ്രഷനുകൾ എന്ന് വിളിക്കും.


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

കോൺക്രീറ്റ് എക്സ്പ്രഷനുകളെ തത്തുല്യമായ അമൂർത്തമായ പദപ്രയോഗങ്ങളിലേക്ക് വിവർത്തനം ചെയ്യാൻ കഴിയും.


The reverse translation is trivial as long as no projections are used.

പ്രൊജക്ഷനുകളൊന്നും ഉപയോഗിക്കാത്തപ്പോൾ വിപരീത വിവർത്തനം വളരെ ലളിതമാണ്.


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 and grouping rules.

പദപ്രയോഗങ്ങളുടെ ടെക്സ്റ്റു്വൽ പ്രാതിനിധ്യത്തിനായി ആവശ്യമായ அடைப்புக்குறிகள் എണ്ണം കുറയ്ക്കുന്നതിന്, ഒരു ഭാഷയുടെ കോൺക്രീറ്റ് ശൈലി ഓപ്പറേറ്റർ മുൻഗണനകളും ഗ്രൂപ്പിംഗ് നിയമങ്ങളും നിർണ്ണയിക്കുന്നു.


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 dynamic semantics represents functional values as so-called closures combining the syntactic description of a function with a value environment providing values for the free variables.

ചലനാത്മകമായ അർത്ഥം പ്രവർത്തനപരമായ മൂല്യങ്ങളെ ഒരു ഫംഗ്ഷന്റെ ശൈലീപരമായ വിവരണവും സ്വതന്ത്ര വേരിയബിളുകൾക്കായി മൂല്യങ്ങൾ നൽകുന്ന ഒരു മൂല്യ പരിതസ്ഥിതിയും സംയോജിപ്പിച്ച് ക്ലോഷറുകൾ എന്ന് വിളിക്കുന്നു.


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 (so-called type safety).

ഒരു തരം പദപ്രയോഗം t എന്ന തരത്തിലുള്ള ഒരു മൂല്യത്തിലേക്ക് വിലയിരുത്തപ്പെടുന്നു (അതായത് ടൈപ്പ് സുരക്ഷ).


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

ടൈപ്പിംഗ് നിയമങ്ങൾ നൽകുന്ന ടൈപ്പ് പരിശോധനാ അൽഗോരിതം എപ്പോഴും അവസാനിപ്പിക്കും.


This is in contrast to the evaluation algorithm given by the evaluation rules, which may diverge on expressions not identified as evaluable by the evaluation rules.

ഇത് മൂല്യനിർണ്ണയ നിയമങ്ങൾ നൽകുന്ന മൂല്യനിർണ്ണയ അൽഗോരിതവുമായി വിരുദ്ധമാണ്, ഇത് മൂല്യനിർണ്ണയ നിയമങ്ങൾ വിലയിരുത്താൻ കഴിയാത്ത പദപ്രയോഗങ്ങളിൽ വ്യതിചലിച്ചേക്കാം.


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 list [1, 2, 3] may be depicted as the tree.

[1, 2, 3] എന്ന ലിസ്റ്റ് ഒരു വൃക്ഷമായി ചിത്രീകരിക്കാവുന്നതാണ്.


Every list is obtained with either the constructor nil or the constructor cons.

ഓരോ ലിസ്റ്റും ഒന്നുകിൽ nil എന്ന കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ചോ അല്ലെങ്കിൽ cons എന്ന കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ചോ ലഭിക്കുന്നതാണ്.


We call the values x1, ..., xn the elements or the members of the list.

x1, ..., xn എന്നീ മൂല്യങ്ങളെ ലിസ്റ്റിന്റെ അംഗങ്ങൾ അല്ലെങ്കിൽ ഘടകങ്ങൾ എന്ന് വിളിക്കുന്നു.


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.

പോളിമോർഫിക് ഫംഗ്ഷൻ ലെങ്‌തിന്റെ നിർവചനത്തിൽ നിന്ന് ആരംഭിക്കാം.


Another prominent list operation is concatenation.

മറ്റൊരു പ്രധാനപ്പെട്ട ലിസ്റ്റ് ഓപ്പറേഷൻ ആണ് കോൺകാറ്റിനേഷൻ.


How can we define an operation reversing lists?

ലിസ്റ്റുകൾ റിവേഴ്സ് ചെയ്യുന്ന ഒരു പ്രവർത്തനം എങ്ങനെ നിർവചിക്കാം?


We can also define a tail recursive list reversal function.

ഒരു ടെയിൽ റിcursive ലിസ്റ്റ് റിവേഴ്സൽ ഫംഗ്ഷനും നമുക്ക് നിർവചിക്കാം.


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

ഇതുവരെ നിർവചിക്കപ്പെട്ട ഫംഗ്ഷനുകളെല്ലാം ലിസ്റ്റ് റിക്കർഷൻ ഉപയോഗിച്ചാണ് നിർവചിച്ചിരിക്കുന്നത്.


List recursion always terminates since lists are obtained from nil with finitely many applications of cons.

ലിസ്റ്റുകൾ nil-ൽ നിന്ന് cons-ന്റെ പരിമിതമായ ആപ്ലിക്കേഷനുകൾ ഉപയോഗിച്ച് ലഭിക്കുന്നതിനാൽ ലിസ്റ്റ് റിക്കർഷൻ എപ്പോഴും അവസാനിക്കും.


Another prominent list operation is map.

മറ്റൊരു പ്രധാനപ്പെട്ട ലിസ്റ്റ് ഓപ്പറേഷൻ ആണ് മാപ്.


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

മാപ്, ഒരു ലിസ്റ്റിലേക്ക് ഫംഗ്ഷൻ f പോയിന്റ് വൈസ് ആയി പ്രയോഗിക്കുന്നു എന്ന് പറയാം.


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

അവസാനമായി, രണ്ട് സംഖ്യകൾ (m, n) തമ്മിലുള്ള എല്ലാ പൂർണ്ണസംഖ്യകളുടെയും ലിസ്റ്റ് നൽകുന്ന ഒരു ഫംഗ്ഷൻ നമുക്ക് നിർവചിക്കാം.


This time the recursion is not on a list but on the number m.

ഈ സമയം റിക്കർഷൻ ഒരു ലിസ്റ്റിലല്ല, മറിച്ച് സംഖ്യയായ m-ലാണ്.


The recursion terminates since every recursion step decreases n - m and recursion stops once n - m < 0.

ഓരോ റിക്കർഷൻ ഘട്ടത്തിലും n - m കുറയുന്നതിനാലും n - m < 0 ആകുമ്പോൾ റിക്കർഷൻ അവസാനിക്കുന്നതിനാലും ഇത് അവസാനിക്കും.


Given a mathematical definition of a list function, it is straightforward to declare the function in OCaml.

ഒരു ലിസ്റ്റ് ഫംഗ്ഷന്റെ ഗണിതപരമായ നിർവചനം നൽകുമ്പോൾ, OCaml-ൽ ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുന്നത് വളരെ ലളിതമാണ്.


The essential new construct are so-called match expressions making it possible to discriminate between empty and nonempty lists.

ശൂന്യമായതും ശൂന്യമല്ലാത്തതുമായ ലിസ്റ്റുകൾ തമ്മിൽ വേർതിരിക്കുന്നത് സാധ്യമാക്കുന്ന മാച്ച് എക്സ്പ്രഷനുകളാണ് പ്രധാനപ്പെട്ട പുതിയ ഘടന.


The match expression realizes a case analysis on lists using separate rules for the empty list and for nonempty lists.

മാച്ച് എക്സ്പ്രഷൻ ശൂന്യമായ ലിസ്റ്റിനും ശൂന്യമല്ലാത്ത ലിസ്റ്റുകൾക്കും പ്രത്യേക നിയമങ്ങൾ ഉപയോഗിച്ച് ലിസ്റ്റുകളിൽ ഒരു കേസ് അനാലിസിസ് നടത്തുന്നു.


കാട്ടിലെ മരങ്ങൾ വളരെ ഉയരമുള്ളവയായിരുന്നു.


നിങ്ങളുടെ പേരും വിലാസവും നൽകുക.


ഒരു വലിയ ഭൂകമ്പത്തെക്കുറിച്ച് വാർത്തയിൽ റിപ്പോർട്ട് ചെയ്തു.


I am going to the market to buy some vegetables.

ഞാൻ കുറച്ച് പച്ചക്കറികൾ വാങ്ങാൻ മാർക്കറ്റിൽ പോകുകയാണ്.


The company announced a new product launch.

കമ്പനി ഒരു പുതിയ ഉൽപ്പന്നം പുറത്തിറക്കുന്നതായി പ്രഖ്യാപിച്ചു.


Could you please repeat that information?

ആ വിവരങ്ങൾ ഒന്ന് ആവർത്തിക്കാമോ?


The algorithm efficiently sorts the data.

അൽഗോരിതം ഡാറ്റയെ കാര്യക്ഷമമായി അടുക്കുന്നു.


She is a talented musician and composer.

അവൾ ഒരു കഴിവുള്ള സംഗീതജ്ഞനും, സംഗീത സംവിധായകനുമാണ്.


The government is implementing new policies.

സർക്കാർ പുതിയ നയങ്ങൾ നടപ്പാക്കുകയാണ്.


The research paper explores complex topics.

ഗവേഷണ പ്രബന്ധം സങ്കീർണ്ണമായ വിഷയങ്ങൾ പരിശോധിക്കുന്നു.


പ്രതിസന്ധികൾ ഉണ്ടായിരുന്നിട്ടും, അവർ വിജയിച്ചു.


സാമ്പത്തിക പ്രവചനം വളർച്ച പ്രവചിക്കുന്നു.


സോഫ്റ്റ്‌വെയറിന് പതിവായ അപ്‌ഡേറ്റുകൾ ആവശ്യമാണ്.


The philosophical debate was quite intense.

തത്വചിന്താപരമായ സംവാദം വളരെ ശക്തമായിരുന്നു.


The implications of the discovery are far-reaching.

കണ്ടുപിടുത്തത്തിന്റെ അനന്തരഫലങ്ങൾ വളരെ ദൂരവ്യാപകമാണ്.


The intricacies of the legal system are often misunderstood.

നിയമ വ്യവസ്ഥയുടെ സങ്കീർണ്ണത പലപ്പോഴും തെറ്റിദ്ധരിക്കപ്പെടുന്നു.


The company's strategic plan involves global expansion.

കമ്പനിയുടെ തന്ത്രപരമായ പദ്ധതിയിൽ ലോകമെമ്പാടുമുള്ള വിപുലീകരണം ഉൾപ്പെടുന്നു.


The quantum physics experiment yielded unexpected results.

ക്വാണ്ടം ഫിസിക്സ് പരീക്ഷണം, പ്രതീക്ഷിക്കാത്ത ഫലങ്ങൾ നൽകി.


The historical context is crucial for understanding the events.

സംഭവങ്ങൾ മനസ്സിലാക്കാൻ ചരിത്രപരമായ പശ്ചാത്തലം അത്യാവശ്യമാണ്.


The ethical considerations surrounding artificial intelligence are complex.

കൃത്രിമ ബുദ്ധിയുമായി ബന്ധപ്പെട്ട ധാർമ്മിക പരിഗണനകൾ സങ്കീർണ്ണമാണ്.


The code defines a function to calculate the factorial of a number.

ഒരു സംഖ്യയുടെ ഫാക്ടോറിയൽ കണക്കാക്കാൻ കോഡ് ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു.


Variables are represented as strings in this programming language.

ഈ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ വേരിയബിളുകൾ സ്ട്രിംഗുകളായി പ്രതിനിധീകരിക്കുന്നു.


The parser translates strings into abstract syntax trees.

പാഴ്സർ സ്ട്രിംഗുകളെ അമൂർത്തമായ സിന്റാക്സ് ട്രീകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.


The lexer converts the input string into a list of tokens.

ലെക്സർ ഇൻപുട്ട് സ്ട്രിംഗിനെ ടോക്കണുകളുടെ ഒരു ലിസ്റ്റായി മാറ്റുന്നു.


This chapter discusses recursive descent parsing.

ഈ അധ്യായത്തിൽ റിcursive descent parsing-നെക്കുറിച്ച് പറയുന്നു.


The grammar follows the conventions of OCaml.

ഗ്രാമർ OCaml-ൻ്റെ നിയമങ്ങൾ പിന്തുടരുന്നു.


We will see a parser translating strings into abstract syntax trees.

സ്ട്രിംഗുകളെ അമൂർത്തമായ സിന്റാക്സ് ട്രീകളിലേക്ക് വിവർത്തനം ചെയ്യുന്ന ഒരു പാഴ്സറെ നമ്മൾ കാണും.


The process of translating string representations is known as parsing.

സ്ട്രിംഗ് പ്രാതിനിധ്യങ്ങളെ വിവർത്തനം ചെയ്യുന്ന പ്രക്രിയയെ പാഴ്സിംഗ് എന്ന് വിളിക്കുന്നു.


The function String.get yields the character at a specific position.

String.get എന്ന ഫംഗ്ഷൻ ഒരു പ്രത്യേക സ്ഥാനത്തുള്ള പ്രതീകം നൽകുന്നു.


The main advantage is the fast get operation.

പ്രധാന നേട്ടം വേഗത്തിലുള്ള get പ്രവർത്തനം ആണ്.


The recursive calls of the parsing function can be visualized.

പാഴ്സിംഗ് ഫംഗ്ഷൻ്റെ റിcursive കോളുകൾ ദൃശ്യവൽക്കരിക്കാൻ കഴിയും.


The new grammar rule is realized with an additional rule.

പുതിയ ഗ്രാമർ നിയമം ഒരു അധിക നിയമം ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു.


The helper function gets the tree that has been parsed before.

സഹായകരമായ ഫംഗ്ഷൻ മുമ്പ് പാഴ്സ് ചെയ്ത ട്രീ ലഭിക്കുന്നു.


We now come to the case where we have two infix operators.

രണ്ട് ഇൻഫിക്സ് ഓപ്പറേറ്റർമാരുള്ള കേസിലേക്ക് നമ്മൾ ഇപ്പോൾ വരുന്നു.


The key idea is to work with a stack of already parsed subtrees.

മുമ്പേ പാഴ്സ് ചെയ്ത സബ്‌ട്രീകളുടെ ഒരു സ്റ്റാക്കുമായി പ്രവർത്തിക്കുക എന്നതാണ് ഇതിലെ പ്രധാന ആശയം.


The techniques suffice to construct a parser for Mini-OCaml.

മിനി-ഒകാമിനായി ഒരു പാഴ്സർ നിർമ്മിക്കാൻ ഈ ടെക്നിക്കുകൾ മതി.


Each of the components can be written and debugged by itself.

ഓരോ ഘടകവും സ്വയം എഴുതാനും ഡീബഗ് ചെയ്യാനും കഴിയും.


നിങ്ങൾക്ക് ഒരു മോഡുലാർ ഡിസൈൻ ഞങ്ങൾ നൽകുന്നു.


Debugging larger programs can be very difficult.

വലിയ പ്രോഗ്രാമുകൾ ഡീബഗ് ചെയ്യുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്.


c എന്ന അക്ഷരം സ്ഥിരമായ സംഖ്യകളെ സൂചിപ്പിക്കുന്നു.


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 list.

എല്ലാ ഘടകങ്ങളും ചേർ‌ത്തുകഴിഞ്ഞാൽ, ലിസ്റ്റിന്റെ അടുക്കിയുള്ള പുനഃക്രമീകരണം നമുക്ക് ലഭിക്കും.


Make sure you understand every detail of the definition.

നിങ്ങൾ നിർവചനത്തിന്റെ എല്ലാ വിശദാംശങ്ങളും മനസ്സിലാക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.


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.

എങ്കിലും, ടൈപ്പ് സ്പെസിഫിക്കേഷൻ നൽകിയില്ലെങ്കിൽ insert, isort എന്നിവയ്ക്കായി OCaml പോളിമോർഫിക് തരങ്ങൾ ഉണ്ടാക്കുന്നു എന്നത് അത്ഭുതകരമാണ്.


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

ട്യൂപ്പിളുകളിലും ലിസ്റ്റുകളിലും താരതമ്യങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുമെന്നും പിന്നീട് വിശദീകരിക്കുന്നതാണ്.


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

Boolean മൂല്യങ്ങൾക്കായി, OCaml false < true എന്ന ക്രമം തിരിച്ചറിയുന്നു.


Declare a function that tests whether a list is sorted.

ഒരു ലിസ്റ്റ് അടുക്കിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്ന ഒരു ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുക.


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 order in which this is done does not matter for the result.

ഇത് ചെയ്യുന്ന ക്രമം ഫലത്തെ ബാധിക്കില്ല.


If we switch to the definition isort l := foldl insert l [] we obtain a tail-recursive insertion function inserting the elements of the input list in the order they appear in the input list.

isort l := foldl insert l [] എന്ന നിർവചനത്തിലേക്ക് മാറുകയാണെങ്കിൽ, ഇൻപുട്ട് ലിസ്റ്റിലെ ഘടകങ്ങളെ ഇൻപുട്ട് ലിസ്റ്റിൽ കാണുന്ന ക്രമത്തിൽ ചേർക്കുന്ന ഒരു ടെയിൽ-റിcursive ചേർക്കൽ ഫംഗ്ഷൻ നമുക്ക് ലഭിക്കും.


Declare a function such that (x,n) ∈ table if and only if x occurs n > 0 times in l.

(x,n) ∈ table എന്നത് x, l-ൽ n > 0 തവണ സംഭവിക്കുമ്പോൾ മാത്രമുള്ള ഒരു ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുക.


Make sure table lists the count pairs for the elements of l in the order the elements appear in l, as in the example above.

table, മുകളിലുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, l-ലെ ഘടകങ്ങൾ വരുന്ന അതേ ക്രമത്തിൽ, എലമെന്റുകളുടെ എണ്ണം ജോഡികളായി ലിസ്റ്റ് ചെയ്യുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.


Rather than sorting lists using the predefined order ≤, we may sort lists using an order given as argument.

മുന്‍കൂട്ടി നിശ്ചയിച്ച ≤ എന്ന ക്രമം ഉപയോഗിച്ച് ലിസ്റ്റുകൾ അടുക്കുന്നതിനുപകരം, ഒരു ആർഗ്യുമെന്റായി നൽകിയിട്ടുള്ള ക്രമം ഉപയോഗിച്ച് ലിസ്റ്റുകൾ അടുക്കാൻ കഴിയും.


Now the function gisort(≤) sorts as before in ascending order, while the function gisort(≥) sorts in descending order.

ഇപ്പോൾ gisort(≤) ഫംഗ്ഷൻ, മുമ്പത്തെപ്പോലെ ആരോഹണ ക്രമത്തിലും, gisort(≥) ഫംഗ്ഷൻ അവരോഹണ ക്രമത്തിലും അടുക്കുന്നു.


This way we avoid the forwarding of the argument p.

ഈ രീതിയിൽ, p എന്ന ആർഗ്യുമെന്റ് കൈമാറുന്നത് ഒഴിവാക്കുന്നു.


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 എന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ ഇവാലുവേറ്റർ തിരിച്ചറിയുന്നു.


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.

true, false എന്നീ സ്ഥിരമായവയും if പോലുള്ള കീവേഡുകളും ആദ്യം ഐഡന്റിഫയറുകളായി തിരിച്ചറിയുകയും പിന്നീട് അതത് സ്ഥിരമായ അല്ലെങ്കിൽ കീവേഡ് ടോക്കണുകളായി രൂപാന്തരപ്പെടുത്തുകയും ചെയ്യുന്നു.


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-നെ പിന്തുടർന്ന്, ഒരു ഐഡന്റിഫയർ ചെറിയ അക്ഷരത്തിൽ ആരംഭിക്കണം, തുടർന്ന് അക്കങ്ങൾ, ചെറിയതും വലിയതുമായ അക്ഷരങ്ങൾ, കൂടാതെ ‘_’ (അണ്ടർലൈൻ), ‘'’ (അപ്പോസ്ട്രോഫി) എന്നീ പ്രത്യേക പ്രതീകങ്ങളും ഉപയോഗിക്കാം.


The parsing grammar for Mini-OCaml expressions has 6 levels: expif, fun, lettop level cexp≤comparisons sexp+,−additive operators mexp·multiplicative operators aexpfunction applications pexpbottom level

Mini-OCaml എക്സ്പ്രഷനുകൾക്കായുള്ള പാഴ്സിംഗ് വ്യാകരണത്തിന് 6 ലെവലുകൾ ഉണ്ട്: expif, fun, lettop level cexp≤comparisons sexp+,−additive operators mexp·multiplicative operators aexpfunction applications pexpbottom level


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

പ്രീഫിക്സ് ശൈലികൾ ടോപ് ലെവലിലേക്ക് ആവർത്തിക്കുന്നവ ടോപ് ലെവൽ ശ്രദ്ധിക്കുന്നു.


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 project consists in writing one file realizing two functions checkStr:string→type evalStr:string→value parsing strings as Mini-OCaml expressions and either type checking or evaluating the expressions.

മിനി-ഒകാമൽ എക്സ്പ്രഷനുകളായി സ്ട്രിംഗുകൾ പാഴ്സ് ചെയ്യുന്ന checkStr:string→type evalStr:string→value എന്നീ രണ്ട് ഫംഗ്ഷനുകൾ ഉൾക്കൊള്ളുന്ന ഒരു ഫയൽ എഴുതുന്നതാണ് പ്രോജക്റ്റ്, കൂടാതെ എക്സ്പ്രഷനുകൾ ടൈപ്പ് പരിശോധിക്കുകയോ വിലയിരുത്തുകയോ ചെയ്യുന്നു.


ഒരു സാധാരണ ഉദാഹരണം ലിസ്റ്റുകൾ അടുക്കുന്നതാണ്.


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.

ഒരു എക്സ്പ്രഷന്റെ റണ്ണിംഗ് ടൈം അതിന്റെ എക്സിക്യൂഷനായി ആവശ്യമായ ഫംഗ്ഷൻ കോളുകളുടെ എണ്ണമായി നിർവചിക്കാൻ കഴിയുമെന്ന് ഇത് മാറുന്നു.


Prominent examples of asymptotic running times are O(1) constant time O(logn) logarithmic time O(n) linear time O(nlogn) linearithmic time O(n 2 ) quadratic time O(2 n ) exponential time

അസിംപ്‌റ്റോട്ടിക് റണ്ണിംഗ് ടൈമിന്റെ പ്രധാന ഉദാഹരണങ്ങളാണ് O(1) സ്ഥിരമായ സമയം, O(logn) ലോഗരിഥമിക് സമയം, O(n) രേഖീയ സമയം, O(nlogn) ലീനിയറിത്തമിക് സമയം, O(n 2 ) ക്വാഡ്രാറ്റിക് സമയം, O(2 n ) എക്സ്പോണൻഷ്യൽ സമയം എന്നിവ.


In practice, constant, linear, and linearithmic running time is what one looks for, quadratic running times signals that there will be performance problems for larger arguments, and exponential running time signals that there are arguments of reasonable size for which the execution time is too high for practical purposes.

പ്രായോഗികമായി, സ്ഥിരമായ, രേഖീയമായ, ലീനിയറിത്തമിക് റണ്ണിംഗ് ടൈമാണ് ഒരാൾ സാധാരണയായി അന്വേഷിക്കുന്നത്, ക്വാഡ്രാറ്റിക് റണ്ണിംഗ് ടൈം വലിയ ആർഗ്യുമെന്റുകൾക്ക് പ്രകടമായ പ്രശ്നങ്ങളുണ്ടാകുമെന്നും, എക്സ്പോണൻഷ്യൽ റണ്ണിംഗ് ടൈം പ്രായോഗിക ആവശ്യങ്ങൾക്കായി എക്സിക്യൂഷൻ സമയം വളരെ കൂടുതലാണെന്നും സൂചിപ്പിക്കുന്നു.


The running times for list sorting algorithms are interesting.

ലിസ്റ്റ് സോർട്ടിംഗ് അൽഗോരിതങ്ങളുടെ റണ്ണിംഗ് ടൈമുകൾ രസകരമാണ്.


A good measure of the abstract running time of an expression is the number of function calls needed for its execution.

ഒരു എക്സ്പ്രഷന്റെ അമൂർത്തമായ റണ്ണിംഗ് ടൈമിന്റെ നല്ല അളവുകോൽ അതിന്റെ എക്സിക്യൂഷനായി ആവശ്യമായ ഫംഗ്ഷൻ കോളുകളുടെ എണ്ണമാണ്.


We remark that we distinguish between function applications and function calls.

ഫംഗ്ഷൻ ആപ്ലിക്കേഷനുകളും ഫംഗ്ഷൻ കോളുകളും തമ്മിൽ നമ്മൾ വേർതിരിക്കുന്നു എന്ന് ശ്രദ്ധിക്കുക.


The function induction is used to prove properties of recursive functions.

പുനരാവർത്തന ഫംഗ്ഷനുകളുടെ ഗുണങ്ങൾ തെളിയിക്കാൻ ഫംഗ്ഷൻ ഇൻഡക്ഷൻ ഉപയോഗിക്കുന്നു.


Euclid's algorithm efficiently computes the greatest common divisor.

യൂക്ലിഡിന്റെ അൽഗോരിതം ഏറ്റവും വലിയ സാധാരണ ഘടകം (GCD) കാര്യക്ഷമമായി കണക്കാക്കുന്നു.


Complete induction allows assuming proofs of all propositions.

എല്ലാ പ്രൊപ്പോസിഷനുകളുടെയും തെളിവുകൾ അനുമാനിക്കാൻ പൂർണ്ണമായ ഇൻഡക്ഷൻ അനുവദിക്കുന്നു.


Arrays are mutable data structures in programming.

പ്രോഗ്രാമിംഗിൽ, അറേകൾ മാറ്റം വരുത്താവുന്ന ഡാറ്റാ ഘടനകളാണ്.


The modulo rule is applied until the zero rule applies in Euclid's algorithm.

യൂക്ലിഡിന്റെ അൽഗോരിതത്തിൽ, പൂജ്യ നിയമം ബാധകമാകുന്നതുവരെ മോഡുലോ നിയമം പ്രയോഗിക്കുന്നു.


We can prove the property following the defining equations of the function.

ഫംഗ്ഷന്റെ നിർവചന സമവാക്യങ്ങൾ പിന്തുടർന്ന് നമുക്ക് പ്രോപ്പർട്ടി തെളിയിക്കാൻ കഴിയും.


രണ്ട് സംഖ്യകളുടെ GCD-യ്ക്ക് ഒരു പ്രത്യേകതയുണ്ട്.


Arrays have fixed-length and constant-time field access.

അറേകൾക്ക് സ്ഥിരമായ നീളവും സ്ഥിര സമയ ഫീൽഡ് ആക്സസും ഉണ്ട്.


The running time of the GCD algorithm is logarithmic.

GCD അൽഗോരിതത്തിന്റെ പ്രവർത്തിക്കാനുള്ള സമയം ലോഗരിതമിക് ആണ്.


Complete induction is a generalization of mathematical induction.

ഗണിതശാസ്ത്രപരമായ ഇൻഡക്ഷന്റെ ഒരു പൊതുവൽക്കരണമാണ് പൂർണ്ണമായ ഇൻഡക്ഷൻ.


The algorithm can be derived from basic principles.

അടിസ്ഥാന തത്വങ്ങളിൽ നിന്ന് ഈ അൽഗോരിതം രൂപപ്പെടുത്താൻ കഴിയും.


Arrays are represented by special array values.

പ്രത്യേക അറേ മൂല്യങ്ങൾ ഉപയോഗിച്ചാണ് അറേകൾ പ്രതിനിധീകരിക്കുന്നത്.


The key difference between lists and arrays is mutability.

ലിസ്റ്റുകളും അറേകളും തമ്മിലുള്ള പ്രധാന വ്യത്യാസം മാറ്റാനാകുമെന്നതാണ്.


We will not go further into logical details here.

ഇവിടെ ലോജിക്കൽ വിശദാംശങ്ങളിലേക്ക് കൂടുതൽ കടന്നുപോവുന്നില്ല.


The function relies on a helper function.

ഈ ഫംഗ്ഷൻ ഒരു സഹായി ഫംഗ്ഷനെ ആശ്രയിച്ചിരിക്കുന്നു.


The declaration may be seen as derived syntax.

പ്രഖ്യാപനം ഒരു വ്യുൽപ്പന്ന ശൈലിയായി കാണാവുന്നതാണ്.


Sequentializations execute e1 before e2.

തുടർച്ചയായ പ്രവർത്തനങ്ങൾ e1, e2 എന്നിവയ്ക്ക് മുമ്പ് നടപ്പിലാക്കുന്നു.


The state of an array can be represented as a list.

ഒരു അറേയുടെ അവസ്ഥയെ ഒരു ലിസ്റ്റായി പ്രതിനിധീകരിക്കാൻ കഴിയും.


Binary search has a logarithmic running time.

ബൈനറി സെർച്ചിന് ലോഗരിതമിക് പ്രവർത്തിക്കാനുള്ള സമയമുണ്ട്.


Arrays are mutable, unlike the immutability of values.

മൂല്യങ്ങളുടെ മാറ്റമില്ലായ്മയിൽ നിന്ന് വ്യത്യസ്തമായി, അറേകൾ മാറ്റാനാകുന്നവയാണ്.


The heap is an array-based data structure.

ഹീപ്പ് ഒരു അറേ അടിസ്ഥാനമാക്കിയുള്ള ഡാറ്റാ ഘടനയാണ്.


ഹീപ്പിൽ ബ്ലോക്കുകൾ സംഭരിച്ചിരിക്കുന്നു.


The list [10, 11, 12] can be stored using blocks.

[10, 11, 12] എന്ന ലിസ്റ്റ് ബ്ലോക്കുകൾ ഉപയോഗിച്ച് സംഭരിക്കാൻ കഴിയും.


Each block has fields for data and links.

ഓരോ ബ്ലോക്കിനും ഡാറ്റയ്ക്കും ലിങ്കുകൾക്കും ഫീൽഡുകൾ ഉണ്ട്.


Links point to the next block or indicate the end.

ലിങ്കുകൾ അടുത്ത ബ്ലോക്കിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു അല്ലെങ്കിൽ അവസാനം സൂചിപ്പിക്കുന്നു.


The address of a block is the index of its first field.

ഒരു ബ്ലോക്കിന്റെ വിലാസം അതിന്റെ ആദ്യ ഫീൽഡിന്റെ സൂചികയാണ്.


Links are represented by block addresses.

ലിങ്കുകൾ ബ്ലോക്ക് വിലാസങ്ങൾ ഉപയോഗിച്ച് പ്രതിനിധീകരിക്കുന്നു.


ശൂന്യമായ ലിസ്റ്റ് -1 ആയി പ്രതിനിധീകരിക്കുന്നു.


We can choose where to allocate blocks in the heap.

ഹീപ്പിൽ ബ്ലോക്കുകൾ എവിടെയാണ് അനുവദിക്കേണ്ടതെന്ന് നമുക്ക് തിരഞ്ഞെടുക്കാം.


വൃത്താകൃതിയിലുള്ള ലിസ്റ്റുകളും പ്രതിനിധീകരിക്കാൻ കഴിയും.


Linked lists are commonly used in block representation.

ബ്ലോക്ക് പ്രാതിനിധ്യത്തിൽ ലിങ്ക്ഡ് ലിസ്റ്റുകൾ സാധാരണയായി ഉപയോഗിക്കുന്നു.


How many blocks are needed to store [1, 2, 3, 4]?

[1, 2, 3, 4] സംഭരിക്കുന്നതിന് എത്ര ബ്ലോക്കുകൾ ആവശ്യമാണ്?


The HEAP module defines functions for memory management.

മെമ്മറി മാനേജ്മെൻ്റിനായുള്ള ഫംഗ്ഷനുകൾ HEAP മൊഡ്യൂൾ നിർവചിക്കുന്നു.


The alloc function allocates a new block.

alloc ഫംഗ്ഷൻ ഒരു പുതിയ ബ്ലോക്ക് അനുവദിക്കുന്നു.


The get function retrieves a value from a block.

get ഫംഗ്ഷൻ ഒരു ബ്ലോക്കിൽ നിന്ന് ഒരു മൂല്യം വീണ്ടെടുക്കുന്നു.


The set function updates a value in a block.

set ഫംഗ്ഷൻ ഒരു ബ്ലോക്കിലെ ഒരു മൂല്യം അപ്‌ഡേറ്റ് ചെയ്യുന്നു.


The release function deallocates a block.

release ഫംഗ്ഷൻ ഒരു ബ്ലോക്ക് ഒഴിവാക്കുന്നു.


ഒരു അറേ ഉപയോഗിച്ചാണ് ഹീപ്പ് നടപ്പിലാക്കുന്നത്.


The alloc' function allocates a block for a list of integers.

alloc' ഫംഗ്ഷൻ ഒരു ലിസ്റ്റ് പൂർണ്ണസംഖ്യകൾക്കായി ഒരു ബ്ലോക്ക് അനുവദിക്കുന്നു.


The putlist function allocates a linked block representation of a list.

putlist ഫംഗ്ഷൻ ഒരു ലിസ്റ്റിന്റെ ലിങ്ക്ഡ് ബ്ലോക്ക് പ്രാതിനിധ്യം അനുവദിക്കുന്നു.


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

അറേകൾക്ക് ശരിയാണെങ്കിലും, ഫീൽഡ് ആക്സസ് സ്ഥിരമായ സമയമെടുക്കുമെന്നാണ് ഈ അൽഗോരിതത്തിന്റെ പ്രവർത്തിക്കാനുള്ള സമയം.


Binary search is used to distinguish it from linear search.

ലീനിയർ സെർച്ചിന് നിന്നും വ്യത്യസ്തമാക്കാൻ ബൈനറി സെർച്ച് ഉപയോഗിക്കുന്നു.


Binary search usually returns an index where the element is found.

ബൈനറി സെർച്ച് സാധാരണയായി, തിരഞ്ഞെടുത്ത മൂലകം എവിടെയാണോ കാണുന്നത്, ആ സൂചിക നൽകുന്നു.


The worker function 'loop' is tail-recursive.

'ലൂപ്പ്' എന്ന വർക്കർ ഫംഗ്ഷൻ ടെയിൽ-റിcursive ആണ്.


The array segment is at least halved upon recursion.

പുനരാവർത്തനത്തിൽ, അറേയുടെ ഭാഗം കുറഞ്ഞത് പകുതിയായി കുറയുന്നു.


The state of the array remains unchanged.

അറേയുടെ അവസ്ഥ മാറ്റമില്ലാതെ തുടരുന്നു.


All elements to the left of 'l' are smaller than 'x'.

'l'-ന്റെ ഇടതുവശത്തുള്ള എല്ലാ മൂലകങ്ങളും 'x'-നേക്കാൾ ചെറുതാണ്.


Linear search doesn’t assume the array is sorted.

അറേ അടുക്കിയിട്ടുണ്ടെന്ന് ലീനിയർ സെർച്ച് അനുമാനിക്കുന്നില്ല.


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

ഒരു മൂല്യം ഒരു അറേയിൽ കാണുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്ന ഒരു ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുക.


The running time of lsearch should be O(n).

lsearch-ന്റെ പ്രവർത്തിക്കാനുള്ള സമയം O(n) ആയിരിക്കണം.


The algorithm reverses the elements of an array.

ഈ അൽഗോരിതം ഒരു അറേയിലെ ഘടകങ്ങളെ വിപരീതമാക്കുന്നു.


The algorithm is based on a function 'swap'.

ഈ അൽഗോരിതം 'swap' എന്ന ഫംഗ്ഷനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


The function 'reverse' satisfies two invariants.

'റിവേഴ്സ്' എന്ന ഫംഗ്ഷൻ രണ്ട് ഇൻവേരിയന്റുകളെ തൃപ്തിപ്പെടുത്തുന്നു.


The state of the array agrees with the initial state.

അറേയുടെ അവസ്ഥ, പ്രാരംഭ അവസ്ഥയുമായി യോജിക്കുന്നു.


The segments agree with the reversed initial state.

വിഭാഗങ്ങൾ വിപരീതമായ പ്രാരംഭ അവസ്ഥയുമായി യോജിക്കുന്നു.


A naive sorting algorithm for arrays is selection sort.

അറേകൾക്കായുള്ള ഒരു ലളിതമായ സോർട്ടിംഗ് അൽഗോരിതം ആണ് സെലക്ഷൻ സോർട്ട്.


The running time of selection sort is quadratic.

സെലക്ഷൻ സോർട്ടിന്റെ പ്രവർത്തിക്കാനുള്ള സമയം ക്വാഡ്രാറ്റിക് ആണ്.


A prominent sorting algorithm for arrays is quick sort.

അറേകൾക്കായുള്ള ഒരു പ്രധാനപ്പെട്ട സോർട്ടിംഗ് അൽഗോരിതമാണ് ക്വിക്ക് സോർട്ട്.


Quick sort partitions an array into two segments.

ക്വിക്ക് സോർട്ട് ഒരു അറേയെ രണ്ട് ഭാഗങ്ങളായി തിരിക്കുന്നു.


It is easy to verify that qsort terminates.

qsort അവസാനിക്കുമെന്ന് എളുപ്പത്തിൽ പരിശോധിക്കാൻ കഴിയും.