1. Use R Studio: Include R Code A survey is taken of 250 students, and a phat of 0.48 is found. The same survey is repeated with 1000 students, and the same phat value is found. Compare the two 95% confidence intervals. What is the relationship between them? Is the margin of error for the second one four times smaller? If not, how much smaller is it?
In: Statistics and Probability
Suppose that 45 studentsare applying to a company. There are 5 job openings but 8 offers are made because typically a few students will turn down the job. Each student has a 60% chance of accepting a job offer, independent of the other student’s decisions. What is the CDF for the number of students who accept job offers?
please show me the method and the answer
In: Statistics and Probability
Now that you are thinking about graduate school and signaling vs. human capital; What do you think explains the fact that law schools accept students with a wide array of majors while medical school typically requires students to have a specific science based major? Write a brief response using the language of signaling vs. human capital.
In: Economics
Consider Ghana Technology University College, of which the students are the product of the manufacturing process.
A. What will be quality from the producer’s perspective (producers in this case are lecturers) and administrator’s? at least five
B. What will be quality from the consumer’s perspective? Consumers in this case are Students. at least 5
C. What will be quality from the consumer’s perspective? Consumers in this case are employers. At least 5
In: Operations Management
C++ program
Complete the following functions for linked list. You are not
allowed to alter the names or the function prototypes.
#ifndef _ULL
#define _ULL
#include <iostream>
#include "nodeType.h"
using namespace std;
void initializeList(nodeType *&head,
nodeType *&tail, int&count);
//Initialize the list to an empty state.
//Postcondition: head = NULL, tail = NULL, count = 0;
bool isEmptyList(const nodeType *head)
;
//Function to determine whether the list is empty.
//Postcondition: Returns true if the list is empty,
// otherwise it returns false.
void print(const nodeType *head) ;
//Function to output the data contained in each node.
//Postcondition: none
int length(const nodeType *head) ;
//Function to return the number of nodes in the list.
//Postcondition: The value of count is returned.
void destroyList(nodeType *& head,
nodeType *& tail, int&count);
//Function to delete all the nodes from the list.
//Postcondition: head= NULL, tail = NULL, count = 0;
void insertFirst(..... you figure this
out);
//Function to insert newItem at the end of the list.
//Postcondition: first points to the new list, newItem
// is inserted at the end of the list,
// last points to the last node in the list,
// and count is incremented by 1.
void insertLast(nodeType *&head,
nodeType *&tail, int&count, const int& newItem);
//Function to insert newItem at the beginning of the list.
//Postcondition: first points to the new list, newItem is
// inserted at the beginning of the list,
// last points to the last node in the list,
// and count is incremented by 1.
bool search(nodeType *srcHead, const int &searchItem)
;
//Function to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is in the
// list, otherwise the value false is
// returned.
void deleteNode(nodeType *&srcHead, nodeType *&srcTail,
const int & deleteItem);
//Function to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the list.
// first points to the first node, last
// points to the last node of the updated
// list, and count is decremented by 1.
void copyList(nodeType *srcHead, nodeType *dstHead, nodeType *dstTail, int &dstCount);
//Function to make a copy of otherList (src).
//Postcondition: A copy of otherList(src) is created and
// assigned to this list (dst).
After completing the functions, write the following
menu based program that performs the listed functions.
<0> initializeList
<1> isEmptyList
<2> print
<a> Print src
<b> Print dst
<3> length
<4> destroyList
<5> search
<6> insertFirst
<7> insertLast
<8> deleteNode
<9> copyList
<Q> QuitRun your code,
using your menu to create a list with the following int
values 8,9,6,12,133,12,18,8,0,1
- search for 133
- search for 28
- copyList (deep copy src to dst)
- deleteNode 12 in src list
- print src
- print dst
Ensure that you destroy both list prior to "Quitting"
your program.
Turn in your code along with a screenshot printing
your list.
nodeType.h contains the struct
struct nodeType{
int data;
struct nodeType *next;
};
In: Computer Science
a. Enable an individual to have a good life
b. Have a high standard of living
c. Bridge the gap between desired and expected living standard
d. Enable the individual to have some savings
a. Selecting from different kinds and types
b. Applying your free will when choosing a good or commodity
c. Selecting the kind of good that satisfies you most
d. None of the above
a. Students and individuals gain knowledge in savings
b. Students and individuals can make good investment decisions
c. Students and individuals would know how to retire
d. Students and individuals would have a better chance of dealing with financial challenges they face
a. Time Value of Money
b. Opportunity Cost
c. Marginal Utility
d. None of the above
a. Enable an individual to have a good life
b. Have a high standard of living
c. Bridge the gap between desired and expected living standard
d. Enable the individual to have some savings
a. Selecting from different kinds and types
b. Applying your free will when choosing a good or commodity
c. Selecting the kind of good that satisfies you most
d. None of the above
a. Students and individuals gain knowledge in savings
b. Students and individuals can make good investment decisions
c. Students and individuals would know how to retire
d. Students and individuals would have a better chance of dealing with financial challenges they face
a. Time Value of Money
b. Opportunity Cost
c. Marginal Utility
d. None of the above
In: Finance
In: Psychology
Design a role-based access control system. Thank you. Will leave a great rating
A course registration system is a computer system used by the university's administration to plan courses, for students to register for courses, and for faculty to grade them.
Students and faculty can only enroll or teach a class if they have been recorded in the registration system. Students are entered into the system by and Admissions representatives; faculty members by a Human Resources employee. For all persons, their university ID number, last name, first name, date of birth, and username is recorded. Usernames must be unique (no username may be allocated to more than one person at a time).
Before students can enroll for a course, the course needs to be created. Each course is identified by a course number (up to 7 characters), a course name, credits awarded, and a cap. The cap represents the largest number of students that should be enrolled in the course, and must be greater than zero. Courses are created by faculty.
When the university's administration decides to offer a course, a department chair create a course section. Department chairs are faculty members who have been given additional duties. The course section always refers to a single course, and has a course section identifier (3 characters) and a term in which it is offered. The faculty member who is assigned to teach the course is also recorded with the section.
When students start enrolling for a course, they must search for available sections and choose one. Students may only register once for each course in a given term, but if a course is offered in multiple section, the system must be able to track which students are enrolled in each section.
Faculty can grade courses. Each student can only receive one grade for each term in which they take a course. When grades are recorded, the registration system must record who issued the grade, and when it was issued. The database must enforce that only valid grades can be assigned. Valid grades include F (fail), D- through A+, and I (incomplete).
The Registrar's Office can create transcripts of grades. Faculty advisers can inspect transcripts and enrollments for student advising.
Assignment
Design a role-based access control system to support this case study. Clearly identify roles, role hierarchies, and permissions.
Your solution must have
-A schematic of the role-hierarchy
-A tabular explanation of each role, and the permissions it has.
In: Computer Science
What are the real-world implications or application of the obtained results? (The answer to this question can be found by reading the “Discussion” section of the article, especially the “Conclusion” or last few paragraphs).
and here are the discussion:
Today’s students are quite different than those who populated university classrooms at the turn of the century. Raised in the internet age, constantly “plugged in”, seemingly inextricably attached to cell phones, and facile with all types of electronic media, these students nonetheless are expected to learn much of the same material as did their predecessors of the late 20th century. Today’s students’ classroom behaviors, however reflective of their engagement and facility with current technology, may be putting students’ learning at risk. And today’s classrooms, configured for wireless computing or equipped with computers, may be enabling students to engage in behaviors that compromise learning. Although many stories and anecdotes describe professors who find their students shopping online, playing games, texting friends, and checking Facebook, no prevalence data have indicated how widespread of a phenomenon classroom multitasking is. The purpose of this study was to describe the multitasking behaviors of university students while sitting in their traditional classrooms and while on their computers working on online classes. The finding that the majority of students multitask is not surprising; however, in an institution where the average class size was 22.7 during the semester that the study was done, it is surprising that more than 50% of the students sitting in class were frequently text messaging and more than one fourth were frequently checking Facebook, presumably while their professors looked on. Abaté (2008) claims that the consequence of tolerating multitasking in the classroom is an education that is limited in its adaptability, superficial, and short term memory based. The negative association between multitasking and GPA that was found in this study may not provide evidence for Abaté’s (2008) specific claims, but it does provide some justification for those professors who are banning laptops and cell phones from their classrooms (Adams, 2006; Jan, 2011). Banning phones and laptops in the classroom may meet with resistance because students may not be aware of the frequency of their multitasking, and if they are, they may not see it as problematic. Turkle (2011) comments that today’s youth grew up in a culture of distraction and that technology is so much a part of life, it has become like a phantom limb. She refers to individuals as “tethered” to technology, and contends that for many, the “unplugged” world does not provide satisfaction. Turkle (2008) writes that a phenomenon such as e-mailing during classes is so mundane that it is scarcely noticed, and that once done surreptitiously, it is currently not something people feel they need to hide. The proliferation of online classes and the significantly greater amounts of multitasking that take place among students engaged in online coursework may lead to some concern about the quality of attention and learning going on in online classes. Some of the focus group responses to the question asking participants what else they were doing while they were engaged in coursework were unique to students who took online classes. These included cooking dinner, caring for children, playing with pets, and conversing with family/roommates. These kinds of activities not only divert cognitive focus and attention, they also can physically remove the student from the act of engaging in the class. 8 Multitasking in the University Classroom http://digitalcommons.georgiasouthern.edu/ij-sotl/vol6/iss2/8 The associations between multitasking and risk behaviors are disconcerting. College students worldwide have been known to engage in various risk behaviors, including alcohol, tobacco, and other drug use, unhealthy sexual practices, and disregard for preventive and protective habits (Centers for Disease Control, 1997; Steptoe et al, 2002). Indeed, the overall risk behavior of the current study population is similar to that of the general US college population. However, the significant correlations between multitasking and risk behaviors, and the significant differences in risk behaviors between high and low multitaskers support Foehr’s (2006) findings that multitaskers tend to engage in risk behaviors, and point to an additional factor to examine when considering risk behaviors among college and university students. Clearly understanding that correlations do not support causality, these results may, however, lead one to wonder if multitasking in the classroom may be yet another risk that some university students are inclined to take. The results may also lead one to believe that classroom multitaskers must also be engaging in multitasking behaviors outside of the classroom – perhaps while driving, doing homework, or engaging in other activities whose effectiveness and safety multitasking may compromise. The consideration of multitasking as a risk behavior is exacerbated by Greenfield’s (2011) claim that the digital communication and entertainment devices frequently used by multitaskers have addictive properties that can distract users as well as alter their moods and consciousness. Wang & Tchernev’s (2012) findings that college students’ multitasking behaviors generate emotional gratification provide evidence that students have a powerful drive to repeatedly engage in multitasking behavior. The addictive and emotionally gratifying nature of multitasking make it all the more difficult, and perhaps all the more important, to address. This study had several limitations: the sample was a nonrandom convenience sample, the data were self-reported, and the design was correlational. These limitations constrain inferences or generalizations regarding the entire university student population. Another limitation was that the multitasking behaviors that were listed on the survey might not adequately represent all of the multitasking activities in which the student respondents engaged. Despite the limitations, however, the results of this study can provide a starting point for further research as well as for discussions about learning in the 21st century, about standards for classroom behavior, and about the nature of risk behaviors. Ongoing research into the phenomenon of classroom multitasking may provide guidelines for the mitigation of the problems and their sequelae. Further research is needed to assess the associations between multitasking and risk behaviors; one suggestion would be to add multitasking items to the National Youth Risk Behavior Surveys and the College Health Risk Behavior Survey. Another important area for continued investigation is to examine the predictors of multitasking behaviors: what kinds of attitudes, beliefs, personality traits, and learning environments lend themselves to multitasking behaviors? And are said attitudes, beliefs, characteristics, and environments modifiable? University professors might also engage in small action research studies in their classrooms, experimenting with and assessing the effects of different pedagogical styles and approaches that might decrease multitasking among students. Although it is very likely that students have been engaging in distracting behaviors in the classroom throughout the history of education, the ubiquity of technologies seems to make the possibilities for classroom multitasking even more likely in the near future. A recent white paper by the global telecommunications company, Ericsson (2011), projects that by 9 IJ-SoTL, Vol. 6 [2012], No. 2, Art. 8 2020 there will be 50 billion connected devices, with individuals possessing between 5 and 10 devices each, so it’s quite clear that the temptations and opportunities for multitasking will not abate and will not go away. The sheer number of electronic devices, their addictive nature, and the tethered selves that students have become can make addressing the issue of classroom multitasking quite daunting. For the sake of student learning outcomes, however, instructors should attempt to mitigate the problem to the extent possible. Some suggestions include having and enforcing clear written policies regarding multitasking behaviors and media use in the classroom, along with clear penalties for non-compliance with said policies. Instructors can utilize hands-on, active learning strategies that require that students be on task with tasks that minimize opportunities for engagement with electronic devices. And, if possible, professors can set up classroom seating that minimizes visual obstructions and maximizes opportunities for circulating around classrooms. Many university professors are aware that their students are engaging in multiple behaviors while sitting in their classrooms; these professors should not avert their eyes, but rather help their students become aware of the consequences of multitasking. Perhaps engaging students in discussions about multitasking and seeking student input in addressing the issue can be a first step in resolving what has the potential to become a pernicious problem.
In: Psychology
Create a file named StudentArrayList.java,within the file create a class named StudentArrayList. This class is meant to mimic the ArrayList data structure. It will hold an ordered list of items. This list should have a variable size, meaning an arbitrary number of items may be added to the list. Most importantly this class should implement the interface SimpleArrayList provided. Feel free to add as many other functions and methods as needed to your class to accomplish this task. In other words, the class StudentArrayList must implement the interface SimpleArrayList. You have to write the code for each of the functions specified in the SimpleArrayList interface. Make sure the class that implements SimpleArrayList is named "StudentArrayList" or else the test code will not compile.
You are not allowed to use any 3rd party data structures or libraries such as Java.Utils.ArrayList or Java.awt.ArrayList.
Hints:
public interface SimpleArrayList<E> {
/**
* Returns the number of elements in this list. If this
list contains more
* than <tt>Integer.MAX_VALUE</tt>
elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of elements in this list
*/
int size();
/**
* Returns <tt>true</tt> if this list
contains no elements.
*
* @return <tt>true</tt> if this list
contains no elements
*/
boolean isEmpty();
/**
* Returns <tt>true</tt> if this list
contains the specified element. More
* formally, returns <tt>true</tt> if and
only if this list contains at
* least one element <tt>e</tt>
*
* @param o
* element whose presence in this list is to be
tested
* @return <tt>true</tt> if this list
contains the specified element
*/
boolean contains(E o);
/**
* Returns an array containing all of the elements in
this list in proper
* sequence (from first to last element).
*
* <p>
* The returned array will be "safe" in that no
references to it are
* maintained by this list. (In other words, this
method must allocate a new
* array even if this list is backed by an array). The
caller is thus free
* to modify the returned array.
*
* <p>
* This method acts as bridge between array-based and
student.SimpleArrayList-based
* APIs.
*
* @return an array containing all of the elements in
this list in proper
* sequence
*/
E[] toArray();
/**
* Appends the specified element to the end of this
list
*
* @param e
* element to be appended to this list
*/
void add(E e);
/**
* Removes the first occurrence of the specified
element from this list, if
* it is present (optional operation). If this list
does not contain the
* element, it is unchanged.
*
* @param o
* element to be removed from this list, if
present
*/
void remove(E o);
/**
* Returns <tt>true</tt> if this list
contains all of the elements of the
* specified student.SimpleArrayList.
*
* @param c
* student.SimpleArrayList to be checked for
containment in this list
* @return <tt>true</tt> if this list
contains all of the elements of the
* specified student.SimpleArrayList
*/
boolean containsAll(SimpleArrayList<E> c);
/**
* Appends all of the elements in the specified
student.SimpleArrayList to the end
* of this list, in the order that they are returned by
the specified
* student.SimpleArrayList.
*
* @param c
* student.SimpleArrayList containing elements to be
added to this list
* @return <tt>true</tt> if this list
changed as a result of the call
*/
boolean addAll(SimpleArrayList<E> c);
/**
* Inserts all of the elements in the specified
student.SimpleArrayList into this
* list at the specified position. Shifts the element
currently at that
* position (if any) and any subsequent elements to the
right (increases
* their indices). The new elements will appear in this
list in the order
* that they are returned by the specified
student.SimpleArrayList's iterator. The
* behavior of this operation is undefined if the
specified student.SimpleArrayList
* is modified while the operation is in
progress.
*
* @param index
* index at which to insert the first element from the
specified
* student.SimpleArrayList
* @param c
* student.SimpleArrayList containing elements to be
added to this list
* @return <tt>true</tt> if this list
changed as a result of the call
*/
boolean addAll(int index, SimpleArrayList<E>
c);
/**
* Removes from this list all of its elements that are
contained in the
* specified student.SimpleArrayList.
*
* @param c
* student.SimpleArrayList containing elements to be
removed from this
* list
* @return <tt>true</tt> if this list
changed as a result of the call
*/
boolean removeAll(SimpleArrayList<E> c);
/**
* Retains only the elements in this list that are
contained in the
* specified student.SimpleArrayList. In other words,
removes from this list all of
* its elements that are not contained in the specified
student.SimpleArrayList.
*
* @param c
* student.SimpleArrayList containing elements to be
retained in this
* list
* @return <tt>true</tt> if this list
changed as a result of the call
*/
boolean retainAll(SimpleArrayList<E> c);
/**
* Removes all of the elements from this list (optional
operation). The list
* will be empty after this call returns.
*
*/
void clear();
/**
* Compares the specified object with this list for
equality. Returns
* <tt>true</tt> if and only if the
specified object is also a list, both
* lists have the same size, and all corresponding
pairs of elements in the
* two lists are <i>equal</i>. In other
words, two lists are defined to be
* equal if they contain the same elements in the same
order. This
* definition ensures that the equals method works
properly across different
* implementations of the
<tt>student.SimpleArrayList</tt> interface.
*
* @param o
* the object to be compared for equality with this
list
* @return <tt>true</tt> if the specified
object is equal to this list
*/
@Override
boolean equals(Object o);
In: Computer Science