Answer:
import java.util.*;
public class num3 {
public static void main(String[] args) {
String sentence = "All good people";
System.out.println("The vowels in the sentence are ");
returnVowels(sentence);
}
public static void returnVowels(String word){
String newWord = word.toLowerCase();
String vowels ="";
for (int i = 0; i < newWord.length(); i++){
if(newWord.charAt(i)=='a'||newWord.charAt(i)=='e'||newWord.charAt(i)==i||
newWord.charAt(i)=='o'||newWord.charAt(i)=='u'){
vowels = vowels+newWord.charAt(i);
//System.out.print(newWord.charAt(i)+" ");
}
}
String [] chars = vowels.split("");
Set<String> uniqueVowels = new LinkedHashSet<>();
for (String s : chars) {
uniqueVowels.add(s);
}
System.out.println(uniqueVowels);
}
}
Explanation:
In Java
Create the method/function to receive a string as argument
Change the string to all small letters using the toLowerMethod
Iterate through the string using if statement identify the vowels and store in a new String
Since the sentence does not contain unique vowel characters, use the set collections in java to extract the unique vowels and print out
Programming Project 6: GUI program
Last program assignment.
You need to create the Graphical User Interface program that allows a user to select their lunch items and have the program calculate the total. Use tkinter to produce a form that looks much like the following. It doesn't need to look exactly like this, but the drinks should all be in a row, the entrees should all be in a row, the desserts should all be in a row, and the 2 buttons should all be in a row. Use the grid layout manager to make all this happen.
Because of the radio buttons, in the program the user can select only one drink. For the entrees and desserts, any combination of selections is possible. Perfect alignment is not a requirement.
For full credit:
Use a class that inherits from Frame to implement your program.
Your program should display all the labels as shown in the image.
the drinks should be radio buttons, all on a row, the other items should be checkboxes in their respective rows.
The correct total rounded to 2 decimal places should appear in the total entry box only when the Calculate Total button is clicked, and the Clear Form button should put the form back into its default state, as shown in the image above..
Arrange the widgets more or less a shown above. I recommend using the grid layout manager for this. .
Here is a possible program run. Oh, and it would help a little if you spelled Total correctly.
Answer:
Explanation:
So i have issues typing it here, because it keeps saying trouble uploading your answer as a result of inappropriate words/links, so i will just make a screenshot of it.......
Just save the the above code in python file and execute it, you should arrive at your answer.
Attached below is the code and sample screenshot of what you should expect
cheers !!!!
This project involves writing a java program to simulate a blackjack card game. You will use a simple console-based user interface to implement this game.
A simple blackjack card game consists of a player and a dealer. A player is provided with a sum of money with which to play. A player can place a bet between $0 and the amount of money the player has. A player is dealt cards, called a hand. Each card in the hand has a point value. The objective of the game is to get as close to 21 points as possible without exceeding 21 points. A player that goes over is out of the game. The dealer deals cards to itself and a player. The dealer must play by slightly different rules than a player, and the dealer does not place bets. A game proceeds as follows:
A player is dealt two cards face up. If the point total is exactly 21 the player wins immediately. If the total is not 21, the dealer is dealt two cards, one face up and one face down. A player then determines whether to ask the dealer for another card (called a "hit") or to "stay" with his/her current hand. A player may ask for several "hits." When a player decides to "stay" the dealer begins to play. If the dealer has 21 it immediately wins the game. Otherwise, the dealer must take "hits" until the total points in its hand is 17 or over, at which point the dealer must "stay." If the dealer goes over 21 while taking "hits" the game is over and the player wins. If the dealer’s points total exactly 21, the dealer wins immediately. When the dealer and player have finished playing their hands, the one with the highest point total is the winner. Play is repeated until the player decides to quit or runs out of money to bet.
You must use an object-oriented solution for implementing this game.
Answer:i dont know sorry
Explanation:
Write the Python code to implement each step of the following algorithm. Your code should use descriptive variable names and perform all of the calculations necessary using the variables you define. You should not manually perform any calculation.
Answer:
# the number of pizza is initialised
# to 5
number_of_pizza = 5
# number of slice in each pizza
# is initialised to 8
slice_in_each_pizza = 8
# total number of pizza is calculated
total_number_of_slices = number_of_pizza * slice_in_each_pizza
# number of guest who respond yes
# is initialised to 10
number_of_guest_respond_yes = 10
# additional 3 guest is added to existing guest
number_of_guest_respond_yes += 3
# number of left over slice is gotten by using modulo arithmetic
number_of_left_over_slice = total_number_of_slices % number_of_guest_respond_yes
# the number of left over slice
# is printed which is 1
print(number_of_left_over_slice)
Explanation:
Missing Question Part: Use a variable to store the number of pizzas ordered as 5.
Assuming there are 8 slices in each pizza, use a variable to store the total number of slices calculated using the number of pizzas ordered.
Use another variable to store the number of guests who had responded YES as 10.
Three more people responded YES. Update the corresponding variable using an appropriate expression.
Based on the guest count, set up an expression to determine the number of left-over slices if the slices would be evenly distributed among the guests. Store the result of the expression in a variable.
The program is written in Python and it is well commented.
Recall that two strings u and v are ANAGRAMS if the letters of one can be rearranged to form the other, or, equivalently, if they contain the same number of each letter. If L is a language, we define its ANAGRAM CLOSURE AC(L) to be the set of all strings that have an anagram in L. Prove that the set of regular languages is _not_ closed under this operation. That is, find a regular language L such that AC(L) is not regular. (We’re now allowed to use Kleene’s Theorem, so you just need to show that AC(L) is not recognizable.)
Final answer:
We use a non-regular language, L = {a^n b^n | n ≥ 0}, to demonstrate by contradiction that the anagram closure AC(L) including strings with any order of 'a's and 'b's cannot be recognized by a finite automaton, proving that the set of regular languages is not closed under the operation of forming an anagram closure.
Explanation:
To prove that the set of regular languages is not closed under the operation of forming the anagram closure (AC), let us consider a simple regular language L over some alphabet Σ such that L = {anbn | n ≥ 0}. Although this definition of language L leads to a non-regular language, it is routinely used in theoretical computer science as a starting point to demonstrate properties of language classes. For the sake of argument, we are considering the set of strings where the number of 'a's is equal to the number of 'b's, and for our purposes, this forms our regular language L.
The anagram closure of L, AC(L), would include all strings with equal numbers of 'a's and 'b's regardless of order. However, if we consider languages recognizable by finite automata, which are a characterization of regular languages due to Kleene's Theorem, we realize that a finite automaton cannot keep count of an unbounded number of characters, and thus cannot recognize a language that has an unbounded interchangeable ordering of 'a's and 'b's with equality. This makes AC(L) non-regular because a finite state machine cannot handle the counting necessary for validating anagrams in this context.
Therefore, since AC(L) is not recognizable by a finite automaton, it follows that the set of regular languages is not closed under the operation of taking an anagram closure, and we have our proof by contradiction.
Package Newton’s method for approximating square roots (Case Study 3.6) in a function named newton. This function expects the input number as an argument and returns the estimate of its square root. The script should also include a main function that allows the user to compute square roots of inputs until she presses the enter/return key.
Final answer:
The question is about creating a programming function named newton that utilizes Newton's method for an efficient approximation of square roots without solving for quadratic equation roots. The function is applicable in various mathematical scenarios, particularly where manual computation is required, such as in equilibrium problems.
Explanation:
The student's question relates to the programming of a function called newton that implements Newton's method for approximating square roots. The method is a mathematical approach that allows for expedient calculations by avoiding the need to solve for the roots of a quadratic equation. Newton's method is particularly useful in situations where square roots need to be computed manually or understood conceptually, such as in some equilibrium problems in chemistry or physics. By creating a function and utilizing a loop, users can repeatedly input numbers and receive an estimate of the square root until the enter/return key is pressed.
In the context of programming, it can be wrapped in a function to allow for repeated efficient calculation of the square root of any positive number. The square root function is fundamental in handling various mathematical computations like in equilibrium problems or any scenario where roots need to be analyzed for a final answer. Also, understanding the approximate square root computation is beneficial for students working without a calculator or aiming to grasp the underpinning principles of square roots and exponents, as indicated by √x² = √x.
Final answer:
The newton function can be implemented in Python using Newton's method for approximating square roots. The main function can then call the newton function repeatedly until the user presses the enter/return key.
Explanation:
The newton function can be implemented in Python using Newton's method for approximating square roots. Here's how you can define the newton function:
def newton(number):A prime number is any integer greater than 1 that is evenly divisible only by itself and 1. The Sieve of Eratosthenes is a method of finding prime numbers. It operates as follows: Create a primitive type Boolean array with all elements initialized to true. Array elements with prime indices will remain true. All other array elements will eventually be set to false. Starting with array index 2, determine whether a given element is true. If so, loop through the remainder of the array and set to false every element whose index is a multiple of the index for the element with value true. Then continue the process with the next element with value true. For array index 2, all elements beyond element 2 in the array that have indices which are multiples of 2 (indices 4, 6, 8, 10, etc.) will be set to false; for array index 3, all elements beyond element 3 in the array that have indices which are multiples of 3 (indices 6, 9, 12, 15, etc.) will be set to false; and so on. When this process completes, the array elements that are still true indicate that the index is a prime number. These indices can be displayed. Write an application that uses an array of 1000 elements to determine and display the prime numbers between 2 and 999. Ignore array elements 0 and 1.
Answer:
see explaination
Explanation:
public class test{
public static void main(String[] args){
boolean flag[] = new boolean[1000];
for(int i = 0; i < 1000; i++){
flag[i] = true;
}
for(int i = 2; i < 1000; i++){
if(flag[i] == true){
for(int j = i + 1; j < 1000; j++){
if(j % i == 0) flag[j] = false;
}
}
}
System.out.println("The prime numbers in the range 0 to 1000 are:");
for(int i = 2; i < 1000; i++){
if(flag[i] == true) System.out.print(i + " ");
}
}
}
You client has stipulated that open-source software is to be used. Is this a functional or non-functional requirement? How early in the life-cycle model can this requirement be handled? Explain your answer.
Answer:
In the beginning of the model
Explanation:
This is believed to be a non functional requirement because the non- functional type of requirement as platform restrictions, reliability and time of response. These requirements are meant to be handled during the beginning of the life cycle model because all planing and analysis should be centered around the fact that customers desires to adopt the open source model.
The history teacher at your school needs help in grading a True/False test. The students’ IDs and test answers are stored in a file. The first entry in the file contains answers to the test in the form: TFFTFFTTTTFFTFTFTFTT Every other entry in the file is the student ID, followed by a blank, followed by the student’s responses. For example, the entry: ABC54301 TFTFTFTT TFTFTFFTTFT indicates that the student ID is ABC54301 and the answer to question 1 is True, the answer to question 2 is False, and so on. This student did not answer question 9. The exam has 20 questions, and the class has more than 150 students. Each correct answer is awarded two points, each wrong answer gets one point deducted, and no answer gets zero points. Write a program that processes the test data. The output should be the student’s ID, followed by the answers, followed by the test score, followed by the test grade. Assume the following grade scale: 90%–100%, A; 80%–89.99%, B; 70%–79.99%, C; 60%–69.99%, D; and 0%–59.99%, F.
This program assumes that the test data file is formatted as described in your question.
def calculate_score(answers, student_answers):
score = 0
for i in range(len(answers)):
if student_answers[i] == answers[i]:
score += 2
elif student_answers[i] != ' ':
score -= 1
return max(0, score) # Ensure the score is not negative
def calculate_grade(score, total_questions):
percentage = (score / (2 * total_questions)) * 100
if 90 <= percentage <= 100:
return 'A'
elif 80 <= percentage < 90:
return 'B'
elif 70 <= percentage < 80:
return 'C'
elif 60 <= percentage < 70:
return 'D'
else:
return 'F'
def process_test_data(file_path):
with open(file_path, 'r') as file:
data = file.read().split()
answers = data[0]
student_data = data[1:]
total_questions = len(answers)
This response explains how to programmatically grade a True/False test, including reading answers from a file, calculating scores, and assigning grades based on a percentage scale. An example Python code snippet illustrates the process. The final output displays each student's ID, their answers, score, and grade.
You can write a program to help your history teacher grade the True/False test. Here's a step-by-step approach:
Read the test answers and student responses from the file.The first entry contains the correct answers, the subsequent entries contain student IDs and their responses.For each student, calculate the test score based on the given rules: each correct answer gets 2 points, each wrong answer deducts 1 point, and no answer gets 0 points.Calculate the percentage score and determine the letter grade using the given scale.Output the student ID, responses, test score, and grade.Example Code:
def grade_test(filename):This program will read from a file called 'test_answers.txt' and output each student's ID, their answers, score, and grade.
Similar to Wi-Fi, ____ is designed to provide Internet access to fixed locations (sometimes called hotzones), but the coverage is significantly larger. a. WinMax b. WiMAX c. EMax d. 802.11b
Similar to Wi-Fi, WiMAX is a kind of hotspot, is designed to provide Internet access to fixed locations (sometimes called hot zones), but the coverage is significantly larger. Thus, the correct option for this question is B.
What is Wi-Fi?Wi-Fi stands for Wireless fidelity. It may be characterized as a wireless technology that is significantly used in order to connect computers, tablets, smartphones, and other devices to the internet. It processes the radio signal sent from a wireless router to a nearby device, which translates the signal into data you can see and use.
According to the context of this question, hotspot also follows the same working principle in order to connect devices like computers, mobile phones, etc, to the internet.
But the problem is that it connects the devices over a short distance. While WiMAX has the capability to connect devices where the coverage is significantly larger.
Therefore, similar to Wi-Fi, WiMAX is a kind of hotspot, is designed to provide Internet access to fixed locations (sometimes called hot zones), but the coverage is significantly larger. Thus, the correct option for this question is B.
To learn more about Wi-Fi, refer to the link:
https://brainly.com/question/13267315
#SPJ5
Final answer:
WiMAX, also known as Worldwide Interoperability for Microwave Access, is designed to provide Internet connectivity over larger areas than Wi-Fi, and is standardized as IEEE 802.16. It uses microwave communications to provide broadband wireless access, especially useful in areas without traditional cable or DSL infrastructure.
Explanation:
Similar to Wi-Fi, which is a wireless local area network technology allowing devices to connect to the Internet, WiMAX (Worldwide Interoperability for Microwave Access) is designed to provide Internet access to fixed locations over much larger coverage areas, sometimes referred to as hotzones.
WiMAX is standardized as IEEE 802.16, providing broadband wireless access (BWA) and enabling the formation of connections over long distances. It is essentially used for providing last mile broadband wireless access and can be a cost-effective alternative to traditional cable or DSL methods. WiMAX has become a valuable technology especially in areas that lack the infrastructure for cable or DSL connections, providing the necessary Internet access using microwave communications.
13. Question
What are two characteristics of a 5Ghz band wireless network?
Check all that apply.
Answer:
The two major characteristics of the 5GHZ are Fast speed and Short range.
Explanation:
The two major characteristics of the 5GHZ are Fast speed and Short range.
5GHz operates over a great number of unique channels. With the 5GHz, there is less overlap, which means less interference, and this makes it produce a better performance. The 5GHz is a better option as long as the device is close to the router/access point. Thus, it operates at shirt ranges.
The 5GHz band possesses the ability to cut through network disarray and interference to maximize network performance. It has more channels for communication, and usually, there are not as many competing devices on the 5GHz band. Thus, it has a very fast speed.
Consider the Telnet example discussed in Slide 78 in Chapter 3. A few seconds after the user types the letter ‘C’, the user types the letter ‘R’. After typing the letter ‘R’, how many segments are sent, and what is put in the sequence number and acknowledgement fields of the segments?
Answer:
3 Segments,
First segment : seq = 43, ack=80
Second Segment : seq = 80, ack=44
Third Segment: seq = 44, ack=81
Explanation:
Three segments will be sent as soon as the user types the letter ‘C’ and the he waits for a few seconds to type the letter ‘R’.
In our Telnet example, 42 and 79 for the client and server were the starting sequence number. Since the letter 'R' is typed and the starting seq is 42 is incremented by 1 byte. Therefore the sequence number in the first segment is 43 and the acknowlegement number is 80.
The second segment is sent from the server to the client. It echoes back the letter ‘C’. 43 is put in the acknowledgment field and tells the client that it has successfully received everything up through byte 42 and is now waiting for bytes 43 onward. This second segment has the sequence number 79 which is incremented by 1 byte. Therefore the sequence number in the second segment is 80 and the acknowlegement number is 44.
The third segment is sent from the client to the server. Its acknowledges the data it has received from the server. It has 80 in the acknowledgment number field because the client has received the stream of bytes up through byte sequence number 79 and it is now waiting for bytes 80 onward. This is also incremented by 1 byte. Therefore the sequence number in the second segment is 44 and the acknowlegement number is 81.
Final answer:
In a Telnet session, each keystroke is sent as a separate segment. Therefore, typing 'R' after 'C' sends one segment with a sequence number incremented by one from the previous, and an acknowledgment number also increased by one to acknowledge receipt of the previously received segment.
Explanation:
When the user types the letter 'R' after typing 'C' in a Telnet session, generally a single segment is sent for each keystroke because Telnet operates in character mode. In this mode of operation, every character generates a pair of segments: one from the client to the server (the telnet command) and one from the server to the client (the acknowledgment).
The sequence number in the segment sent after typing 'R' would be incremented by one compared to the previous segment's sequence number because each character sent is considered one byte of data. Similarly, the acknowledgment number would be set to one more than the last received segment's sequence number, acknowledging the successful receipt of that segment.
If we assume the initial sequence number is 'X' for the first segment carrying the 'C' and the server acknowledges with 'Y', then for the 'R' segment, the sequence number would be 'X+1' and the acknowledgment field would have 'Y+1' if no other data was sent or received in the interim.
(3 points) Write a program to process two large chunks of data (e.g., a large 3D array and an array of self-defined structures with each structure at least 256 Bytes) respectively. The array elements can be random. The process can be incrementing every element by 1 or others. Try different ways (e.g., stride-k reference, the loop orders or others) to traverse the array elements and simulate the program performance (i.e., running time). Note that you should record the time just before and after the data processing program, not including the data generation or other initiation programs. And you should calculate an average time of at least 5 experiments for each program.
Answer:
Check the explanation
Explanation:
#include <iostream> #include <chrono> using namespace std::chrono; using namespace std; struct X{ int a,b,c,d,e,f,g,h; }; int main(){ // 3D Array of integers 1000 x 1000 x 1000 int data1[10][10][10]; //Array of struct X struct X data2[10000] ; auto start = high_resolution_clock::now(); //stride 1 access data 1 Loop order 1: for(int i=0;i<1000;i++){ for(int j=0;j<1000;j++){ for(int k=0;k<1000;k++){ data1[i][j][k]; } } } auto stop = high_resolution_clock::now(); auto duration = duration_cast<microseconds>(stop - start); cout<<"3D array Stride 1 Loop Order 1"<<duration.count()<<endl; start = high_resolution_clock::now(); //stride 2 access data 1 Loop order 1: for(int i=0;i<1000;i+=2){ for(int j=0;j<1000;j+=2){ for(int k=0;k<1000;k+=2){ data1[i][j][k]; } } } stop = high_resolution_clock::now(); duration = duration_cast<microseconds>(stop - start); cout<<"3D array Stride 2 Loop Order 1"<<duration.count()<<endl; start = high_resolution_clock::now(); //stride 1 access data 1 Loop order 2: for(int i=0;i<1000;i++){ for(int j=0;j<1000;j++){ for(int k=0;k<1000;k++){ data1[j][i][k]; } } } stop = high_resolution_clock::now(); duration = duration_cast<microseconds>(stop - start); cout<<"3D array Stride 1 Loop Order 2"<<duration.count()<<endl; start = high_resolution_clock::now(); for(int i=0;i<10000;i++){ data2[i]; } stop = high_resolution_clock::now(); duration = duration_cast<microseconds>(stop - start); cout<<"Struct Array "<<duration.count()<<endl; }
Some Observations on the order:
Stride 1 goes over all the elements of the array Hence takes more time than stride 2 which goes over alternate elements.
Loop order in the row major form takes leads time than column major form!
Struct array takes no time to execute because the structs are not being accessed.
Check the code screenshot and code output in the attached image below.
Answer:
See explaination
Explanation:
#include <iostream> #include <chrono> using namespace std::chrono; using namespace std; struct X{ int a,b,c,d,e,f,g,h; }; int main(){ // 3D Array of integers 1000 x 1000 x 1000 int data1[10][10][10]; //Array of struct X struct X data2[10000] ; auto start = high_resolution_clock::now(); //stride 1 access data 1 Loop order 1: for(int i=0;i<1000;i++){ for(int j=0;j<1000;j++){ for(int k=0;k<1000;k++){ data1[i][j][k]; } } } auto stop = high_resolution_clock::now(); auto duration = duration_cast<microseconds>(stop - start); cout<<"3D array Stride 1 Loop Order 1"<<duration.count()<<endl; start = high_resolution_clock::now(); //stride 2 access data 1 Loop order 1: for(int i=0;i<1000;i+=2){ for(int j=0;j<1000;j+=2){ for(int k=0;k<1000;k+=2){ data1[i][j][k]; } } } stop = high_resolution_clock::now(); duration = duration_cast<microseconds>(stop - start); cout<<"3D array Stride 2 Loop Order 1"<<duration.count()<<endl; start = high_resolution_clock::now(); //stride 1 access data 1 Loop order 2: for(int i=0;i<1000;i++){ for(int j=0;j<1000;j++){ for(int k=0;k<1000;k++){ data1[j][i][k]; } } } stop = high_resolution_clock::now(); duration = duration_cast<microseconds>(stop - start); cout<<"3D array Stride 1 Loop Order 2"<<duration.count()<<endl; start = high_resolution_clock::now(); for(int i=0;i<10000;i++){ data2[i]; } stop = high_resolution_clock::now(); duration = duration_cast<microseconds>(stop - start); cout<<"Struct Array "<<duration.count()<<endl; }
Kindly check attachment for screenshot of the source code for proper indentation.
Sam has worked for a project-based firm for five years. After being assigned to a high profile special project, he realized that he needed a quiet environment that was free from distractions to finalize project files on a daily basis. His project supervisor agreed and approved for Sam to telecommute from his home. The organization furnished Sam with a standard PC laptop and upgrades to the business class DSL modem. Sam must upload all completed project files to a secured server at the end of each business day, plus maintain a backup copy on his tower unit.
Required:
a. What firewall configuration would you recommend for Sam's home-based office/network? Justify your response.
b. What firewall setup would provide the firm both flexibility and security? Justify your response.
c. Which firewall technologies should be deployed
i. to secure the internet-facing web servers.
ii. to protect the link between the web servers and customer database.
iii. to protect the link between internal users and the customer database?
Answer:
a. Packet filter gateway
b. The dynamic firewall
c. I. Proxy firewall. ii. Application firewall iii. Circuit level gateway
Explanation:
A. The packet filter gateway firewall is the recommended firewall off Sam operation from home. This is because it operates at the network OSI model level where it filter all unwanted packet and content across the home/ office network
B. The dynamic firewall or the stateful packet filter operates changeably without distorting the security of the network. Hence it is the most ideal that provides flexibility and security.
C. I. The proxy firewall is a technology that provides security between the internet to web server
ii. Application firewall technologies take care of the link between web server and customer database.
iii. The circuit level gateways ensure that the link between internal users and customer database are secured.
Which of the following is true about open-source enterprise resource planning (ERP) system software? a. An open-source ERP system software’s source code can be modified easily. b. An open-source ERP system software’s source code is not flexible enough to adapt it for changing business needs. c. An open-source ERP system software’s source code is too complex to be modified. d. An open-source ERP system software’s source code is not visible to users.
Answer:
a. An open-source ERP system software’s source code can be modified easily.
Explanation:
Open source software is the software that is available for modification by any one easily. These software are available publicly for the purpose of modifications. User can modify these software as their requirements. There are different software available for enterprise resource planing. Different users and companies use this software freely and modify them for their company according to the demand and need.
Tryton, Odoo and ERPNext are the examples of some open source enterprise resource planning (ERP) software. These software are available for free to modify their source code and use according to the need of the company. As the main advantage of these software is they are available and modifiable easily.
Consider the three major Vs as Volume, Velocity and Variety along with other Big Data contexts. Match the terms with the short scenarios or frameworks, related to Big Data. A Big Data application that handles very large-sized block of data (64 MB). Variability Big Data, applied to collect data on visitors purchase behavior in a theme park. MapReduce Health systems transmit electronic prescriptions and receive 'no-pickup' messages. Feedback loop processing Sentiment analysis determines if a statement conveys a positive or negative attitude. Volume, Velocity, Variety Programming model to process large data sets in a parallel, distributed manner. Hadoop
Answer:
See explaination
Explanation:
(MapReduce) = Programming Model
(Variability) = Sentiment analysis
(Feedback Loop Processing) = Health Systems transit
(volume, velocity, variety) = Big Data, applied to collect data
(Hadoop) = A Big Data Application that handles very large-sized block of data.
Write a program that prints the block letter “B” in a 7x7 grid of stars like this:
*****
* *
* *
*****
* *
* *
*****
Then extend your program to print the first letter of your last name as a block letter in a 7X7 grid of stars.
Answer:
output = "" for i in range(7): if(i % 3 == 0): for i in range(5): output+= "*" output += "\n" else: for i in range(2): output += "* " output += "\n" print(output)Explanation:
The solution code is written in Python 3.
Firstly, create a output variable that holds an empty string (Line 1).
Create an outer loop that will loop over 7 times to print seven rows of stars (Line 2). In row 0, 3 and 6 (which are divisible by 3) will accumulate up to 5 stars using an inner loop (Line 4-5) whereas the rest of the row will only print two stars with each start followed by a single space (Line 8-9) using another inner loop.
At last, print the output (Line 12).
A Grocery store has 184 shelves for bottled goods. Each shelf can hold 27 bottles. How many bottles will the shelves hold in all.
Answer:
4,968
Explanation:
You just have to multiply
Write a predicate function called check_list that accepts a list of integers as an argument and returns True if at least half of the values in the list are less than the first number in the list. Return False otherwise.
Answer:
# the function check_list is defined
# it takes a parameter
def check_list(integers):
# length of half the list is assigned
# to length_of_half_list
length_of_half_list = len(integers) / 2
# zero is assigned to counter
# the counter keep track of
# elements whose value is less
# than the first element in the list
counter = 0
# the first element in list is
# assigned to index
index = integers[0]
# for loop that goes through the
# list and increment counter
# whenever an element is less
# than the index
for i in range(len(integers)):
if integers[i] < index:
counter += 1
# if statement that returns True
# if counter is greater than half
# length of the list else it will return
# False
if counter > length_of_half_list:
return True
else:
return False
# the function is called with a
# sample list and it returns True
print(check_list([5, 6, 6, 1, 9, 2, 3, 4, 1, 2, 3, 1, 7]))
Explanation:
The program is written is Python and is well commented.
The example use returns True because the number of elements with value less than 5 are more than half the length of the list.
The students assume the role of a networking intern at Richman Investments, a mid-level financial investment and consulting firm. In this assignment, the students will research malicious code attacks and select one that occurred within the last year. They must write a summary report explaining what kind of malicious attack it was, how it spread and attacked other devices, and how it was mitigated. They must also explain how they would prevent the attack from recurring on a network under their control.
Answer:
Malicious code: Trojan
Explanation:
Trojan
A Trojan is malicious code that, unlike viruses and worms, cannot reproduce itself and infect files. It is usually in the form of an executable file (.exe, .com) and does not contain any other elements, except for the Trojan's own code. For this reason the only solution is to remove it.
It has several functions -from acting as keyloggers (connecting and transmitting the actions performed on the keyboard) and deleting files to formatting disks. Some contain special functionality that installs Trojan programs, a client-server application that guarantees the developer remote access to your computer. Unlike many (legitimate) programs with similar functions, they are installed without user consent.
Answer:
Malicious code : Spyware
Explanation:
The kind of malicious attack on the the intern in making a research on is Spyware
Spyware gathers information about a users and it activities without them knowing and also without their permission or consent. Type of user information we talking about here are pins, passwords, unstructured messages and payment information.
Spyware attack does only affect desktop browser, it also operate on different platform like a mobile phone having a critical application.
How to prevent spyware.
1.Update your system. Make sure you update your browser and device often.
Give attention to the type of things you download.
2. Using anti-spyware software. The software is the obstruction between you and an attacker.
3. Always be watching your email
4.Always avoid pop-ups.
Modify the program so that it can do any prescribed number of multiplication operations (at least up to 25 pairs). The program should have the user first indicate how many operations will be done, then it requests each number needed for the operations. When complete, the program should then return "done running" after displaying the results of all the operations in order. It is in the Arduino Language
You can write the code from scratch if you'd like without modifying the given code. In any expected output.
//Initializing the data
float num1 = 0;
float num2 = 0;
int flag1 = 0;
// a string to hold incoming data
String inputString = " ";
// Whether the string is Complete
boolean stringComplete = false;
//This is where the void setup begins
void setup() {
//Initializing the serial
Serial.begin (9600);
//Reserving 200 bytes for the inputString
inputString.reserve (200);
Serial.println("Provide The First Number");
}
void loop() {
//Print the string when the new line arrives
if (stringComplete) {
if (flag1 == 0) {
Serial.println(inputString);
num1 = inputString.toFloat( );
flag1 = 1;
//Asking the user to input their second string
Serial.println("Provide The Second Number");
}
else if (flag1 == 1) {
Serial.println(inputString);
num2 = inputString.toFloat( );
flag1 = 2;
Serial.println("The Product is Calculating...");
}
if (flag1 == 2) {
Serial.println("The Product is: ");
Serial.println(num1*num2);
Serial.println("Press Reset");
flag1 = 5;
}
//This clears the string
inputString = " ";
stringComplete = false;
}
}
void serialEvent() {
while (Serial.available( )) {
// get the new byte
char inChar = (char)Serial.read( );
//add it to the inputString
inputString += inChar;
//if the incoming character is a newline, set a flag so the main loop can
//do something about it
if (inChar == '\n') {
stringComplete = true;
}
}
}
The provided Arduino program was modified to allow user input for the total number of multiplication operations. It prompts the user, performs each multiplication as numbers are input, and outputs results immediately after each operation, indicating completion with 'Done running.'
Explanation:The student is working with a program written in the Arduino programming language, which involves performing multiple multiplication operations. To modify the program to handle a user-specified number of operations, we need to include a loop and some condition checks to process multiple pairs of numbers. Below is an example sketch that allows the user to specify the number of multiplication operations to perform, input each pair of numbers, and then output the results in order:
int numOperations = 0;20 POINTS
You put an image on instagram while at a football game, what type of digital footprint would this be?
A) explicit
B) implicit
Express the worst case run time of these pseudo-code functions as summations. You do not need to simplify the summations. a) function(A[1...n] a linked-list of n integers) for int i from 1 to n find and remove the minimum integer in A endfor endfunction
Answer:
The answer is "O(n2)"
Explanation:
The worst case is the method that requires so many steps if possible with compiled code sized n. It means the case is also the feature, that achieves an average amount of steps in n component entry information.
In the given code, The total of n integers lists is O(n), which is used in finding complexity. Therefore, O(n)+O(n-1)+ .... +O(1)=O(n2) will also be a general complexity throughout the search and deletion of n minimum elements from the list.Al and Bill are arguing about the performance of their sorting algorithms. Al claims that his O(N log N)-time algorithm is always faster than Bill's O(N2)-time algo- rithm. To settle the issue, they implement and run the two algorithms on many randomly generated data sets. To Al's dismay, they find that if N 〈 1000 the O(N2)- time algorithm actually runs faster, and only when N 〉 1000 the 0(N logN)-time (10 pts.) one is better. Explain why the above scenario is possible
The observed performance difference is due to the constant factors and lower-order terms in the algorithms, affecting the actual running times for different input sizes.
The observed difference in performance between Al's O(N log N)-time algorithm and Bill's O(N^2)-time algorithm is due to the inherent nature of Big O notation.
While Big O provides an upper bound on an algorithm's growth rate as N approaches infinity, it neglects constant factors and lower-order terms, which are crucial for smaller input sizes.
Consequently, for N < 1000, Al's algorithm may have a higher constant factor or additional overhead, causing it to be slower than Bill's algorithm with O(N^2) complexity.
However, as N increases and surpasses 1000, the superior growth rate of Al's O(N log N) algorithm starts to dominate, making it faster than Bill's O(N^2) algorithm.
This discrepancy emphasizes the significance of considering constant factors and lower-order terms when evaluating algorithm performance in real-world scenarios.
Learn more about algorithms here:
https://brainly.com/question/33337820
#SPJ3
Final answer:
Al's O(N log N) sorting algorithm may run slower than Bill's O(N^2) algorithm for small data sets due to the practical influence of constant factors, lower-order terms, and the characteristics of specific programming languages that Big-O notation ignores. Al's algorithm outperforms Bill's only for larger N, where Big-O's highest-order term dominates the run-time.
Explanation:
The scenario where Al's O(N log N)-time sorting algorithm is outperformed by Bill's O(N2)-time algorithm for N < 1000 can be explained by considering the constants and lower-order terms involved in algorithm performance, which are not captured by Big-O notation. Big-O provides an abstract overview of complexity, focusing on the highest-order term, and it tends to ignore constants and lower-order terms. However, these neglected elements can significantly impact the actual run-time in practice, especially for smaller sizes of N.
Moreover, programming languages' execution speeds and overheads for various operations can differ, which might result in a less efficient algorithm (in terms of Big-O) running faster in practice due to language-specific optimizations or lower constant factors. For instance, a simple O(N2) algorithm like bubble sort might have less overhead than a more complex O(N log N) algorithm and can execute faster for small data sets.
Only when data sets grow large enough does the complexity described by Big-O notation become the dominating factor, and Al's algorithm starts to outperform Bill's. It's a classic illustration of why algorithm analysis must consider both theoretical performance and practical implementation details such as constant factors and the characteristics of specific data sets.
g (Locate the largest element) Write the following method that returns the location of the largest element in a two-dimensional array: public static int [] locateLargest(double [][] a) The return value is a one-dimensional array that contains two elements. These two elements indicate the row and column indices of the largest element in the two-dimensional array. Write a test program (the main method) that prompts the user to enter a two-dimensional array and displays the location of the largest element of the array.
Answer:
The method in JAVA is shown below.
static double largest = 0.0;
static int[] idx = new int[2];
public static int r = 20;
public static int c = 20;
public static int[] locateLargest(double[][] a)
{
for(int j=0; j<c; j++)
{
for(int k=0; k<r; k++)
{
if(largest<a[j][k])
{
largest=a[j][k];
idx[0]=k;
idx[1]=j;
}
}
}
return idx;
}
The JAVA program is shown below.
import java.util.Scanner;
import java.lang.*;
class program
{
//static variables declared and initialized as required
static double largest = 0.0;
static int[] idx = new int[2];
public static int r = 20;
public static int c = 20;
public static int[] locateLargest(double[][] a)
{
for(int j=0; j<c; j++)
{
for(int k=0; k<r; k++)
{
if(largest<a[j][k])
{
largest=a[j][k];
idx[0]=k;
idx[1]=j;
}
}
}
return idx;
}
}
public class Main
{
static double[][] arr;
static double input;
public static void main(String[] args){
program ob = new program();
arr = new double[ob.r][ob.c];
Scanner sc = new Scanner(System.in);
for(int j=0; j<ob.c; j++)
{
for(int k=0; k<ob.r; k++)
{
arr[j][k]=0;
}
}
System.out.println("Enter the elements of two dimensional array ");
for(int j=0; j<ob.c; j++)
{
for(int k=0; k<ob.r; k++)
{
input = sc.nextDouble();
if(input>0)
{ arr[j][k] = input;
//System.out.println(arr[j][k]);
}
else
break;
}
break;
}
int[] large_idx = ob.locateLargest(arr);
int row = large_idx[0];
int col = large_idx[1];
double l = arr[col][row];
System.out.println("The largest element in the user entered array is " + l);
}
}
OUTPUT
Enter the elements of two dimensional array
1
2
3
4
5
6
7
8
9
0
The largest element in the user entered array is 9.0
Explanation:
1. The class program contains the locateLargest() method as mentioned in the question.
2. The public class Main contains the main() method.
3. User input for array is taken inside main().
4. This array is passed to the locateLargest() method.
5. This method returns the one dimensional array having row and column indices of the largest element in the array.
6. The indices are used to display the largest element in the main().
1. In the.js file, write the JavaScript code for this application. Within the click event handlers for the elements in the sidebar, use the title attribute for each link to build the name of the JSON file that needs to be retrieved. Then, use that name to get the data for the speaker, enclose that data in HTML elements that are just like the ones that are used in the starting HTML for the first speaker, and put those elements in the main element in the HTML. That way, the CSS will work the same for the Ajax data as it did for the starting HTML. 2. Don’t forget to clear the elements from the main element before you put the new Ajax data in that element. 3. Verify there are no errors.
Answer:
Kindly note that the codes below must be executed through any server like apache, xampp, ngnix, etc...
Explanation:
Other files are not changed... only speakers.js modified
speakers.js
$(document).ready(function() {
$("#nav_list li").click(function() {
var title = $(this).children("a").attr("title");
$.get(title + ".json", function(data, status) {
data = data['speakers'][0];
$("main h1").html(data['title']);
$("main h2").html(data['month']+"<br />"+data['speaker']);
$("main img").attr("src", data.image);
$("main p").html(data.text);
});
});
});
You must keep track of some data. Your options are: (1) A linked-list maintained in sorted order. (2) A linked-list of unsorted records. (3) A binary search tree. (4) An array-based list maintained in sorted order. (5) An array-based list of unsorted records
(a) For sorted records, use an array-based sorted list for efficient O(log n) inserts and searches. Linked lists are less optimal.
(b) With random distribution, opt for a balanced binary search tree for O(log n) insertions and searches. Arrays may lack balance.
(a) For the scenario where records are guaranteed to arrive already sorted from lowest to highest, an array-based list maintained in sorted order (Option 4) would be the most efficient choice. This is because inserting into a sorted array is a relatively quick operation, and with records arriving in sorted order, each insert operation can be performed with a time complexity of O(log n), making it efficient. The subsequent searches would also benefit from the sorted order, allowing for a binary search with a time complexity of O(log n), resulting in optimal performance. Linked lists, whether sorted or unsorted, may not provide the same level of efficiency in this context.
(b) In the case where records arrive with values having a uniform random distribution, a binary search tree (Option 3) is a suitable choice. A well-balanced BST can provide an average-case time complexity of O(log n) for both insertions and searches. The random distribution of values helps maintain the balance of the tree, ensuring that the height is minimized. On the other hand, array-based options, even if sorted, may not guarantee a balanced structure, and linked lists may lead to linear search times in the worst case.
The question probable may be:
You must keep track of some data. Your options are:
(1) A linked-list maintained in sorted order.
(2) A linked-list of unsorted records.
(3) A binary search tree.
(4) An array-based list maintained in sorted order.
(5) An array-based list of unsorted records.
For each of the following scenarios, which of these choices would be best? Explain your answer.
(a) The records are guaranteed to arrive already sorted from lowest to highest (i.e., whenever a record is inserted, its key value will always be greater than that of the last record inserted). A total of 1000 inserts will be interspersed with 1000 searches.
(b) The records arrive with values having a uniform random distribution (so the BST is likely to be well balanced). 1,000,000 insertions are performed, followed by 10 searches.
Consider the following functions: (4) int hidden(int num1, int num2) { if (num1 > 20) num1 = num2 / 10; else if (num2 > 20) num2 = num1 / 20; else return num1 - num2; return num1 * num2; } int compute(int one, int two) { int secret = one; for (int i = one + 1; i <= two % 2; i++) secret = secret + i * i; return secret; } What is the output of each of the following program segments? a. cout << hidden(15, 10) << endl; b. cout << compute(3, 9) << endl; c. cout << hidden(30, 20) << " " << compute(10, hidden(30, 20)) << endl; d. x = 2; y = 8; cout << compute(y, x) << endl;
Answer:
a. cout<<hidden(15,10)<<endl;
output = 5
b. cout << compute(3, 9) << endl;
output=3
c. cout << hidden(30, 20) << " " << compute(10, hidden(30, 20)) << endl;
output = 10
d. x = 2; y = 8; cout << compute(y, x) << endl;
output= 8
Explanation:
solution a:
num1= 15;
num2= 10;
according to condition 1, num1 is not greater than 20. In condition 2, num2 is also not greater than 20.
so,
the solution is
return num1 - num2 = 15 - 10 = 5
So the output for the above function is 5.
solution b:
as in function there are two integer type variables named as one and two. values of variables in given part are:
one = 3
two = 9
secret = one = 3
for (int i= one + 1 = 3+1 = 4; i<=9%2=1; i++ )
9%2 mean find the remainder for 9 dividing by 2 that is 1.
// there 4 is not less than equal to 1 so loop condition will be false and loop will terminate. statement in loop will not be executed.
So the answer will be return from function compute is
return secret ;
secret = 3;
so answer return from the function is 3.
solution c:
As variables in first function are num1 and num2. the values given in part c are:
num1 = 30;
num2= 20;
According to first condition num1=30>20, So,
num1= num2/10
so the solution is
num1 = 20/10 = 2
now
num1=2
now the value return from function Hidden is,
return num1*num2 = 2* 20 = 40
Now use the value return from function hidden in function compute as
compute(10, hidden(30, 20))
as the value return from hidden(30, 20) = 40
so, compute function becomes
compute(10, 40)
Now variable in compute function are named as one and two, so the values are
one= 10;
two = 40;
as
secret = one
so
secret = 10;
for (int i= one + 1 = 10+1 = 11; i<=40%2=0; i++ )
40%2 mean find the remainder for 40 dividing by 2 that is 0.
// there 11 is not less than equal to 0 so loop condition will be false and loop will terminate. statement in loop will not be executed.
So the answer will be return from function compute is
return secret ;
secret = 10;
so answer return from the function is 10.
solution d:
Now variable in compute function are named as one and two, so the values are
one = y = 8
two = x = 2
There
Secret = one = 8;
So
for (int i= one + 1 = 8+1 = 9; i<=2%2=0; i++ )
2%2 mean find the remainder for 2 dividing by 2 that is 0.
// there 9 is not less than equal to 0 so loop condition will be false and loop will terminate. statement in loop will not be executed.
So the answer will be return from function compute is
return secret ;
secret = 8;
so answer return from the function is 8.
Enlighten server and client network architecture. support your answer with diagrams and give an example of servers that your computer or mobile is connected currently
Server & Client Network Architecture:
The server-client network can be described as a network where a centralized server (host) provides services to many clients (users). The server is a powerful machine that can handle multiple clients.
There are various types of servers some of them are:
File serverDNS serverApplication serverWeb serverMail serverDatabase serverBenefits of server & client network:
Centralized and securedEnhanced speed and performanceCustomizationExample:
Take the example of hospital patient management system where a centralized server has a huge database and is running the application and many client computers are connected to this server where doctors enter the information about patients and this information is then stored in the server.
A Personal Fitness Tracker is a wearable device that tracks your physical activity, calories burned, heart rate, sleeping patterns, and so on. One common physical activity that most of these devices track is the number of steps you take each day. If you have downloaded this book's source code from the Computer Science Portal, you will find a file named steps.txt in the Chapter 06 folder. (The Computer Science Portal can be found at www.pearsonhighered.com/gaddis.) The steps.txt file contains the number of steps a person has taken each day for a year. There are 365 lines in the file, and each line contains the number of steps taken during a day. (The first line is the number of steps taken on January 1st, the second line is the number of steps taken on January 2nd, and so forth.) Write a program that reads the file, then displays the average number of steps taken for each month. (The data is from a year that was not a leap year, so February has 28 days.)
Answer:
See explaination for the program code.
Explanation:
fh = open('steps.txt', 'r')
lines = fh.readlines()
start = 0
days_in_months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
print('{:<7s} {:<10s}'.format('Month', 'Average Steps'))
for m in range(12):
end = start + days_in_months[m]
steps = lines[start:end]
avg = 0
for s in steps:
avg = avg + int(s)
avg = avg // len(steps)
print('{:<7d} {:<10d}'.format(m+1, avg))
start = start + days_in_months[m]
Please kindly check attachment for for the program code.
In this exercise we have to use the knowledge of computational language in python to write the code.
This code can be found in the attached image.
To make it simpler the code is described as:
fh = open('steps.txt', 'r')
lines = fh.readlines()
start = 0
days_in_months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
print('{:<7s} {:<10s}'.format('Month', 'Average Steps'))
for m in range(12):
end = start + days_in_months[m]
steps = lines[start:end]
avg = 0
for s in steps:
avg = avg + int(s)
avg = avg // len(steps)
print('{:<7d} {:<10d}'.format(m+1, avg))
start = start + days_in_months[m]
See more about python at brainly.com/question/22841107
ABC software company is to develop software for effective counseling for allotment of engineering seats for students with high scores ranking from top colleges. The product has to be upgraded if the common entrance score is to be considered.
Describe the appropriate product development life cycle and the standard skills required.
Answer:
A series of update steps must be done in the required software; for example:
Explanation:
Option 1: add the timestamp at the top of the view :
Open a workbook containing the dashboard in Tableau Desktop, then go to the sheet where you want to show the time of the last data update.
-Select Worksheet> Show Title.
-Double-click on the title.
-In the Edit Title dialog box, select Insert> Data update time, and then click OK.
-Add any field to the filter shelf, leave all other selections blank, and click OK.
-Save the changes.
-Add sheet to dashboard.
Option 2: add the timestamp at the bottom of the view.
Open a workbook containing the dashboard in Tableau Desktop, then go to the sheet where you want to show the time of the last data update.
-Select Worksheet> Show Caption.
-Double-click the subtitle.
-In the Edit Subtitle dialog box, select Insert> Data update time, and then click OK.
-Add any field to the filter shelf, leave all other selections blank, and click OK.
-Save the changes.
-Add the sheet to the dashboard.
-Right-click on the sheet and select Caption to display the update time.
You can modify the size of these sheets in the dashboard to take up the space you consider necessary. They can also be set as floating objects, so they don't alter the size of the rest of the sheets in the view.