Write Report Essay 3000 5000 Words Following Topic Survey Internet Things Cloud Computing Q43823206
Write a report/essay (should have 3000-5000 words) with thefollowing topic
“A Survey on Internet of Things and Cloud Computing forHealthcare”
Give an introduction to Internet of Things and Computing forHealthcare.
List the Advancements in IT in healthcare.
Should also give (in details) reasons why we need to build SmartHosptials
Should also list and explain the types of IoT and CloudComputing
Should also list and explain (in paragraphs) the benefits,advantages, and disadvantages of IoT and Cloud Computer forHealthcare.
Expert Answer
Answer to Write a report/essay (should have 3000-5000 words) with the following topic “A Survey on Internet of Things and Cloud Co…
Write Report Technology Democracy Q43778898
write a report on technology and democracy?
Expert Answer
Answer to write a report on technology and democracy?…
Write Required Functions Script Prompts User Name File Representing Finite Automaton Indic Q43902850
Write the required functions and script that prompts the userfor the name of a file representing a finite automaton: indicatingits states and input->statetransitions; reads the information in the file(storing the finite automaton in a dictionary); prints thefinite-automaton/dictionary in a special form; prompts the user forthe name of a file storing the start-state and inputs to process(each line in the file contains this combination); repeatedlyprocesses these lines, computing the results of the finiteautomaton on each input, and then prints the results. Note that afinite automaton is really a program; in thisproblem we are reading a program from a file and then executing it(running the finite automaton) on various inputs. So, we are reallywriting a compiler/interpreter for a small programming language.
A finite automaton (FA) is an machine that issometimes called a Deterministic Finite Automaton (DFA; see thenext problem for an NDFA: a non-deterministic finite automaton). AnFA is described by its states and itstransitions: each transition fora state specifies an input andwhat state in the FA that input leads to. We canillustrate an FA as a graph with state labels in circles and edgelabels for transitions (see below).
Input and Output:
Read a file that describes a FA: each line contains a state and anarbitrary number of input->state transitions.Build a dictionary such that each key is a strstate and whose associated value is another dictionary specifyingall the transitions from that state: this second dictionary haskeys that are str inputs and associated values arestr states. The first token on each line is thestr state and the remaining tokens (always comingin pairs) are str inputs and their resultingstates. All tokens (which can comprise any number of characters)are separated by one semicolon character. We annotate thisdictionary as {str:{str:str}}.
For example, the input file faparity.txtcontains the following lines (which could appear in this order, orany other and still specify the same FA):
even;0;even;1;odd odd;0;odd;1;evenHere is a picture of the parity FA. It graphicallyillustrates the two states (evenand odd) and their transitions,using inputs (0and1) that always lead back to one of these twostates.
Here, the state even (meaning it has seen aneven number of 1 inputs so far) is a key in themain dictionary. Its value is a dictionary with two key/value pairs0->even and1->odd. It means that in theeven state, if the input is a 0the FA stays in the even state; if the input is a1 the FA goes to the odd state.And similarly (the next line) means that for theodd state, if the input is a 0the FA stays in the odd state; if the input is a1 the FA goes back to the evenstate. So, seeing an input of 0 keeps the FA inthe same state; seeing an input of 1 flips the FAinto the other state.
Print the finite automaton, one state (and its transitions) perline; the states are printed alphabetically and the transitiondictionary for each state is printed as a list ofinput/state items (tuples) such that these are printedalphabetically by the inputs.
For example, the file above would print as:
The Contents of the file picked for this Finite Automaton even transitions: [(‘0’, ‘even’), (‘1’, ‘odd’)] odd transitions: [(‘0’, ‘odd’), (‘1’, ‘even’)]
Note that there are multiple data files for this program:faparity.txt andfadivisibleby3.txt; test/debug your program on thefirst file; when you are done, test it on the last file. Draw theFA represented by each for to ensure that your code correctlyprints and computes with it. Important: This taskis not to write a Python code that simulates theParity FA; it is to write code that simulates anyFA, whose description it reads from a file.
Next, repeatedly read and process lines from a second inputfile, computing the results of the finite automaton running on thespecified start-state with its inputs; then print out the resultsin a special form. Each line in the file contains a start-statefollowed by a sequence of inputs (all separated by semicolons). Thestart-state will be a state in the FA (it is a key in the outerdictionary) the inputs may specify legal or illegal transitions(may or may not be keys in some inner dictonary).
For example, the input file fainputparity.txtcontains the following three lines:
even;1;0;1;1;0;1 even;1;0;1;1;0;x odd;1;0;1;1;0;1The first line means, the start-state is even andthe inputs are 1, 0,1, 1, 0, and1.
The result of processing each line is to print the start-state,and then each input and the new state it transitions to, andfinally print the stop-state. For the parity FAand the first line in this file, it should print
Start state = even Input = 1; new state = odd Input = 0; new state = odd Input = 1; new state = even Input = 1; new state = odd Input = 0; new state = odd Input = 1; new state = evenStop state = even
Note that the second line contains an input xwhich is not a legal input allowed in any state; any such inputshould stop the simulation for that line only, continuing to starta new simulation for all following lines (as illustrated in theSample Interaction).
Functions and Script:
Write the following functions and script. I am providing linecounts for these function bodies not as requirements, but toindicate the lengths of well-written Pythonic code.
- read_fa has an open (file) parameter; itreturns the dictionary representing the finite automaton;hint: I used splicing and the zipfunction to build the inner dictionaries. (body is 6 lines).
- fa_as_str has a dictionary parameter(representing the FA); it returns a multi-line string (each line isended by ‘n’), which when printed shows thecontents of the FA in the appropriate textual form: sortedalphabetically by state, with a state’s transitions sorted by theirinput value (body is 4 lines; can you do it in 1?).
- process has a dictionary parameter(representing the FA), a str parameter(representing the start-state), and a listparameter (representing a list ofstr inputs); it returns a listthat contains the start-state followed by tuplesthat show the input and resulting state after each transition. Forthe example shown above, process returns thefollowing list.[‘even’, (‘1’, ‘odd’), (‘0’, ‘odd’), (‘1’, ‘even’), (‘1’, ‘odd’), (‘0’, ‘odd’), (‘1’, ‘even’)]Finally, if an input is illegal (is not the key in some transitionfor the current state), say ‘x’, for the parityFA, then processshould terminate with the lasttuple in the list indicating aproblem: (‘x’, None) (body is 9 lines).
- interpret has a listparameter (the list result producedby process); it returns a multi-linestring (each line is ended by ‘n’), which whenprinted illustrates the results of processing an FA on an input inthe appropriate textual form. See how it prints the examplelist argument shown above in the output furtherabove. Also see the Sample Interaction below tosee how it prints input errors: see the middle example(body is 9 lines).
- Write a script at the bottom of this module (in if__name__ == ‘__main__’:) that prompts the user to enterthe file describing the FA, prints it, prompts the user to enterthe file containing lines of start-states and input, simulates theFA on each line, printing the results in the appropriate textualform (body is 7 lines).
Sample Interaction:
The program, as specified, will have the following interaction:user-typed information appears in italics. Your outputshould match this one. Pick the file name containing this Finite Automaton: faparity.txt The Contents of the file picked for this Finite Automaton even transitions: [(‘0’, ‘even’), (‘1’, ‘odd’)] odd transitions: [(‘0’, ‘odd’), (‘1’, ‘even’)] Pick the file name containing a sequence of start-states and subsequent inputs: fainputparity.txt Commence tracing this FA from its start-state Start state = even Input = 1; new state = odd Input = 0; new state = odd Input = 1; new state = even Input = 1; new state = odd Input = 0; new state = odd Input = 1; new state = even Stop state = even Commence tracing this FA from its start-state Start state = even Input = 1; new state = odd Input = 0; new state = odd Input = 1; new state = even Input = 1; new state = odd Input = 0; new state = odd Input = x; illegal input: simulation terminated Stop state = None Commence tracing this FA from its start-state Start state = odd Input = 1; new state = even Input = 0; new state = even Input = 1; new state = odd Input = 1; new state = even Input = 0; new state = even Input = 1; new state = odd Stop state = odd
You can also try the fadivisibleby3.txt finiteautomaton file, which determines whether an integer (sequence ofdigits) is divisible by 3: it is divisible if thefinite automaton stops in state rem0. It’s inputfile fainputdivisibleby3.txt tries thenumber12,435,711, which is divisible by3 and number 823, which is notdivisible by 3: dividing 823 by3 leaves a remainder of 1.
even odd Show transcribed image text even odd
Expert Answer
Answer to Write the required functions and script that prompts the user for the name of a file representing a finite automaton: in…
Write Required Functions Script Solve Non Deterministic Finite Automaton Problem Solved De Q43902860
Write the required functions and script that solve, for aNon-Deterministic Finite Automaton, the same problem that wassolved for a Deterministic Finite Automaton in Problem #3 (above).Read about the differences between these two automata (below).Hint: Adapt your code for the FA problem to solve the more generalNDFA problem.
A non-deterministic finite automaton (NDFA) is machine describedby its states and itstransitions: each transition fora statespecifies an input and aset of states (more than one isallowed) that input can lead to: sets withmore than one states is what makes itnon-deterministic. We can illustrate a NDFA as a graph with statelabels in circles and edge labels for transitions (see below). Thecritical difference between an FA and an NDFA is that an NDFA canhave multiple edges with the same label going to different states(we’ll see how to represent and simulate such transitionsbelow).
Input and Output:
Read a file that describes a NDFA: each line contains a state andan arbitrary number of input->statetransitions. Build a dictionary such that each keyis a str state and whose associated value isanother dictionary specifying all the transitions from that state:this second dictionary has keys that are strinputs and associated values that are sets ofstr states: all the states a particular input canlead to. The first token on each line is the strstate and the remaining tokens (always coming in pairs) arestrinputs and states. All tokens (which cancomprise any number of characters) are separated by one semicoloncharacter. We annotate this dictionary as{str:{str:{str}}}.
For example, the input file ndfaendin01.txtcontains the following lines (which could appear in this order, orany other and still specify the same NDFA):
start;0;start;1;start;0;near near;1;end endHere is a picture of the endin01 NDFA. Itgraphically illustrates the three states(start, near, andend) and their transitions, usinginputs (0 and1).
Here, the state start is a key in the maindictionary. It’s value is a dictionary with two key/value pairs:0 mapping to the setcontainingstart and near, and1 mapping to the set containingjust start. It means that in thestart state, if the input is a 0the NDFA can stay in the start state or it can goto the near state; if the input is a1 the NDFA must stay in the startstate. And similarly the next line means that in thenear state, if the input is a 1the NDFA must go into the end state. The last linemeans that the end state has no transitions out ofit.
Print the NDFA, one state (and its transitions) per line; thestates are printed alphabetically and the transition dictionary foreach state is printed as a list of input/set ofstate items (2-tuples) such that these are printed alphabeticallyby the inputs, and the set of states for each input is printed asan alphabetically sorted list (e.g., near comesbefore start). Note that the stateend is a key in the main dictionary, whoseassociated transitions are an empty dictionary.
For example, the file above would produce:
The Contents of the file picked for this Non-Deterministic Finite Automaton end transitions: [] near transitions: [(‘1’, [‘end’])] start transitions: [(‘0’, [‘near’, ‘start’]), (‘1’, [‘start’])]
Note that there are multiple data files for this program:ndfaendin01.txt and ndfatrain.txtand ndfare.txt;; test/debug your program on thefirst file; when you are done, test it on the last file. Draw theFA represented by each for to ensure that your code correctlyprints and computes with it.
Next, repeatedly read and process lines from a second inputfile, computing the results of the non-determinisitc finiteautomaton on the specified start-state with its inputs ; then printout the results in a special form. Each line in the file contains astart-state followed by a sequence of inputs (all separated bysemicolons). The start-state will be a state in the FA (it is a keyin the outer dictionary) the inputs may specify legal or illegaltransitions (may or may not be keys in some inner dictionary).
For example, the input filendfainputendin01.txt contains the following twolines:
start;1;0;1;1;0;1 start;1;0;1;1;0;0For example, the first line means, the start-state isstart and the inputs 1,0, 1, 1,0, and 1.
The result of processing each line is to print the start-state,and then each input and the new states (plural) it could transitionto (the could is what makes it non-deterministic),and finally print the stop-states. For thendfaendin01 NDFA and the first line in this file,it should print
Start state = start Input = 1; new possible states = [‘start’] Input = 0; new possible states = [‘near’, ‘start’] Input = 1; new possible states = [‘end’, ‘start’] Input = 1; new possible states = [‘start’] Input = 0; new possible states = [‘near’, ‘start’] Input = 1; new possible states = [‘end’, ‘start’] Stop state(s) = [‘end’, ‘start’]
Note that the set of states it might be in areprinted as an alphabetized list. Also noteespecially that in the start state, if the inputis a 0, then the NDFA can either remain in thestart state or go into the nearstate. For this program, we keep track of all states that the NDFAcan be in, using a set ofnew possible states. For the next input,1, we can be either in the startstate (from the start state; an input of1 allows us to stay in the startstate) or the end state (from thenear state; an input of 1 allowsus to transition to the end state). Thus, we keeptrack of the set of states the NDFA can be in, andthe new set of states the NDFA can be in afterprocessing the next input. In this example, because‘end’ is included in the stop-states, this inputdoes end in 01.
For any state that does not have a transition specifying thecurrent input, ignore that input for that state. For example, ifnear is one of the possible states and0 is the input, ignore the 0 forthe near state.
Functions and Script:
Write the following functions and script. I am providing linecounts for these function bodies not as requirements, but toindicate the lengths of well-written Pythonic code.
- read_ndfa has an open (file) parameter; itreturns the dictionary representing the non-deterministic finiteautomaton; hint: I used splicing and thezip function to build the inner dinctionaries, andI called the setdefault function for the innerdict: alternatively I could have built it asdefaultdicts from thestandard collections module (body is 9lines).
- ndfa_as_str has a dictionary parameter(representing the FA); it returns a multi-line string (each line isended by ‘n’), which when printed shows thecontents of the NDFA in the appropriate textual form: sortedalphabetically by state, with a state’s transitions sorted by theirinput values, and sorted by states if an input results in multiplestates (body is 4 lines; can you do it in 1?).
- process has a dictionary parameter(representing the NDFA), a str parameter(representing the start-state), and alistparameter (representing alist of str inputs); it returns alist that contains the start-state followed bytuples that show the input and resultingset of states after each transition. For theexample shown above, process returns the followinglist. [‘start’, (‘1’, {‘start’}), (‘0’, {‘near’, ‘start’}), (‘1’, {‘end’, ‘start’}), (‘1’, {‘start’}), (‘0’, {‘near’, ‘start’}), (‘1’, {‘end’, ‘start’})]Finally, remember that if an input is illegal for the current state(is not the key in some transition for the current state), justignore it. But if the input leads to no possible states (the emptyset of states) terminate processing there (body is 12 lines).
- interpret has a listparameter (the list result produced byprocess); it returns a multi-line string (eachline is ended by ‘n’), which when printedillustrates the results of processing an NDFA on an input in theappropriate textual form. Note that in this output thesets computed in process appearas lists sorted alphabetically by state. See howit prints the example list argument shown above inthe Sample Interaction below (body is 5lines).
- Write a script at the bottom of this module (in if__name__ == ‘__main__’:) that prompts the user to enterthe file describing the NDFA, prints it, prompts the user to enterthe file containing lines of start-states and input, and simulatesthe NDFA on each line, printing the results in the appropriatetextual form (body is 7 lines).
Sample Interaction:
The program, as specified, will have the following interaction:user-typed information appears in italics. Your outputshould “match” this one. Pick the file name containing this Non-Deterministic Finite Automaton: ndfaendin01.txt The Contents of the file picked for this Non-Deterministic Finite Automaton end transitions: [] near transitions: [(‘1’, [‘end’])] start transitions: [(‘0’, [‘near’, ‘start’]), (‘1’, [‘start’])] Pick the file name containing a sequence of start-states and subsequent inputs: ndfainputendin01.txt Commence tracing this NDFA from its start-state Start state = start Input = 1; new possible states = [‘start’] Input = 0; new possible states = [‘near’, ‘start’] Input = 1; new possible states = [‘end’, ‘start’] Input = 1; new possible states = [‘start’] Input = 0; new possible states = [‘near’, ‘start’] Input = 1; new possible states = [‘end’, ‘start’] Stop state(s) = [‘end’, ‘start’] Commence tracing this NDFA from its start-state Start state = start Input = 1; new possible states = [‘start’] Input = 0; new possible states = [‘near’, ‘start’] Input = 1; new possible states = [‘end’, ‘start’] Input = 1; new possible states = [‘start’] Input = 0; new possible states = [‘near’, ‘start’] Input = 0; new possible states = [‘near’, ‘start’] Stop state(s) = [‘near’, ‘start’]
In Week #2 of this course we will cover EBNF and regularexpressions, which relate to the files below. You can run thesefiles on your code to ensure they produce the correct results.
The ndfatrain.txt file is a non-deterministicfinite automaton that determines whether or not a train (a sequenceof characters representing different kinds of cars) is a legaltrain according to Chapter Exercise #7 in the ENBF lecture. Itsinput file is ndfainputtrain.txt, which startswith a legal train (one that ends with the statedone as one possible state) followed by an illegaltrain (one that does not end with the state doneas one possible state).
The ndfare.txt file is a non-deterministicfinite automaton translation of the regular expression((a*|b)cd)+. Its input file isndfainputre.txt, which starts with a match (onethat ends with the state last as one possiblestate) followed by a non-match (one that does not end with thestate last as one possible state).
0,1 start near end Show transcribed image text 0,1 start near end
Expert Answer
Answer to Write the required functions and script that solve, for a Non-Deterministic Finite Automaton, the same problem that was …
Write Rmi Java Code Uses Gui Client Side Check Whether Username Java Netbeans Database Tab Q43876842
write an RMI Java code that uses the below GUI from client-sideand check whether the username from the java Netbeans databasetable that already created and pop up the sucess or not foundmessage if its found and if not popup. but the GUI should bedesigned from the Jframe.
Username Password Login Cancel Show transcribed image text Username Password Login Cancel
Expert Answer
Answer to write an RMI Java code that uses the below GUI from client-side and check whether the username from the java Netbeans da…
Write Run Experiment Mapreduce Task Perform Big Matrix Multiplication Apache Spark Languag Q43786317
Write, run and experiment a MapReduce task to be performa big matrix multiplication over Apache Spark in the language youprefer. Choose a matrix at least 500 x 500 elements. Use the coresof your computer to involve gradual number of workers, startingwith one, two, four, eight works to check the performance in termsof speedup.
Expert Answer
Answer to Write, run and experiment a MapReduce task to be perform a big matrix multiplication over Apache Spark in the language y…
Write Script Find Display Sum First N Terms Following B Series Correct 2 Decimal Places 1 Q43795257
Can you show the correct MATLAB script for this? Thanks
Write a script to find and display the sum of the first n terms of the following (b) series correct to 2 decimal places: 1 3 5 7 8. 2 Show transcribed image text Write a script to find and display the sum of the first n terms of the following (b) series correct to 2 decimal places: 1 3 5 7 8. 2
Expert Answer
Answer to Write a script to find and display the sum of the first n terms of the following (b) series correct to 2 decimal places:…
Write Script Java Language Let Get Hidden Links Image Urls Total Count Urls Total Count Hi Q43807938
write script in java language which let you get all hiddenlinks, image urls, total count of urls and total count of hiddenlinks. use website amazon.com
Expert Answer
Answer to write script in java language which let you get all hidden links, image urls, total count of urls and total count of hid…
Write Search Expression Would Use Following Using Google S Syntax Information Winners Aust Q43900063
Write the search expression you would use for the following(using Google’s syntax):
(a) Information on the winners of the Australian Open from 2016 to2019 (2 marks)
(b) Web pages of bochk.com without www in URL. (2 marks)
(c) Information about INTERNET2 excluding pages from Wikipedia (2marks)
(d) Pages where the term “EJU Test” appears in the title (2marks)
(e) Information on the song “Man on the Moon” by the band R.E.M (2marks)
(f) Power point presentations on social media marketing fromacademic web sites only (4 marks)
Expert Answer
Answer to Write the search expression you would use for the following (using Google’s syntax): (a) Information on the winners of…
Write Select Statement Select Vendorname Vendorcontactlastname Vendorcontactfirstname Vend Q43893703
Write the same SELECT statement from SELECT vendor_name,vendor_contact_last_name, vendor_contact_first_name FROM vendorsORDER vendor_contact_last_name, vendor_contact_first_name ASC andadditionally add a WHERE clause that limits the results to onlythose last names that begin with A or B. (Hint, LIKE is the way todo this; this will give you 26 rows.
Expert Answer
Answer to Write the same SELECT statement from SELECT vendor_name, vendor_contact_last_name, vendor_contact_first_name FROM vendor…