Tag: Programming

Q1. List all instructors. Show salutation in all lower cases, last name in all upper cases and phone number in the format of ‘(xxx) xxx-xxxx’. (HINT: use LOWER, UPPER and SUBSTR function)

Q2. List all students (display student_id, first name, last name, street address, zipcode, city, and state) who live in New York, NY. Sort results by last name, and then first name, in descending order.

Q3. Display the city in which each instructor lives. List first name, last name, zip, city, and state. Display “N/A” for zip, city, and state if an instructor does not have a zipcode. (HINT: left join INSTRUCTOR and ZIPCODE; use NVL function)

Q4. Show the number of instructors who live in NY state and has a street number of 518. (HINT: use string functions such as SUBSTR and INSTR)

Q5. Display the lowest, highest, and average numeric grade of Project grade type. (HINT: use the MIN, MAX, and AVG function; join GRADE and GRADE_TYPE)

— LEFT JOIN, DATE

Q6. List all students (display student_id, first name, last name, and registration date) who registered on or before 2/15/2007 but have not enrolled in any course. (HINT: left outer join STUDENT and ENROLLMENT; use the TO_DATE function)

— COUNT WITH 3-TABLE JOIN

Q7. Find how many students are enrolled in sections taught by Todd Smythe. (HINT: join INSTRUCTOR, SECTION, and ENROLLMENT)

— 4-TABLE JOIN

Q8. Show all students who are taking, or have taken the course “Advanced Java Programming”. List student name, enrollment date, and section location. (HINT: join COURSE, SECTION, ENROLLMENT, and STUDENT)

— 4-TABLE JOIN

Q9. List the students who have received any numeric grade score of at least 95 in an Advanced Java Programming course. Show student name, the grade type code, and the numeric grade.

— 4-TABLE JOIN WITH DISTINCT

Q10. List the instructors who teach Advanced Java Programming (having a section with students enrolled), without duplication. Show instructor name and course name. (HINT: use the DISTINCT keyword)

1) Multiple alternative answers to the same question, and provide a default answer scheme;

2) Can answer questions through regular expressions, pattern matching, keyword extraction, syntactic conversion, etc.;

3) It can extract user intent through regular expression, nearest neighbor classification or one or more schemes of support vector machines;

4) Identify named entities through pre-built named entity types, role relationships, dependency analysis, etc.

5) Construction of local basic chatbot system based on RASA NLU;

6) Database query and use natural language to explore database content (extract parameters, create queries, responses)

7) Single round multiple incremental query technology based on incremental filter and screening and negating entity technology

8) Realize the multi-round multi-query technology of the state machine, and provide explanations and answers based on contextual questions

9) Multi-round multi-query technology to handle rejections, wait state transitions and pending actions 

1. Use as many of the nine implementation techniques in four examples as you can in your code, preferably from the beginning to the end. Requires to be able to achieve at least three kinds of intention queries (such as asking some stock price information, trading volume information, market value, etc.), each intention needs at least two rounds of queries to get the query results;

2. The following example of IexFinance API can be used to query real-time stock price, trading volume, opening price and other information.

https://pypi.org/project/iexfinance/

3. The training is completed by asking and answering questions. You need to construct the training data and use the training model by yourself according to the training data in RASA NLU for example.

4. Here are the four examples of the chatbox, you can use the code in examples as you want.

   1.https://colab.research.google.com/drive/1cJ5UAQTBI… 

  2. https://colab.research.google.com/drive/1uXo5MIkPY…

  3.https://colab.research.google.com/drive/1n6cYMO40p…

  4.https://colab.research.google.com/drive/1oxOFQ1C6Y…

The purpose of this assignment is to give you practice implementing your own classes. It also provides extra practice with arrays.

Because it is the end of the semester and we have a short deadline for submitting grades, absolutely no late assignments can be accepted for credit.

Task

Implement a class Task, which is used to represent a job that should be done. It should contain the following private fields:

• name text description of what job should be done (e.g., take out the trash, finish 1068 homework).
• priority, a non-negative integer which stores the importance of a Task.
• estMinsToComplete, a non-negative integer which holds the anticipated number of minutes it should take to complete the task
• extra credit: whenDue a java.time.LocalDateTime object representing the date and time when the task should be completed

Implement at least the following public methods within the Task class:

• a constructor, which initializes each of the fields
• accessor methods for each of the fields. Use the naming convention getXXX() where XXX is the name of the field, e.g., you’ll write a method called getName() which returns the name of the Task.
• mutator methods for each of the fields except for priority. Use the naming convention setXXX() where XXX is the name of the field, e.g., you’ll write a method called setName(String newName), which would update the name field of the Task to newName.
• toString( ), which returns a String representation of the Task.
• increasePriority(int amount) increases the priority level by amount. If a negative amount is specified, the method returns without making any changes.
• decreasePriority(int amount) decreases the priority level by amount. If the decrease is more than the current value of priority (and subtracting this amount would result in a negative priority), priority should be set to 0.
• extra credit: overdue() returns true if the current date/time is later than whenDue or false otherwise.

For example, we should be able to do something like the following:

    // creates a new Task object to remind you
    // to finish your 1068 homework. It has priority 3
    // and I anticipate that it's going to take 120 minutes
    Task doMyHW = new Task("finish 1068 homework", 3, 120);
    // if we're doing extra credit, we might instead write:
    Task postHW = new Task("post 1068 homework", 1, LocalDateTime.of(2019, 3, 23, 13, 0), 180);

    // which would be to remind me to post the 1068 homework assignment.
    // This has priority 1, should take me 180 minutes
    // and it's due March 23, 2019 at 1 PM (i.e., 13:00)

Write a very short driver program (a separate class containing a main()) to test your code to make sure it’s working. You are not required to write JUnit tests.

HoneyDoList

Implement a class HoneyDoList, which is used to manage a collection of Task. It should contain the following private fields:

• tasks[] an array of Task
• numTasks, a non-negative integer storing the number of items contained in tasks[].
• INITIAL_CAPACITY, a constant non-negative integer. This is how large the task array should be at creation time.

Implement at least the following public methods within the HoneyDo class:

• a constructor, which creates the tasks[] array, giving it the capacity of INITIAL_CAPACITY, and setting numTasks to 0.
• toString( ), which returns a String representation of each Task in tasks[]. Do not include in the String null for entries in tasks[] that are empty.
• find(String name), which returns the index of the first occurence of a Task whose name matches the name specified ignoring case. Recall that there is an equalsIgnoreCase() method in the String class. The method should return -1 if no match is found.
• addTask(), which appends a new Task to the occupied end of tasks[]. If tasks[] is already full when you attempt to add the new Task, a new array is created, all of the items are copied from the old array into the new one, and tasks[] is set to point to the new array.
• totalTime() which returns the total time in minutes required to complete all tasks in the list.
• shortestTime() which returns the index of the task that should take the least amount of time to finish or -1 if the list is empty.
• completeTask(int index), which removes and returns the Task at the specified index shifting all subsequent tasks in the array one position to the left. If index is invalid, returns null. See example.
• extra credit: overdueTasks() returns an array of Task consisting of only the items in tasks[] that are overdue.

For example, we should be able to do something like the following:

   // create a new empty list
   HoneyDoList honeydo = new HoneyDoList();

   System.out.println(honeydo);		
   honeydo.addTask(new Task("take aspirin", 1, 120));
   System.out.println(honeydo);

   // print the item in the list which should
   // take the least amount of time
   System.out.println(honeydo.shortestTime()); // calls toString() in Task

Write a very short driver program to test your code to make sure it’s working. You are not required to write JUnit tests.

Implementation Notes

One of the purposes of this assignment is give you practice managing fixed-sized arrays. Although you may use the Arrays class, please refrain from using ArrayList or any other class in Java’s Collections Framework. (We’ll get to these soon .)

Shifting Tasks

Suppose that we have a HoneyDoList with a capacity of 10 items and contains 4. We can visualize it this way:

1.

The principal of a local school wants a program that displays the average number of students per teacher at the school. The principal will enter the number of students enrolled and the number of teachers employed. Complete an IPO chart for this 

problem. Plan the algorithm using a flowchart. Also complete a desk-check table for your algorithm. For the first desk-check, use 1200 and 60 as the number of students and number of teachers, respectively. Then use 2500 and 100.  

1. Enter the number of students and teacher. 2. Calculate the average number of students per teacher by dividing the number of  students by the number of teachers. 3. Display the average number of students per teacher 

 5. Norbert Catering is famous for its roast beef sandwiches. The store’s owner wants a  program that he can use to estimate the number of pounds of roast beef a customer  should purchase, given the desired number of sandwiches and the amount of meat  per sandwich. Typically, one sandwich requires two to three ounces of meat, but  some customers prefer four or five ounces per sandwich. Complete an IPO chart for  this problem. Desk-check the algorithm using 50 as the number of sandwiches and 4  ounces as the amount of meat per sandwich. Then desk-check it using 224 and 2  ounces.

1. Enter the number of sandwiches and amounts of meat per sandwich in ounces. 2. Calculate the number of ounces of roast beef by multiplying the number of  sandwiches and amounts of meat per sandwich in ounces. 3. Calculate the number of pounds of roast beef a customer should purchase by  dividing by 16 the number of ounces of roast beef. 4. Display the number of pounds of roast beef a customer should purchase. 

8. Each time Tania visits the dentist, her dental insurance requires her to pay a $20 copay and 15% of the remaining charge. She wants a program that displays the total  amount she needs to pay, as well as the total amount the insurance should pay.  Complete an IPO chart for this problem. You can assume that the dental charge will  always be at least $20. Desk-check the algorithm using $110 as the dental charge.  Then desk-check it using your own data. 

1. Enter the dental charge. 2. Subtract $20 from the dental charge. 3. Multiplicate the rest of the dental charge by 0.15 4. Calculate the amount of money we need to pay by adding $20 to the rest of the  dental charge 5. Display the amount of money we need to pay 

1st. Provide a detailed description of systems integration problem for a specific organization. Integration problem and organization can be real or fictitious. The integration problem should be complex enough to warrant utilization of advanced service integration technologies. The problem must involve more than three applications and five interactions among them. Here are some integration problem examples from Enterprise Integration Patterns book:

View the Enterprise Integration Patterns Loan Broker System Management

View the Enterprise Integration Patterns Case Study: Bond Trading System

View the Enterprise Integration Patterns Solving Integration Problems using Patterns (see Widget-Gadget Corp example)

2nd

Provide preliminary analysis and design for the identified systems integration problem. This preliminary solution should contain a conceptual service-oriented architecture design, depicting different service components along with existing applications/systems and interactions among these components. Provide detailed description for each component and interaction. For example, provide details on the application modules involved within a service component and existing application/system; whether a service component is atomic service or composed services; details of messages and documents exchanged between components; application programing interface details; data exchange format details; user interface details; service client interface details; and utilizationof protocols and standards. Provide example scenarios and use cases to demonstrate the actual usage of your solution.

3rd.

Provide a detailed design solution and implementation plan for the identified systems integration problem. Discuss assumptions made to analyze the problem and design the solution. Justify your assumptions, design decisions, and solutions adopted. Justify why you made such decisions and why they make sense. Provide a detailed plan to implement a designed solution along with details of service-oriented frameworks, platforms, servers, orchestration engines, etc. Discuss the feasibility of the implementation plan. Provide recommended products that will be used for the implementation. Provide comparative feature set evaluation of similar products to justify your selection. Discuss shortcomings of the solution developed and how it could be improved.

Remember # 3 only implementation plan

Finally write a report regarding all parts following the rubric attached

Pizza Servings Calculator GUI Assignment

Write a GUI to calculate the number of servings that a circular pizza of a certain diameter will make. The GUI will have the following appearance:

It must include the following features:

• The frame title must say ‘Pizza Servings Calculator’.
• A grid layout will be used for the GUI.
• The JLabel title of the GUI will say ‘Pizza Servings Calculator’ and be in red and will be placed in grid slot 1.
• A JLabel of ‘Enter the size of the pizza in inches: ‘ will be placed in grid slot 2 followed by a JTextField where the pizza size will be entered and have a width of 4.
• A JButton will be placed in grid slot 3 and will contain ‘Calculate Servings’.
• A JLabel, initially blank, will be placed in grid slot 4.

To execute the GUI, enter a pizza size in the JTextField and click the Calculate Servings button. The Calculate Servings button handler will then execute and calculate the number of servings and display it as shown in the following image:

The number of servings will be calculate using the following formula:

servings = (size / 8)**2

and displayed to two decimal places. You can use the Double.parseDouble(textField.getText() ) to get the string value from the JTextField and parse it to a double. This formula assumes that an 8 inch pie makes 1 serving. Based on the area of an 8″ pie as one serving, the number of servings will vary with the ratio of the radius of the new pie to the 8″ pie squared. Therefore, a 16″ pie would give you a ratio of 16/8 or 2 squared which is 4 servings.

Line 2 of the GUI contains two GUI components but each cell of a grid can only contain one component. This is where JPanels come in for GUI design. A JPanel is a container that simply holds other components, so we can use a JPanel as the component for line 2. We can create a JPanel by using a statement like:
private JPanel line2 = new JPanel();
Then we can add components to it with statements like:
line2.add(variable that represents your JLabel for Enter the size of the pizza…);
Then we can add line2 to the grid layout in slot 2.

To set the layout of the frame to a 4 line grid layout, you would use a setLayout statement such as:
setLayout(new GridLayout(4,1));

Once the servings have been calculated, they are displayed in the JLabel in grid slot 4 as shown.

Set the size of your GUI to (350, 300). This should give it the appearance as shown above. Your class that represents the GUI should extend JFrame.

Do not use the NetBeans GUI generator for this project.

Rubrics

Frame

a. Title set to ‘Pizza Servings Calculator’ (5)

b. Size set to (350, 300). (5)

Title Label

a. Text set to ‘Pizza Servings Calculator’ (2)

b. Text color set to red. (5)

c. Positioned in grid slot 1 (5)

d. Title is centered. (5)

Enter Pizza size Prompt Label

a. Text set to ‘Enter the size of the pizza in inches: ‘. (3)

b. Positioned in grid slot 2. (5)

Pizza size TextField

a. 4 columns wide. (5)

b. Positioned in grid slot 2. (5)

Convert Button

a. Text set to ‘Calculate Servings’. (5)

b. Has a handler that implements ActionListener (5)

c. Calculates the proper number of servings (10)

d. Handler gets added to JFrame as ActionListener. (5)

e. Positioned in grid slot 3. (5)

Number of servings Label

a. Text initially set to blank. (5)

b. On conversion, displays the number of servings to 2 decimal places. (10)

c. Positioned in grid slot 4. (5)

Grid line 2

a. Use a JPanel to create line 2. (5)

In this assignment, you will design the AddNode and AddEdge methods for the supplied graph data structure.The AddNode and AddEdge methods are to support the construction of undirected (bi-directional) graphs.That is if node A is connected to node B then node B is also connected to node A.

In addition to the AddNode and AddEdge methods, create a method called BreadthFirstSearch that accepts a starting node and performs a Breadth First Search of the graph.The algorithm for the breadth first traversal is provided below.

• Add a node to the queue (starting node)
• While the queue is not empty, dequeue a node
• Add all unvisited nodes of the dequeued node from step 2 and add them to queue 4. End While

Demonstrate your methods by creating the graph depicted in Figure 1 below and running the Breadth First Search on the graph using 0 as the starting node.

Figure 1

You may use C++ or C#, to implement this program as long as the following requirements are met.

A C++ or C# project must be created using Visual Studio 2019. The entire project must be submitted as a single ZIP file that contains the project folder, source code, and documentation.

#INSTRUCTIONS

#Type the codes for each question

#Include answers to ALL questions in the script as a comment (with a #).

#Questions with a * next to it will ALSO require you to input the answer in Canvas.

#Lastly, upload this R script AND input the corresponding answers to Canvas.

#If you are missing codes or answers in this script, points will be deducted.

#Download and call each package from library

install.packages(“openintro”)

install.packages(“dplyr”)

install.packages(“ggplot2”)

library(openintro)

library(dplyr)

library(ggplot2)

#Run data and view the name of variables

data(acs12)

names(acs12)

#The data is named “acs12”

View(acs12)

###CONFIDENCE INTERVALS

###EXAMPLE, solve the problems using this guideline###

#1. Construct a 95% CI for the average commute time for Americans (the variable we’re looking at is caled “time_to_work”)

#What is the interval for the average commute time? What does this mean?

#The average commute time is 24.4, 27.6 minutes. This means that we can be 95% confident that the average commute time is between these values.

t.test(acs12$time_to_work)

#*2. Construct a 95% CI for the average income and explain your results. The variable is called “income”

#*3. Construct a 95% CI for the average hours worked and explain your results. This variable is called “hrs_work”

#*4. Construct a 95% CI for the average age and explain your results. This variable is called “age”

### T-Tests HYPOTHESIS TESTS

###REMEMBER we REJECT the Ho if the p-value is LESS than alpha of 0.05

###EXAMPLE BELOW, solve the problems using this question

#5. Assume the average commute time of Americans is thought to be 26 min.

#Write the null hypothesis and the conclusion

#***This is a two-sided test, meaning we are not looking at greater or less than

#Ho: average commute = 26

#Ha: average commute NOT equal to 26

t.test(acs12$time_to_work, mu=26, alternative = “two.sided”)

#The p-value is 1 which is GREATER than alpha of 0.05. Therefore we FAIL TO REJECT the HO. The average commute is equal to 26

# *6. Assume that the average age is thought to be GREATER than 30.

#Write the null hypothesis and the conclusion

#*** This is a one-sided test, we are looking at GREATER than 30 as the alternative

#Ho:

#Ha:

# P-value and conclusion:

# *7. Assume that the average age is thought to be LESS than 50.

#Write the null hypothesis and the conclusion

#*** This is a one-sided test, we are looking at LESS than 50 as the alternative

#Ho:

#Ha:

# P-value and conclusion:

# *8. Assume that the average age is thought to be EQUAL TO 30.

#Write the null hypothesis and the conclusion

#*** This is a two-sided test, we are looking at “two.sided” as the alternative

#Ho:

#Ha:

# P-value and conclusion:

I’m working on a software development multi-part question and need an explanation and answer to help me learn.

reflection 

how the knowledge, skills, or theories of this course have been applied, or could be applied, in a practical manner to your current work environment. If you are not currently working, share times when you have or could observe these theories and knowledge could be applied to an employment opportunity in your field of study.