Acct 510 - MN CAFR Independent Assignment Page 1

Chapter 18 Lab => Government Accounting - MN Comprehensive Annual

Financial Report (CAFR)

Note: The MN CAFR is available online in the state of MN website (www.finance.state.mn.us).

NOTE: If you are not sure if you are interpreting a question correctly…just note your assumption.

Introduction Section

Transmittal Letter

1. What basis of accounting is this system maintained?

State Principal Officials

1. List the following:

a. Governor –

b. Attorney General –

c. State Auditor –

d. Chief Justice of the MN Supreme Court -

Financial Section

Management Discussion and Analysis (MD&A)

1. List the government wide financial statements.

2. List the three types of government activities broken down in the government wide financial

statements.

3. What type of activity would Metropolitan State University considered?

4. List the state’s top three component units.

5. The state’s funds are separated into three types of funds;

a. List the three fund types.

b. What fund is Metropolitan State University a part?

6. Explain in your own words the difference between Budgetary Basis vs. GAAP?

Basic Financial Statements

1. What % of Total Assets do Cash and Cash Equivalents (unrestricted) represent?

2. Why would the state of MN carry such a high % of cash and cash equivalents?

3. What is the amount of General Obligation Bonds Payable?

Acct 510 - MN CAFR Independent Assignment Page 2

a. Current

b. Noncurrent

c. Total

4. In descending order, list the five largest “General Revenue” sources and the dollar amounts

(exclude “Other Taxes” from your list). Hint: All are found in the tax section.

5. What is the difference between Program Revenues and General Revenues?

6. List the three largest net expenditures for the state; in the following format.

Description Expense Revenue Total Net Expenditure

1st

2nd

3rd

7. Compare Net Assets of Governmental Activities to the Total Fund Balance for Governmental

Funds.

a. What is the total difference?

b. List the largest asset and the largest liability driving this difference. Why do these

differences exist? Be specific (provide examples) in your explanation for the

difference.

c. Explain in your own words why there is a $ revenue difference.

8. Compare the Change in Net Assets of Governmental Activities to the Net Change in Fund

Balances for Governmental Funds.

a. What is the total difference?

b. List and explain the three largest reconciling differences.

9. How does the University of Minnesota compare to the State Colleges and Universities from

a financial perspective?

class LinkListTest
{
    public static void main(String[] args)
    {
        LinkList theList = new LinkList();
        theList.insertFirst(7);
        theList.insertFirst(6);
        theList.insertFirst(5);
        theList.insertFirst(4);
        theList.insertFirst(3);
        theList.insertFirst(2);
        theList.insertFirst(1);

        theList.displayList();
        System.out.println("delete(4)");
        theList.delete(4);

        System.out.println("delete(16)");
        theList.delete(16);

        theList.displayList(); 

        System.out.println("insertAfter(2, 12)");
        theList.insertAfter(2, 12);

        System.out.println("insertAfter(4, 14)");
        theList.insertAfter(4, 14);

        System.out.println("insertAfter(7, 17)");
        theList.insertAfter(7, 17);

        theList.displayList();

        System.out.println("insertLast(20)");
        theList.insertLast(20);

        theList.displayList();

    } 
} 

class Link
{
    public int iData;              // data item
    public Link next;              // next link in list
    // -------------------------------------------------------------
    public Link(int id)             // constructor
    {
        iData = id;                 // initialize data
        next = null;
    }                           
    // -------------------------------------------------------------
    public void displayLink()      // display ourself
    {
        System.out.print(iData +" ");
    }
}  // end class Link
public class LinkList
{
    private Link first;            // ref to first item on list
    // -------------------------------------------------------------
    public LinkList()              // constructor
    { 
        first = null; 
    }           // no items on list yet
    // -------------------------------------------------------------
    public boolean isEmpty()       // true if list is empty
    { 
        return (first==null); 
    }
    // -------------------------------------------------------------
    public void insertFirst(int dd) // insert at start of list
    {                           // make new link
        Link newLink = new Link(dd);
        newLink.next = first;       // newLink --> old first
        first = newLink;            // first --> newLink
    }
    // -------------------------------------------------------------
    public Link deleteFirst()      // delete first item
    {                           // (assumes list not empty)
        Link temp = first;          // save reference to link
        first = first.next;         // delete it: first-->old next
        return temp;          // return deleted link
    }
    // -------------------------------------------------------------
    public void displayList()
    {
        Link current = first;       // start at beginning of list
        while(current != null)      // until end of list,
        {
            current.displayLink();   // print data
            current = current.next;  // move to next link
        }
        System.out.println("");
    }
    // -------------------------------------------------------------
}  // end class LinkList

For methods find and delete the return type is Link not key. The method returns a Link object.

Add these methods to the provided LinkList class:

1-     Key find(int key) returns the link with the specified key or null if not found.

2-     void insertAfter(int afterKey, int newKey) inserts a new link with key newKey after the node with key afterKey. If the afterKey node does not exist, the method just returns. Must call method find(int key).

3-     Key delete(int key) removes and returns the Link with the specified key if the node exists, returns null otherwise.

4-     Link getLast() returns a reference to the last link in the list.

5-     void insertLast(int key) adds a new node with the specified key to the end of the list. Must call method getLAst().

Use LinkListTest.java to test your code.

/*
Array List

Modified from CS2 Software Design & Data Structures by Cliff Shaffer. OpenDSA

*/
#ifndef ALIST_H_RVC
#define ALIST_H_RVC
#include "List.h"

template // Array-based list implementation

class AList : public List {

private:
   ListItemType* listArray; //Dynamic Array (pointer)
   int listSize; //Current number of list items
   int curr; //Position of current element
   int MAX_SIZE;

public:

   //Constructors

   AList() {
       MAX_SIZE = 1000; // arbitrary
       listArray = new ListItemType[MAX_SIZE];
       clear();
   } //end constructor

   // Create a new list element with maximum size "MAX_SIZE" as a parameter
   AList(int m) {
       MAX_SIZE = m;
       listArray = new ListItemType[MAX_SIZE];
       clear();
   } //end constructor

   bool isEmpty() const {
       return listSize == 0;
   }

   void clear() { // Reinitialize the list
       listSize = curr = 0; // Simply reinitialize values
   }

   // Insert "it" at current position
   // return value indicates success

   bool insert(const ListItemType& it) {
       if (listSize >= MAX_SIZE) return false;

       for (int i = listSize; i > curr; i--) //Shift elements up
           listArray[i] = listArray[i - 1]; //to make room
       listArray[curr] = it;
       listSize++; //Increment list size
       return true;
   }

   // Append "it" to list
   bool append(const ListItemType& it) {
       cout << "\n\n******* This is to be completed for the lab\n\n";
       return true;
   }

   // Remove and return the current element
   ListItemType remove() {
       if (curr == listSize) curr--;

       ListItemType it = listArray[curr]; // Copy the element
       for (int i = curr; i < listSize - 1; i++) // Shift them down
           listArray[i] = listArray[i + 1];
       listSize--; // Decrement size
       if (curr > listSize) {
           curr = listSize;
       }
       return it;
   }

   void moveToStart() { curr = 0; } // Set to front
   void moveToEnd() { curr = listSize; } // Set to end
   void prev() { if (curr != 0) curr--; } // Move left
   void next() { if (curr < listSize) curr++; } // Move right
   int length() const { return listSize; } // Return list size
   int currPos() const { return curr; } // Return current position

                                           // Set current list position to "pos"
   bool moveToPos(int pos) {
       if ((pos < 0) || (pos > listSize)) return false;
       curr = pos;
       return true;
   }

   // Return true if current position is at end of the list5
   bool isAtEnd() const { return curr == listSize; }

   // Return the current element
   ListItemType getValue() const {
       return listArray[curr];
   }

   bool find(const ListItemType& it) {
       ListItemType curr =
       cout << "\n\n******* This is to be completed for the assignment\n\n";
       return true;
   }

   bool findNext(const ListItemType& it) {
       cout << "\n\n******* This is to be completed for the assignment\n\n";
       return true;
   }

   int count(const ListItemType& it) {
       cout << "\n\n******* This is to be completed for the assignment\n\n";
       return 0;
   }

};

#endif

Write the code for the find, findNext and count method in AList.h. This is an Array based list implementation problem in ADT, where we discuss about stacks

List three institutional barriers that prevent ethical dilemmas from being resolved

Identifies key ethical dilemmas list 3 approaches to assist nurses in dealing with ethical issues

what are some of the situations that can cause a nurse to feel moral distress?

Do you think it is safer for a nurse to work in a prison or a hospital and why?

1.List three important things that kidneys do to REGULATE your blood chemistry

2.List two types of molecules or cells that are retained by the glomerulus. Explain why these items are NOT filtered out of the blood.

3.Describe how urea is used in the loop of the nephron to create the countercurrent multiplier system. What other benefit does this have for the body

Write the Java source code necessary to build a solution for the problem below:
Create a MyLinkedList class. Create methods in the class to add an item to the head, tail, or middle of a linked list; remove an item from the head, tail, or middle of a linked list; check the size of the list; and search for an element in the list.

Create a test class to use the newly created MyLinkedList class. Add the following names in to the list: James, John, Michael, Peter, Allison, Daniel, George, Simon, Jason, and Mark. Your program should allow the user to enter a name from the console, and then search to see if the name exists in the list.

*************************************************************************************************************************

Just need help creating methods to ":remove an item from the head, tail, or middle of a linked list;"

My existing code is below:

************MyLinked List class**************

public class MyLinkedList<E> {
private Node<E> head;
private Node<E> tail;

public void addAtStart(E data) {

Node<E> newNode = new Node<>(data);

if (head == null) {
head = newNode;
tail = newNode;
} else {
Node<E> temp = head;
head = newNode;
head.next = temp;
}
}

public void addAtMid(E data) {
if (head == null)
head = new Node<>(data);
else {
Node<E> newNode = new Node<>(data);
Node<E> ptr = head;
int length = 0;
while (ptr != null) {
length++;
ptr = ptr.next;
}
int count = ((length % 2) == 0) ? (length / 2) : (length + 1) / 2;
ptr = head;
while (count-- > 1)
ptr = ptr.next;
newNode.next = ptr.next;
ptr.next = newNode;
}
}

public void addAtEnd(E data) {
Node<E> newNode = new Node<>(data);
if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
tail = newNode;
}
}

public void display() {

Node<E> current = head;
if (head == null) {
System.out.println("List is empty");
return;
}
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}

public boolean search(E data) {
Node<E> current = head;
int i = 1;
boolean flag = false;
if (head == null) {
System.out.println("List is empty");
} else {
while (current != null) {
if (current.data.equals(data)) {
flag = true;
break;
}
i++;
current = current.next;
}
}
if (flag)
return true;
else
return false;
}

private class Node<E> {
public E data;
public Node<E> next;
public Node(E data) {
this.data = data;
this.next = null;
}
}
}

************Testclass class****************

import java.util.Scanner;
public class Testclass {

public static void main(String[] args) {

MyLinkedList<String> names = new MyLinkedList<>();
names.addAtStart("James");
names.addAtStart("John");
names.addAtStart("Michael");
names.addAtStart("Peter");
names.addAtMid("Allison");
names.addAtMid("Daniel");
names.addAtMid("George");
names.addAtEnd("Simon");
names.addAtEnd("Jason");
names.addAtEnd("Mark");

System.out.print("Enter the name you want to search: ");
Scanner scan = new Scanner(System.in);
String name = scan.nextLine();

if (names.search(name)) {
System.out.println("Name is in list");
}
    else {
System.out.println("That name is not in list");
}
scan.close();
names.display();
}
}

Hello, I am having trouble getting started on my project and building these functions. How do I build a function that continuously adds new "slices" to the list if they are below/above the size limit? I didn't copy the entire problem, but just for reference, when the code is run it will take user input for size limit (L), time cost for a random slice(R), and time cost for an accurate slice(A).

Question:

In real life, a steak is a 3-dimensional object, but for this project, let’s simplify the situation so that we are only chopping along a single dimension. In other words, imagine we just want really thin slices of beef (but the slices can be as tall and long as the steak itself). We can represent the length of steak using a numeric interval, let’s say 0 to 100 (where 0 is the left-most edge of beef and 100 is the right-most edge, and 50 is right in the middle, etc.). Then we can represent the location of a “slice” numerically so that, for instance, if we wanted to slice the beef into exact quarters we would have to cut at lengths 25, 50, and 75. Indeed, let’s agree to store all of the slices we make as an ordered list of numbers, where [0,100] represents an uncut steak, [0,25,50,75,100] represents a steak cut into even quarters, and [0, 13, 46, 77, 100] represents a steak cut into random, uneven quarters.

First, write two functions called fast slices and slow slices. Each function should take two inputs, slice list and size limit. The slice list input represents the current list of slices (see previous paragraph), and size limit represents the size we’re trying to get all pieces to be smaller than or equal to. The fast slices function should take the slice list and continually add random slices until all pieces are within the size limit. The slow slices function should take the slice list and continually look for pieces larger than the size limit and (from left to right) slicing them into smaller pieces with size exactly equal to the size limit. Both fast slices and slow slices must return the new slice list. Second, write another function called ave chop time which takes six inputs: slice list, fast limit, slow limit, fast cost, slow cost, and n. The slice list once again represents a list of slices (probably just an uncut steak [0,100]), the fast limit is the size limit for the fast slices, slow limit is the size limit for the slow slices, fast cost is the time it costs to do a fast slice, and slow cost is the time it costs to do a slow slice.

The function should take the slice list, run it through the fast slices function using fast limit as the size limit, then run it through the slow slices function using slow limit as the size limit. After each function, you can calculate the number of slices performed by comparing the length of the slice list before and after the function. Once you know the number of fast slices and slow slices, multiply them by fast cost and slow cost, respectively, and add together to calculate the total time it took to chop the beef. Finally, this whole process should be repeated n times and the average total time should be returned.

I am implementing a generic List class and not getting the expected output.

My current output is: [0, 1, null]

Expected Output in a separate test class:

List list = new SparseList<>(); 
list.add("0");
list.add("1");
list.add(4, "4");

will result in the following list of size 5: [0, 1, null, null, 4].

list.add(3, "Three");

will result in the following list of size 6: [0, 1, null, Three, null, 4].

list.set(3, "Three");

is going to produce a list of size 5 (unchanged): [0, 1, null, Three, 4].

When removing an element from the list above, via list.remove(1); the result should be the following list of size 4: [0, null, Three, 4]

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class SparseList<E> implements List<E>{
    private int endIndex = 0;
    
    private HashMap<Integer,E> list;
    
    public SparseList() {
        list = new HashMap<>();
    }
    
    public SparseList(E[] arr) {
        list = new HashMap<>();
        for(int i = 0; i <arr.length; i++) {
            list.put(i, arr[i]);
        }
        endIndex = arr.length - 1;
    }
    
    @Override
    public boolean add(E e) {
        list.put(endIndex, e);
        endIndex++;
        return true;
    }
    
    @Override
    public void add(int index, E element) {
        list.put(index, element);
    }
    
    @Override
    public E remove(int index) {
        return list.remove(index);
    }
    
    @Override
    public E get(int index) {
        return list.get(index);
    }
    
    @Override
    public E set(int index, E element) {
        E previous = list.get(index);
        list.put(index, element);
        return previous;
    }
    
    @Override
    public int size() {
        return endIndex + 1;
    }

    @Override
    public void clear() {
        list.clear();
        
    }
    
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public String toString() {
        String s = "";
        for(int i = 0; i < list.size(); i++) {
            if(list.get(i) == null) {
                s += "null, ";
            }else {
            s += list.get(i).toString() + ", ";
        }
        }
        return "[" + s + "]";
    }

    @Override
    public boolean contains(Object o) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Iterator<E> iterator() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Object[] toArray() {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        throw new UnsupportedOperationException();
    }


    @Override
    public boolean containsAll(Collection<?> c) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean remove(Object o) {
        throw new UnsupportedOperationException();
    }
    
    @Override
    public int indexOf(Object o) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int lastIndexOf(Object o) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ListIterator<E> listIterator() {
        throw new UnsupportedOperationException();
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        throw new UnsupportedOperationException();
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        throw new UnsupportedOperationException();
    }

}