Computer programming has been, largely, an intuitive activity.

കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗ്, പ്രധാനമായും, ഒരു അവബോധപരമായ പ്രവർത്തനമാണ്.


Programmers are taught to understand programming in operational terms.

പ്രോഗ്രാമർമാരെ പ്രവർത്തനപരമായ രീതിയിൽ പ്രോഗ്രാമിംഗ് മനസ്സിലാക്കാൻ പഠിപ്പിക്കുന്നു.


അത്തരം സിദ്ധാന്തങ്ങൾ മാനസികമായ പ്രയത്നം കുറയ്ക്കുന്നു.


They are as indispensable for their domains as calculus is for solving scientific and engineering problems.

ശാസ്ത്ര-എഞ്ചിനിയറിംഗ് പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് കാൽക്കുലസ് എത്രത്തോളം അത്യാവശ്യമാണോ, അത്രത്തോളം തന്നെ ഈ മേഖലയിൽ ഇത് അനിവാര്യമാണ്.


I am attracted to effective theories primarily because they save labor.

പ്രധാനമായും, അദ്ധ്വാനം ലാഭിക്കുന്നതുകൊണ്ടാണ് ഞാൻ കാര്യക്ഷമമായ സിദ്ധാന്തങ്ങളിലേക്ക് ആകർഷിക്കപ്പെടുന്നത്.


The original inspiration to design a computer science course came from Elaine Rich and J Moore.

ഒരു കമ്പ്യൂട്ടർ സയൻസ് കോഴ്സ് രൂപകൽപ്പന ചെയ്യാനുള്ള പ്രചോദനം എലൈൻ റിച്ചിൽ നിന്നും ജെ മൂറിൽ നിന്നുമാണ് ലഭിച്ചത്.


I prepared a set of notes and taught the course in the Spring and Fall of 2003.

2003-ലെ സ്പ്രിംഗ്, ശരത്കാല സെമസ്റ്ററുകളിൽ ഞാൻ ഒരു കൂട്ടം നോട്ടുകൾ തയ്യാറാക്കുകയും കോഴ്സ് പഠിപ്പിക്കുകയും ചെയ്തു.


The choice of topics and the style of presentation are my own.

വിഷയങ്ങളുടെ തിരഞ്ഞെടുപ്പും അവതരണ ശൈലിയും എന്റേതു മാത്രമാണ്.


I have made no effort to be comprehensive.

വിപുലമായ രീതിയിൽ ആക്കാൻ ഞാൻ ശ്രമിച്ചിട്ടില്ല.


Greg Plaxton has used my original notes and made extensive revisions.

ഗ്രെഗ് പ്ലാക്സ്റ്റൺ എന്റെ യഥാർത്ഥ നോട്ടുകൾ ഉപയോഗിക്കുകയും, അതിൽ വലിയ മാറ്റങ്ങൾ വരുത്തുകയും ചെയ്തു.


I am also grateful to the graduate teaching assistants.

ബിരുദാനന്തര ബിരുദ വിദ്യാർത്ഥികൾക്കും, അദ്ധ്യാപകർക്കും ഞാൻ നന്ദി പറയുന്നു.


This chapter introduces the concept of text compression.

ഈ അധ്യായത്തിൽ ടെക്സ്റ്റ് കംപ്രഷൻ എന്ന ആശയം അവതരിപ്പിക്കുന്നു.


ഹഫ്‌മാൻ കോഡിംഗ് നമ്മൾ ഇവിടെ പഠിക്കും.


Error detection and correction are crucial in data transmission.

ഡാറ്റാ കൈമാറ്റത്തിൽ പിശക് കണ്ടെത്തലും തിരുത്തലും വളരെ പ്രധാനമാണ്.


The properties of Exclusive-Or are important.

എക്സ്ക്ലൂസീവ്-ഓറിൻ്റെ(Exclusive-Or) ഗുണങ്ങൾ പ്രധാനമാണ്.


സുരക്ഷിതമായ ആശയവിനിമയത്തെക്കുറിച്ച് നമ്മൾ ചർച്ച ചെയ്യും.


രഹസ്യവാക്യവിദ്യ (Cryptography) ഒരു ആകർഷകമായ മേഖലയാണ്.


We will look at early encryption schemes.

ആദ്യകാല എൻക്രിപ്ഷൻ സ്കീമുകളെക്കുറിച്ച് നമുക്ക് നോക്കാം.


Public key cryptography revolutionized the field.

പബ്ലിക് കീ ക്രിപ്റ്റോഗ്രാഫി ഈ മേഖലയിൽ വിപ്ലവം സൃഷ്ടിച്ചു.


Finite state machines are a fundamental concept.

പരിമിതമായ അവസ്ഥയിലുള്ള മെഷീനുകൾ ഒരു അടിസ്ഥാന ആശയമാണ്.


The receiver computes ˆ P ′ . IfP=P ′ , he gets ˆ P ′ = ˆ P= 0.

സ്വീകർത്താവ് ˆ P ′ കണക്കാക്കുന്നു. P=P ′ ആണെങ്കിൽ, അയാൾക്ക് ˆ P ′ = ˆ P= 0 ലഭിക്കും.


IfP ′ =P∪{t}, he gets ˆ P ′ = ˆ P⊕{t}= 0⊕{t}=t.

P ′ =P∪{t} ആണെങ്കിൽ, അയാൾക്ക് ˆ P ′ = ˆ P⊕{t}= 0⊕{t}=t ലഭിക്കും.


IfP=P ′ ∪{t}, he gets ˆ P= ˆ P ′ ⊕{t}, or ˆ P ′ = ˆ P⊕{t}= 0⊕{t}=t.

P=P ′ ∪{t} ആണെങ്കിൽ, അയാൾക്ക് ˆ P= ˆ P ′ ⊕{t}, അല്ലെങ്കിൽ ˆ P ′ = ˆ P⊕{t}= 0⊕{t}=t ലഭിക്കും.


Thus, in both cases where the bit atthas been flipped, ˆ P ′ =t.

അതുകൊണ്ട്, ബിറ്റ് മാറിയ രണ്ട് സാഹചര്യങ്ങളിലും, ˆ P ′ =t.


If t6= 0, the receiver can distinguish error-free transmission from erroneous transmission and correct the error in the latter case.

t6= 0 ആണെങ്കിൽ, സ്വീകർത്താവിന് തെറ്റില്ലാത്ത പ്രക്ഷേപണത്തെയും തെറ്റായ പ്രക്ഷേപണത്തെയും വേർതിരിക്കാനും രണ്ടാമത്തേതിൽ പിശക് തിരുത്താനും കഴിയും.


Therefore, the positions in the transmitted string are numbered starting at 1.

അതുകൊണ്ട്, പ്രക്ഷേപണം ചെയ്ത സ്ട്രിംഗിലെ സ്ഥാനങ്ങൾ 1 ൽ ആരംഭിച്ച് നമ്പറിംഗ് ചെയ്യുന്നു.


ഓരോ സ്ഥാനവും ഒരു n-ബിറ്റ് വാക്കാണ്.


കൂടാതെ, ഞങ്ങൾ n ചെക്ക് ബിറ്റുകൾ ഉപയോഗിക്കും.


Check bits are put at every position that is a power of 2 and the remaining bits are data bits.

2-ന്റെ ശക്തിയായ എല്ലാ സ്ഥാനത്തും ചെക്ക് ബിറ്റുകൾ സ്ഥാപിച്ചിരിക്കുന്നു, ബാക്കിയുള്ള ബിറ്റുകൾ ഡാറ്റാ ബിറ്റുകളാണ്.


In the example given earlier, check bits are put at positions 1, 2, 4 and 8, and the remaining nine bits are data bits.

മുമ്പത്തെ ഉദാഹരണത്തിൽ, 1, 2, 4, 8 എന്നീ സ്ഥാനങ്ങളിൽ ചെക്ക് ബിറ്റുകൾ സ്ഥാപിച്ചിരിക്കുന്നു, ബാക്കിയുള്ള ഒമ്പത് ബിറ്റുകൾ ഡാറ്റാ ബിറ്റുകളാണ്.


So the position of any check bit as a word has a single 1 in it.

അതിനാൽ ഏതെങ്കിലും ചെക്ക് ബിറ്റിന്റെ സ്ഥാനത്തിന് ഒരു വാക്കായി അതിൽ ഒരു 1 ഉണ്ട്.


Further, no two check bit position numbers have 1s in the same place.

കൂടാതെ, രണ്ട് ചെക്ക് ബിറ്റ് സ്ഥാന നമ്പറുകൾക്കും ഒരേ സ്ഥലത്ത് 1-കൾ ഉണ്ടാകില്ല.


LetCbe the set of positions where the check bits are 1s andDthe positions where the data bits are 1s.

ചെക്ക് ബിറ്റുകൾ 1-കൾ ആകുന്ന സ്ഥാനങ്ങളുടെ കൂട്ടമാണ് C, കൂടാതെ ഡാറ്റാ ബിറ്റുകൾ 1-കൾ ആകുന്ന സ്ഥാനങ്ങളാണ് D.


We knowD, but we don’t knowCyet, because check bits have not been assigned values.

നമുക്ക് D അറിയാം, എന്നാൽ C ഇതുവരെ അറിയില്ല, കാരണം ചെക്ക് ബിറ്റുകൾക്ക് ഇതുവരെ മൂല്യങ്ങൾ നൽകിയിട്ടില്ല.


We show next thatCis uniquely determined from rule HC.

HC നിയമത്തിൽ നിന്ന് C എങ്ങനെയാണ് നിർണ്ണയിക്കപ്പെടുന്നതെന്ന് നമുക്ക് നോക്കാം.


HC നിയമം അനുസരിച്ച്, ˆ C⊕ ˆ D= 0.


അതുകൊണ്ട്, ˆ C= ˆ D.


നമുക്ക് D അറിയുന്നതുകൊണ്ട്, ˆ D കണക്കാക്കാൻ കഴിയും.


For the example considered earlier, ˆ D= 1101.

മുമ്പത്തെ ഉദാഹരണത്തിൽ, ˆ D= 1101.


Therefore, we have to set the check bits so that ˆ C= 1101.

അതുകൊണ്ട്, ˆ C= 1101 ആകുന്ന രീതിയിൽ നമ്മൾ ചെക്ക് ബിറ്റുകൾ ക്രമീകരിക്കണം.


Data compression is useful and necessary in a variety of applications.

വിവിധ ആപ്ലിക്കേഷനുകളിൽ ഡാറ്റ കംപ്രഷൻ ഉപകാരപ്രദവും അത്യാവശ്യവുമാണ്.


These applications can be broadly divided into two groups: transmission and storage.

ഈ ആപ്ലിക്കേഷനുകളെ പ്രധാനമായും രണ്ട് ഗ്രൂപ്പുകളായി തിരിക്കാം: ട്രാൻസ്മിഷനും സംഭരണവും.


Compression reduces the number of bits to be transmitted, thus making the transmission process more efficient.

കംപ്രഷൻ കൈമാറ്റം ചെയ്യേണ്ട ബിറ്റുകളുടെ എണ്ണം കുറയ്ക്കുന്നു, അതുവഴി പ്രക്ഷേപണ പ്രക്രിയ കൂടുതൽ കാര്യക്ഷമമാക്കുന്നു.


Storing a file in a compressed form typically requires fewer bits, thus utilizing storage resources more efficiently.

കംപ്രസ് ചെയ്ത രൂപത്തിൽ ഒരു ഫയൽ സംഭരിക്കുന്നത് സാധാരണയായി കുറഞ്ഞ ബിറ്റുകൾ ആവശ്യമാണ്, അതുവഴി സംഭരണ വിഭവങ്ങൾ കൂടുതൽ കാര്യക്ഷമമായി ഉപയോഗിക്കുന്നു.


Data compression can be applied to any kind of data: text, image, audio and video.

ഡാറ്റ കംപ്രഷൻ ഏത് തരത്തിലുള്ള ഡാറ്റയിലും പ്രയോഗിക്കാൻ കഴിയും: ടെക്സ്റ്റ്, ചിത്രം, ഓഡിയോ, വീഡിയോ.


A 1-second video without compression takes around 20 megabytes.

കംപ്രഷൻ ഇല്ലാത്ത ഒരു സെക്കൻഡ് വീഡിയോ ഏകദേശം 20 മെഗാബൈറ്റ് എടുക്കും.


Impressive gains can be made by compressing video, for instance, because successive frames are very similar to each other.

വീഡിയോ കംപ്രസ് ചെയ്യുന്നതിലൂടെ ശ്രദ്ധേയമായ നേട്ടങ്ങൾ ഉണ്ടാക്കാം, ഉദാഹരണത്തിന്, തുടർച്ചയായ ഫ്രെയിമുകൾ പരസ്പരം വളരെ സാമ്യമുള്ളവയാണ്.


In fact, real-time video transmission would be impossible without considerable compression.

വാസ്തവത്തിൽ, കാര്യമായ കംപ്രഷൻ ഇല്ലാതെ തത്സമയ വീഡിയോ പ്രക്ഷേപണം അസാധ്യമാകും.


There are several new applications that generate data at prodigious rates.

അമിതമായ നിരക്കിൽ ഡാറ്റ ഉണ്ടാക്കുന്ന നിരവധി പുതിയ ആപ്ലിക്കേഷനുകൾ ഉണ്ട്.


Certain earth orbiting satellites create around half a terabyte of data per day.

ചില ഭൗമ ഭ്രമണപഥത്തിലുള്ള ഉപഗ്രഹങ്ങൾ ഒരു ദിവസം ഏകദേശം അര ടെറാബൈറ്റ് ഡാറ്റ ഉണ്ടാക്കുന്നു.


Without compression there is no hope of storing such large files.

കംപ്രഷൻ ഇല്ലാതെ, അത്രയും വലിയ ഫയലുകൾ സംഭരിക്കാൻ കഴിയില്ല.


നഷ്ടപ്പെടുന്നതും നഷ്ടമില്ലാത്തതുമായ കംപ്രഷൻ


Most data types, except text, are compressed in such a way that a very good approximation can be recovered.

ടെക്സ്റ്റ് ഒഴികെയുള്ള മിക്ക ഡാറ്റാ തരങ്ങളും കംപ്രസ് ചെയ്യുന്നത് വളരെ നല്ല ഏകദേശരൂപം വീണ്ടെടുക്കാൻ കഴിയുന്ന രീതിയിലാണ്.


Text transmissions are required to be lossless.

ടെക്സ്റ്റ് ട്രാൻസ്മിഷനുകൾ നഷ്ടമില്ലാത്തതായിരിക്കണം.


It will be a disaster to change even a single symbol in a text file.

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


In this note, we study several lossless compression schemes for text files.

ഈ കുറിപ്പിൽ, ടെക്സ്റ്റ് ഫയലുകൾക്കായി നിരവധി നഷ്ടമില്ലാത്ത കംപ്രഷൻ സ്കീമുകൾ ഞങ്ങൾ പഠിക്കുന്നു.


Henceforth, we use the terms string and text file synonymously.

ഇനിമുതൽ, സ്ട്രിംഗ്, ടെക്സ്റ്റ് ഫയൽ എന്നീ പദങ്ങൾ പര്യായപദങ്ങളായി ഉപയോഗിക്കുന്നു.


Error detection and correction can be applied to uncompressed as well as compressed strings.

കംപ്രസ് ചെയ്യാത്തതും കംപ്രസ് ചെയ്തതുമായ സ്ട്രിംഗുകളിൽ പിശക് കണ്ടെത്തലും തിരുത്തലും പ്രയോഗിക്കാൻ കഴിയും.


What is the typical level of compression?

എന്താണ് സാധാരണ കംപ്രഷൻ നില?


The amount by which a text string can be compressed depends on the string itself.

ഒരു ടെക്സ്റ്റ് സ്ട്രിംഗിനെ കംപ്രസ് ചെയ്യാൻ കഴിയുന്ന അളവ് സ്ട്രിംഗിനെ ആശ്രയിച്ചിരിക്കുന്നു.


The sender scans the text from left to right identifying certain strings.

അയക്കുന്നയാൾ വാചകം ഇടത്തുനിന്ന് വലത്തോട്ട് സ്കാൻ ചെയ്ത് ചില സ്ട്രിംഗുകളെ തിരിച്ചറിയുന്നു.


Lempel-Ziv coding does not require the frequencies to be known a priori.

Lempel-Ziv കോഡിംഗിന് ആവൃത്തി മുൻകൂട്ടി അറിയേണ്ടതില്ല.


The sender adds this word to the dictionary, and assigns it the next higher index.

അയക്കുന്നയാൾ ഈ വാക്ക് നിഘണ്ടുവിൽ ചേർക്കുകയും അടുത്ത ഉയർന്ന സൂചിക നൽകുകയും ചെയ്യുന്നു.


The receiver recreates the string by looking up the word with index 3.

സ്വീകർത്താവ് സൂചിക 3 ഉപയോഗിച്ച് വാക്ക് തിരയുന്നതിലൂടെ സ്ട്രിംഗ് പുനഃസൃഷ്ടിക്കുന്നു.


Initially, the dictionary has a single word, the empty string, as its only entry.

തുടക്കത്തിൽ, നിഘണ്ടുവിൽ ഒരൊറ്റ വാക്ക് മാത്രമേയുള്ളൂ, ശൂന്യമായ സ്ട്രിംഗ്, അതിന്റെ ഏക എൻട്രിയായി.


To ensure that the sender can always find a word which is not in the dictionary, assume that the end of the file, written as #, occurs nowhere else in the string.

അയക്കുന്നയാൾക്ക് എപ്പോഴും നിഘണ്ടുവിൽ ഇല്ലാത്ത ഒരു വാക്ക് കണ്ടെത്താൻ കഴിയുമെന്ന് ഉറപ്പാക്കാൻ, ഫയലിന്റെ അവസാനം, # ആയി എഴുതിയത്, സ്ട്രിംഗിൽ മറ്റൊരിടത്തും സംഭവിക്കില്ലെന്ന് കരുതുക.


In the small example shown above, there is hardly any compression.

മുകളിൽ കാണിച്ചിരിക്കുന്ന ചെറിയ ഉദാഹരണത്തിൽ, കംപ്രഷൻ വളരെ കുറവാണ്.


But for longer files with much redundancy, this scheme achieves excellent results.

എന്നാൽ വളരെ അധികം ആവർത്തനങ്ങളുള്ള വലിയ ഫയലുകൾക്ക്, ഈ സ്കീം മികച്ച ഫലങ്ങൾ നൽകുന്നു.


Lempel-Ziv coding is asymptotically optimal.

Lempel-Ziv കോഡിംഗ് അസിംപ്റ്റോറ്റിക്കായി ഒപ്റ്റിമൽ ആണ്.


In practice, the dictionary is limited to a fixed size, like 4096.

പ്രായോഗികമായി, നിഘണ്ടു 4096 പോലുള്ള ഒരു നിശ്ചിത വലുപ്പത്തിലേക്ക് പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.


Beyond that point, the transmissions continue in the same manner, but the dictionary is not updated.

അതിനുശേഷം, ട്രാൻസ്മിഷനുകൾ അതേ രീതിയിൽ തുടരുന്നു, എന്നാൽ നിഘണ്ടു അപ്‌ഡേറ്റ് ചെയ്യുന്നില്ല.


Also, in practical implementations, the dictionary is initially populated by all the symbols of the alphabet.

കൂടാതെ, പ്രായോഗികമായ നടപ്പാക്കലുകളിൽ, നിഘണ്ടു ആരംഭത്തിൽ അക്ഷരമാലയിലെ എല്ലാ ചിഹ്നങ്ങളും ഉപയോഗിച്ച് ജനകീയമാക്കുന്നു.


The receiver merely maintains an array D, where D(i) is the string of index i in the tree.

സ്വീകർത്താവ് ഒരു അറേ D നിലനിർത്തുന്നു, അവിടെ D(i) എന്നത് ട്രീയിലെ സൂചിക i-യുടെ സ്ട്രിംഗാണ്.


The tree shown in Figure 1.6 results from the string taccagtaccagtaccacta#.

ചിത്രം 1.6-ൽ കാണിച്ചിരിക്കുന്ന ട്രീ taccagtaccagtaccacta# എന്ന സ്ട്രിംഗിൽ നിന്നുള്ളതാണ്.


Is it necessary to maintain the word at each node?

ഓരോ നോഡിലും വാക്ക് നിലനിർത്തേണ്ടത് ആവശ്യമാണോ?


Devise an efficient implementation of the tree in this case.

ഈ സാഹചര്യത്തിൽ ട്രീയുടെ കാര്യക്ഷമമായ ഒരു നടപ്പാക്കൽ രൂപകൽപ്പന ചെയ്യുക.


What is the condition on x and u so that (x ⊕ u) < x?

(x ⊕ u) < x ആകുന്നതിന് x, u എന്നിവയിലുള്ള വ്യവസ്ഥയെന്താണ്?


The following description captures the essence of error correction and detection.

പിശക് തിരുത്തുന്നതിൻ്റെയും കണ്ടെത്തലിൻ്റെയും സത്ത ഈ വിവരണം ഉൾക്കൊള്ളുന്നു.


These contain internal tricks that allow the receiver to determine whether what has been received is accurate.

സ്വീകർത്താവിന് ലഭിച്ചത് കൃത്യമാണോ എന്ന് നിർണ്ണയിക്കാൻ സഹായിക്കുന്ന ആന്തരിക തന്ത്രങ്ങൾ ഇവയിൽ അടങ്ങിയിരിക്കുന്നു.


First, we study the logical operator exclusive-or, which plays a central role in error detection and correction.

ആദ്യം, പിശക് കണ്ടെത്തലിനും തിരുത്തുന്നതിനും ഒരു പ്രധാന പങ്ക് വഹിക്കുന്ന എക്സ്ക്ലൂസീവ്-ഓർ എന്ന ലോജിക്കൽ ഓപ്പറേറ്ററെക്കുറിച്ച് പഠിക്കാം.


The final state, where all piles are empty, is a losing state.

എല്ലാ കൂനകളും ശൂന്യമായ അവസാന അവസ്ഥ ഒരു തോൽക്കുന്ന അവസ്ഥയാണ്.


A player in a losing state will definitely lose provided his opponent makes the right moves.

തോൽക്കുന്ന അവസ്ഥയിലുള്ള ഒരു കളിക്കാരൻ തീർച്ചയായും തോൽക്കും, എതിരാളി ശരിയായ നീക്കങ്ങൾ നടത്തിയാൽ.


So, one of the players has a winning strategy based on the initial state.

അതിനാൽ, കളിക്കാരിലൊരാൾക്ക് പ്രാരംഭ അവസ്ഥയെ ആശ്രയിച്ച് ഒരു വിജയകരമായ തന്ത്രമുണ്ട്.


The proof of this result is based on the following state diagram.

ഈ ഫലത്തിന്റെ തെളിവ്, താഴെ പറയുന്ന അവസ്ഥാ ചിത്രത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


We show that any possible move in a losing state can only lead to a winning state.

തോൽക്കുന്ന അവസ്ഥയിലെ ഏതൊരു നീക്കവും ഒരു വിജയകരമായ അവസ്ഥയിലേക്ക് മാത്രമേ നയിക്കൂ എന്ന് ഞങ്ങൾ കാണിക്കുന്നു.


A player in a winning state has at least one move to transform the state to losing.

വിജയിക്കുന്ന അവസ്ഥയിലുള്ള ഒരു കളിക്കാരന്, അവസ്ഥയെ തോൽക്കുന്ന ഒന്നാക്കി മാറ്റാൻ കുറഞ്ഞത് ഒരു നീക്കമെങ്കിലും ഉണ്ട്.


Let the exclusive-or of the remaining piles be s.

ബാക്കിയുള്ള കൂനകളുടെ എക്സ്ക്ലൂസീവ്-ഓർ s ആവട്ടെ.


Before the move, exclusive-or of all piles was s ⊕ p.

നീക്കുന്നതിന് മുമ്പ്, എല്ലാ കൂനകളുടെയും എക്സ്ക്ലൂസീവ്-ഓർ s ⊕ p ആയിരുന്നു.


നീക്കിയതിന് ശേഷം അത് s ⊕ q ആണ്.


First, we show that in a losing state, i.e., s ⊕ p = 0, all possible moves establish a winning state, i.e., s ⊕ q ≠ 0.

ആദ്യം, തോൽക്കുന്ന അവസ്ഥയിൽ, അതായത്, s ⊕ p = 0, സാധ്യമായ എല്ലാ നീക്കങ്ങളും ഒരു വിജയകരമായ അവസ്ഥ സ്ഥാപിക്കുന്നു എന്ന് ഞങ്ങൾ കാണിക്കുന്നു, അതായത്, s ⊕ q ≠ 0.


Now, we show that there is a move in the winning state to take it to losing state.

ഇനി, വിജയകരമായ അവസ്ഥയിൽ നിന്ന് തോൽക്കുന്ന അവസ്ഥയിലേക്ക് മാറ്റാനുള്ള ഒരു നീക്കം ഉണ്ടെന്ന് ഞങ്ങൾ കാണിക്കുന്നു.


Let the exclusive-or of all piles be u, u ≠ 0.

എല്ലാ കൂനകളുടെയും എക്സ്ക്ലൂസീവ്-ഓർ u ആവട്ടെ, u ≠ 0.


Let x be any pile that has a 1 in the same position as the leading 1 bit of u (show that x exists).

u-ന്റെ പ്രധാന 1 ബിറ്റിന്റെ അതേ സ്ഥാനത്ത് 1 ഉള്ള ഏതെങ്കിലും കൂന x ആവട്ടെ (x നിലവിലുണ്ടെന്ന് കാണിക്കുക).


The winning move is to replace x by x ⊕ u.

വിജയകരമായ നീക്കം x-നെ x ⊕ u ഉപയോഗിച്ച് മാറ്റുക എന്നതാണ്.


We show that (1) x ⊕ u < x, and (2) the exclusive-or of the resulting set of piles is 0, i.e., the state after the move is a losing state.

ഞങ്ങൾ കാണിക്കുന്നത് (1) x ⊕ u < x, കൂടാതെ (2) ഫലമായുണ്ടാകുന്ന കൂനകളുടെ എക്സ്ക്ലൂസീവ്-ഓർ 0 ആണ്, അതായത്, നീക്കത്തിന് ശേഷമുള്ള അവസ്ഥ ഒരു തോൽക്കുന്ന അവസ്ഥയാണ്.


The problem in secure communication is for a sender to send a message to a receiver so that no eavesdropper can read the message during transmission.

സുരക്ഷിതമായ ആശയവിനിമയത്തിലെ പ്രശ്നം, ഒരു അയക്കുന്നയാൾക്ക് ഒരു സന്ദേശം സ്വീകരിക്കുന്നയാൾക്ക് അയയ്ക്കുക എന്നതാണ്, അതുവഴി ഒരു ഒളിഞ്ഞുനോട്ടക്കാരനും പ്രക്ഷേപണ സമയത്ത് സന്ദേശം വായിക്കാൻ കഴിയില്ല.


In most cases, the sender and the receiver agree on a transmission protocol.

മിക്ക കേസുകളിലും, അയക്കുന്നയാളും സ്വീകരിക്കുന്നയാളും ഒരു പ്രക്ഷേപണ പ്രോട്ടോക്കോളിനോട് യോജിക്കുന്നു.


The sender encrypts the message in such a fashion that only the receiver can decrypt it.

സ്വീകരിക്കുന്നയാൾക്ക് മാത്രമേ ഡീക്രിപ്റ്റ് ചെയ്യാൻ കഴിയൂ എന്ന രീതിയിലാണ് അയക്കുന്നയാൾ സന്ദേശം എൻക്രിപ്റ്റ് ചെയ്യുന്നത്.


The sender first converts the message to be sent to a bit string, by replacing each symbol of the alphabet by its ascii representation, for instance.

അയയ്‌ക്കേണ്ട സന്ദേശം ആദ്യം ഒരു ബിറ്റ് സ്ട്രിംഗിലേക്ക് മാറ്റുന്നു, ഉദാഹരണത്തിന്, അക്ഷരമാലയിലെ ഓരോ ചിഹ്നത്തെയും അതിന്റെ ascii പ്രാതിനിധ്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.


For encryption, the sender and the receiver agree on a key k, which is a bit string of the same length as the block.

എൻക്രിപ്ഷനായി, അയക്കുന്നയാളും സ്വീകരിക്കുന്നയാളും k എന്ന ഒരു കീയിൽ സമ്മതിക്കുന്നു, ഇത് ബ്ലോക്കിന്റെ അതേ നീളമുള്ള ഒരു ബിറ്റ് സ്ട്രിംഗാണ്.


Alice sends a public key to Bob which Bob uses to send her a secret.

ആലീസ് ഒരു പബ്ലിക് കീ ബോബിന് അയയ്ക്കുന്നു, അത് ഉപയോഗിച്ച് ബോബ് രഹസ്യ സന്ദേശം അയയ്ക്കുന്നു.


Using RSA, only Alice can decrypt it, and Bob already knows the secret.

RSA ഉപയോഗിച്ച്, ആലീസിന് മാത്രമേ ഇത് ഡീക്രിപ്റ്റ് ചെയ്യാൻ കഴിയൂ, ബോബിന് ഇതിനകം രഹസ്യം അറിയാം.


They can then employ the secret for further communications.

തുടർന്നുള്ള ആശയവിനിമയങ്ങൾക്കായി അവർക്ക് രഹസ്യം ഉപയോഗിക്കാം.


Alice and Bob publicly settle on two positive integers gand p.

ആലീസും ബോബും പരസ്യമായി രണ്ട് പോസിറ്റീവ് പൂർണ്ണസംഖ്യകളിൽ (g, p) എത്തുന്നു.


Here, p is a prime number; typically p is large.

ഇവിടെ, p ഒരു പ്രൈം സംഖ്യയാണ്; സാധാരണയായി p വലുതാണ്.


This means g k mod p != 1, for any k, k < p-1.

ഏതെങ്കിലും k-യ്‌ക്ക്, k < p-1 ആകുമ്പോൾ g k mod p != 1 എന്ന് ഇതിനർത്ഥം.


Alice and Bob privately choose integers a and b which are less than p.

ആലീസും ബോബും രഹസ്യമായി p-യെക്കാൾ കുറഞ്ഞ സംഖ്യകളായ a, b എന്നിവ തിരഞ്ഞെടുക്കുന്നു.


Alice sends g a mod p and Bob sends g b mod p.

ആലീസ് g a mod p അയക്കുന്നു, ബോബ് g b mod p അയക്കുന്നു.


Then Alice computes (g b mod p) a mod p.

അതിനുശേഷം ആലീസ് (g b mod p) a mod p കണക്കാക്കുന്നു.


Similarly, Bob computes (g a mod p) b mod p = g ab mod p.

അതുപോലെ, ബോബ് (g a mod p) b mod p = g ab mod p കണക്കാക്കുന്നു.


They both have g ab mod p, and they settle on that as the secret key.

അവർ ഇരുവരും g ab mod p-യിൽ എത്തുന്നു, അത് രഹസ്യ കീ ആയി ഉപയോഗിക്കുന്നു.


ഒരു ഉദാഹരണമായി, g = 3 എന്നും p = 17 എന്നും കരുതുക.


Verify that g is a 16th primitive root of 1.

g, 1-ന്റെ 16-ാമത്തെ പ്രിമിറ്റീവ് റൂട്ട് ആണെന്ന് പരിശോധിക്കുക.


Let Alice choose a = 5 and Bob choose b = 9.

ആലീസ് a = 5 എന്നും ബോബ് b = 9 എന്നും തിരഞ്ഞെടുക്കട്ടെ.


Then, Alice and Bob send to each other 3 5 mod 17 = 5 and 3 9 mod 17 = 14, respectively.

അതിനുശേഷം, ആലീസും ബോബും പരസ്പരം 3 5 mod 17 = 5, 3 9 mod 17 = 14 എന്നിങ്ങനെ അയക്കുന്നു.


Next, Alice computes 14 5 mod 17 and Bob computes 5 9 mod 17, both of which are 12.

അടുത്തതായി, ആലീസ് 14 5 mod 17 കണക്കാക്കുന്നു, ബോബ് 5 9 mod 17 കണക്കാക്കുന്നു, രണ്ടും 12 ആണ്.


Each of them now knows 12 as the secret key.

അവർ ഓരോരുത്തരും ഇപ്പോൾ 12 രഹസ്യ കീ ആയി അറിയുന്നു.


We have to choose a large prime number p and a positive integer g which is a (p-1)th root of 1.

നാം ഒരു വലിയ പ്രൈം സംഖ്യ p-യും, (p-1)th root of 1 ആകുന്ന ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യ g-യും തിരഞ്ഞെടുക്കണം.


From the description of the protocol, we don’t really need that g be a (p-1)th root of 1.

പ്രോട്ടോക്കോളിന്റെ വിവരണത്തിൽ നിന്ന്, g ഒരു (p-1)th root of 1 ആകേണ്ട ആവശ്യമില്ല.


All we need is that g k mod p != 1, for many values of k, k < p-1.

k-യുടെ പല വിലകൾക്കും g k mod p != 1 ആയിരിക്കണം, k < p-1.


Variables u, v, p, x and y are positive integers.

u, v, p, x, y എന്നീ চলങ്ങൾ ধনাত্মক পূর্ণ সংখ্যাകാണ്.


For all n, n ≥ 0, x mod p ≡ y x^n mod p ≡ y^n

എല്ലാ n-നും, n ≥ 0, x mod p ≡ y x^n mod p ≡ y^n


Let e be any expression over integers that has only addition, subtraction, multiplication and exponention as its operators.

കൂട്ടിച്ചേർക്കൽ, കുറയ്ക്കൽ, ഗുണനം, എക്സ്പോണൻഷൻ എന്നിവ മാത്രമുള്ള പൂർണ്ണസംഖ്യകളെക്കുറിച്ചുള്ള ഏതെങ്കിലും പദമാണ് e എന്ന് കരുതുക.


Note that an exponent is not a subexpression; so, it can’t be replaced by its mod.

ഒരു എക്സ്പോണന്റ് ഒരു ഉപ-പ്രകടനമല്ല എന്നത് ശ്രദ്ധിക്കുക; അതിനാൽ, അതിനെ അതിന്റെ മോഡ് ഉപയോഗിച്ച് മാറ്റാൻ കഴിയില്ല.


Relatively Prime Positive integers x and y are relatively prime iff gcd(x, y) = 1.

പരസ്പരം പ്രൈം സംഖ്യകളായ x, y എന്നിവ gcd(x, y) = 1 ആണെങ്കിൽ പരസ്പരം പ്രൈം ആണ്.


For p and q relatively prime, (u mod p ≡ v ∧ u mod q ≡ v) ≡ (u mod p × q ≡ v)

p, q എന്നിവ പരസ്പരം പ്രൈം ആണെങ്കിൽ, (u mod p ≡ v ∧ u mod q ≡ v) ≡ (u mod p × q ≡ v)


Disprove each of the following conclusions.

ഇനി പറയുന്ന ഓരോ നിഗമനങ്ങളും തെളിയിക്കുക.


p = 3, u, v = 2, 2, x, y = 4, 1 എന്നിവ ഉപയോഗിക്കുക.


b^(p−1) mod p = 1, where p is prime, and b and p are relatively prime.

b^(p−1) mod p = 1, ഇവിടെ p ഒരു പ്രൈം സംഖ്യയും, b, p എന്നിവ പരസ്പരം പ്രൈം സംഖ്യകളുമാണ്.


Show that for any nonnegative integer m b^m mod p ≡ b^(m mod (p−1))

ഏതൊരു നെഗറ്റീവ് ഇന്റീജർ m-നും b^m mod p ≡ b^(m mod (p−1)) എന്ന് കാണിക്കുക.


We prove the following result: given nonnegative integers x and y, where both integers are not zero, there exist integers a and b such that a × x + b × y = gcd(x, y).

ഇനി പറയുന്ന ഫലം നമ്മൾ തെളിയിക്കുന്നു: x, y എന്നീ നെഗറ്റീവ് ഇന്റീജറുകൾ തന്നിരിക്കുന്നു, ഇവിടെ രണ്ട് ഇന്റീജറുകളും പൂജ്യമല്ല, a, b എന്നീ ഇന്റീജറുകൾ നിലവിലുണ്ട്, അതുപോലെ a × x + b × y = gcd(x, y).


For example, let x, y = 12, 32. Then gcd(x, y) = 4.

ഉദാഹരണത്തിന്, x, y = 12, 32 എന്ന് എടുക്കുക. അപ്പോൾ gcd(x, y) = 4.


Note that a and b need not be positive, nor are they unique.

a, b എന്നിവ പോസിറ്റീവ് ആകണമെന്നില്ല, അതുപോലെ അവ അദ്വിതീയവുമല്ല.


We can prove Bézout’s lemma easily by applying induction on x + y.

x + y എന്നിവയിൽ ഇൻഡക്ഷൻ പ്രയോഗിക്കുന്നതിലൂടെ ബീസൗട്ടിന്റെ ലഘുവായ നിയമം എളുപ്പത്തിൽ തെളിയിക്കാൻ കഴിയും.


Then gcd(x, y) = y. We have to display a and b such that a × x + b × y = y

അപ്പോൾ gcd(x, y) = y. a × x + b × y = y ആകുന്ന a, b എന്നിവ കണ്ടെത്തണം.


Similarly, if y = 0 and x > 0, set a, b = 1, 0.

അതുപോലെ, y = 0, x > 0 ആണെങ്കിൽ, a, b = 1, 0 എന്ന് നൽകുക.


Without loss in generality, assume that x ≥ y.

സാമാന്യതക്ക് ഒരു കുറവും വരുത്താതെ, x ≥ y എന്ന് കരുതുക.


Since x−y+y < x+y, applying induction, there exist a' and b' such that a' × (x−y) + b' × y = gcd(x−y, y)

x−y+y < x+y ആയതിനാൽ, ഇൻഡക്ഷൻ പ്രയോഗിക്കുന്നതിലൂടെ, a', b' എന്നിവ നിലവിലുണ്ട്, അതുപോലെ a' × (x−y) + b' × y = gcd(x−y, y)


We will modify this algorithm to compute a and b as well.

a, b എന്നിവ കണക്കാക്കാൻ ഈ അൽഗോരിതം നമ്മൾ പരിഷ്കരിക്കും.


The remaining task is to calculate a', b', c', d' so that the given annotations are correct, i.e., the invariant (a × x + b × y = u) ∧ (c × x + d × y = v) holds at program point β.

ബാക്കിയുള്ളത്, നൽകിയിട്ടുള്ള വിവരണം ശരിയാണെന്ന് ഉറപ്പാക്കാൻ a', b', c', d' എന്നിവ കണക്കാക്കുക എന്നതാണ്, അതായത്, പ്രോഗ്രാം പോയിന്റ് β-യിൽ (a × x + b × y = u) ∧ (c × x + d × y = v) നിലനിൽക്കുന്നു.


മെഷീൻ എന്നെന്നും ജി-യിൽ തുടരും.


We will simplify Figure 4.21 to Figure 4.22.

നമ്മൾ ചിത്രം 4.21 ചിത്രം 4.22 ആയി ലളിതമാക്കും.


How do we construct a machine to recognize concatenation?

കൺകാറ്റനേഷൻ തിരിച്ചറിയാൻ ഒരു മെഷീൻ എങ്ങനെ നിർമ്മിക്കും?


നമ്മൾ c* സ്വീകരിക്കണം എന്ന് കരുതുക.


മെഷീൻ ചിത്രം 4.24-ൽ കാണിച്ചിരിക്കുന്നു.


Clearly, we can build machines for both bc* and cb* separately.

വ്യക്തമായും, നമുക്ക് bc* , cb* എന്നിവയ്ക്കായി പ്രത്യേകം മെഷീനുകൾ നിർമ്മിക്കാൻ കഴിയും.


Regular expressions have a syntax in which a few characters are special constructs.

ചില പ്രതീകങ്ങൾ പ്രത്യേക ഘടനകളുള്ള ഒരു ശൈലിയാണ് റെഗുലർ എക്സ്പ്രഷനുകൾക്കുള്ളത്.


An ordinary character is a simple regular expression which matches that same character and nothing else.

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


Any two regular expressions A and B can be concatenated.

ഏതെങ്കിലും രണ്ട് റെഗുലർ എക്സ്പ്രഷനുകളായ A, B എന്നിവയെ ബന്ധിപ്പിക്കാൻ കഴിയും.


To do something nontrivial, you need to use one of the special characters.

അസാധാരണമായ എന്തെങ്കിലും ചെയ്യുന്നതിന്, നിങ്ങൾ പ്രത്യേക പ്രതീകങ്ങളിൽ ഒന്ന് ഉപയോഗിക്കണം.


‘.’ is a special character that matches any single character except a newline.

ഒരു പുതിയ വരി ഒഴികെയുള്ള ഏതെങ്കിലും ഒരൊറ്റ പ്രതീകവുമായി പൊരുത്തപ്പെടുന്ന ഒരു പ്രത്യേക പ്രതീകമാണ് ‘.’.


The matcher processes a ‘*’ construct by matching, immediately, as many repetitions as can be found.

മാച്ചർ, എത്ര ആവർത്തനങ്ങൾ കണ്ടെത്താൻ കഴിയുമോ അത്രയും ആവർത്തനങ്ങൾ ഉടനടി പൊരുത്തപ്പെടുത്തി ഒരു ‘*’ ഘടനയെ പ്രോസസ്സ് ചെയ്യുന്നു.


For example, matching ‘ca*ar’ against the string ‘caaar’, the ‘a*’ first tries to match all three ‘a’s.

ഉദാഹരണത്തിന്, ‘ca*ar’ എന്നതിനെ ‘caaar’ എന്ന സ്ട്രിംഗുമായി പൊരുത്തപ്പെടുത്തുമ്പോൾ, ‘a*’ ആദ്യം തന്നെ മൂന്ന് ‘a’ കളുമായി പൊരുത്തപ്പെടാൻ ശ്രമിക്കുന്നു.


‘+’ is a postfix character, similar to ‘*’ except that it must match the preceding expression at least once.

‘+’ എന്നത് ‘*’-യോട് സാമ്യമുള്ള ഒരു പോസ്റ്റ്ഫിക്സ് പ്രതീകമാണ്, എന്നാൽ ഇത് കുറഞ്ഞത് ഒരു തവണയെങ്കിലും മുൻ‌ഗണനാ പ്രകടനവുമായി പൊരുത്തപ്പെടണം.


‘?’ is a postfix character, similar to ‘*’ except that it can match the preceding expression either once or not at all.

‘?’ എന്നത് ‘*’-യോട് സാമ്യമുള്ള ഒരു പോസ്റ്റ്ഫിക്സ് പ്രതീകമാണ്, എന്നാൽ ഇതിന് ഒന്നുകിൽ മുൻ‌ഗണനാ പ്രകടനവുമായി പൊരുത്തപ്പെടാം അല്ലെങ്കിൽ ഒട്ടും പൊരുത്തപ്പെടാതിരിക്കാം.


You can also include character ranges a character set, by writing two characters with a ‘-’ between them.

രണ്ട് പ്രതീകങ്ങൾക്കിടയിൽ ‘-’ ഉപയോഗിച്ച് എഴുതി, നിങ്ങൾക്ക് പ്രതീക ശ്രേണികളും ഒരു പ്രതീക സെറ്റിൽ ഉൾപ്പെടുത്താം.


To include a ‘-’, write ‘-’ at the beginning or end of a range.

ഒരു ‘-’ ഉൾപ്പെടുത്താൻ, ശ്രേണിയുടെ തുടക്കത്തിലോ അവസാനത്തിലോ ‘-’ എന്ന് എഴുതുക.


‘^’ is a special character that matches the empty string, but only at the beginning of a line in the text being matched.

‘^’ എന്നത് ശൂന്യമായ സ്ട്രിംഗുമായി പൊരുത്തപ്പെടുന്ന ഒരു പ്രത്യേക പ്രതീകമാണ്, എന്നാൽ പൊരുത്തപ്പെടുന്ന ടെക്സ്റ്റിലെ വരിയുടെ തുടക്കത്തിൽ മാത്രമേ ഇത് സംഭവിക്കൂ.


‘’ matches the empty string, provided it is at the beginning or end of a word.

ഒരു വാക്കിന്റെ തുടക്കത്തിലോ അവസാനത്തിലോ ആണെങ്കിൽ ‘’ ശൂന്യമായ സ്ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നു.


Finite state machines may be enhanced —by adding structures to states and transitions— which make them effective in specifying a variety of hardware and software systems.

പരിമിതമായ അവസ്ഥയിലുള്ള മെഷീനുകൾ മെച്ചപ്പെടുത്താൻ കഴിയും - അവസ്ഥകളിലേക്കും സംക്രമണങ്ങളിലേക്കും ഘടനകൾ ചേർക്കുന്നതിലൂടെ - ഇത് വിവിധതരം ഹാർഡ്‌വെയർ, സോഫ്റ്റ്‌വെയർ സിസ്റ്റങ്ങൾ എന്നിവ വ്യക്തമാക്കുന്നതിൽ അവരെ ഫലപ്രദമാക്കുന്നു.


We retrieve the top pair of values from the stack, assign them to s and p, and simulate the transition that handles a constant, i.e., we set p := p × a.

നമ്മൾ സ്റ്റാക്കിൽ നിന്ന് ഏറ്റവും മുകളിലുള്ള രണ്ട് മൂല്യങ്ങൾ എടുത്ത് s, p എന്നിവയിലേക്ക് നൽകുന്നു, കൂടാതെ ഒരു സ്ഥിരസംഖ്യ കൈകാര്യം ചെയ്യുന്ന ട്രാൻസിഷൻ അനുകരിക്കുന്നു, അതായത്, p := p × a എന്ന് നാം സജ്ജമാക്കുന്നു.


We store the length of the stack in n, incrementing it on encountering a '(' and decrementing it for a ')'.

'(' കണ്ടുമുട്ടുമ്പോൾ n-ൽ സ്റ്റാക്കിന്റെ നീളം വർദ്ധിപ്പിക്കുകയും ')' കാണുമ്പോൾ കുറയ്ക്കുകയും ചെയ്യുന്നു.


A ')' is accepted only when n > 0 and '#' when n = 0.

n > 0 ആകുമ്പോൾ മാത്രമേ ')' സ്വീകരിക്കൂ, കൂടാതെ n = 0 ആകുമ്പോൾ '#' സ്വീകരിക്കുന്നു.


Computes value of arithmetic expression.

ഗണിതശാസ്ത്രപരമായ പ്രകടനത്തിന്റെ മൂല്യം കണക്കാക്കുന്നു.


Run the machine of Figure 4.34 on input string 3 + (4 × (2 × 6 + 8) × 3) + 7# and show the values of the variables (including contents of the stack) at each step.

ഇൻപുട്ട് സ്ട്രിംഗിൽ 3 + (4 × (2 × 6 + 8) × 3) + 7# എന്നതിലെ ചിത്രം 4.34 പ്രവർത്തിപ്പിക്കുക, കൂടാതെ ഓരോ ഘട്ടത്തിലും വേരിയബിളുകളുടെ മൂല്യങ്ങൾ (സ്റ്റാക്കിന്റെ ഉള്ളടക്കം ഉൾപ്പെടെ) കാണിക്കുക.


Would it be simpler to specify the machine in Figure 4.34 if we could call a machine recursively?

ഒരു മെഷീനെ ആവർത്തിച്ച് വിളിക്കാൻ കഴിയുമെങ്കിൽ ചിത്രം 4.34-ൽ മെഷീൻ വ്യക്തമാക്കുന്നത് ലളിതമാവുമോ?


Explore the possibility of adding recursion to finite state machines.

പരിമിതമായ സ്റ്റേറ്റ് മെഷീനുകളിലേക്ക് ആവർത്തനം ചേർക്കുന്നതിനുള്ള സാധ്യത പര്യവേക്ഷണം ചെയ്യുക.


An event happens in the external world and the machine has to react to the event.

ഒരു സംഭവം ബാഹ്യ ലോകത്ത് സംഭവിക്കുകയും ആ സംഭവത്തോട് മെഷീൻ പ്രതികരിക്കുകയും വേണം.


Consider the dome light in a car that is either “on” or “off”.

ഓൺ അല്ലെങ്കിൽ ഓഫ് ആയിട്ടുള്ള കാറിലെ ഡോം ലൈറ്റ് പരിഗണിക്കുക.


The light comes on if a switch is pressed or if the door is opened.

ഒരു സ്വിച്ച് അമർത്തിയാൽ അല്ലെങ്കിൽ വാതിൽ തുറന്നാൽ ലൈറ്റ് പ്രകാശിക്കും.


The light goes off if the switch is pressed again, the door is closed or 5 minutes elapse with the light being on.

സ്വിച്ച് വീണ്ടും അമർത്തിയാൽ, വാതിൽ അടച്ചാൽ അല്ലെങ്കിൽ 5 മിനിറ്റ് ലൈറ്റ് കത്തിയാൽ ലൈറ്റ് അണയും.


The example just described denotes an elementary event-based system.

വിവരിച്ച ഉദാഹരണം ഒരു പ്രാഥമിക ഇവന്റ് അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റത്തെ സൂചിപ്പിക്കുന്നു.


The events are sw, door, door', and tmout.

സംഭവങ്ങൾ sw, door, door', tmout എന്നിവയാണ്.


The designer has no control over if or when the events happen.

സംഭവങ്ങൾ എപ്പോൾ സംഭവിക്കുമെന്നതിനെക്കുറിച്ച് ഡിസൈനർക്ക് നിയന്ത്രണമില്ല.


He has to design a system that enters the correct state and carries out the appropriate actions when an event happens.

ഒരു സംഭവം ഉണ്ടാകുമ്പോൾ ശരിയായ അവസ്ഥയിൽ പ്രവേശിക്കുകയും ഉചിതമായ പ്രവർത്തനങ്ങൾ നടത്തുകയും ചെയ്യുന്ന ഒരു സിസ്റ്റം രൂപകൽപ്പന ചെയ്യണം.


The event may be likened to the occurrence of a symbol.

സംഭവത്തെ ഒരു ചിഹ്നത്തിന്റെ സംഭവവുമായി താരതമ്യം ചെയ്യാം.


Therefore, we treat each event as a symbol and use the diagrams as before to depict the state transitions.

അതുകൊണ്ട്, ഓരോ സംഭവത്തെയും ഒരു ചിഹ്നമായി കണക്കാക്കുകയും സ്റ്റേറ്റ് ട്രാൻസിഷനുകൾ ചിത്രീകരിക്കുന്നതിന് മുമ്പത്തെ ഡയഗ്രമുകൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നു.


Figure 4.35 shows a possible specification of the dome light problem.

ചിത്രം 4.35 ഡോം ലൈറ്റ് പ്രശ്നത്തിന്റെ ഒരു സാധ്യതയുള്ള സ്പെസിഫിക്കേഷൻ കാണിക്കുന്നു.


Here, we have taken the liberty of writing compound events as boolean combinations of simpler events.

ഇവിടെ, ലളിതമായ സംഭവങ്ങളുടെ ബൂളിയൻ കോമ്പിനേഷനുകളായി കോമ്പൗണ്ട് ഇവന്റുകൾ എഴുതാനുള്ള സ്വാതന്ത്ര്യം ഞങ്ങൾ എടുത്തിട്ടുണ്ട്.


Suppose that the switch is pressed to turn on the dome light, the door is then opened and closed.

ഡോം ലൈറ്റ് ഓൺ ചെയ്യാൻ സ്വിച്ച് അമർത്തുകയും തുടർന്ന് വാതിൽ തുറക്കുകയും അടയ്ക്കുകയും ചെയ്യുന്നു എന്ന് കരുതുക.


initial state holds for the empty string, and (3) for each transition do the following verification: suppose the transition is labeledsand it is from a state annotated withbto one withc; then, show that ifbholds for any string x, thencholds forxs.

ആരംഭ അവസ്ഥ ശൂന്യമായ സ്ട്രിംഗിന് നിലനിൽക്കുന്നു, കൂടാതെ (3) ഓരോ സംക്രമണത്തിനും ഇനിപ്പറയുന്ന പരിശോധന നടത്തുക: സംക്രമണം ലേബൽ ചെയ്‌തിരിക്കുന്നത് s എന്നും അത് b എന്ന അടയാളപ്പെടുത്തിയ അവസ്ഥയിൽ നിന്ന് c എന്നതിലേക്ക് ആണെന്നും കരുതുക; ഏതെങ്കിലും സ്ട്രിംഗ് x-ന് b നിലനിൽക്കുകയാണെങ്കിൽ, xs-ന് c നിലനിൽക്കുമെന്ന് കാണിക്കുക.


For the machine in Figure 4.12, we have already done step (1).

ചിത്രം 4.12-ൽ കാണിച്ചിരിക്കുന്ന മെഷീനിൽ, നമ്മൾ ഇതിനകം തന്നെ (1) ഘട്ടം പൂർത്തിയാക്കിയിട്ടുണ്ട്.


For step (2), we have to show that the empty string satisfiesp∧q, that is, the empty string has an even number of 0s and 1s, which clearly holds.

(2) ഘട്ടത്തിനായി, ശൂന്യമായ സ്ട്രിംഗ് p∧q തൃപ്തിപ്പെടുത്തുന്നു എന്ന് നമ്മൾ കാണിക്കണം, അതായത്, ശൂന്യമായ സ്ട്രിംഗിൽ 0-കളുടെയും 1-കളുടെയും ഇരട്ട സംഖ്യയുണ്ട്, ഇത് വ്യക്തമായി നിലനിൽക്കുന്നു.


For step (3), we have to verify all eight transitions, as shown in Table 4.8.

(3) ഘട്ടത്തിനായി, പട്ടിക 4.8-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, എട്ട് സംക്രമണങ്ങളും നമ്മൾ പരിശോധിക്കേണ്ടതുണ്ട്.


For example, it is straightforward to verify the transition from A to B by considering an arbitrary stringxwith an even number of 0s and 1s (p∧q) and proving thatx0 has odd number of 0s and even number of 1s (¬p∧q).

ഉദാഹരണത്തിന്, A-യിൽ നിന്ന് B-യിലേക്കുള്ള സംക്രമണം പരിശോധിക്കുന്നത് എളുപ്പമാണ്, 0-കളുടെയും 1-കളുടെയും ഇരട്ട സംഖ്യയുള്ള (p∧q) ഏതെങ്കിലും സ്ട്രിംഗ് x പരിഗണിച്ച് x0-ന് ഒറ്റ സംഖ്യ 0-കളും, ഇരട്ട സംഖ്യ 1-കളും (¬p∧q) ഉണ്ടെന്ന് തെളിയിക്കുക.


Why Does the Verification Procedure Work?

എന്തുകൊണ്ടാണ് പരിശോധനാ നടപടിക്രമം പ്രവർത്തിക്കുന്നത്?


It seems that we are using some sort of circular argument, but that is not so.

നമ്മൾ ഒരുതരം വൃത്താകൃതിയിലുള്ള വാദമാണ് ഉപയോഗിക്കുന്നതെന്ന് തോന്നുന്നു, എന്നാൽ അത് ശരിയല്ല.


In order to convince yourself 4.2. FINITE STATE MACHINE83 that the argument is not circular, construct a proof using induction.

ആ വാദം വൃത്താകൃതിയിലുള്ളതല്ലെന്ന് സ്വയം ബോധ്യപ്പെടുത്താൻ, ഇൻഡക്ഷൻ ഉപയോഗിച്ച് ഒരു തെളിവ് ഉണ്ടാക്കുക.


The the- orem we need to prove is as follows: after processing any stringx, the machine state is A, B, C or D iffxsatisfiesp∧q,¬p∧q,¬p∧¬qorp∧¬q, respectively.

നമ്മൾ തെളിയിക്കേണ്ട സിദ്ധാന്തം ഇപ്രകാരമാണ്: ഏതെങ്കിലും സ്ട്രിംഗ് x പ്രോസസ്സ് ചെയ്ത ശേഷം, മെഷീൻ അവസ്ഥ A, B, C അല്ലെങ്കിൽ D എന്നിവയാണ്, അതായത് x യഥാക്രമം p∧q, ¬p∧q, ¬p∧¬q അല്ലെങ്കിൽ p∧¬q എന്നിവയെ തൃപ്തിപ്പെടുത്തുന്നു.


The proof of this statement is by induction on the length ofx.

ഈ പ്രസ്താവനയുടെ തെളിവ് x-ന്റെ നീളത്തെ ആശ്രയിച്ചുള്ള ഇൻഡക്ഷൻ വഴിയാണ്.


For|x|= 0:xis an empty string andp∧qholds for it.

|x|= 0: x ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്, കൂടാതെ p∧q അതിനായി നിലനിൽക്കുന്നു.


The finite state machines we have seen so far simply accept or reject a string.

നമ്മൾ ഇതുവരെ കണ്ട ഫൈനൈറ്റ് സ്റ്റേറ്റ് മെഷീനുകൾ ഒരു സ്ട്രിംഗിനെ സ്വീകരിക്കുകയോ നിരസിക്കുകയോ ചെയ്യുന്നു.


So, they are useful for doing complicated tests, such as to determine if a string matches a given pattern.

അതിനാൽ, ഒരു സ്ട്രിംഗ് ഒരു പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ ഇത് ഉപയോഗപ്രദമാണ്.


അത്തരം മെഷീനുകളെ സ്വീകരിക്കുന്നവർ എന്ന് വിളിക്കുന്നു.


Now, we will en- hance the machine so that it also produces a string as output; such machines are calledtransducers.

ഇപ്പോൾ, ഒരു ഔട്ട്‌പുട്ടായി ഒരു സ്ട്രിംഗ് നിർമ്മിക്കുന്ന രീതിയിൽ നമ്മൾ മെഷീനെ മെച്ചപ്പെടുത്തും; അത്തരം മെഷീനുകളെ ട്രാൻസ്‌ഡ്യൂസറുകൾ എന്ന് വിളിക്കുന്നു.


Transducers provide powerful string processing mechanism.

ട്രാൻസ്‌ഡ്യൂസറുകൾ ശക്തമായ സ്ട്രിംഗ് പ്രോസസ്സിംഗ് സംവിധാനം നൽകുന്നു.


Typically, acceptance or rejection of the input string is of no particular im- portance in transducers; only the construction of the appropriate output string matters.

സാധാരണയായി, ഇൻപുട്ട് സ്ട്രിംഗിന്റെ സ്വീകാര്യതയോ നിരസിക്കലോ ട്രാൻസ്‌ഡ്യൂസറുകളിൽ ഒരു പ്രത്യേക പ്രാധാന്യവുമില്ല; ഉചിതമായ ഔട്ട്‌പുട്ട് സ്ട്രിംഗിന്റെ നിർമ്മാണം മാത്രമേ പ്രധാനമാകൂ.


Pictorially, we will depict a transition as shown in Figure 4.13.

ചിത്രപരമായി, ചിത്രം 4.13-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഒരു സംക്രമണം നമ്മൾ ചിത്രീകരിക്കും.


It denotes that on reading symbols, the machine transits from A to B and outputs string t.

ചിഹ്നങ്ങൾ വായിക്കുമ്പോൾ, മെഷീൻ A-യിൽ നിന്ന് B-യിലേക്ക് മാറുകയും സ്ട്രിംഗ് t ഔട്ട്‌പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു എന്ന് ഇത് സൂചിപ്പിക്കുന്നു.


The output alphabet of the machine —over whichtis a string— may differ from its input alphabet.

മെഷീന്റെ ഔട്ട്‌പുട്ട് അക്ഷരമാല - ഏതിലാണോ t ഒരു സ്ട്രിംഗ് - അതിന്റെ ഇൻപുട്ട് അക്ഷരമാലയിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കാം.


The infix operator `rem` is used for the remainder after division.

`rem` എന്ന ഇൻഫിക്സ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നത് ഹരണശേഷം ലഭിക്കുന്ന ശിഷ്ടം കാണാനാണ്.


The `mod` operator returns the modulo, resulting in a value between 0 and y-1 for positive y.

`mod` ഓപ്പറേറ്റർ മോഡുലസ് നൽകുന്നു, ഇത് പോസിറ്റീവ് y-ന് 0-നും y-1-നും ഇടയിലുള്ള ഒരു മൂല്യം നൽകുന്നു.


For example, (-2) `rem` 3 is -2 and (-2) `mod` 3 is 1.

ഉദാഹരണത്തിന്, (-2) `rem` 3 എന്നത് -2 ആണ്, (-2) `mod` 3 എന്നത് 1 ആണ്.


The functions `even` and `odd` return boolean results for integer arguments.

`even`, `odd` എന്നീ ഫങ്ഷനുകൾ പൂർണ്ണസംഖ്യ ആർഗ്യുമെന്റുകൾക്കായി ബൂളിയൻ ഫലങ്ങൾ നൽകുന്നു.


Functions `max` and `min` take two arguments and return the maximum and minimum values, respectively.

`max`, `min` എന്നീ ഫങ്ഷനുകൾ രണ്ട് ആർഗ്യുമെന്റുകൾ എടുക്കുകയും യഥാക്രമം ഏറ്റവും വലിയതും ചെറിയതുമായ വിലകൾ നൽകുകയും ചെയ്യുന്നു.


It's possible to write a function name followed by its arguments without parentheses.

ഒരു ഫംഗ്ഷൻ നാമം, അതിനുശേഷം ആർഗ്യുമെന്റുകൾ എന്നിവ ബ്രാക്കറ്റില്ലാതെ എഴുതാൻ കഴിയും.


Parentheses are needed only to enforce an evaluation order.

വിലയിരുത്തുന്ന ക്രമം നടപ്പിലാക്കാൻ മാത്രമേ ബ്രാക്കറ്റുകൾ ആവശ്യമുള്ളൂ.


The arithmetic relations are <, <=, ==, /=, >, >=.

ഗണിത ബന്ധങ്ങൾ <, <=, ==, /=, >, >= എന്നിവയാണ്.


Each of these is a binary operator that returns a boolean result, True or False.

ഇവയോരോന്നും ഒരു ബൂളിയൻ ഫലം നൽകുന്ന ഒരു ബൈനറി ഓപ്പറേറ്ററാണ്, ശരി അല്ലെങ്കിൽ തെറ്റ്.


The equality operator is written as == and inequality as /=.

സമത്വ ഓപ്പറേറ്റർ == ആയും,  അസമത്വം /= ആയും എഴുതുന്നു.


Unlike in C++, 3 + (5 >= 2) is not a valid expression in Haskell.

C++-ൽ നിന്ന് വ്യത്യസ്തമായി, 3 + (5 >= 2) എന്നത് Haskell-ൽ സാധുവായ ഒരു പ്രയോഗമല്ല.


Haskell does not specify how to add an integer to a boolean.

ഒരു പൂർണ്ണസംഖ്യയെ ഒരു ബൂളിയനുമായി എങ്ങനെ കൂട്ടിച്ചേർക്കണമെന്ന് Haskell-ൽ വ്യക്തമാക്കിയിട്ടില്ല.


There are two boolean constants, written as True and False.

True, False എന്നിങ്ങനെ എഴുതുന്ന രണ്ട് ബൂളിയൻ സ്ഥിരകങ്ങളുണ്ട്.


The boolean operators are: not, &&, ||, ==, /=.

ബൂളിയൻ ഓപ്പറേറ്റർമാർ: not, &&, ||, ==, /= എന്നിവയാണ്.


Haskell supports two kinds of integers, Integer and Int data types.

Haskell രണ്ട് തരത്തിലുള്ള പൂർണ്ണസംഖ്യകളെ പിന്തുണയ്ക്കുന്നു, Integer, Int ഡാറ്റാ ടൈപ്പുകൾ.


A character is enclosed within single quotes and a string is enclosed within double quotes.

ഒരു പ്രതീകം ഒറ്റ ഉദ്ധരണിക്കുള്ളിലും ഒരു സ്ട്രിംഗ് ഇരട്ട ഉദ്ധരണിക്കുള്ളിലുമായി നൽകുന്നു.


You can compare characters using arithmetic relations.

ഗണിത ബന്ധങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പ്രതീകങ്ങൾ താരതമ്യം ചെയ്യാൻ കഴിയും.


The letters are ordered in the usual fashion with uppercase letters smaller than lowercase letters.

അക്ഷരങ്ങൾ സാധാരണ രീതിയിൽ അടുക്കിയിരിക്കുന്നു, വലിയ അക്ഷരങ്ങൾ ചെറിയ അക്ഷരങ്ങളേക്കാൾ ചെറുതാണ്.


There are two functions defined on characters, ord and chr.

പ്രതീകങ്ങളിൽ നിർവചിക്കപ്പെട്ടിട്ടുള്ള രണ്ട് ഫംഗ്ഷനുകളാണ് ord, chr എന്നിവ.


Function ord(c) returns the value of the character c in the internal coding table.

ord(c) എന്ന ഫംഗ്ഷൻ, c എന്ന പ്രതീകത്തിന്റെ മൂല്യം ആന്തരിക കോഡിംഗ് പട്ടികയിൽ നൽകുന്നു.


The algorithm efficiently sorts the data.

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


Please provide the necessary input for the program.

പ്രോഗ്രാമിന് ആവശ്യമായ ഇൻപുട്ട് നൽകുക.


ഫംഗ്ഷൻ ഒരു ബൂളിയൻ മൂല്യം നൽകുന്നു.


This code snippet demonstrates recursion.

ഈ കോഡ് ഭാഗം റിക്രൂഷൻ (recursion)  പ്രദർശിപ്പിക്കുന്നു.


The program is designed to handle large datasets.

വലിയ ഡാറ്റാ സെറ്റുകൾ കൈകാര്യം ചെയ്യാൻ ഈ പ്രോഗ്രാം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു.


Debugging the code can be a challenging task.

കോഡ് ഡീബഗ്ഗിംഗ് ഒരു വെല്ലുവിളി നിറഞ്ഞ ജോലിയാണ്.


The compiler optimizes the code for better performance.

മെച്ചപ്പെട്ട പ്രകടനത്തിനായി കംപൈലർ കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു.


The software architecture is modular and scalable.

സോഫ്റ്റ്‌വെയർ ആർക്കിടെക്ചർ മോഡുലാറും സ്കേലബിളുമാണ്.


The system uses parallel processing to speed up computations.

കമ്പ്യൂട്ടേഷനുകൾ വേഗത്തിലാക്കാൻ സിസ്റ്റം സമാന്തര പ്രോസസ്സിംഗ് ഉപയോഗിക്കുന്നു.


The algorithm's time complexity is O(n log n).

അൽഗോരിതത്തിന്റെ സമയ സങ്കീർണ്ണത O(n log n) ആണ്.


The program efficiently manages memory allocation.

പ്രോഗ്രാം മെമ്മറി വിതരണം കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യുന്നു.


The code is well-documented and easy to understand.

കോഡ് നന്നായി രേഖപ്പെടുത്തിയിട്ടുണ്ട്, മനസ്സിലാക്കാൻ എളുപ്പമാണ്.


The function utilizes higher-order functions.

ഈ ഫംഗ്ഷൻ ഉയർന്ന-ഓർഡർ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു.


The system employs a distributed database.

സിസ്റ്റം ഒരു വിതരണം ചെയ്ത ഡാറ്റാബേസ് ഉപയോഗിക്കുന്നു.


The software is designed for fault tolerance.

സോഫ്റ്റ്‌വെയർ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് തകരാറുകൾ സഹിക്കാൻ കഴിയും വിധമാണ്.


The program uses a cache to improve performance.

പ്രകടനം മെച്ചപ്പെടുത്താൻ പ്രോഗ്രാം ഒരു കാഷെ ഉപയോഗിക്കുന്നു.


The algorithm is based on dynamic programming.

അൽഗോരിതം പ്രവർത്തിക്കുന്നത് ഡൈനാമിക് പ്രോഗ്രാമിംഗിനെ അടിസ്ഥാനമാക്കിയാണ്.


The system is designed to handle concurrent requests.

സമാന്തര അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യാൻ ഈ സിസ്റ്റം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു.


കോഡ് ഒരു ഡിസൈൻ പാറ്റേൺ നടപ്പിലാക്കുന്നു.


The program's efficiency is crucial for large-scale data processing.

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


The execution time is at most logarithmic in the argument values.

ആർഗ്യുമെന്റ് മൂല്യങ്ങളിൽ, എക്സിക്യൂഷൻ സമയം ഏറ്റവും കൂടുതൽ ലോഗരിഥമിക് ആയിരിക്കും.


We have, so far, seen a few elementary data types.

നമ്മൾ ഇതുവരെ കുറച്ച് പ്രാഥമിക ഡാറ്റാ തരങ്ങൾ കണ്ടു.


Tuple is the Haskell’s version of a record; we may put several kinds of data together and give it a name.

ട്യൂപ്പിൾ എന്നത് റെക്കോർഡിന്റെ Haskell പതിപ്പാണ്; നമുക്ക് പലതരം ഡാറ്റ ഒരുമിപ്പിക്കാനും ഒരു പേര് നൽകാനും കഴിയും.


Here are some examples: (3,5) ("Misra","Jayadev") (True,3) (False,0)

ചില ഉദാഹരണങ്ങൾ ഇതാ: (3,5) ("മിശ്ര","ജയദേവ്") (ശരി,3) (തെറ്റ്,0)


There are two predefined functions, fst and snd, that return the first and the second components of a pair, respectively.

ജോഡിയുടെ ആദ്യത്തെയും രണ്ടാമത്തെയും ഘടകങ്ങൾ നൽകുന്ന fst, snd എന്നീ രണ്ട് മുൻകൂട്ടി നിർവചിക്കപ്പെട്ട ഫംഗ്ഷനുകൾ ഉണ്ട്.


There is no restriction at all in Haskell about what you can have as the first and the second component of a tuple.

ഒരു ട്യൂപ്പിളിന്റെ ആദ്യത്തെയും രണ്ടാമത്തെയും ഘടകമായി നിങ്ങൾക്ക് എന്തെല്ലാം ഉണ്ടാകാം എന്നതിനെക്കുറിച്ച് Haskell-ൽ ഒരു നിയന്ത്രണവുമില്ല.


Revisiting the Fibonacci Computation As we saw in the Figure 5.1 of page 133, there is considerable recomputation in evaluating fib n, in general.

ഫിബൊനാച്ചി കമ്പ്യൂട്ടേഷനെ വീണ്ടും സന്ദർശിക്കുമ്പോൾ, 133-ാം പേജിലെ ചിത്രം 5.1-ൽ കണ്ടതുപോലെ, പൊതുവെ fib n വിലയിരുത്തുന്നതിൽ കാര്യമായ വീണ്ടും കണക്കുകൂട്ടൽ ഉണ്ട്.


Haskell-ലെ എല്ലാ എക്സ്പ്രഷനും ഒരു തരം ഉണ്ട്.


The type of a tuple is a tuple of types, one entry for the type of each operand.

ഒരു ട്യൂപ്പിളിന്റെ തരം എന്നത് ടൈപ്പുകളുടെ ഒരു ട്യൂപ്പിളാണ്, ഓരോ ഓപ്പറാൻഡിന്റെയും ടൈപ്പിനായി ഒരു എൻട്രി.


Each function has a type, namely, the types of its arguments in order followed by the type of the result, all separated by ->.

ഓരോ ഫംഗ്ഷനും ഒരു തരം ഉണ്ട്, അതായത്, അതിന്റെ ആർഗ്യുമെന്റുകളുടെ തരങ്ങൾ, തുടർന്ന് ഫലത്തിന്റെ തരം, എല്ലാം -> ഉപയോഗിച്ച് വേർതിരിക്കുന്നു.


Haskell allows us to write functions whose arguments can be any type, or any type that satisfies some constraint.

ഏത് തരത്തിലുള്ള ആർഗ്യുമെന്റുകളും സ്വീകരിക്കാൻ കഴിയുന്ന ഫംഗ്ഷനുകൾ എഴുതാൻ Haskell-ന് കഴിയും, അല്ലെങ്കിൽ ചില നിയന്ത്രണങ്ങൾ പാലിക്കുന്ന ഏതെങ്കിലും തരം.


Polymorphism means that a function can accept and produce data of many different types.

പോളിമോർഫിസം എന്നാൽ ഒരു ഫംഗ്ഷന് വ്യത്യസ്ത തരത്തിലുള്ള ഡാറ്റ സ്വീകരിക്കാനും നിർമ്മിക്കാനും കഴിയും.


Haskell has an extensive type system, which we will not cover in this course.

Haskell-ന് ഒരു വിപുലമായ ടൈപ്പ് സിസ്റ്റം ഉണ്ട്, അത് ഈ കോഴ്സിൽ നമ്മൾ ഉൾക്കൊള്ളുന്നില്ല.


A list consists of a finite sequence of items all of the same type.

ഒരേ തരത്തിലുള്ള ഇനങ്ങളുടെ പരിമിതമായ ശ്രേണിയാണ് ഒരു ലിസ്റ്റ്.


The type of any list is [ItemType] where ItemType is the type of one of its items.

ഏത് ലിസ്റ്റിന്റെയും തരം [ItemType] ആണ്, അവിടെ ItemType അതിന്റെ ഒരിനത്തിന്റെ തരം ആണ്.


A string is a list of characters, i.e. [Char]; each of its characters is taken to be a list item.

ഒരു സ്ട്രിംഗ് എന്നത് പ്രതീകങ്ങളുടെ ഒരു ലിസ്റ്റാണ്, അതായത് [Char]; അതിന്റെ ഓരോ പ്രതീകവും ഒരു ലിസ്റ്റ് ഇനമായി കണക്കാക്കപ്പെടുന്നു.


There is one built-in operator that is used to construct a list element by element; it is pronounced Cons and is written as : (a colon).

ഓരോ ഘടകവും ചേർത്ത് ഒരു ലിസ്റ്റ് നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ബിൽറ്റ്-ഇൻ ഓപ്പറേറ്റർ ഉണ്ട്; ഇത് Cons എന്ന് ഉച്ചരിക്കുന്നു, കൂടാതെ : (ഒരു കോളൻ) എന്ന് എഴുതുന്നു.


Pattern matching can be applied very effectively in such situations.

അത്തരം സാഹചര്യങ്ങളിൽ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ വളരെ ഫലപ്രദമായി പ്രയോഗിക്കാൻ കഴിയും.


This style of programming on lists is very common: we define the function separately for empty and non-empty lists.

ലിസ്റ്റുകളിൽ പ്രോഗ്രാം ചെയ്യുന്ന ഈ രീതി വളരെ സാധാരണമാണ്: ശൂന്യമായ ലിസ്റ്റുകൾക്കും ശൂന്യമല്ലാത്ത ലിസ്റ്റുകൾക്കും വേണ്ടി നമ്മൾ പ്രത്യേകം ഫംഗ്ഷൻ നിർവചിക്കുന്നു.


The running time of this algorithm is O(n 2), where n is the length of the argument list.

ഈ അൽഗോരിതത്തിന്റെ പ്രവർത്തിക്കുന്ന സമയം O(n 2) ആണ്, ഇവിടെ n എന്നത് ആർഗ്യുമെന്റ് ലിസ്റ്റിന്റെ നീളമാണ്.


Show that the execution time of reverse xs ys is O(n) where the length of xs is n.

xs-ൻ്റെ നീളം n ആകുമ്പോൾ reverse xs ys-ൻ്റെ എക്സിക്യൂഷൻ സമയം O(n) ആണെന്ന് കാണിക്കുക.


Prove from the definition of rev that rev (rev xs) = xs.

rev-ൻ്റെ നിർവചനത്തിൽ നിന്ന് rev (rev xs) = xs എന്ന് തെളിയിക്കുക.


Prove from the definition of rev and reverse that reverse xs ys = (rev xs) ++ ys.

rev, reverse എന്നിവയുടെ നിർവചനങ്ങളിൽ നിന്ന് reverse xs ys = (rev xs) ++ ys എന്ന് തെളിയിക്കുക.


Show how to right-rotate a list efficiently (i.e., in linear time in the size of the argument list).

ഒരു ലിസ്റ്റ് എങ്ങനെ കാര്യക്ഷമമായി വലത്തോട്ട് തിരിക്കാമെന്ന് കാണിക്കുക (അതായത്, ആർഗ്യുമെൻ്റ് ലിസ്റ്റിൻ്റെ വലുപ്പത്തിൽ ലീനിയർ സമയത്ത്).


Right-rotation of [1,2,3,4] yields [4,1,2,3].

[1,2,3,4]-ൻ്റെ വലത് ഭ്രമണം [4,1,2,3] നൽകുന്നു.


സൂചന: rev ഉപയോഗിക്കുക.


Try proving rev (xs ++ ys) = (rev ys) ++ (rev xs).

rev (xs ++ ys) = (rev ys) ++ (rev xs) എന്ന് തെളിയിക്കാൻ ശ്രമിക്കുക.


ഇതൊരു സുപരിചിതമായ കടങ്കഥയാണ്.


Given is a board on which there are three pegs marked ‘a’, ‘b’ and ‘c’, on each of which can rest a stack of disks.

a, b, c എന്നിങ്ങനെ അടയാളപ്പെടുത്തിയ മൂന്ന് തറകളുള്ള ഒരു ബോർഡ് നൽകിയിരിക്കുന്നു, അതിൽ ഓരോന്നിനും ഡിസ്കുകളുടെ ഒരു അടുക്ക് വിശ്രമിക്കാൻ കഴിയും.


There are n disks, n > 0, of varying sizes, numbered 1 through n in order of size.

n ഡിസ്കുകൾ ഉണ്ട്, n > 0, വ്യത്യസ്ത വലുപ്പത്തിലുള്ളവ, വലുപ്പത്തിനനുസരിച്ച് 1 മുതൽ n വരെ നമ്പറിട്ടിരിക്കുന്നു.


The disks are correctly stacked if they are increasing in size from top to bottom in each peg.

ഓരോ തറയിലും മുകളിൽ നിന്ന് താഴേക്ക് വലുപ്പം വർദ്ധിക്കുമ്പോഴാണ് ഡിസ്കുകൾ ശരിയായി അടുക്കിയിരിക്കുന്നത്.


Initially, all disks are correctly stacked at ‘a’.

തുടക്കത്തിൽ, എല്ലാ ഡിസ്കുകളും ‘a’-യിൽ ശരിയായി അടുക്കിയിരിക്കുന്നു.


It is required to move all the disks to ‘b’ in a sequence of steps under the constraints that (1) in each step, the top disk of one peg is moved to the top of another peg, and (2) the disks are correctly stacked at all times.

(1) ഓരോ ഘട്ടത്തിലും, ഒരു തറയുടെ മുകളിലുള്ള ഡിസ്ക് മറ്റൊരു തറയുടെ മുകളിലേക്ക് മാറ്റണം, കൂടാതെ (2) എല്ലാ സമയത്തും ഡിസ്കുകൾ ശരിയായി അടുക്കിയിരിക്കണം എന്നീ നിയന്ത്രണങ്ങൾ പാലിച്ച് എല്ലാ ഡിസ്കുകളും ‘b’-യിലേക്ക് നീക്കാൻ ആവശ്യമാണ്.


For n= 3, the sequence of steps given below is sufficient.

n= 3-ന്, താഴെ നൽകിയിട്ടുള്ള ഘട്ടങ്ങളുടെ ക്രമം മതി.


In this sequence, a triple (i,x,y) denotes a step in which disk i is moved from peg x to y.

ഈ ക്രമത്തിൽ, (i,x,y) എന്ന ത്രികം ഡിസ്ക് i, x എന്ന തറയിൽ നിന്ന് y എന്നതിലേക്ക് നീക്കുന്ന ഘട്ടത്തെ സൂചിപ്പിക്കുന്നു.


Clearly, i is at the top of peg x before the step and at the top of peg y after the step.

തീർച്ചയായും, ഘട്ടത്തിന് മുമ്പ് i, x എന്ന തറയുടെ മുകളിലും, ഘട്ടത്തിന് ശേഷം y എന്ന തറയുടെ മുകളിലുമായിരിക്കും.


There is an iterative solution for this problem, which goes like this.

ഈ പ്രശ്നത്തിന് ഒരു ആവർത്തന പരിഹാരമുണ്ട്, അത് ഇങ്ങനെ പോകുന്നു.


Disk 1 moves in every alternate step starting with the first step.

ഒന്നാമത്തെ ഘട്ടത്തിൽ ആരംഭിച്ച്, എല്ലാ ഇടവിട്ടുള്ള ഘട്ടങ്ങളിലും ഡിസ്ക് 1 നീങ്ങുന്നു.


If n is odd, disk 1 moves cyclically from ‘a’ to ‘b’ to ‘c’ to ‘a’..., and if n is even, disk 1 moves cyclically from ‘a’ to ‘c’ to ‘b’ to ‘a’....

n ഒറ്റ സംഖ്യയാണെങ്കിൽ, ഡിസ്ക് 1 ‘a’-യിൽ നിന്ന് ‘b’-യിലേക്ക്, ‘c’-യിലേക്ക്, ‘a’യിലേക്ക്... എന്നിങ്ങനെ ചക്രീയമായി നീങ്ങുന്നു, കൂടാതെ n ഇരട്ട സംഖ്യയാണെങ്കിൽ, ഡിസ്ക് 1 ‘a’-യിൽ നിന്ന് ‘c’-യിലേക്ക്, ‘b’-യിലേക്ക്, ‘a’യിലേക്ക്... എന്നിങ്ങനെ ചക്രീയമായി നീങ്ങുന്നു.


In each remaining step, there is exactly one possible move: ignore the peg of which disk 1 is the top; compare the tops of the two remaining pegs and move the smaller one to the top of the other peg (if one peg is empty, move the top of the other peg to its top).

ബാക്കിയുള്ള ഓരോ ഘട്ടത്തിലും, ഒരൊറ്റ നീക്കം മാത്രമേ സാധ്യമാകൂ: ഡിസ്ക് 1 മുകളിലുള്ള തറ അവഗണിക്കുക; ബാക്കിയുള്ള രണ്ട് തറകളുടെ മുകൾ ഭാഗങ്ങൾ താരതമ്യം ചെയ്യുക, ചെറിയ ഡിസ്ക് മറ്റേ തറയുടെ മുകളിലേക്ക് നീക്കുക (ഒരു തറ കാലിയാണെങ്കിൽ, മറ്റേ തറയുടെ മുകൾ ഭാഗം അതിൻ്റെ മുകളിലേക്ക് നീക്കുക).


The main idea behind their scheme is the observation that many web-based applications can be written as a map operation followed by a reduce operation.

അവരുടെ പദ്ധതിയുടെ പിന്നിലെ പ്രധാന ആശയം, നിരവധി വെബ്-അധിഷ്ഠിത ആപ്ലിക്കേഷനുകൾ ഒരു മാപ്പ് പ്രവർത്തനമായും തുടർന്ന് ഒരു റെഡ്യൂസ് പ്രവർത്തനമായും എഴുതാൻ കഴിയും എന്ന നിരീക്ഷണമാണ്.


First, map is a function that takes a (key, value) pair as argument and returns a list of (key, value) pairs.

ആദ്യം, മാപ്പ് എന്നത് ഒരു (കീ, മൂല്യം) ജോഡിയെ ഒരു ആർഗ്യുമെന്റായി എടുക്കുകയും (കീ, മൂല്യം) ജോഡികളുടെ ഒരു ലിസ്റ്റ് തിരികെ നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷനാണ്.


The argument keys and values may have different types from the result keys and values.

ആർഗ്യുമെന്റ് കീകൾക്കും മൂല്യങ്ങൾക്കും, ഫല കീകൾക്കും മൂല്യങ്ങൾക്കും വ്യത്യസ്ത തരങ്ങൾ ഉണ്ടാകാം.


As an example, the argument may be a pair (n, s), where n is a positive integer and s is a string.

ഒരു ഉദാഹരണമായി, ആർഗ്യുമെന്റ് (n, s) എന്ന ജോഡിയായിരിക്കാം, ഇവിടെ n ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യയും s ഒരു സ്ട്രിംഗുമാണ്.


Function map may return a list of (w, c) pairs, where w is a word of length n or less in the document, and c is the number of occurrences of w in the document.

മാപ്പ് ഫംഗ്ഷൻ (w, c) ജോഡികളുടെ ഒരു ലിസ്റ്റ് നൽകാം, ഇവിടെ w എന്നത് n അല്ലെങ്കിൽ അതിൽ കുറഞ്ഞ നീളമുള്ള ഒരു വാക്കാണ്, കൂടാതെ c എന്നത് പ്രമാണത്തിൽ w എത്ര തവണ ആവർത്തിച്ചു എന്നതിന്റെ എണ്ണമാണ്.


Typically, map is applied not to a single document, but millions of documents at once.

സാധാരണയായി, മാപ്പ് ഒരു ഡോക്യുമെന്റിൽ മാത്രമല്ല, ദശലക്ഷക്കണക്കിന് ഡോക്യുമെന്റുകളിൽ ഒരേസമയം പ്രയോഗിക്കുന്നു.


Next, the outputs of all the maps, say M lists of (w, c) pairs for M documents, are aggregated into R lists where each list holds all the counts for a single word.

അടുത്തതായി, എല്ലാ മാപ്പുകളുടെയും ഔട്ട്‌പുട്ടുകൾ, അതായത് M ഡോക്യുമെന്റുകൾക്കായുള്ള (w, c) ജോഡികളുടെ M ലിസ്റ്റുകൾ, R ലിസ്റ്റുകളായി സംയോജിപ്പിക്കുന്നു, അവിടെ ഓരോ ലിസ്റ്റും ഒരു വാക്കിനായുള്ള എല്ലാ എണ്ണങ്ങളും ഉൾക്കൊള്ളുന്നു.


Now, reduce operation is applied to each of these R lists individually, producing R outputs.

ഇപ്പോൾ, ഈ R ലിസ്റ്റുകളിൽ ഓരോന്നിനും റെഡ്യൂസ് പ്രവർത്തനം വ്യക്തിഗതമായി പ്രയോഗിക്കുന്നു, ഇത് R ഔട്ട്‌പുട്ടുകൾ ഉണ്ടാക്കുന്നു.


In this example, a reduce operation might sum up the counts, which will tell us something about the most commonly occurring words in all the documents.

ഈ ഉദാഹരണത്തിൽ, ഒരു റെഡ്യൂസ് പ്രവർത്തനം എണ്ണങ്ങൾ കൂട്ടിച്ചേർത്തേക്കാം, ഇത് എല്ലാ ഡോക്യുമെന്റുകളിലെയും ഏറ്റവും സാധാരണയായി സംഭവിക്കുന്ന വാക്കുകളെക്കുറിച്ച് നമ്മോട് പറയും.


In general, the user provides the code for both map and reduce, specifies the arguments over which they have to be applied, and suggests certain parameters for parallel processing.

പൊതുവേ, ഉപയോക്താവ് മാപ്പിനും റെഡ്യൂസിനും കോഡ് നൽകുന്നു, അവ എവിടെയാണ് പ്രയോഗിക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്നു, കൂടാതെ സമാന്തര പ്രോസസ്സിംഗിനായി ചില പാരാമീറ്ററുകൾ നിർദ്ദേശിക്കുന്നു.


The run-time system takes care of the details of partitioning the input data, scheduling the program’s execution across a set of machines, handling machine failures, and managing the required inter-machine communication.

ഇൻപുട്ട് ഡാറ്റയുടെ വിഭജനം, ഒരു കൂട്ടം മെഷീനുകളിൽ പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷൻ ഷെഡ്യൂൾ ചെയ്യൽ, മെഷീൻ പരാജയങ്ങൾ കൈകാര്യം ചെയ്യൽ, ആവശ്യമായ ഇന്റർ-മെഷീൻ ആശയവിനിമയം എന്നിവയുടെ വിശദാംശങ്ങൾ റൺ-ടൈം സിസ്റ്റം ശ്രദ്ധിക്കുന്നു.


This allows programmers without any experience with parallel and distributed systems to easily utilize the resources of a large distributed system.

സമാന്തര വിതരണ സംവിധാനങ്ങളെക്കുറിച്ച് യാതൊരു പരിചയവുമില്ലാത്ത പ്രോഗ്രാമർമാർക്ക് പോലും ഒരു വലിയ വിതരണ സംവിധാനത്തിന്റെ വിഭവങ്ങൾ എളുപ്പത്തിൽ ഉപയോഗിക്കാൻ ഇത് അനുവദിക്കുന്നു.


Distributed Grep “grep” is a unix utility that searches for a pattern in a given string (the string is typically a document).

വിതരണം ചെയ്ത ഗ്രെപ്പ് “grep” എന്നത് ഒരു യൂണിക്സ് യൂട്ടിലിറ്റിയാണ്, ഇത് നൽകിയിട്ടുള്ള ഒരു സ്ട്രിംഗിൽ (സാധാരണയായി ഒരു പ്രമാണമാണ് സ്ട്രിംഗ്) ഒരു പാറ്റേൺ തിരയുന്നു.


In this example, a large number of documents have to be searched for a specific pattern.

ഈ ഉദാഹരണത്തിൽ, ഒരു പ്രത്യേക പാറ്റേണിനായി ധാരാളം പ്രമാണങ്ങൾ തിരയേണ്ടതുണ്ട്.


Function map is applied to a document and a pattern, and it emits a line wherever there is a match.

ഒരു പ്രമാണത്തിലും ഒരു പാറ്റേണിലും മാപ്പ് ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു, കൂടാതെ പൊരുത്തപ്പെടുന്നിടത്തെല്ലാം ഇത് ഒരു വരി പുറപ്പെടുവിക്കുന്നു.


Function reduce is the identity function; it merely copies the supplied argument to the output.

റെഡ്യൂസ് ഫംഗ്ഷൻ ഒരു ഐഡന്റിറ്റി ഫംഗ്ഷനാണ്; ഇത് നൽകിയിട്ടുള്ള ആർഗ്യുമെന്റ് ഔട്ട്‌പുട്ടിലേക്ക് പകർത്തുന്നു.


We are given a large log of web page requests.

വെബ് പേജ് അഭ്യർത്ഥനകളുടെ ഒരു വലിയ ലോഗ് നമുക്ക് നൽകിയിട്ടുണ്ട്.


We would like to know how often certain web pages are being accessed.

ചില വെബ് പേജുകൾ എത്ര തവണ ആക്സസ് ചെയ്യപ്പെടുന്നു എന്ന് അറിയാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.


The map function takes a single request and outputs 〈URL,1〉.

മാപ്പ് ഫംഗ്ഷൻ ഒരു അഭ്യർത്ഥന എടുക്കുകയും 〈URL,1〉 ഔട്ട്‌പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു.


The reduce function sums the values for the same URL and emits a total count for each URL.

റെഡ്യൂസ് ഫംഗ്ഷൻ ഒരേ URL-നുള്ള മൂല്യങ്ങൾ കൂട്ടിച്ചേർക്കുകയും ഓരോ URL-നും ഒരു ടോട്ടൽ എണ്ണം പുറപ്പെടുവിക്കുകയും ചെയ്യുന്നു.


The algorithm transforms the input into a form that can be efficiently evaluated.

ഈ അൽഗോരിതം ഇൻപുട്ടിനെ കാര്യക്ഷമമായി വിലയിരുത്താൻ കഴിയുന്ന ഒരു രൂപത്തിലേക്ക് മാറ്റുന്നു.


The query uses predicates p and q to filter data based on actor and time.

അഭിനേതാവിനെയും സമയത്തെയും അടിസ്ഥാനമാക്കി ഡാറ്റ ഫിൽട്ടർ ചെയ്യാൻ ചോദ്യം p, q എന്നീ പ്രെഡിക്കേറ്റുകൾ ഉപയോഗിക്കുന്നു.


The relational expression is transformed to optimize the query execution.

ചോദ്യം നടപ്പിലാക്കുന്നത് ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിന്, ബന്ധുഗതമായ പദപ്രയോഗം രൂപാന്തരപ്പെടുത്തിയിരിക്കുന്നു.


Selection operations extract tuples that satisfy the predicate.

തിരഞ്ഞെടുക്കൽ പ്രവർത്തനങ്ങൾ പ്രെഡിക്കേറ്റ് തൃപ്തികരമായ ട്യൂപ്പിളുകൾ വേർതിരിച്ചെടുക്കുന്നു.


The projection operation lists the addresses.

പ്രൊജക്ഷൻ പ്രവർത്തനം വിലാസങ്ങൾ ലിസ്റ്റ് ചെയ്യുന്നു.


The transformed query is more efficient for evaluation.

രൂപാന്തരപ്പെടുത്തിയ ചോദ്യം വിലയിരുത്തുന്നതിന് കൂടുതൽ കാര്യക്ഷമമാണ്.


The original query involves a costly operation with three tables.

തുടക്കത്തിലുള്ള ചോദ്യം മൂന്ന് പട്ടികകളുള്ള വളരെ ചെലവേറിയ ഒരു പ്രവർത്തനമാണ് ഉൾപ്പെടുന്നത്.


Selections are applied as soon as possible in the transformed expression.

രൂപാന്തരപ്പെടുത്തിയ പദപ്രയോഗത്തിൽ, തിരഞ്ഞെടുക്കലുകൾ എത്രയും പെട്ടെന്ന് പ്രയോഗിക്കുന്നു.


Aggregation operations combine values in a column.

അഗ്രഗേഷൻ പ്രവർത്തനങ്ങൾ ഒരു കോളത്തിലെ മൂല്യങ്ങൾ സംയോജിപ്പിക്കുന്നു.


Grouping creates subrelations based on attribute values.

ഗ്രൂപ്പിംഗ്, ആട്രിബ്യൂട്ട് മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഉപബന്ധങ്ങൾ ഉണ്ടാക്കുന്നു.


The aggregation function 'Count' counts distinct values.

'കൗണ്ട്' എന്ന അഗ്രഗേഷൻ ഫംഗ്ഷൻ വ്യത്യസ്ത മൂല്യങ്ങൾ എണ്ണുന്നു.


The result of aggregation is a relation with one tuple.

അഗ്രഗേഷന്റെ ഫലം ഒരു ട്യൂപ്പിളുള്ള ഒരു ബന്ധമാണ്.


SQL is a standard language for database manipulation.

ഡാറ്റാബേസ് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സാധാരണ ഭാഷയാണ് SQL.


String matching algorithms locate occurrences of a pattern within a text.

സ്ട്രിംഗ് മാച്ചിംഗ് അൽഗോരിതങ്ങൾ ഒരു ടെക്സ്റ്റിനുള്ളിൽ ഒരു പാറ്റേണിന്റെ സ്ഥാനങ്ങൾ കണ്ടെത്തുന്നു.


The naive algorithm matches the pattern against the text at every position.

എല്ലാ സ്ഥാനത്തും പാറ്റേൺ ടെക്സ്റ്റിനെതിരെ നൈവ് അൽഗോരിതം പൊരുത്തപ്പെടുത്തുന്നു.


The Knuth-Morris-Pratt algorithm runs in linear time.

Knuth-Morris-Pratt അൽഗോരിതം രേഖീയ സമയത്തിനുള്ളിൽ പ്രവർത്തിക്കുന്നു.


The KMP algorithm is a refined version of the naive algorithm.

KMP അൽഗോരിതം നൈവ് അൽഗോരിതത്തിന്റെ പരിഷ്കരിച്ച പതിപ്പാണ്.


The core of a string is the longest proper prefix and suffix.

ഒരു സ്ട്രിംഗിന്റെ കാമ്പ് ഏറ്റവും വലിയ ശരിയായ പ്രിഫിക്സും സഫിക്സുമാണ്.


The KMP algorithm pre-computes the cores of all prefixes of the pattern.

KMP അൽഗോരിതം പാറ്റേണിന്റെ എല്ലാ പ്രിഫിക്സുകളുടെയും കോറുകൾ മുൻകൂട്ടി കണക്കാക്കുന്നു.


Incremental computation of the core is crucial for efficiency.

കാമ്പിന്റെ ഇൻക്രിമെന്റൽ കണക്കുകൂട്ടൽ കാര്യക്ഷമതയ്ക്ക് നിർണായകമാണ്.


rev എന്ന ഫംഗ്ഷൻ ഒരു പവർലിസ്റ്റിനെ വിപരീതമാക്കുന്നു.


Scalar functions operate on scalars and return a scalar value.

സ്കേലർ ഫംഗ്ഷനുകൾ സ്കേലറുകളിൽ പ്രവർത്തിക്കുകയും ഒരു സ്കേലർ മൂല്യം നൽകുകയും ചെയ്യുന്നു.


The base case of a powerlist is a singleton list, not an empty list.

ഒരു പവർലിസ്റ്റിന്റെ അടിസ്ഥാന കേസ് ഒരു സിംഗിൾടൺ ലിസ്റ്റാണ്, ശൂന്യമായ ലിസ്റ്റല്ല.


In matrix algorithms, the base case is a 1x1 matrix.

മാട്രിക്സ് അൽഗോരിതങ്ങളിൽ, അടിസ്ഥാന കേസ് ഒരു 1x1 മാട്രിക്സാണ്.


The recursive definition of a powerlist says that it is either of the form p|q or u ./ v.

ഒരു പവർലിസ്റ്റിന്റെ റിcursive നിർവചനം പറയുന്നത്, അത് p|q അല്ലെങ്കിൽ u ./ v എന്നീ രൂപത്തിലായിരിക്കും എന്നാണ്.


A simple way to view p|q=L is that if the elements of L are indexed by n-bit strings.

p|q=L എന്നതിനെക്കുറിച്ചുള്ള ലളിതമായ ഒരു വീക്ഷണം, L-ന്റെ ഘടകങ്ങൾ n-ബിറ്റ് സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് സൂചികയിലാക്കിയാൽ.


The Fast Fourier Transform is a prominent example of an algorithm that exploits both forms of construction.

രൂപകൽപ്പനയുടെ രണ്ട് രൂപങ്ങളും പ്രയോജനപ്പെടുത്തുന്ന ഒരു അൽഗോരിതത്തിന്റെ മികച്ച ഉദാഹരണമാണ് ഫാസ്റ്റ് ഫോറിയർ ട്രാൻസ്ഫോം.


The length of a powerlist is a power of 2.

ഒരു പവർലിസ്റ്റിന്റെ നീളം 2-ന്റെ ശക്തിയാണ്.


These laws can be derived by suitably defining tie and zip.

ഈ നിയമങ്ങൾ, ടൈ, സിപ് എന്നിവയെ κατάλληλα നിർവചിക്കുന്നതിലൂടെ ലഭിക്കും.


Law L3 is crucial; it is the only law relating the two construction operators.

നിയമം L3 വളരെ പ്രധാനമാണ്; രണ്ട് നിർമ്മാണ ഓപ്പറേറ്റർമാരെ ബന്ധിപ്പിക്കുന്ന ഒരേയൊരു നിയമം ഇതാണ്.


Most proofs on powerlists are by induction on the length, depth or shape of the list.

പവർലിസ്റ്റുകളെക്കുറിച്ചുള്ള മിക്ക തെളിവുകളും ലിസ്റ്റിന്റെ നീളം, ആഴം അല്ലെങ്കിൽ ആകൃതി എന്നിവയെ ആശ്രയിച്ചുള്ള ഇൻഡക്ഷൻ വഴിയാണ്.


The shape and the type of the scalar elements define the structure of a powerlist completely.

സ്കേലർ ഘടകങ്ങളുടെ ആകൃതിയും തരവും ഒരു പവർലിസ്റ്റിന്റെ ഘടന പൂർണ്ണമായി നിർവചിക്കുന്നു.


We show a few small algorithms on powerlists.

പവർലിസ്റ്റുകളിൽ കുറച്ച് ചെറിയ അൽഗോരിതങ്ങൾ ഞങ്ങൾ കാണിക്കുന്നു.


These include such well-known examples as the Fast Fourier Transform and Batcher sorting schemes.

ഫാസ്റ്റ് ഫോറിയർ ട്രാൻസ്ഫോം, ബാച്ചർ സോർട്ടിംഗ് സ്കീമുകൾ തുടങ്ങിയ അറിയപ്പെടുന്ന ഉദാഹരണങ്ങൾ ഇതിൽ ഉൾപ്പെടുന്നു.


We define a few functions that permute the elements of powerlists.

പവർലിസ്റ്റുകളുടെ ഘടകങ്ങളെ പെർമ്യൂട്ട് ചെയ്യുന്ന കുറച്ച് ഫംഗ്ഷനുകൾ ഞങ്ങൾ നിർവചിക്കുന്നു.


The function rev, defined in Section 8.2.2, is a permutation function.

8.2.2-ാം വകുപ്പിൽ നിർവചിച്ചിട്ടുള്ള rev എന്ന ഫംഗ്ഷൻ ഒരു പെർമ്യൂട്ടേഷൻ ഫംഗ്ഷനാണ്.


A powerlist may be rotated through an arbitrary amount, k, by applying k successive rotations.

k തുടർച്ചയായ റൊട്ടേഷനുകൾ പ്രയോഗിക്കുന്നതിലൂടെ, ഒരു പവർലിസ്റ്റിനെ k എന്ന അളവിൽ ഇഷ്ടമുള്ള രീതിയിൽ റൊട്ടേറ്റ് ചെയ്യാൻ കഴിയും.


A better scheme for rotating (u ./ v) by k is to rotate both u, v by about k/2.

(u ./ v)-യെ k-ആയി റൊട്ടേറ്റ് ചെയ്യുന്നതിനുള്ള നല്ലൊരു രീതി u, v എന്നിവയെ ഏകദേശം k/2-ആയി റൊട്ടേറ്റ് ചെയ്യുക എന്നതാണ്.


For a powerlist of 2^n elements we associate an n-bit index with each element.

2^n ഘടകങ്ങളുള്ള ഒരു പവർലിസ്റ്റിനായി, ഓരോ ഘടകത്തിനും n-ബിറ്റ് സൂചികയെ ഞങ്ങൾ ബന്ധപ്പെടുത്തുന്നു.


The function inv is defined by the following function on indices.

inv എന്ന ഫംഗ്ഷൻ സൂചികകളിൽ താഴെ പറയുന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിർവചിക്കപ്പെട്ടിരിക്കുന്നു.


The algorithms in this paper use an inductive theorem prover.

ഈ പേപ്പറിലെ അൽഗോരിതങ്ങൾ ഇൻഡക്റ്റീവ് തിയറം പ്രൂവർ ഉപയോഗിക്കുന്നു.


They are extending their theorem prover.

അവർ അവരുടെ സിദ്ധാന്തം തെളിയിക്കുന്നതിനുള്ള ഉപകരണം വികസിപ്പിക്കുകയാണ്.


One of the fundamental problems is devising compilation strategies.

അടിസ്ഥാനപരമായ പ്രശ്നങ്ങളിലൊന്ന് സമാഹരണ തന്ത്രങ്ങൾ രൂപകൽപ്പന ചെയ്യുക എന്നതാണ്.


The architecture that is the closest conceptually is the hypercube.

ഏറ്റവും അടുത്ത ആശയം ഹൈപ്പർക്യൂബാണ്.


Combinational circuit verification is an area where powerlist notation may be employed.

കോമ്പിനേഷണൽ സർക്യൂട്ട് പരിശോധന പവർലിസ്റ്റ് നൊട്ടേഷൻ ഉപയോഗിക്കാവുന്ന ഒരു മേഖലയാണ്.


Adams has proved the correctness of adder circuits.

ആഡർ സർക്യൂട്ടുകളുടെ ശരിതെറ്റുകൾ ആഡംസ് തെളിയിച്ചിട്ടുണ്ട്.


A ripple-carry adder is typically easy to describe.

ഒരു റിപ്പിൾ-കാരി ആഡർ സാധാരണയായി വിവരിക്കാൻ എളുപ്പമാണ്.


A carry-lookahead adder is much more difficult.

ഒരു കാരി-ലുക്ക്അഹെഡ് ആഡർ കൂടുതൽ ബുദ്ധിമുട്ടാണ്.


He obtains a succinct description of the carry-lookahead circuit.

അദ്ദേഹം കാരി-ലുക്ക്അഹെഡ് സർക്യൂട്ടിന്റെ സംക്ഷിപ്ത വിവരണം നൽകുന്നു.


ഏകപക്ഷീയമായ നീളമുള്ള പവർലിസ്റ്റുകൾ


Steele suggests padding enough "dummy" elements.

ശരിയായ “ഡമ്മി” ഘടകങ്ങൾ ചേർക്കാൻ സ്റ്റീൽ നിർദ്ദേശിക്കുന്നു.


This scheme retains the simple algebraic laws.

ഈ രീതി ലളിതമായ ബീജഗണിത നിയമങ്ങൾ നിലനിർത്തുന്നു.


Another approach is based on the observation.

മറ്റൊരു സമീപനം നിരീക്ഷണത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


The last line of this definition applies to a non-singleton list.

ഈ നിർവചനത്തിന്റെ അവസാന വരി, സിംഗിൾടൺ അല്ലാത്ത ലിസ്റ്റിന് ബാധകമാണ്.


The notation proposed in this paper addresses only a small aspect.

ഈ പേപ്പറിൽ നിർദ്ദേശിച്ചിട്ടുള്ള ഈ രീതി, ഒരു ചെറിയ ഭാഗത്തെക്കുറിച്ച് മാത്രം പറയുന്നു.


Powerlists have proved to be highly successful.

പവർലിസ്റ്റുകൾ വളരെ വിജയകരമാണെന്ന് തെളിയിക്കപ്പെട്ടിട്ടുണ്ട്.


Parallel and sequential computations are interleaved.

സമാന്തരവും, ക്രമാനുഗതവുമായ കമ്പ്യൂട്ടിംഗുകൾ ഇടകലർത്തിയിരിക്കുന്നു.


Gaussian elimination represents a mixture.

ഗൗസിയൻ ഒഴിവാക്കൽ ഒരു മിശ്രിതത്തെ പ്രതിനിധീകരിക്കുന്നു.


The powerlist notation can be integrated into a language.

പവർലിസ്റ്റ് രീതി ഒരു ഭാഷയിലേക്ക് സംയോജിപ്പിക്കാൻ കഴിയും.


A mixture of linear lists and powerlists can exploit various combinations.

നേർരേഖയിലുള്ള ലിസ്റ്റുകളുടെയും, പവർലിസ്റ്റുകളുടെയും മിശ്രിതം വിവിധ കോമ്പിനേഷനുകൾ പ്രയോജനപ്പെടുത്തും.


The prefix sum is of fundamental importance in parallel computing.

സമാന്തര കമ്പ്യൂട്ടിംഗിൽ പ്രിഫിക്സ് തുക അടിസ്ഥാനപരമായി പ്രാധാന്യമർഹിക്കുന്നു.


We show that two known algorithms for this problem can be concisely represented and proved in our theory.

ഈ പ്രശ്നത്തിനായുള്ള രണ്ട് അറിയപ്പെടുന്ന അൽഗോരിതങ്ങൾ നമ്മുടെ സിദ്ധാന്തത്തിൽ സംഗ്രഹിക്കുകയും തെളിയിക്കുകയും ചെയ്യാമെന്ന് ഞങ്ങൾ കാണിക്കുന്നു.


Initially, processor i holds the list element L i, for all i.

തുടക്കത്തിൽ, എല്ലാ i-ക്കും, പ്രോസസ്സർ i, ലിസ്റ്റ് എലമെന്റ് L i കൈവശം വെക്കുന്നു.


The connections among the processors at different levels depict data transmissions.

വിവിധ തലങ്ങളിലുള്ള പ്രോസസ്സറുകൾ തമ്മിലുള്ള ബന്ധങ്ങൾ ഡാറ്റാ കൈമാറ്റം ചിത്രീകരിക്കുന്നു.


Each processor updates its own data, d, to r ⊕ d where r is the data it receives.

ഓരോ പ്രോസസ്സറും അതിൻ്റെ സ്വന്തം ഡാറ്റ, d, r ⊕ d ആയി അപ്‌ഡേറ്റ് ചെയ്യുന്നു, അവിടെ r എന്നത് അതിന് ലഭിക്കുന്ന ഡാറ്റയാണ്.


It can be shown that after completion of the computation at level (log 2 (len L)), processor i holds the i th element of (ps L).

(log 2 (len L)) ലെവലിൽ കമ്പ്യൂട്ടേഷൻ പൂർത്തിയാക്കിയ ശേഷം, പ്രോസസ്സർ i, (ps L)-ൻ്റെ i-ാം ഘടകം കൈവശം വെക്കുമെന്ന് ഇത് കാണിക്കാൻ കഴിയും.


Another scheme, due to Ladner and Fischer, first applies ⊕ to adjacent elements x 2i, x 2i+1 to compute the list.

ലാഡ്‌നറും, ഫിഷറും ചേർന്നുള്ള മറ്റൊരു പദ്ധതി, ലിസ്റ്റ് കണക്കാക്കാൻ, അടുത്തടുത്തുള്ള ഘടകങ്ങളായ x 2i, x 2i+1 എന്നിവയിലേക്ക് ആദ്യം ⊕ പ്രയോഗിക്കുന്നു.


This list has half as many elements as the original list.

ഈ ലിസ്റ്റിന് യഥാർത്ഥ ലിസ്റ്റിൻ്റെ പകുതി ഘടകങ്ങൾ ഉണ്ട്.


Both schemes for prefix computation are inherently recursive.

പ്രിഫിക്സ് കണക്കുകൂട്ടലിനായുള്ള രണ്ട് സ്കീമുകളും അന്തർലീനമായി ആവർത്തന സ്വഭാവമുള്ളവയാണ്.


We introduce an operator in terms of which the prefix sum problem can be defined.

പ്രിഫിക്സ് സം പ്രശ്നം നിർവചിക്കാൻ കഴിയുന്ന ഒരു ഓപ്പറേറ്ററെ ഞങ്ങൾ അവതരിപ്പിക്കുന്നു.


First, we postulate that 0 is the left identity element of ⊕, i.e., 0 ⊕ x = x.

ആദ്യം, 0 എന്നത് ⊕-ൻ്റെ ഇടത് ഐഡൻ്റി ഘടകമാണെന്ന് ഞങ്ങൾ അനുമാനിക്കുന്നു, അതായത്, 0 ⊕ x = x.


For a powerlist p, let p * be the powerlist obtained by shifting p to the right by one.

ഒരു പവർലിസ്റ്റ് p-ക്ക്, p * എന്നത് p-യെ ഒന്ന് വലത്തേക്ക് മാറ്റുന്നതിലൂടെ ലഭിക്കുന്ന പവർലിസ്റ്റായിരിക്കട്ടെ.


The effect of shifting is to append a 0 to the left and discard the rightmost element of p.

മാറ്റുന്നതിൻ്റെ ഫലം, ഇടത് ഭാഗത്ത് ഒരു 0 ചേർക്കുകയും p-യുടെ വലത് അറ്റത്തുള്ള ഘടകം ഒഴിവാക്കുകയും ചെയ്യുക എന്നതാണ്.


Consider the following equation in the powerlist variable z.

പവർലിസ്റ്റ് വേരിയബിൾ z-ലെ താഴെയുള്ള സമവാക്യം പരിഗണിക്കുക.


This equation has a unique solution in z, because z 0 = (z * ) 0 ⊕ L 0 = 0 ⊕ L 0 = L 0, and z i+1 = z i ⊕ L i+1, 0 ≤ i < (len L) - 1

ഈ സമവാക്യത്തിന് z-ൽ ഒരു അദ്വിതീയ പരിഹാരമുണ്ട്, കാരണം z 0 = (z * ) 0 ⊕ L 0 = 0 ⊕ L 0 = L 0, കൂടാതെ z i+1 = z i ⊕ L i+1, 0 ≤ i < (len L) - 1


We define (ps L) to be the unique solution of (DE), and we call (DE) the defining equation for (ps L).

(ps L)-ൻ്റെ അദ്വിതീയ പരിഹാരമായി (ps L) നെ ഞങ്ങൾ നിർവചിക്കുന്നു, കൂടാതെ (DE)-യെ (ps L)-നുള്ള നിർവചന സമവാക്യമെന്നും വിളിക്കുന്നു.


The operator ⊕ is not necessarily commutative.

ഓപ്പറേറ്റർ ⊕, എല്ലായ്പ്പോഴും ക്രമാനുഗതമായിരിക്കണമെന്നില്ല.


The operator ⊕ is scalar; so, it commutes with ./.

ഓപ്പറേറ്റർ ⊕ സ്കേലാർ ആണ്; അതിനാൽ, ഇത് ./ -മായി ക്രമാനുഗതമാണ്.


The uniqueness of the solution of (DE) can be proved entirely within the powerlist algebra.

(DE)-യുടെ സൊല്യൂഷൻ്റെ അദ്വിതീയത പവർലിസ്റ്റ് ബീജഗണിതത്തിൽ പൂർണ്ണമായും തെളിയിക്കാൻ കഴിയും.


The functions ps (simpleprefixsum) defines the scheme of Figure 8.4.

ps (ലളിതമായ പ്രിഫിക്സം) എന്നത് ചിത്രം 8.4-ലെ സ്കീം നിർവചിക്കുന്നു.