The derivation system was chosen for explanation.

వివరణ కోసం ఈ ఉత్పన్న వ్యవస్థను ఎంచుకున్నారు.


In practice, derivation systems describe computational relations.

ఆచరణలో, ఉత్పన్న వ్యవస్థలు గణన సంబంధాలను వివరిస్తాయి.


Typing and evaluation of expressions are examples of such relations.

ఎక్స్ప్రెషన్ల టైపింగ్ మరియు మూల్యాంకనం అలాంటి సంబంధాలకు ఉదాహరణలు.


5 < 9 కోసం అన్ని ఉత్పన్నాలను ఇవ్వండి.


Give two inference rules for judgments x < y.

x < y తీర్పుల కోసం రెండు ఇన్‌ఫరెన్స్ నియమాలను ఇవ్వండి.


The semantic layers see phrases as abstract syntactic objects.

అర్థవంతమైన పొరలు పదబంధాలను నైరూప్య సింటాక్టిక్ వస్తువులుగా చూస్తాయి.


Lexical details don’t play a role in 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 మరియు స్ట్రింగ్ రకాల విలువలు.


Variables are lexically represented as identifiers.

చరరాశులు పదపరంగా గుర్తింపుదారుల వలె సూచించబడతాయి.


Tuple patterns are replaced by projections.

ట్యూపుల్ నమూనాలను ప్రొజెక్షన్లతో భర్తీ చేస్తారు.


It is possible to translate concrete expressions.

నిర్దిష్ట వ్యక్తీకరణలను అనువదించడం సాధ్యమవుతుంది.


రివర్స్ అనువాదం చాలా సులభం.


The translation of projections poses a problem.

ప్రొజెక్షన్ల అనువాదం ఒక సమస్యను కలిగిస్తుంది.


We formulate the static semantics using typing judgments.

టైపింగ్ తీర్పులను ఉపయోగించి మేము స్టాటిక్ సెమాంటిక్స్ను రూపొందిస్తాము.


An environment is a finite collection of bindings.

ఒక వాతావరణం బంధనాల యొక్క పరిమిత సేకరణ.


The inference rules establish a derivation system.

ఇన్‌ఫరెన్స్ నియమాలు ఉత్పన్న వ్యవస్థను ఏర్పాటు చేస్తాయి.


If the judgment E ` e : t is derivable, we say that expression e has type t.

తీర్పు E ` e : t ఉత్పన్నమైతే, వ్యక్తీకరణ e రకం t అని మేము చెబుతాము.


The typing rules for constants and operators assume types are given in tables.

స్థిరాంకాలు మరియు ఆపరేటర్ల కోసం టైపింగ్ నియమాలు పట్టికలలో ఇవ్వబడిన రకాలను ఊహిస్తాయి.


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

ప్రోగ్రామ్ 'a' అనే గుర్తింపుని 8 అనే పూర్ణాంకానికి బంధిస్తుంది.


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

ఎగ్జిక్యూషన్ తర్వాత, ఇంటర్‌ప్రెటర్ అది లెక్కించిన విలువలను చూపుతుంది.


ప్రతి వ్యక్తీకరణకు ఒక రకం ఉంటుంది.


The values of the type int are integers.

int రకం యొక్క విలువలు పూర్ణాంకాలు.


We assume that incoming students are familiar with mathematical thinking.

వచ్చే విద్యార్థులకు గణిత ఆలోచనతో బాగా తెలుసునని మేము భావిస్తున్నాము.


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

కోర్సు అధ్యయన సమయం మూడో వంతు తీసుకోవడానికి రూపొందించబడింది.


Students perceive the course as challenging and exciting.

విద్యార్థులు కోర్సును సవాలుగా మరియు ఉత్తేజకరమైనదిగా భావిస్తారు.


We cover higher-order recursive functions, polymorphic typing, and constructor types.

మేము ఉన్నత-క్రమ పునరావృత విధులు, బహురూప టైపింగ్ మరియు కన్స్ట్రక్టర్ రకాలను కవర్ చేస్తాము.


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

సరిగ్గా ఉండటానికి సంబంధించిన ప్రకటనల పాత్రను మేము నొక్కి చెబుతాము మరియు ప్రేరేపిత సరైన రుజువులను అభ్యసిస్తాము.


We also cover asymptotic running time considering binary search, insertion sort, and merge sort.

బైనరీ శోధన, చొప్పించే క్రమం మరియు విలీన క్రమాన్ని పరిగణనలోకి తీసుకుని, అసింప్టోటిక్ రన్నింగ్ సమయాన్ని కూడా మేము కవర్ చేస్తాము.


We study the different layers of syntax and semantics.

మేము సింటాక్స్ మరియు సెమాంటిక్స్ యొక్క వివిధ పొరలను అధ్యయనం చేస్తాము.


Based on these formal descriptions, we program recursive descent parsers.

ఈ అధికారిక వివరణల ఆధారంగా, మేము పునరావృత అవరోహణ పార్సర్‌లను ప్రోగ్రామ్ చేస్తాము.


We also cover stateful programming with arrays and cells.

మేము శ్రేణులు మరియు కణాలతో స్టేట్‌ఫుల్ ప్రోగ్రామింగ్‌ను కూడా కవర్ చేస్తాము.


We explain how lists and trees can be stored as linked blocks in an array.

ఒక శ్రేణిలో జాబితాలు మరియు చెట్లను లింక్ చేయబడిన బ్లాక్‌లుగా ఎలా నిల్వ చేయవచ్చో మేము వివరిస్తాము.


This text teaches functional programming.

ఈ పాఠం ఫంక్షనల్ ప్రోగ్రామింగ్‌ను బోధిస్తుంది.


It is written for the Programming 1 course.

ఇది ప్రోగ్రామింగ్ 1 కోర్సు కోసం వ్రాయబడింది.


We do not assume programming experience.

ప్రోగ్రామింగ్ అనుభవం ఉందని మేము అనుకోము.


కోర్సు 15 వారాల బోధనను కలిగి ఉంది.


ప్రతి వారం రెండు ఉపన్యాసాలతో వస్తుంది.


డిసెంబర్‌లో అర్ధ సంవత్సరం పరీక్ష ఉంది.


Tail recursion can be executed more efficiently 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.


Counterexamples for tail recursive functions are pow and my_div.

తోక పునరావృత ఫంక్షన్లకు వ్యతిరేక ఉదాహరణలు pow మరియు my_div.


Tail recursive functions can be traced in a simple way.

తోక పునరావృత ఫంక్షన్లను సులభమైన మార్గంలో గుర్తించవచ్చు.


For functions where the recursion is not tail recursive, traces look more complicated.

పునరావృతం తోక పునరావృతం కాని ఫంక్షన్ల కోసం, జాడలు మరింత సంక్లిష్టంగా కనిపిస్తాయి.


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

ఆజ్ఞాపూర్వక ప్రోగ్రామింగ్ భాషలలో, తోక పునరావృత ఫంక్షన్లను లూప్‌లతో వ్యక్తీకరించవచ్చు.


Functional programming languages are designed such that tail recursive functions are preferable over loops.

ఫంక్షనల్ ప్రోగ్రామింగ్ భాషలు తోక పునరావృత ఫంక్షన్లు లూప్‌ల కంటే ఉత్తమంగా ఉండేలా రూపొందించబడ్డాయి.


Often recursive functions that are not tail recursive can be reformulated as tail recursive functions.

తరచుగా తోక పునరావృతం కాని పునరావృత ఫంక్షన్లను తోక పునరావృత ఫంక్షన్లుగా పునరుద్ధరించవచ్చు.


Here is a tail recursive version of pow.

ఇక్కడ pow యొక్క తోక పునరావృత వెర్షన్ ఉంది.


We explain the role of the accumulator argument with a trace.

మేము జాడతో అక్యుములేటర్ వాదన యొక్క పాత్రను వివరిస్తాము.


In mathematics, the factorial of a positive integer n, denoted by n!, is the product of all positive integers less than or equal to n.

గణితంలో, సానుకూల పూర్ణాంకం n యొక్క కారకం, n! ద్వారా సూచించబడుతుంది, ఇది n కంటే తక్కువ లేదా సమానమైన అన్ని సానుకూల పూర్ణాంకాల ఉత్పత్తి.


అదనంగా, 0! 1 గా నిర్వచించబడింది.


We capture this specification with a recursive function.

మేము ఈ నిర్దేశాన్ని పునరావృత ఫంక్షన్‌తో సంగ్రహిస్తాము.


Sometimes we want a function that returns more than one value.

కొన్నిసార్లు మేము ఒకటి కంటే ఎక్కువ విలువను అందించే ఫంక్షన్ కావాలి.


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

ఒక మారథాన్ సమయాన్ని h:m:s ఆకృతిలో మూడు సంఖ్యలతో ఇవ్వవచ్చు.


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

2018లో బెర్లిన్‌లో ఎలియుడ్ కిప్‌చోగే ప్రపంచ రికార్డు సమయం 2 : 01 : 39.


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

ఒక విలువగా విలువల సేకరణలను సూచించడానికి OCaml ట్యూపుల్స్‌ను కలిగి ఉంది.


We can now write two functions sec and hms translating between times.

మేము ఇప్పుడు సమయాల మధ్య అనువదించే రెండు ఫంక్షన్లు sec మరియు hms వ్రాయవచ్చు.


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.

టైపింగ్ నియమాల ద్వారా ఇవ్వబడిన టైప్ చెకింగ్ అల్గోరిథం లాంబ్డా వ్యక్తీకరణల యొక్క వాదన వేరియబుల్స్ యొక్క రకాలను ఊహించాలి.


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.

టైపింగ్ నియమాల ద్వారా ఇవ్వబడిన టైప్ చెకింగ్ అల్గోరిథం ఎల్లప్పుడూ ముగుస్తుంది.


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.

మూల్యాంకనం రకం సమాచారంపై ఆధారపడదని నొక్కి చెప్పడానికి ఒకరు స్టాటిక్ టైపింగ్ గురించి మాట్లాడుతారు.


In fact, evaluation is defined for all expressions, not just well-typed expressions.

వాస్తవానికి, మూల్యాంకనం బాగా టైప్ చేయబడిన వ్యక్తీకరణలకు మాత్రమే కాకుండా, అన్ని వ్యక్తీకరణల కోసం నిర్వచించబడింది.


Types give us an organizing principle for the language constructs.

రకాలు మనకు భాషా నిర్మాణాల కోసం ఒక వ్యవస్థీకృత సూత్రాన్ని అందిస్తాయి.


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.

ప్రోగ్రామింగ్ భాషలలో మెషిన్ పూర్ణాంకాల ఆధారంగా పెద్ద పూర్ణాంకాల అంతరాలను గుర్తించడానికి పద్ధతులు ఉన్నాయి.


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: `let pow8 x = square (square (square x))`

సులభం, మనం పూర్ణాంకం x ని మూడు సార్లు చతురస్రం చేస్తాము: `let pow8 x = square (square (square x))`


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

ఈ ప్రకటన మనకు `pow8:int→int` అనే ఫంక్షన్‌ను ఇస్తుంది.


Another possibility is the declaration `let pow8' x = let a = x * x in let b = a * a in b * b`

మరొక అవకాశం ఏమిటంటే `let pow8' x = let a = x * x in let b = a * a in b * b` అనే ప్రకటన.


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

`let` మరియు `in` కీలక పదాలను ఉపయోగించి, ప్రకటన `d` ని ఒక వ్యక్తీకరణ `e` తో కలిపి `let d in e` వ్యక్తీకరణలతో స్థానిక ప్రకటనలు పొందబడతాయి.


Note that the body of `pow'` nests two `let` expressions as `let d1 in (let d2 in e)`.

`pow'` యొక్క బాడీ రెండు `let` వ్యక్తీకరణలను `let d1 in (let d2 in e)` వలె ఎలా పొందుపరుస్తుందో గమనించండి.


OCaml lets you write redundant parentheses marking the nesting (if you want to).

మీరు కోరుకుంటే, నెస్టింగ్ ను గుర్తించే మిగులు బ్రాకెట్‌లను వ్రాయడానికి OCaml మిమ్మల్ని అనుమతిస్తుంది.


Let expressions must not be con- fused 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 (e.g., abs(−5) = 5).

`let abs x = if x < 0 then -x else x` అనే ప్రకటన ఒక పూర్ణాంకం యొక్క సంపూర్ణ విలువను తిరిగి ఇచ్చే `abs:int→int` అనే ఫంక్షన్‌ను ప్రకటిస్తుంది (ఉదాహరణకు, abs(−5) = 5).


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` అనే కీలక పదాలతో ఏర్పడిన షరతును ఉపయోగిస్తుంది.


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` అనే ఫంక్షన్‌ను ప్రకటించవచ్చు.


This time no return type specification is needed since `max` forces the correct type `max3:int→int→int→int`.

ఈసారి రిటర్న్ రకం స్పెసిఫికేషన్ అవసరం లేదు, ఎందుకంటే `max` సరైన రకం `max3:int→int→int→int`ని బలవంతం చేస్తుంది.


Next we declare a three-argument maximum function using a local declaration: `let max3 x y z :int = let a = if x <= y then y else x in if a <= z then z else a`

తరువాత మనం స్థానిక ప్రకటనను ఉపయోగించి మూడు వాదనల గరిష్ట ఫంక్షన్‌ను ప్రకటిస్తాము: `let max3 x y z :int = let a = if x <= y then y else x in if a <= z then z else a`


పిల్లి పరుపు మీద కూర్చుంది.


ఈ రోజు వాతావరణం చాలా ఆహ్లాదకరంగా ఉంది.


I am going to the market to buy vegetables.

నేను కూరగాయలు కొనడానికి మార్కెట్‌కి వెళ్తున్నాను.


దయచేసి తలుపు మూయండి.


మీ పేరు ఏమిటి?


The company announced a new product launch.

కంపెనీ కొత్త ఉత్పత్తిని ప్రారంభించినట్లు ప్రకటించింది.


The government is discussing new policies.

ప్రభుత్వం కొత్త విధానాలపై చర్చిస్తోంది.


The research team made a significant discovery.

పరిశోధనా బృందం ఒక ముఖ్యమైన ఆవిష్కరణ చేసింది.


The economy is showing signs of recovery.

ఆర్థిక వ్యవస్థ కోలుకుంటున్న సూచనలు కనిపిస్తున్నాయి.


వచ్చే వారం సమావేశం జరుగుతుంది.


The algorithm efficiently sorts the data.

అల్గారిథం డేటాను సమర్ధవంతంగా క్రమబద్ధీకరిస్తుంది.


The implications of the new technology are far-reaching.

కొత్త సాంకేతిక పరిజ్ఞానం యొక్క ప్రభావాలు చాలా దూరం వరకు ఉంటాయి.


The complex system requires careful analysis.

సంక్లిష్టమైన వ్యవస్థను జాగ్రత్తగా విశ్లేషించాలి.


The philosophical debate explored the nature of consciousness.

తత్వశాస్త్ర చర్చ స్పృహ యొక్క స్వభావాన్ని పరిశోధించింది.


The company's strategic plan involves global expansion.

కంపెనీ వ్యూహాత్మక ప్రణాళికలో ప్రపంచ విస్తరణ ఉంది.


దయచేసి మీరు మళ్ళీ చెప్పగలరా?


మీరు ఏమంటున్నారో నాకు అర్థం కాలేదు.


ప్రాజెక్ట్ షెడ్యూల్ ప్రకారం లేదు.


The data analysis revealed a significant trend.

డేటా విశ్లేషణ ఒక ముఖ్యమైన ధోరణిని వెల్లడించింది.


The impact of climate change is undeniable.

వాతావరణ మార్పుల ప్రభావం కాదనలేనిది.


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.

ప్రతి జాబితా నిర్మాణం కోసం శూన్య లేదా కన్స్ట్రక్టర్లను ఉపయోగించి పొందబడుతుంది.


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

మనం x1, ..., xn విలువలను జాబితాలోని మూలకాలు లేదా సభ్యులు అని పిలుస్తాము.


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 ని పరిష్కరిస్తుంది.


Another prominent list operation is concatenation.

మరొక ముఖ్యమైన జాబితా ఆపరేషన్ అనుసంధానం.


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 always terminates since lists are obtained from nil with finitely many applications of 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 (including m and n).

చివరగా, రెండు సంఖ్యల m మరియు n మధ్య ఉన్న అన్ని పూర్ణాంకాల జాబితాను అందించే ఫంక్షన్‌ను మనం నిర్వచిస్తాము (m మరియు nతో సహా).


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

జాబితా ఫంక్షన్ యొక్క గణిత నిర్వచనం ఇచ్చినట్లయితే, OCaml లో ఫంక్షన్‌ను ప్రకటించడం నేరుగా ఉంటుంది.


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

మ్యాచ్ ఎక్స్ప్రెషన్ ఖాళీ జాబితా మరియు శూన్యేతర జాబితాల కోసం ప్రత్యేక నియమాలను ఉపయోగించి జాబితాలపై కేస్ విశ్లేషణను గుర్తిస్తుంది.


OCaml provides predefined functions for lists as fields of a predefined standard module List.

OCaml జాబితాల కోసం ముందే నిర్వచించిన ఫంక్షన్లను ముందే నిర్వచించిన ప్రామాణిక మాడ్యూల్ జాబితా యొక్క ఫీల్డ్‌లుగా అందిస్తుంది.


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.

అయితే, టైప్ స్పెసిఫికేషన్ ఇవ్వకపోతే, OCaml insert మరియు isort కోసం బహురూప రకాలను పొందుతుంది.


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

ట్యూపుల్స్ మరియు జాబితాలపై పోలికలు ఎలా ప్రవర్తిస్తాయో మేము తరువాత వివరిస్తాము.


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

బూలియన్ విలువల కోసం, OCaml false < true క్రమాన్ని గుర్తిస్తుంది.


Declare a function sorted that tests whether a list is sorted.

జాబితా క్రమబద్ధీకరించబడిందో లేదో పరీక్షించే సార్టెడ్ అనే ఫంక్షన్‌ను ప్రకటించండి.


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

రెండు జాబితాలు తిరిగి అమర్చడం వరకు సమానంగా ఉన్నాయో లేదో పరీక్షించే perm అనే ఫంక్షన్‌ను ప్రకటించండి.


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

మూలకాలు అవరోహణ క్రమంలో కనిపించే విధంగా జాబితాను తిరిగి అమర్చే sortdesc అనే ఫంక్షన్‌ను ప్రకటించండి.


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

జాబితాను క్రమబద్ధీకరించే మరియు అన్ని నకిలీలను తీసివేసే dsort అనే ఫంక్షన్‌ను ప్రకటించండి.


The order in which this is done does not matter for the result.

దీనిని ఏ క్రమంలో చేసినా ఫలితానికి సంబంధం లేదు.


If we define isort as isort l := fold insert l [] we preserve the insertion order.

isort l := fold insert l []గా మనం isortని నిర్వచిస్తే, మనం చొప్పించే క్రమాన్ని కాపాడుకుంటాము.


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

(x, n) ∈ table l అయితే మరియు మాత్రమే x, lలో n > 0 సార్లు సంభవిస్తే table అనే ఫంక్షన్‌ను ప్రకటించండి.


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(≥) ఫంక్షన్ అవరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.


Declare a function reorder that reorders a list of pairs such that the first components of the pairs are ascending.

జోడీల జాబితాను తిరిగి అమర్చే reorder అనే ఫంక్షన్‌ను ప్రకటించండి, తద్వారా జంటల మొదటి భాగాలు ఆరోహణంగా ఉంటాయి.


మేము ఒక పద క్రమాన్ని గురించి మాట్లాడుతున్నాము.


The algorithm efficiently sorts the data.

అల్గారిథం డేటాను సమర్థవంతంగా క్రమబద్ధీకరిస్తుంది.


She enjoys reading novels in her free time.

ఆమె ఖాళీ సమయంలో నవలలు చదవడానికి ఇష్టపడుతుంది.


The company announced a new product launch.

కంపెనీ కొత్త ఉత్పత్తిని ప్రారంభించినట్లు ప్రకటించింది.


Could you please repeat that information?

దయచేసి ఆ సమాచారాన్ని మళ్ళీ చెప్పగలరా?


The research team is working on a groundbreaking discovery.

పరిశోధనా బృందం ఒక సంచలనాత్మక ఆవిష్కరణపై పనిచేస్తోంది.


Despite the challenges, they persevered and succeeded.

సవాళ్లు ఎదురైనా, వారు పట్టుదలతో ముందుకు సాగి విజయం సాధించారు.


The economic forecast predicts a period of growth.

ఆర్థిక సూచన వృద్ధి కాలాన్ని అంచనా వేస్తుంది.


He is a highly skilled software engineer.

అతను అత్యంత నైపుణ్యం కలిగిన సాఫ్ట్‌వేర్ ఇంజనీర్.


The museum houses a vast collection of artifacts.

మ్యూజియంలో అనేక కళాఖండాల భారీ సేకరణ ఉంది.


The government implemented new regulations.

ప్రభుత్వం కొత్త నిబంధనలను అమలు చేసింది.


The complex equation required advanced mathematical knowledge.

సంక్లిష్టమైన సమీకరణానికి అధునాతన గణిత పరిజ్ఞానం అవసరం.


She expressed her gratitude for their support.

వారి మద్దతుకు ఆమె కృతజ్ఞతలు తెలిపారు.


The project faced several unexpected setbacks.

ప్రాజెక్ట్ అనేక ఊహించని ఆటంకాలను ఎదుర్కొంది.


The company's profits increased significantly this quarter.

ఈ త్రైమాసికంలో కంపెనీ లాభాలు గణనీయంగా పెరిగాయి.


He is fluent in multiple foreign languages.

అతను బహుళ విదేశీ భాషలలో అనర్గళంగా మాట్లాడతాడు.


The scientific study provided compelling evidence.

శాస్త్రీయ అధ్యయనం బలమైన ఆధారాలను అందించింది.


The negotiations reached a successful conclusion.

చర్చలు విజయవంతంగా ముగిశాయి.


The intricate design showcased the artist's skill.

చిక్కుముడి నమూనా కళాకారుడి నైపుణ్యాన్ని ప్రదర్శించింది.


The team collaborated effectively to achieve their goals.

తమ లక్ష్యాలను సాధించడానికి బృందం సమర్థవంతంగా సహకరించింది.


The impact of climate change is becoming increasingly evident.

వాతావరణ మార్పుల ప్రభావం మరింత స్పష్టంగా కనిపిస్తోంది.


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

టైప్ చెకర్ ఇచ్చిన ఎక్స్ప్రెషన్తో సరిపోలుతుంది మరియు ప్రతి వేరియంట్ కోసం సంబంధిత టైపింగ్ నియమం యొక్క అల్గోరిథమిక్ రీడింగ్‌ను అనుసరిస్తుంది.


We are using helper functions for operator and function applications for better readability.

మంచి రీడబిలిటీ కోసం ఆపరేటర్ మరియు ఫంక్షన్ అప్లికేషన్ల కోసం మేము సహాయక ఫంక్షన్లను ఉపయోగిస్తున్నాము.


The evaluator matches on the given expression and for each variant follows the algorithmic reading of the respective evaluation rule.

ఎవల్యుయేటర్ ఇచ్చిన ఎక్స్ప్రెషన్తో సరిపోలుతుంది మరియు ప్రతి వేరియంట్ కోసం సంబంధిత మూల్యాంకన నియమం యొక్క అల్గోరిథమిక్ రీడింగ్‌ను అనుసరిస్తుంది.


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ని అనుసరించి, ఒక గుర్తింపుదారు చిన్న అక్షరంతో ప్రారంభం కావాలి, ఆపై అంకెలు, చిన్న మరియు పెద్ద అక్షరాలు మరియు ప్రత్యేక అక్షరాలు ‘_’ (అండర్‌లైన్) మరియు ‘'’ (కోట్)తో కొనసాగించవచ్చు.


Note the use of patterns with when conditions in the declaration of the parsing function lex.

లెక్సింగ్ ఫంక్షన్ లెక్స్ యొక్క ప్రకటనలో ఉన్నప్పుడు పరిస్థితులతో నమూనాల వినియోగాన్ని గమనించండి.


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

Mini-OCaml ఎక్స్ప్రెషన్ల కోసం పార్సింగ్ గ్రామర్‌కు 6 స్థాయిలు ఉన్నాయి: expif, fun, lettop స్థాయి cexp ≤ పోలికలు sexp +, - అదనపు ఆపరేటర్లు mexp · గుణకార ఆపరేటర్లు aexp ఫంక్షన్ అప్లికేషన్లు pexp దిగువ స్థాయి


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

అగ్రస్థాయి ఉపసర్గ పదబంధాలను చూసుకుంటుంది, ఇవి అగ్రస్థాయికి తిరిగి వస్తాయి.


We then have 4 infix levels taking care of operator applications and function applications.

ఆపరేటర్ అప్లికేషన్లు మరియు ఫంక్షన్ అప్లికేషన్లను చూసుకునే 4 ఇన్‌ఫిక్స్ స్థాయిలు మాకు ఉన్నాయి.


Function applications are at the lowest infix level and are realized with juxtaposition.

ఫంక్షన్ అప్లికేషన్లు అత్యల్ప ఇన్‌ఫిక్స్ స్థాయిలో ఉన్నాయి మరియు వాటిని పక్కన పెట్టడం ద్వారా గ్రహించబడతాయి.


Additive and multiplicative operators and function applications are realized with left-associativity, and comparisons are realized without associativity, deviating from OCaml.

అదనపు మరియు గుణకార ఆపరేటర్లు మరియు ఫంక్షన్ అప్లికేషన్లు ఎడమ-అసోసియేటివిటీతో గ్రహించబడతాయి మరియు పోలికలు అసోసియేటివిటీ లేకుండా గ్రహించబడతాయి, OCaml నుండి భిన్నంగా ఉంటాయి.


The bottom level takes care of variables, constants, and parenthesized expressions.

దిగువ స్థాయి వేరియబుల్స్, స్థిరమైనవి మరియు బ్రాకెట్‌లలో ఉన్న వ్యక్తీకరణలను చూసుకుంటుంది.


For the 3 levels realizing left-associativity the parsing grammar has auxiliary categories sexp ′ , mexp ′ , and aexp ′ .

ఎడమ-అసోసియేటివిటీని గ్రహించే 3 స్థాయిల కోసం పార్సింగ్ గ్రామర్‌కు సహాయక వర్గాలు sexp ′ , mexp ′ , మరియు aexp ′ ఉన్నాయి.


The parsing function for the top level is interesting in that it can make good use of pattern matching.

అగ్రస్థాయి కోసం పార్సింగ్ ఫంక్షన్ ఆసక్తికరంగా ఉంటుంది, ఎందుకంటే ఇది నమూనా సరిపోలికను బాగా ఉపయోగించుకుంటుంది.


We follow OCaml’s concrete syntax for typed lambda expressions in that we require parentheses around typed argument variables; for instance, the abstract lambda expression λx:int. x must be written as “fun(x:int)->x”.

టైప్ చేయబడిన లాంబ్డా వ్యక్తీకరణల కోసం మేము OCaml యొక్క కాంక్రీట్ సింటాక్స్‌ను అనుసరిస్తాము, ఎందుకంటే టైప్ చేయబడిన వాదన వేరియబుల్స్ చుట్టూ బ్రాకెట్‌లను మేము కోరుకుంటున్నాము; ఉదాహరణకు, అబ్‌స్ట్రాక్ట్ లాంబ్డా ఎక్స్ప్రెషన్ λx:int. xని “fun(x:int)->x”గా రాయాలి.


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 algorithm efficiently computes the greatest common divisor.

అల్గారిథం అత్యంత సాధారణ భాజకాన్ని సమర్థవంతంగా లెక్కిస్తుంది.


Function induction is a useful technique for proving properties of recursive functions.

పునరావృత విధుల లక్షణాలను నిరూపించడానికి ఫంక్షన్ ప్రేరణ ఒక ఉపయోగకరమైన పద్ధతి.


Euclid's algorithm is an elegant method for finding the greatest common divisor.

యూక్లిడ్స్ అల్గారిథం అత్యంత సాధారణ భాజకాన్ని కనుగొనడానికి ఒక సొగసైన పద్ధతి.


The modulo rule is applied repeatedly in Euclid's algorithm.

యూక్లిడ్స్ అల్గారిథమ్‌లో మాడ్యులో నియమం పదేపదే వర్తించబడుతుంది.


Complete induction allows us to assume proofs of all propositions.

పూర్తి ప్రేరణ అన్ని ప్రతిపాదనల యొక్క రుజువులను ఊహించడానికి అనుమతిస్తుంది.


అరేలు మార్పు చేయగల డేటా నిర్మాణాలు.


The array's length is fixed at allocation time.

అరే యొక్క పొడవు కేటాయింపు సమయంలో స్థిరంగా ఉంటుంది.


Array elements can be overwritten by an update operation.

అప్‌డేట్ ఆపరేషన్ ద్వారా అరే మూలకాలను తిరిగి వ్రాయవచ్చు.


OCaml provides arrays through the standard structure Array.

OCaml ప్రామాణిక నిర్మాణం Array ద్వారా అరేలను అందిస్తుంది.


The function Array.make allocates a fresh array.

Array.make ఫంక్షన్ ఒక కొత్త అరేను కేటాయిస్తుంది.


Array.get yields the ith element of an array.

Array.get ఒక అరే యొక్క iవ మూలకాన్ని ఇస్తుంది.


Array.set updates the ith element of an array.

Array.set ఒక అరే యొక్క iవ మూలకాన్ని అప్‌డేట్ చేస్తుంది.


Sequentializations execute e1 before e2.

అనుక్రమణలు e1ని e2కి ముందు అమలు చేస్తాయి.


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

ఒక అరే యొక్క స్థితిని జాబితాగా సూచించవచ్చు.


Conversion between arrays and lists is provided.

అరేలు మరియు జాబితాల మధ్య మార్పిడి అందించబడుతుంది.


Binary search has a logarithmic running time.

బైనరీ శోధనకు లాగరిథమిక్ రన్నింగ్ సమయం ఉంది.


The key difference between lists and arrays is mutability.

జాబితాలు మరియు అరేల మధ్య ముఖ్యమైన వ్యత్యాసం మార్పు చేయగల లక్షణం.


Invariants are essential for verifying the prime factorization algorithm.

ప్రధాన కారకాల అల్గారిథమ్‌ను ధృవీకరించడానికి స్థిరకాలు అవసరం.


The running time of pfac is quadratic in the running time of pfac'.

pfac యొక్క రన్నింగ్ సమయం pfac' యొక్క రన్నింగ్ సమయంలో చతురస్రాకారంగా ఉంటుంది.


We will now review the correctness arguments.

ఇప్పుడు మనం సరైన వాదనలను సమీక్షిస్తాము.


Binary search is an efficient algorithm.

బైనరీ శోధన ఒక సమర్థవంతమైన అల్గారిథం.


The algorithm's running time is logarithmic.

అల్గారిథం యొక్క రన్ సమయం లాగరిథమిక్.


Arrays are used to store data in a contiguous memory location.

అరేలు డేటాను నిరంతర మెమరీ స్థానంలో నిల్వ చేయడానికి ఉపయోగించబడతాయి.


Linear search has a linear running time.

లీనియర్ శోధనకు లీనియర్ రన్ సమయం ఉంటుంది.


The function bsearch searches for an element in a sorted array.

బైనరీ శోధన ఫంక్షన్ క్రమబద్ధీకరించబడిన శ్రేణిలో ఒక మూలకాన్ని శోధిస్తుంది.


The worker function loop is tail-recursive.

వర్కర్ ఫంక్షన్ లూప్ టెయిల్-రీకర్సివ్.


బైనరీ శోధన రెండు స్థిరాలను సంతృప్తిపరుస్తుంది.


శ్రేణి యొక్క స్థితి మారదు.


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 lsearch to check if a value occurs in an array.

ఒక విలువ శ్రేణిలో ఉందో లేదో తనిఖీ చేయడానికి lsearch అనే ఫంక్షన్‌ను ప్రకటించండి.


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

lsearch యొక్క రన్ సమయం O(n) ఉండాలి.


The algorithm reverses the elements of an array.

అల్గారిథం ఒక శ్రేణిలోని మూలకాలను రివర్స్ చేస్తుంది.


The swap function exchanges values at two positions.

స్వాప్ ఫంక్షన్ రెండు స్థానాల్లోని విలువలను మార్చుకుంటుంది.


The reverse function swaps values and continues.

రివర్స్ ఫంక్షన్ విలువలను మార్చుకుంటుంది మరియు కొనసాగుతుంది.


The state of the array agrees with the initial state.

శ్రేణి యొక్క స్థితి ప్రారంభ స్థితితో ఏకీభవిస్తుంది.


The segments agree with the reversed initial state.

విభాగాలు రివర్స్ చేయబడిన ప్రారంభ స్థితితో ఏకీభవిస్తాయి.


Selection sort is a naive sorting algorithm.

ఎంపిక క్రమం ఒక అమాయక క్రమబద్ధీకరణ అల్గారిథం.


The running time of selection sort is quadratic.

ఎంపిక క్రమం యొక్క రన్ సమయం చతురస్రాకారంగా ఉంటుంది.


Quick sort partitions an array into two segments.

క్విక్ క్రమం ఒక శ్రేణిని రెండు విభాగాలగా విభజిస్తుంది.


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

[10,11,12] జాబితాను మూడు బ్లాక్‌లతో లింక్‌ల ద్వారా నిల్వ చేయవచ్చు.


A heap is an array where mutable fixed-length sequences of machine integers called blocks are stored.

హీప్ అనేది ఒక శ్రేణి, ఇక్కడ బ్లాక్‌లు అని పిలువబడే మార్చగల స్థిర-పొడవు యంత్ర పూర్ణాంకాల సీక్వెన్స్‌లు నిల్వ చేయబడతాయి.


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

లింక్‌లు ఎల్లప్పుడూ బ్లాక్‌లకు సూచిస్తాయి మరియు బ్లాక్‌ల చిరునామాల ద్వారా సూచించబడతాయి.


The fields of a block are allocated consecutively in the heap array.

ఒక బ్లాక్ యొక్క ఫీల్డ్‌లు హీప్ శ్రేణిలో వరుసగా కేటాయించబడతాయి.


We might for instance choose the following addresses: 101112 -1 95 96 62 63 104 105

ఉదాహరణకు, మేము ఈ క్రింది చిరునామాలను ఎంచుకోవచ్చు: 101112 -1 95 96 62 63 104 105


It is also perfectly possible to represent circular lists like 1 2

1 2 వంటి వృత్తాకార జాబితాలను సూచించడం కూడా పూర్తిగా సాధ్యమే.


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.

అలొక్ ఫంక్షన్ హీప్‌లో ఇచ్చిన పొడవుతో కొత్త బ్లాక్‌ను కేటాయిస్తుంది మరియు బ్లాక్ యొక్క చిరునామాను అందిస్తుంది.


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, and the block is given by its address in the heap.

గెట్ ఫంక్షన్ ఒక బ్లాక్ యొక్క ఫీల్డ్‌లోని విలువను ఇస్తుంది, ఇక్కడ ఫీల్డ్ దాని ఇండెక్స్ ద్వారా బ్లాక్‌లో ఇవ్వబడుతుంది మరియు బ్లాక్ దాని చిరునామా ద్వారా హీప్‌లో ఇవ్వబడుతుంది.


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

సెట్ ఫంక్షన్ ఒక బ్లాక్ యొక్క ఫీల్డ్‌లోని విలువను భర్తీ చేస్తుంది.


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.

రిలీజ్ ఫంక్షన్ కేటాయించిన బ్లాక్ యొక్క చిరునామాను అందుకుంటుంది మరియు ఈ బ్లాక్‌ను మరియు ఈ బ్లాక్ తర్వాత కేటాయించిన అన్ని బ్లాక్‌లను డీఅలొకేట్ చేస్తుంది.


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.

సెట్, గెట్ మరియు రిలీజ్ ద్వారా కేటాయించిన చిరునామాలను మాత్రమే ఉపయోగించబడుతున్నాయని నిర్ధారించడానికి మేము సహాయక ఫంక్షన్ చెక్‌ని ఉపయోగిస్తాము.


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

ఒక బ్లాక్‌ను కేటాయించేటప్పుడు లేదా యాక్సెస్ చేసేటప్పుడు సంభవించిన చిరునామా లోపాన్ని చిరునామా మినహాయింపు సూచిస్తుంది.


Given the heap H, we declare a high-level allocation function alloc' : L(int) -> address allocating a block for a list of integers:

హీప్ H ఇచ్చినప్పుడు, మేము పూర్ణాంకాల జాబితా కోసం ఒక బ్లాక్‌ను కేటాయించే అధిక-స్థాయి కేటాయింపు ఫంక్షన్ alloc' : L(int) -> addressని ప్రకటిస్తాము:


It is now straightforward to declare a function putlist: L(int) -> address allocating a linked block representation of a given list in the heap:

ఇప్పుడు హీప్‌లో ఇచ్చిన జాబితా యొక్క లింక్డ్ బ్లాక్ ప్రాతినిధ్యాన్ని కేటాయించే ఫంక్షన్ పుట్‌లిస్ట్: L(int) -> addressని ప్రకటించడం నేరుగా ఉంది: