2. Consider the two-dimensional array A: int A[][] = new int[100][100]; where A[0][0] is at location 200 in a paged memory system with pages of size 200. Asmall process that manipulates the matrix resides in page 0 (locations 0 to 199). Thus, every instruction fetch will be from page 0. For three page frames, how many page faults are generated by the following array-initialization loops? Use LRU replacement, and assume that page frame 1 contains the process and the other two are initially empty. a. for (int j = 0; j < 100; j++) for (int i = 0; i < 100; i++) A[i][j] = 0; b. for (int i = 0; i < 100; i++) for (int j = 0; j < 100; j++) A[i][j] = 0;

Answer:

Check the explanation

Explanation:

Given below is the code for the question.

import java.util.*;

public class PlaceAnOrder

{

  public static void main(String[] args)

  {

      final int HIGHITEM = 9999;

      final int HIGHQUAN = 12;

      int code;

      int x;

      boolean found;

      final int[] ITEM = {111, 222, 333, 444};

      final double[] PRICE = {0.89, 1.47, 2.43, 5.99};

      int item;

      int quantity;

      double price = 0;

      double totalPrice = 0;

      Scanner input = new Scanner(System.in);

      try{

          System.out.print("Enter Item number: ");

          if(input.hasNextInt()){

              item = input.nextInt();

              if(item < 0)

                  throw new OrderException(OrderMessages.message[2]);

              if(item > HIGHITEM)

                  throw new OrderException(OrderMessages.message[3]);

              System.out.print("Enter Item quantity: ");

              if(input.hasNextInt()){

                  quantity = input.nextInt();

                  if(quantity < 1)

                      throw new OrderException(OrderMessages.message[4]);

                  if(quantity > HIGHQUAN)

                      throw new OrderException(OrderMessages.message[5]);

                  found = false;

                  for(int i = 0; i < ITEM.length; i++){

                      if(ITEM[i] == item){

                          found = true;

                          totalPrice = PRICE[i] * quantity;

                          break;

                      }

                  }

                  if(!found)

                      throw new OrderException(OrderMessages.message[6]);

                  System.out.println("Total Amount due: $" + totalPrice);

              }

              else

                  throw new OrderException(OrderMessages.message[1]);

          }

          else

              throw new OrderException(OrderMessages.message[0]);

      }catch(OrderException e){

          System.out.println(e.getMessage());

      }

  }

}

Answer:

The solution is in C++

Explanation:

// C++ programs to search a word in a 2D grid  

#include<bits/stdc++.h>  

using namespace std;  

// Rows and columns in given grid  

#define R 3  

#define C 14  

// For searching in all 8 direction  

int x[] = { -1, -1, -1, 0, 0, 1, 1, 1 };  

int y[] = { -1, 0, 1, -1, 1, -1, 0, 1 };  

// This function searches in all 8-direction from point  

// (row, col) in grid[][]  

bool search2D(char grid[R][C], int row, int col, string word)  

{  

// If first character of word doesn't match with  

// given starting point in grid.  

if (grid[row][col] != word[0])  

return false;  

int len = word.length();  

// Search word in all 8 directions starting from (row,col)  

for (int dir = 0; dir < 8; dir++)  

{  

 // Initialize starting point for current direction  

 int k, rd = row + x[dir], cd = col + y[dir];  

 // First character is already checked, match remaining  

 // characters  

 for (k = 1; k < len; k++)  

 {  

  // If out of bound break  

  if (rd >= R || rd < 0 || cd >= C || cd < 0)  

   break;  

  // If not matched, break  

  if (grid[rd][cd] != word[k])  

   break;  

  // Moving in particular direction  

  rd += x[dir], cd += y[dir];  

 }  

 // If all character matched, then value of must  

 // be equal to length of word  

 if (k == len)  

  return true;  

}  

return false;  

}  

// Searches given word in a given matrix in all 8 directions  

void patternSearch(char grid[R][C], string word)  

{  

// Consider every point as starting point and search  

// given word  

for (int row = 0; row < R; row++)  

for (int col = 0; col < C; col++)  

 if (search2D(grid, row, col, word))  

  cout << "pattern found at " << row << ", "

   << col << endl;  

}  

// Driver program  

int main()  

{  

char grid[R][C] = {"GEEKSFORGEEKS",  

    "GEEKSQUIZGEEK",  

    "IDEQAPRACTICE"

    };  

patternSearch(grid, "GEEKS");  

cout << endl;  

patternSearch(grid, "EEE");  

return 0;  

}  

This response outlines the creation of a word search program including six key methods: horizontal, vertical, and diagonal search methods, along with their respective test methods to ensure accuracy.

In this task, we aim to develop a program that reads a word search from a file and includes six main methods. Below are the steps and methods you need to implement:

1. Horizontal Search Method

Create a method to search for a word placed horizontally in the word search. You can iterate through each row and check for the presence of the target word within that row.

2. Vertical Search Method

Create a method to search for a word placed vertically in the word search. In this method, you'll iterate over each column, constructing potential matches vertically.

3. Diagonal Search Method

Create a method to search for a word placed diagonally in the word search. Handle both diagonals from top-left to bottom-right and top-right to bottom-left.

4. Test Methods

Develop test methods for horizontal, vertical, and diagonal search methods. Ensure you have test cases that cover various scenarios to validate the correctness of your searches.

The code for the following programs are:

class WordSearchSolver:

   def __init__(self, filename):

       self.grid = self.read_word_search(filename)

   def read_word_search(self, filename):

       # Method to read word search from file and return grid

       pass

   def horizontal_search(self, word):

       # Method to search for a word horizontally in the grid

       pass

   def vertical_search(self, word):

       # Method to search for a word vertically in the grid

       pass

   def diagonal_search(self, word):

       # Method to search for a word diagonally in the grid

       pass

   def test_methods(self):

       # Test methods for horizontal, vertical, and diagonal search

       pass

# Test the class

if __name__ == "__main__":

   filename = "word_search.txt"  # Example filename

   solver = WordSearchSolver(filename)

   solver.test_methods()

By implementing these methods, the program can effectively search for words in different orientations within the word search grid.

Answer:

def string_with_most_the(string_list):

   index = 0

   count = []

   max_length = 0

   for i in range(len(string_list)):

       s1 = string_list[i].lower()

       count.append(s1.count("the"))

       if count[i] > max_length:

           max_length = count[i]

           index = i

   return string_list[index]

Explanation:

Create a function called string_with_most_the that takes one parameter, string_list

Inside the function:

Initialize the variables

Initialize a for loop that iterates through string_list

Set the lower case version of the strings in string list to s1

Count how many "the" each string in string_list contain and put the counts in the count list

If any string has more "the" than the previous one, set its count as new maximum, and update its index

When the loop is done, return the string that has maximum number of "the", string_list[index]

Answer:

Check the explanation

Explanation:

Given below is the code for the question. PLEASE MAKE SURE INDENTATION IS EXACTLY AS SHOWN IN IMAGE.

import csv

def read_data(csv_r, keys):

  data = []

  for row in csv_r:

      mydict = {}

      for i in range(len(keys)):

          mydict[keys[i]] = row[i]

      data.append(mydict)

  return data

SCREENSHOT:

Answer:

Check the explanation

Explanation:

The loop runs for when i=0 to i=n-1 ie <n which consequently means that there are n iterations of the for loop, that is equal to array size n, therefore growth function will be

F(n) = n

Also big o notation is the upper bound of the growth function of any algorithm which consequently means that the big oh notation of this code's complexity O(n)

Answer:

Answer is in the provided screenshot!

Explanation:

Steps required:

check if pay is greater than 40, if so then handle logic for pay over 40, else treat normally.

Answer:

Check the explanation

Explanation:

1. The atomic attributes can't be a primary key because the values in the respective attributes should be unique.

So, the size of the primary key should be more than one.

In order to find the candidate key, let the functional dependencies be obtained.

The functional dependencies are :

Emp_ID -> Name, DeptID, Marketing, Salary

Name -> Emp_ID

DeptID -> Emp_ID

Marketing ->  Emp_ID

Course_ID -> Course Name

Course_Name ->  Course_ID

Date_Completed -> Course_Name

Closure of attribute { Emp_ID, Date_Completed } is { Emp_ID, Date_Completed , Name, DeptID, Marketing, Salary, Course_Name, Course_ID}

Closure of attribute { Name , Date_Completed } is { Name, Date_Completed , Emp_ID , DeptID, Marketing, Salary, Course_Name, Course_ID}

Closure of attribute { DeptID, Date_Completed } is { DeptID, Date_Completed , Emp_ID,, Name, , Marketing, Salary, Course_Name, Course_ID}

Closure of attribute { Marketing, Date_Completed } is { Marketing, Date_Completed , Emp_ID,, Name, DeptID , Salary, Course_Name, Course_ID}.

So, the candidate keys are :

{ Emp_ID, Date_Completed }

{ Name , Date_Completed }

{ DeptID, Date_Completed }

{ Marketing, Date_Completed }

Only one candidate key can be a primary key.

So, the primary key chosen be { Emp_ID, Date_Completed }..

2.

The functional dependencies are :

Emp_ID -> Name, DeptID, Marketing, Salary

Name -> Emp_ID

DeptID -> Emp_ID

Marketing ->  Emp_ID

Course_ID -> Course Name

Course_Name ->  Course_ID

Date_Completed -> Course_Name

3.

For a relation to be in 2NF, there should be no partial dependencies in the set of functional dependencies.

The first F.D. is

Emp_ID -> Name, DeptID, Marketing, Salary

Here, Emp_ID -> Salary ( decomposition rule ). So, a prime key determining a non-prime key is a partial dependency.

So, a separate table should be made for Emp_ID -> Salary.

The tables are R1(Emp_ID, Name, DeptID, Marketing, Course_ID, Course_Name, Date_Completed)

and R2( Emp_ID , Salary)

The following dependencies violate partial dependency as a prime attribute -> prime attribute :

Name -> Emp_ID

DeptID -> Emp_ID

Marketing ->  Emp_ID

The following dependencies violate partial dependency as a non-prime attribute -> non-prime attribute :

Course_ID -> Course Name

Course_Name ->  Course_ID

So, no separate tables should be made.

The functional dependency Date_Completed -> Course_Name has a partial dependency as a prime attribute determines a non-prime attribute.

So, a separate table is made.

The final relational schemas that follows 2NF are :

R1(Emp_ID, Name, DeptID, Marketing, Course_ID, Course_Name, Date_Completed)

R2( Emp_ID , Salary)

R3 (Date_Completed, Course_Name, Course_ID)

For a relation to be in 3NF, the functional dependencies should not have any transitive dependencies.

The functional dependencies in R1(Emp_ID, Name, DeptID, Marketing, Date_Completed) is :

Emp_ID -> Name, DeptID, Marketing

This violates the transitive property. So, no table is created.

The functional dependencies in R2 (  Emp_ID , Salary) is :

Emp_ID -> Salary

The functional dependencies in R3 (Date_Completed, Course_Name, Course_ID) are :

Date_Completed -> Course_Name

Course_Name   ->  Course_ID

Here there is a transitive dependency as a non- prime attribute ( Course_Name ) is determining a non-attribute ( Course_ID ).

So, a separate table is made with the concerned attributes.

The relational schemas which support 3NF re :

R1(Emp_ID, Name, DeptID, Course_ID, Marketing, Date_Completed) with candidate key as Emp_ID.

R2 (  Emp_ID , Salary) with candidate key Emp_ID.

R3 (Date_Completed, Course_Name ) with candidate key Date_Completed.

R4 ( Course_Name, Course_ID ).  with candidate keys Course_Name and Course_ID.

Answer:

i) The time taken for 1500 records = 15 seconds.

ii) The time taken for 1500 records = 50 seconds.

Explanation:

A is an O(n) algorithm.

An algorithm with O(n) efficiency is described as a linearly increasing algorithm, this mean that the rate at which the input increases is linear to the time needed to compute that algorithm with n inputs.

From the question, it is given that for 1000 records, the time required is: 10 seconds.

Algorithm time taken is O(n)

Hence,

1) For 1,500 records

=> 10/1000 = x/1500

=> 10x1500/1000 = x

x = 15 seconds

Thus, the time taken for 1500 records = 15 seconds.

2) For 5,000 records

=> 10/1000 = x/5000

=> 10x5000/1000 = x

x = 50 seconds

Thus, the time taken for 1500 records = 50 seconds.

Answer:

import java.util.Scanner;

public class num10 {

   public static void main(String[] args) {

       Scanner in = new Scanner(System.in);

       System.out.println("Enter a word");

       String word = in.nextLine();

       String reversed = "";

       //Get the length of the string entered

       int length = word.length();

       //Loop through the string and reverse th string

       for ( int i = length - 1; i >= 0; i-- )

           reversed = reversed + word.charAt(i);

       //Compare the two strings "word" and "reversed"

       if (word.equals(reversed))

           System.out.println(word+" is a palindrome");

       else

           System.out.println(word+" is not a palindrome");

   }

}

Explanation:

Since we know that a palindrome word is a word that reads the same forward and backward, The Idea here is:

Answer:

class Rectangle:

   def __init__(self, length=1, width=1):

       self.length = length

       self.width = width

   def Area(self):

       return self.length * self.width

   def Perimeter(self):

       return 2 * (self.length + self.width)

   def Print(self):

       print(str(self.length) + " X " + str(self.width))

l = float(input("Enter the length: "))

w = float(input("Enter the width: "))

a = Rectangle(l, w)

print(str(a.Area()) + " " + str(a.Perimeter()))

a.Print()

Explanation:

Create a class called Rectangle

Create its constructor, that sets the length and width

Create a method Area to calculate its area

Create a method Perimeter to calculate its perimeter

Create a Print method that prints the rectangle in the required format

Ask the user for the length and width

Create a Rectangle object

Calculate and print its area and perimeter using the methods from the class

Print the rectangle

Answer:

class Rectangle():

   def __init__(self, l, w):

       self.len = l

       self.wi  = w

   def area(self):

     return self.len*self.wi

   def perimeter(self):

     return self.len+self.len+self.wi+self.wi

   def printing(self):

     print('{} Lenght X Width {}'.format(self.len, self.wi))

length = int(input("enter the length "))

width = int(input("enter the width "))

newRectangle = Rectangle(length, width)

newRectangle.printing()

print("Area is: ")

print(newRectangle.area())

print("The perimeter is: ")

print(newRectangle.perimeter())

Explanation:

The class rectangle is defined with a constructor that sets the length and width

As required the three methods Area, perimeter and printing are also defined

The input function is used to prompt and receive user input for length and width of the rectangle

An object of the Rectangle class is created and initalilized with the values entered by the user for length and width

The three methods are then called to calculate and return their values

Answer:

// This program is written in C++ programming language

// Comments are used for explanatory purpose

// Program starts here

#include<iostream>

using namespace std;

// Function starts here

string ascendingwords(string sentence)

{

// Calculate length of input text

int len = sentence.length() - 1;

// Create a begin and end variable

int begin, end = len + 1;

// Declare and initialize an output string

string output = "";

// Perform iteration while there's still some text in the input string

while(len >= 0)

{

if(sentence[len] == ' ')

{

begin = len + 1;

while(begin != end)

output += sentence[start++];

output += ' ';

end = len;

}

len--;

}

begin = 0;

while(begin != end)

output += sentence[begin++];

return output;

}

// Main method starts here

int main()

{

// Declare string

string sentence;

// Prompt user for input

cout<<"Enter a string: ";

cin>>sentence;

cout <<ascendingwords(sentence);

return 0;

}

Answer:

The answer is in the explanation and check the attached file for the output

Explanation:

GCD.py:

def gcd(a, b):

  if b > a:

       a, b = b, a

  while b != 0:

       t = b

       b = a % t

       a = t

   return a

def main():

   m = eval(input("Enter m: "))

   n = eval(input("Enter n: "))

   print("GCD(",m,",",n,") = ",gcd(m,n))

main()

Output: check the output in the attached file

Answer:

I am writing a C++ program.

#include <iostream> // for input output functions

using namespace std; // to identify objects like cin cout

int gcd(int m, int n) {

//function to compute greatest common divisor of two value m and n

  if (n == 0) //if value of n is equal to 0 (base condition)

  return m; // returns the value of m

  return gcd(n, m % n); }

// calls gcd function recursively until base condition is reached  

void get_value(int c, int d){ // function to obtain two values

  cout<<"Enter the two values: "<<endl;

//prompts user to enter values of c and d

  cin>>c>>d; //reads the input values of c and d

  while(c <= 0 || d<= 0){ // the loop continues to ask user to enter positive //values until user enters values greater than 0

      cout<<"Enter a positive value";

      cin>>c>>d;   } //reads values from user

    cout<<"GCD of "<< c <<" and "<< d <<" is "<< gcd(c, d); }

//calls gcd funtion to compute greatest common divisor of two values    

int main() { // main() function body

   int a,b; //two integer variables are declared

   get_value(a,b); // calls this method to take values of a and b from user

   char ch; // used to enter a choice by user to perform gcd again

   while(true)      {

//asks the user if he wants to continue to compute gcd

       cout<<"Would you like to do another computation or not?(Y/N)\n"<<endl;

       cin >> ch; //reads the choice user enters

/*if user enters Y or y then it calls get_value function to take values from user and computer gcd, if user types N or n then the program exits */

       if(ch == 'Y'|| ch =='y'){

           get_value(a,b);

       }else if(ch =='N'||ch =='n'){

           break;         }    }}

Explanation:

The program has three methods. gcd method that computes greatest common divisor (GCD) of two values can be computed using Euclid's algorithm. get_value method takes two positive integers from user to find gcd of these values. It keeps asking user to enter positive values until user enters positive values. Third is the main() function which calls get_value function and after computing gcd of two values, asks user to if he wants to find gcd again? If user types Y or y which indicates yes, it moves the program control to get_value function and if user enters n, then the program ends.

Answer:

The actual cost of  (n) stack operations will be two ( charge for push and pop )

Explanation:

The cost of (n) stack operations involves two charges which are actual cost of operation of the stack which includes charge for pop ( poping an item into the stack) which is one and the charge for push ( pushing an item into the stack ) which is also one. and the charge for copy which is zero. therefore the maximum size of the stack operation can never exceed K because for every k operation there are k units left.

The amortized cost of the stack operation is constant 0 ( 1 ) and the cost of performing an operation on a stack made up of n elements will be assigned as 0 ( n )

The amortized cost of n stack operations, including backup copying after every k operations, remains O(n). This is achieved by assigning an amortized cost of 2 to each operation and distributing the copying cost evenly.

To analyze the cost of stack operations including backups, we consider the sequence of operations and calculate the total cost over time, assigning an amortized cost. Here’s the breakdown:

Since each operation has an amortized cost of 2, and every k operations involve an additional O(k) time for copying, the total cost for n operations is O(n) over time. This is because the cumulative effect of the every-k copying is distributed evenly across the individual operations, ensuring that the average cost per operation remains constant.

Therefore, the total cost comprises the individual stack operations plus the copying operations, yielding an overall cost of O(n).

Answer:

see explaination

Explanation:

/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package knapsack;

import java.util.*;

/**

*

* atauthor Administrator

*/

public class MyKnapsack {

static int max(int a, int b) { return (a > b)? a : b; }

static int calculate(int W, int wt[], int val[], int n)

{

if (n == 0 || W == 0)

return 0;

if (wt[n-1] > W)

return calculate(W, wt, val, n-1);

else return max( val[n-1] + calculate(W-wt[n-1], wt, val, n-1),

calculate(W, wt, val, n-1)

);

}

public static void main(String[] args)

{

Scanner sc=new Scanner(System.in);

System.out.printf("|Enter value of capacity");

int Capacity =sc.nextInt();

System.out.printf("|Enter value of number of objects");

int n=sc.nextInt();

int profits[] = new int[n];

int weight[] = new int[n];

System.out.printf("|Enter values for profits");

for(int i=0;i<n;i++)

{

profits[i]=sc.nextInt();

}

System.out.printf("|Enter values for weights");

for(int j=0;j<n;j++)

{

weight[j]=sc.nextInt();

}

System.out.println(calculate(Capacity,weight, profits, n));

}

Note: change the at with the sign

}

Answer:

see explaination

Explanation:

#include <stdio.h>

// user defined functions

int min(int arr[], int n)

{

int m=arr[0];

for(int i=1;i<n;i++)

if(arr[i]<m)

m=arr[i];

// return minimum

return m;

}

int max(int arr[], int n)

{

int m=arr[0];

for(int i=1;i<n;i++)

if(arr[i]>m)

m=arr[i];

// return maximum

return m;

}

int main() {

int n;

// read N

printf("Enter number of elements: ");

scanf("%d",&n);

// read n values into list

int arr[n];

printf("Enter elements: ");

for(int i=0;i<n;i++)

scanf("%d",&arr[i]);

// find max and min

printf("The List is: ");

for(int i=0;i<n;i++)

printf("%d ",arr[i]);

printf("\nThe minimum value is: %d\n",min(arr,n));

printf("The maximum value is: %d\n",max(arr,n));

return 0;

}

see attachment for screenshot and output

Final answer:

The minimum bandwidth required to transmit a signal generated at a rate of 1,000,000 ASCII characters per second, with an added parity bit for single error detection, is 4 MHz. This calculation is based on the bit rate of 8 million bits per second and assumes a binary signal requiring a minimum bandwidth that is half of the bit rate.

Explanation:

The question pertains to digital data transmission and requires calculating the minimum bandwidth necessary for a computer that generates data at a rate of 1,000,000 characters per second, using ASCII which has 7-bit binary-coded characters and includes an additional parity bit for error detection, making it 8 bits per character in total.

Bandwidth, in this context, refers to the range of frequencies necessary to transmit the digital signal. The data rate of the signal is given as 1,000,000 characters per second, and since each character is represented by 8 bits (7 bits for ASCII character and 1 for parity), the bit rate is 8,000,000 bits per second, or 8 Mbps (Megabits per second).

To calculate the minimum bandwidth using the Nyquist formula, we assume the signal is binary and requires a minimum bandwidth that is half of the bit rate. Hence, the minimum bandwidth required is 4 MHz (megahertz). This is because the maximum rate of change of a binary signal would be if it alternated between 0 and 1 for every bit, so the minimum bandwidth is also known as the Nyquist bandwidth.

Final answer:

The minimum bandwidth required to transmit ASCII characters with single error detection at 1,000,000 characters per second, assuming a parity bit is added to each character, is 8 Mbps. This figure is based on 8-bit as characters and could vary depending on the modulation technique used.

Explanation:

The minimum bandwidth required to transmit a signal with single error detection for ASCII characters at a rate of 1,000,000 characters per second can be calculated considering the addition of a parity bit to each character. ASCII uses 7 bits per character, making it 8 bits with the parity bit. To find the bandwidth, we multiply the bit rate per character by the number of characters per second. Since the computer generates data at 1,000,000 characters per second, and with the parity bit, we have an 8-bit as character, the data rate becomes 8,000,000 bits per second (or 8 Mbps).

However, the bandwidth can also be affected by various factors such as the modulation technique used. For instance, if a simple binary modulation scheme is used (such as non-return-to-zero, NRZ), where one bit is transmitted per signal change, the bandwidth would be 8 Mbps. But if a more complex modulation scheme is used, which transmits more than one bit per signal change, the required bandwidth could be lower.

Answer:

in_season_price = 120.0

off_season_price = 70.0

price = 0

season = input("Which season you plan to rent \"IN/OFF\" season: ")

days = int(input("Enter the days you want to rent: "))

if season == "IN":

   price = in_season_price * days

elif season == "OFF":

   price = off_season_price * days

print("Rental price is: " + str(price))

Explanation:

Set the prices for in and off season

Ask the user to choose the season and number of days they want to stay

Depending on the user choice calculate the price, multiply the season price with the number of days

Print the total price

Answer:

// This program is written in C++ programming language

// Comments are used for explanatory purpose

// Program starts here

#include<iostream>

using namespace std;

int main ()

{

// Declare and initialize variables

float connecfee = 1.99;

float first3 = 2.00;

float addmin = 0.45; float cost;

int minutes;

// Prompt user for minutes talked

cout<<"Enter Number of Minutes: ";

cin>>minutes;

// Calculate cost;

if(minutes < 1)

{

cout<<"Enter a number greater than 0";

}

else if(minutes <= 3)

{

// Calculating cost for minutes less than or equal to 3

cost = connecfee + first3 * minutes;

cout<<"Talk time of "<<minutes<<" minutes costs "<<cost;

}

else

{

cost = connecfee + first3 * 3 + addmin * (minutes - 3);

cout<<"Talk time of "<<minutes<<" minutes costs "<<cost;

}

return 0;

}

// End of Program

Answer:

See explaination

Explanation:

The code here:

import java.io.*;

public class CISP401V11A5 {

public static void main(String[] args) throws Exception {

try {

CISP401Method();

} catch (Exception e) {

System.out.println("Exception thrown in " + e.getStackTrace()[0].getMethodName() + "\n");

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

String exceptionAsString = sw.toString();

String bagBegin = exceptionAsString.substring(0, 19);

String bagEnd = exceptionAsString.substring(19);

System.out.println(bagBegin + ": Exception thrown in " + e.getStackTrace()[0].getMethodName() + bagEnd);

}

}

public static void CISP401Method() throws Exception {

try {

CISP401Method2();

} catch (Exception e) {

throw e;

}

}

public static void CISP401Method2() throws Exception {

throw new Exception();

}

}

See attachment for sample output

Answer:

To look up functions and their purposes

Explanation:

Edg

Answer:

a on edge

Explanation:

just took the question

Answer:

num1 = float(input("Enter the first number: "))

while True:

   print("Add, Subtract, Multiply, Divide, or Quit ?")

   choice = input("Your choice is: ")

   if choice == "Quit":

       break

   num2 = float(input("Enter the second number: "))

   if choice == "Add":

       num1 += + num2

       print("The subtotal is: " + str(num1))

   elif choice == "Subtract":

       num1 -= num2

       print("The subtotal is: " + str(num1))

   elif choice == "Multiply":

       num1 *= num2

       print("The subtotal is: " + str(num1))

   elif choice == "Divide":

       num1 /= num2

       print("The subtotal is: " + str(num1))

print("The final result is: " + str(num1))

Explanation:

Ask the user for the first number

Create a while loop that iterates until specified condition occurs inside the loop

Ask the user for the operation or quitting

If the user chooses quitting, stop the loop. Otherwise, get the second number, perform the operation and print the subtotal

When the loop is done, the user enters Quit, print the final value result

Answer:

Check the explanation

Explanation:

Circle.java

public class Circle {

private double radius;

public Circle(double r) {

radius = r;

}

public double getArea() {

return Math.PI * radius * radius;

}

public double getRadius() {

return radius;

}

public String toString() {

String str;

str = "Radius: " + radius + "Area: " + getArea();

return str;

}

public boolean equals(Circle c) {

boolean status;

if (c.getRadius() == radius)

status = true;

else

status = false;

return status;

}

public boolean greaterThan(Circle c) {

boolean status;

if (c.getArea() > getArea())

status = true;

else

status = false;

return status;

}

}

I have created a class also to test this class below is the class: -

MainCircle.java

public class MainCircle {

public static void main(String args[]) {

Circle c = new Circle(2.5);

Circle c1 = new Circle(2.5);

Circle c2 = new Circle(4.5);

System.out.println(c);

System.out.println(c1);

System.out.println(c2);

System.out.println("Is c and c1 equal : "+c.equals(c1));

System.out.println("Is c2 greater than c1 : "+c1.greaterThan(c2));

}

}

Output: -

Radius: 2.5Area: 19.634954084936208

Radius: 2.5Area: 19.634954084936208

Radius: 4.5Area: 63.61725123519331

Is c and c1 equal : true

Is c2 greater than c1 : true

Answer:

See explaination for the program code

Explanation:

//SocSecProcessor.java:

import java.util.Scanner;

public class SocSecProcessor

{

public static void main (String [] args)

{

Scanner keyboard = new Scanner (System.in);

String name;

String socSecNumber;

String response;

char answer = 'Y';

while (Character.toUpperCase(answer) == 'Y')

{

try

{

// Task #2 step 1 - To do:

// promote user to enter name and ssn number.

// save the input to variable name and SocSecNumber. Such as:

// System.out.print("Name? ");

// name = keyboard.nextLine();

// validate SSN number by calling isValid(socSecNumber).

// output the checking result.

System.out.print("Name?");

name = keyboard.nextLine();

System.out.print("SSN?");

socSecNumber = keyboard.nextLine();

if(isValid(socSecNumber)){

System.out.println(name + " " + socSecNumber + "is Valid");

}

}

catch (SocSecException e) // To do: catch the SocSecException

{

System.out.println(e.getMessage());

}

System.out.print("Continue? ");

response = keyboard.nextLine();

answer = response.charAt(0);

}

}

private static boolean isValid(String number)throws SocSecException

{

boolean goodSoFar = true;

int index = 0;

// To do: Task #2 step 2

// 1. check the SSN length. Throw SocSecException if it is not 11

if (number.length() != 11)

{

throw new SocSecException("wrong number of characters ");

}

for( index=0;index<number.length();++index){

if(index==3 || index==6){

if (number.charAt(index) != '-'){

throw new SocSecException("dashes at wrong positions");

}

}else if (!Character.isDigit(number.charAt(index))){

throw new SocSecException("contains a character that is not a digit");

}

}

// 2. check the two "-" are in right position. Throw SocSecException if it is not

// if (number.charAt(3) != '-')

// 3. check other position that should be digits. Throw SocSecException if it is not

// if (!Character.isDigit(number.charAt(index)))

return goodSoFar;

}

}

See attachment

Answer:

See explaination for program code

Explanation:

program code below:

#include<stdio.h>

int main()

{

//file pointer to read from the file

FILE *fptr;

//array to store the years

int years[50];

//array to store the population

float population[50];

int n = 0, j;

//variables for the linear interpolation formula

float x0,y0,x1,y1,xp,yp;

//opening the file

fptr = fopen("njpopulation.dat", "r");

if (fptr != NULL)

{

//reading data for the file

while(fscanf(fptr, "%d %f", &years[n], &population[n]) == 2)

n++;

//prompting the user

int year = -1;

printf("Enter the years for which the population is to be estimated. Enter 0 to stop.\n\n");

while(year != 0)

{

printf("Enter the year (1790 - 2010) : ");

scanf("%d", &year);

if (year >= 1790 && year <= 2010)

{

//calculating the estimation

xp = year;

for (j = 0; j < n; j++)

{

if (year == years[j])

{

//if the year is already in the table no nedd for calculation

yp = population[j];

}

else if (j != n - 1)

{

//finding the surrounding census years

if (year > years[j] && year < years[j + 1])

{

//point one

x0 = years[j];

y0 = population[j];

//point two

x1 = years[j + 1];

y1 = population[j + 1];

//interpolation formula

yp = y0 + ((y1-y0)/(x1-x0)) * (xp - x0);

}

}

}

printf("\nEstimated population for year %d : %.2f\n\n", year, yp);

}

else if (year != 0)

{

printf("\nInvalid chioce!!\n\n");

}

}

printf("\nAborting!!");

}

else

{

printf("File cannot be opened!!");

}

close(fptr);

return 0;

}

OUTPUT :

Enter the years for which the population is to be estimated. Enter 0 to stop.

Enter the year (1790 - 2010) : 1790

Estimated population for year 1790 : 184139.00

Enter the year (1790 - 2010) : 1855

Estimated population for year 1855 : 580795.00

Enter the year (1790 - 2010) : 2010

Estimated population for year 2010 : 8791894.00

Enter the year (1790 - 2010) : 4545

Invalid chioce!!

Enter the year (1790 - 2010) : 1992

Estimated population for year 1992 : 7867020.50

Enter the year (1790 - 2010) : 0

Aborting!!

Answer:

Explanation:

Iterative vs Concurrent:

An iterative server handles both the association demand and the exchange engaged with the call itself. Iterative servers are genuinely straightforward and are reasonable for exchanges that don't keep going long.

Be that as it may, if the exchange takes additional time, lines can develop rapidly, when Client A beginnings an exchange with the server, Client B can't make a call until A has wrapped up.

In this way, for extensive exchanges, an alternate kind of server is required — the simultaneous server, Here, Client A has just settled an association with the server, which has then made a youngster server procedure to deal with the exchange. This permits the server to process Client B's solicitation without trusting that An's exchange will finish. Beyond what one youngster server can be begun along these lines. TCP⁄IP gives a simultaneous server program called the IMS™ Listener.

Some idea on on time synchronization is Synchronization of Clocks: Software-Based Solutions

Techniques:

1.time stamps of real-time clocks

2.message passing

3. round-trip time (local measurement)

4.Cristian’s algorithm

5.Berkeley algorithm

6.Network time protocol (Internet)

A system time server isn't something numerous entrepreneurs consider, and timekeeping is generally not a need for organize executives. In any case, legitimate system time synchronization is a fundamental piece of checking a system and settling issues inside it.

Answer:

See explaination

Explanation:

// Defination of MoneyMarketAccount CLASS

MoneyMarketAccount::MoneyMarketAccount(string name, double balance)

{

acctName = name;

acctBalance = balance;

}

int MoneyMarketAccount::getNumWithdrawals() const

{

return numWithdrawals;

}

int MoneyMarketAccount::withdraw(double amt)

{

if (amt < 0)

{

cout << "Attempt to withdraw negative amount - program terminated."<< endl;

exit(1);

}

if((numWithdrawals < FREE_WITHDRAWALS) && (amt <= acctBalance)){

acctBalance = acctBalance - amt;

return OK;

}

if((numWithdrawals >= FREE_WITHDRAWALS) &&((amt + WITHDRAWAL_FEE) <= acctBalance)){

acctBalance = acctBalance - (amt + WITHDRAWAL_FEE);

return OK;

}

return INSUFFICIENT_FUNDS;

}

// Defination of CDAccount CLASS

CDAccount::CDAccount(string name, double balance, double rate)

{

acctName = name;

acctBalance = balance;

interestRate = rate/100.0;

}

int CDAccount::withdraw(double amt)

{

if (amt < 0)

{

cout << "Attempt to withdraw negative amount - program terminated."<< endl;

exit(1);

}

double penalty = (PENALTY*interestRate*acctBalance);

if((amt + penalty) <= acctBalance){

acctBalance = acctBalance - (amt + penalty);

return OK:

}

else

return INSUFFICIENT_FUNDS;

}

void transfer (double amt, BankAccount& fromAcct, BankAccount& toAcct)

{

if (amt < 0 || fromAcct.acctBalance < 0 || toAcct < 0)

{

cout << "Attempt to transfer negative amount - program terminated."<< endl;

exit(1);

}

if(fromAcct.withdraw(amt) == OK){ // if withdraw function on fromAcct return OK, then me can withdraw amt from fromAcct

// and deposit in toAcct

toAcct.acctBalance = toAcct.acctBalance + amt;

}

}

Answer:

D. Low-level components are combined into clusters that perform a specific software sub-function

Explanation:

Normally, regression testing are done on a manual basis by simply re-executing a subset of the entire available test cases or it can be done automatically by utilizing playback tools or automated capture. Hence, from the options, a combination of low-level components into clusters that perform a specific sub-function does not align with how regression testing are done either manually or automatically.

Low-level components are combined into clusters that perform a specific software sub-function. Thus option D is correct.

Regression testing is a statistical method of finding the relation between variables and is done by use of software such as functional and non-functional. It ensures that the development  of the software are made by utilizing playback tools or capture.

Thus, the options, are a combination of the low-level components into the clusters that perform specific sub-functions.

Find out more information about the regression.

brainly.com/question/13676957.

Answer:

A. To set the primary contact on an account record when it is saved

Explanation:

After updating a Contact and then you set the Primary checkbox, the contact becomes the primary contact and this then updates the reference in the Parent Account. Triggers are used for this purpose and not workflow rule. In this case there is only one contact at a time that is set as Primary Contacts, and in the case where an Account does not have any Contacts, the first contact that is created is made the primary and the trigger sets that value in reference.

Final answer:

To find the satisfying assignment that minimizes the number of variables set to TRUE using the satisfiable num program, follow the provided pseudo-code.

Explanation:

To use the Boolean formula satisfiability program satisfiable num to find a satisfying assignment that minimizes the number of variables set to TRUE, you can follow the pseudo-code:

Answer:

def student_minmax(filename):  

  """

      Description: Reads student names and finds min and max score

      Input: Name of the file that has the student data

      Output: Dictionary with name as key and value is a list with min and max values

  """

  # Dictionary that holds the results

  studentDict = {}

  # Opening and reading file

  with open(filename, "r") as fp:

      # Reading data line by line

      for line in fp:

          # Stripping new line

          line = line.strip()

          # Splitting into fields

          fields = line.split(' ')

          # Getting name and scores

          name = fields[0]

          scores = []

          scoresStr = fields[1:]

          # Converting to integer

          for score in scoresStr:

              scores.append(int(score))

          # Storing in dictionary

          studentDict[name] = []

          studentDict[name].append(min(scores))

          studentDict[name].append(max(scores))

  # Returning dictionary

  return studentDict  

# Testing function

resDict = student_minmax("d:\\Python\\studentMarks.txt")

# Printing dict

print(resDict)

Explanation: