There is a riskless asset with a return of 0.020, and a risky asset with an expected return of 0.363 and standard deviation of 0.301. If you were building a portfolio for an investor with a risk aversion of A=2.6, what proportion of their assets would you invest in the risky asset?

18. DEFINE “PROGRESSIVE DELEGATION” EXPLAINING THE PROCESS AND ITS ADVATANGES

The December 31, 2017 statement of financial position of the ABC Company included the following information: 

Accounts Receivable €112,000  Less: Allowance for Doubtful Accounts €2,240

During the company’s fiscal year ending December 31, 2018, the following transactions occurred:

1. Sales on credit €437,300;

2. Collections on accounts previously written off as worthless €230 (Hint: Re-establish the receivable account);

3. Accounts receivable written off as uncollectible €2,290;

4. Collections of accounts receivable €440,500;

5. Bad debts were estimated to be 1,8% of accounts receivable.

Instructions a) Prepare journal entries necessary for ABC Company to record the preceding transactions. b) Prepare an analysis and schedule that shows the amounts of the accounts receivable, allowance for doubtful accounts that will be disclosed on ABC’s December 31, 2018 statement of financial position

Read the article below and analyze it.

Which Behaviors Must Leaders Avoid

If you want to empower, engage, or motivate others, don’t just focus on increasing your positive behaviors. Pay attention to what you need to stop doing as well. Why? Because people remember the bad more than the good. To quote from a previous HBR article, How to Play to Your Strengths, “Multiple studies have shown that people pay keen attention to negative information. For example, when asked to recall important emotional events; people remember four negative memories to every positive one.” So, which behaviors do leaders most need to avoid? Drawing on thousands of 360 qualitative interviews, here are our top three:

Judgmental, non-verbal body language. No one, especially your successful colleagues, can tolerate perceived condescension. Research studies show that somewhere between 75 to 90 percent of our impact comes from our non-verbal communication, and tone is a key ingredient of this. Do you make comments to others in a way that sounds evaluative, harsh, or condescending? Often, this is not our intention but an in-the- moment reaction. Other non-verbal offenders include scowling, furrowed brows, quizzical looks (as if to say, ‘are you stupid?’), rigidity, and sarcasm. While seemingly small, each of these subtle darts creates a considerable amount of relationship damage.

Interrupting and interrogating. There’s been a lot of buzz recently around how to have “conversations that drive innovation” and how to “create safe environments for employees to bring their ideas forward.” It’s almost impossible for people to feel safe if the boss takes up most of the airtime, cuts people off, or interrogates half-baked ideas. Yes, employees have a responsibility to communicate with clarity, but if you expect every idea to be buttoned up, fully thought out, or structured before someone speaks, your colleagues will assume that you’re not willing to invest the time to be a thought partner.

Being inconsistent. Peers and staff often comment on how discouraging it is to see a colleague act in two very different ways — absolutely charming with the executive team and external clients while being disrespectful to those they work with every day. This inconsistency makes these behaviors even more memorable and egregious. Others have shared a different impact — the feeling of walking on eggshells at work, wondering who is going to show up: “smiling, charming, funny person” or “judgmental, intense, snapping person.” Over time, this drives passive aggressive responses from others in their attempt to avoid confrontation.

Ultimately, loyalty and followership are the two things we cannot demand or set as an expectation. What is perceived as fear-based motivation, belittlement, or power play can yield real short-term compliance from others. But negative behaviors ultimately diminish the legacy we leave. Consider what behaviors you might need to stop doing so that you can have a positive, lasting impact.

1. A social psychologist wanted to determine whether attitudes of men toward abortion were different in rural and urban areas. He prepared a questionnaire and administered it to a group of city dwellers and a group of country dwellers. Each city man was matched with a country man on age, income, and education. High scores indicate positive attitudes towards abortion. The data:

1. What can the social psychologist say about differences in the attitudes of rural and urban men?
2. Justify the statistical method you used to analyze the data.

One year​ ago, your company purchased a machine used in manufacturing for $ 120,000. You have learned that a new machine is available that offers many​ advantages; you can purchase it for $ 140,000 today. It will be depreciated on a​ straight-line basis over ten​ years, after which it has no salvage value. You expect that the new machine will contribute EBITDA​ (earnings before​ interest, taxes,​ depreciation, and​ amortization) of $ 55,000 per year for the next ten years. The current machine is expected to produce EBITDA of $ 23,000 per year. The current machine is being depreciated on a​ straight-line basis over a useful life of 11​ years, after which it will have no salvage​ value, so depreciation expense for the current machine is $ 10,909 per year. All other expenses of the two machines are identical. The market value today of the current machine is $ 50,000. Your​ company's tax rate is 40 %​, and the opportunity cost of capital for this type of equipment is 12 %. Is it profitable to replace the​ year-old machine?

What would the limiting reagent be for the reacton between 1.33g of sodium bromide, 0.8g of i-butanol, and 2g of concentrated H2SO4?

I starting a restaurant specifically designed for the senior citizens. It’s ambience and menu will focus on likes and dislikes of olderly people. As per our research there is no restaurant that specifically serves old aged people. Most of them gives only seniority based discounts but we will emotionally connect with them by giving them a friendly atmosphere as well. We will be providing them with both home-delivery as well as in-restaurant services. So, I need competitor analysis and key challenges and solutions and conclusions about that.

I and 5 to 6 pages of this questions.please

A hungry 177177 kg lion running northward at 84.584.5 km/hr attacks and holds onto a 35.335.3 kg Thomson's gazelle running eastward at 60.660.6 km/hr. Find the final speed of the lion–gazelle system immediately after the attack.

final speed:

m/s

Suppose that many stocks are traded in the market and that it is possible to borrow at the risk-free rate, r_ƒ. The characteristics of two of the stocks are as follows:

Which 2 UML diagrams would you say are the most valuable in terms of understanding the requirements of a user? Please provide reasons and examples for your answer.

A) Modify the ArrayOfCircles.java file such that it implements the missing methods in the given SimpleListInterface. circArray and size are member fields which can be accessed by all method. Make sure both circArray and size are updated as needed in the method you write. 1. The methods which are already implemented are:  constructor (not specified in interface)  size, isFull, and the two get methods

2. The methods you need to implement (given and explained in the SimpleListInterface) are:  insert  search  delete Implement the methods in this order and TEST each once you have implemented it. For initial tests update the testing code in the main method of ArrayOfCirclesApp.java. Only move to the next once all prior functions work. (All code needed for testing is on Blackboard and there is a movie which shows how to create the eclipse project with them and run them using the test cases I made available.) B) (i) Add a readFromFile method to the ArrayOfCirclesApp.java file with the heading given below: /** * Insert the circle info from the given file into circLst * as long as circLst is not full; will not remove elements * from circLst * @param fileName The file with the circle information */ public static void readFromFile(String fileName) { (ii) Add a printCircles method to the ArrayOfCirclesApp.java file with the heading given below: /** * Prints the info about the list: * first a message with the number of elements the list holds * and then each element (with its position in the list) * @param list The list to be printed */ public static void printCirles(SimpleListInterface list) { Do not remove or otherwise modify the existing printCircles ( ) method which is already implemented in the ArrayOfCirclesApp.java file. C) Write a short report which includes: a. An illustration of how you implemented the delete method (with diagram and explanation). Be specific – it should be clear from the diagram/explanation how each element in the array is moved during the delete. b. A description of what you considered the most challenging aspect of lab2 (which you overcame) and how you dealt with it. What lesson for future labs/assignment in this or other classes did you learn from that experience?

public class ArrayOfCircles implements SimpleListInterface {
        
        protected  Circle [] circArray = null;
        protected  int size;
        
        
        /**
         * Constructor with specified capacity
         * @param capacity The size of the array to be created
         */
        
        public ArrayOfCircles (int capacity) {
                circArray = new Circle[capacity];
                size = 0;
        }       
        
        /**
         * 
         * @return  The number of elements in the list
         */
        public int size() {
                return size;
        }
        
        /**
         * @ returns True if the list is not full; false otherwise
         */
        public boolean isFull( ) {
                return (size >= circArray.length) ;
        }
        
        /**
         * Gets the circle element - 
         * @param The element to be returned
         * @return The circle element in the list (with the lowest position if more than one); 
         * null if no element in the list is equal to the given element
         */
        public Circle get (Circle element) {
                int index = search(element);
                if (index != -1)
                        return circArray[index];
                // not found
                return null;
        }

        /**
         * Gets the circle at the specified position - 
         * @param position The position of the elem in the list 
         * (Note: position must be between 0 and size-1 (inclusive))
         * @return The circle at the specified position
         */
        public Circle get (int  position) {
                return circArray[position];
        }


}

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ArrayOfCirclesApp {

        static SimpleListInterface circLst = new ArrayOfCircles(5);

        public static void main(String[] args) {

                // testing insert
                circLst = new ArrayOfCircles(3);

                circLst.insert(new Circle(1, 2, 3, "four"));
                circLst.insert(new Circle(3, 4, 5, "three"));
                printCirles();

                // testing readFromFile
                circLst = new ArrayOfCircles(5);
                readFromFile("circleLoadtesting.txt");
                printCirles();

        }

        /**
         * Loads the circLst with the circle info from the given file
         * @param fileName The file with the circle information
         */
        public static void readFromFile(String fileName) {

        /**
         * Prints the info about the list: first a message with the number of elements
         * and then each element
         * 
         * @param list The list to be printed
         */
        public static void printCirles(SimpleListInterface list) {
                System.out.println("The list has " + list.size() + " elements.");
                for (int i = 0; i < list.size(); i++) {
                        System.out.println(i + ": " + list.get(i));
                }
        }

        /**
         * Prints the info about the current list: first a message with the number of
         * elements and then each element
         */
        public static void printCirles() {
                printCirles(circLst);
        }

}

import java.util.Arrays;


// A class to demonstrate how parameters are passed in Java
public class Circle {
        
        private double radius;
        private double [] center = {0,0};
        private String label;
        private  int identifier;
        private static int counter = 1;
        
        // constructors   - function OVERLOADING - one name, several DIFFERENT signatures
        /**
         * no-argument constructor - creates a circle of radius 1 centered at (0,0)
         */
        public Circle () {
                this(1, 0, 0, "none"); // calls the appropriate constructor with 3 parameters
        }
        
        /**
         *  Creates an object of type circle
         *  @param radius  The radius of the circle. The center defaults to  (0,0)
         */
        public Circle (double radius) {
                this(radius, 0, 0, "none"); // calls the appropriate constructor with 3 parameters
        }

        /**
         *  Creates an object of type circle
         *  @param radius  The radius of the circle. 
         *  @param xCenter The x-coordinate of the center
         *  @param yCenter The y-coordinate of the center
         */
        public Circle(double radius, double xCenter, double yCenter, String label) {
//              super();
                this.radius = radius;
                this.center[0] = xCenter;
                this.center[1] = yCenter;
                this.label = label;
                identifier = counter++;


        }
        
        /**
         *  Creates an object of type circle
         *  @param radius  The radius of the circle. 
         *  @param center The 2D coordinates of the center of the circle
         */     public Circle(double radius, double[] center, String label) {
                this ( radius, center[0], center[1], label);
        }


        // transformer and observer methods for all instance variables


        @Override
        public String toString() {
                return "Circle [radius=" + radius + ", center=" + Arrays.toString(center) + ", label=" + label + ", identifier="
                                + identifier + "]";
        }

        /**
         * Determines whether this object is equal to a given object.
         * @param obj The given object which may be equal (or not)
         * @return True if obj is equal to this; false otherwise
         */
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Circle other = (Circle) obj;
                if (!Arrays.equals(center, other.center))
                        return false;
                if (Double.doubleToLongBits(radius) != Double.doubleToLongBits(other.radius))
                        return false;
                return true;
        }

        /**
         * @return the label
         */
        public String getLabel() {
                return label;
        }

        /**
         * @param label the label to set
         */
        public void setLabel(String label) {
                this.label = label;
        }

        /**
         * @return the radius
         */
        public double getRadius() {
                return radius;
        }
        /**
         * @param radius the radius to set
         */
        public void setRadius(double radius) {
                this.radius = radius;
        }

        /**
         * @return the center
         */
        public double[] getCenter() {
                return center;
        }

        /**
         * @param center the center to set
         */
        public void setCenter(double[] center) {
                this.center = center;
        }
        
        

        /**
         * @return the iD
         */
        public int getID() {
                return identifier;
        }

        
        

}

// Note: Usually this should be a generic interface - but for the purpose of lab2 we fix the 
//  type to Circle - we will later look into how to update this to a generic interface and a 
//  generic implementation
public interface SimpleListInterface {
        
        /**
         * 
         * @return  The number of elements in the list
         */
        int size();
        
        /**
         * Search for the element in the list (using the equals function of T)
         * @param element
         * @return The position (start counting at 0) of the element in the list (if found); -1 otherwise
         */
        int search (Circle element);
        
        /**
         * Add an element to the end of the list; if the array is full, the element is 
         * not added.
         * Note: The 'end' is not at index array.length-1 but at size-1
         * @param The element to be added
         * @return True if the element was added; false otherwise
         */
        boolean insert(Circle element);
        
        
        /**
         * Delete the element from the list without changing the order 
         * of the remaining elements in the list. If there is more than one element 
         * equal to the one to be deleted, then the one with the lowest position is deleted.
         * @param The element to be deleted
         * @return true - if the element was deleted; false if the element was not found in the list
         */
        boolean delete (Circle element) ;
        
        /**
         * Gets the circle element - 
         * @param The element to be returned
         * @return The circle element in the list (with the lowest position if more than one); 
         * null if no element in the list is equal to the given element
         */
        Circle get (Circle element) ;

        /**
         * Gets the circle at the specified position - 
         * @param position The position of the elem in the list 
         * (Note: position must be between 0 and size-1 (inclusive))
         * @return The circle at the specified position
         */
        Circle get (int  position) ;

        /**
         * @ returns True if the list is not full; false otherwise
         */
        boolean isFull();

}

The development of the world wide web has led to a variety of Top Level Domains (e.g., Generic, Country Code, Branded). What has led to these diferent types of TLDs? What are the implications to businesses? What are the implications to customers? Please respond with 2-3 paragraphs

What specifically do you need to be aware of when you are using or referring to student development theory?