Why is it important to study about the technological advancements changes in other countries other than the United States? Use at least 150 words

Explain in one paragraph each how the following changes in the business environment described are likely to impact on the organisation’s human resources requirements;

Your organisation builds roads and bridges. It relies on civil engineers to carry out the work. Having reviewed the external business environment you find that there is a shortage of qualified civil engineers in Australia.

Presented below are changes in all the account balances of Wildhorse Furniture Co. during the current year, except for retained earnings.

Compute the net income for the current year, assuming that there were no entries in the Retained Earnings account except for net income and a dividend declaration of $28,270 which was paid in the current year.

Actuary and trustee reports indicate the following changes in the PBO and plan assets of Douglas-Roberts Industries during 2021:

  
Required:
1-a. Determine Douglas-Roberts's pension expense for 2021.
1-b, 2. to 4. Prepare the appropriate journal entries to record the pension expense, to record any 2021 gains and losses, to record the cash contribution to plan assets and to record retiree benefits.

You have been asked to assess the impact of possible changes in reserve requirement components on the dollar amount of reserves required. Assume the reserve percentages are currently set at 2 percent on the first $50 million of traction account amounts; 4 percent on the second $50 million; and 10 percent on transaction amounts over $100 million. The First National Bank has transaction account balances of $100 million, while the Second National Bank’s transaction balances are $150 million and the Third National Bank’s transaction balances are $250 million.

a. Determine the dollar amounts of required reserves for each of the three banks.

b. Calculate the percentage of reserves to total transactions accounts for each of the three banks.

c. The Central Bank wants to slow the economy by raising the reserve requirements for member banks. To do so, the reserve percentages will be increased to 12 percent on transaction balances above $100 million. Simultaneously, the 2 percent rate will apply on the first $25 million. Calculate the reserve requirement amount for each of the three banks after these changes have taken place.

d. Show the dollar amount of changes in reserve requirement amounts for each bank. Calculate the percentage of reserve requirement amounts to transaction account balances for each bank.

e. Which of the two reserve requirement changes discussed in (c) causes the greatest impact on the dollar amount of reserves for all three of the banks?

f. Now assume that you could either: (1) lower the transactions account amount for the lowest category from $50 million down to $25 million, or (2) increase the reserve percentage from 10 percent to 12 percent on transactions account amounts over $200 million. Which choice would you recommend if you were trying to achieve a moderate slowing of economic activity?

Analysis Essay

The evolution of technology is changing every day with those changes we find the version of norm adapts. Radios, computers, cell phones, and even household items have taken a technological route to make a human's life easier. The technology was created to make life easier, using these machines increases productivity. The changes in technology will have society always adapting to the new world, generations before and after will also continue to adapt to the advancement of these changes. Advancement of technology has impacted generations from the past and now in various ways including communication, news flow, an industry of jobs, and the general use of technology now in the 21st century. The similarities and differences will be discussed comparing the impacts from now and then identified by generations.

     Technology has improved over the last one hundred years starting from the invention radio in 1849. In history, inventions are always being created to keep in touch with one another, like cell phones or video messages. Communicating has always evolved through the years before texting and Facetime calls people would write, commute, or even send a page to contact them on the one telephone shared among a family. Ten years ago a family of five might have at least two cell phones in the family now everyone in a family will have a phone regardless of age. The use of a cell phone to communicate with others has become the number one way to do as opposed to those who wrote letters back and forth. The advancement of technology makes it easier to communicate with others by allowing more effective ways to reach someone.

    In the past ten years, our world changed from sending letters, postcards, or even digital photos to one another to all being posted online. Social media is one of the biggest changes between generations. Students to teachers to parents to children and everyone between using social media. Social media is an online site to communicate, share, and explore online without leaving just through a screen. The Internet is fairly new; older generations would not know about social media from when they were young since it is still fairly new and developing every day. The Internet was invented in the late 1900’s back then no one depended on the access of the internet like they do now. Every phone, tablet, laptop even refrigerator has access to the internet to surf the world wide web. One of the famous websites includes Google being one of the number 1 search browsers in the world. Google allows internet surfing for anything from cooking, random questions, maps, images even education. The use of the internet begs the question: Are we dependent on the internet? Nicholas Carr in the Is Google Making Us Stupid, explains the decency that has formed through the huge use of the internet. Carr references the essence of Kubrick’s dark prophecy, that we will rely on the use of the internet instead of actually learning content which makes humanity more artificially intelligent.

    Technology is evolving, cell phones, laptops, TVs and refrigerators are just the beginning of the advancement we are going to see. Generations from now will be following the advancements of technology because it is just at the beginning. Advancement of technology has impacted generations from the past and now in various ways including communication, news flow, an industry of jobs, and the general use of technology now in the 21st century.

Please edit this and what I did wrong.

The following is coded in C++. Please point out any changes or updates you make to the existing code with comments within the code.

Start with the provided code for the class linkedListType. Be sure to implement search, insert, and delete in support of an unordered list (that code is also provided).

Also, add a new function called insertLast that adds a new item to the END of the list, instead of to the beginning of the list. (Note: the link pointer of the last element of the list is NULL.)

Test your new function in main.

-----------------------------------------------------------------------------------

main.cpp (main driver):

#include 
#include "linkedList.h"
using namespace std;


int main()
{
    linkedListType myLL;
    if(myLL.isEmptyList()){
        cout<<"List is empty"<
----------------------------------------------------------------------

linkedList.h (header file containing declarations):

#ifndef H_LinkedListType
#define H_LinkedListType


#include 
#include 


using namespace std;


//Definition of the node


struct nodeType
{
        int info;
        nodeType *link;
};


//*****************  class linkedListType   ****************


class linkedListType
{
public:
    const linkedListType& operator=
                         (const linkedListType&);
      //Overload the assignment operator.


    void initializeList();
      //Initialize the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    bool isEmptyList() const;
      //Function to determine whether the list is empty.
      //Postcondition: Returns true if the list is empty,
      //               otherwise it returns false.


    void print() const;
      //Function to output the data contained in each node.
      //Postcondition: none


    int length() const;
      //Function to return the number of nodes in the list.
      //Postcondition: The value of count is returned.


    void destroyList();
      //Function to delete all the nodes from the list.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    int front() const;
      //Function to return the first element of the list.
      //Precondition: The list must exist and must not be
      //              empty.
      //Postcondition: If the list is empty, the program
      //               terminates; otherwise, the first
      //               element of the list is returned.


    int back() const;
      //Function to return the last element of the list.
      //Precondition: The list must exist and must not be
      //              empty.
      //Postcondition: If the list is empty, the program
      //               terminates; otherwise, the last
      //               element of the list is returned.


    bool search(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 insert(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.




    void deleteNode(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.




    linkedListType();
      //Default constructor
      //Initializes the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    linkedListType(const linkedListType& otherList);
      //copy constructor


    ~linkedListType();
      //Destructor
      //Deletes all the nodes from the list.
      //Postcondition: The list object is destroyed.


protected:
    int count;   //variable to store the number of
                 //elements in the list
    nodeType *first; //pointer to the first node of the list
    nodeType *last;  //pointer to the last node of the list


private:
    void copyList(const linkedListType& otherList);
      //Function to make a copy of otherList.
      //Postcondition: A copy of otherList is created and
      //               assigned to this list.
};
#endif

------------------------------------------------------------------------------------------

linkedList.cpp (cpp file containing definitions):

#include "linkedList.h"


bool linkedListType::isEmptyList() const
{
    return (first == nullptr);
}


linkedListType::linkedListType() //default constructor
{
    first = nullptr;
    last = nullptr;
    count = 0;
}


void linkedListType::destroyList()
{
    nodeType *temp;   //pointer to deallocate the memory
                            //occupied by the node
    while (first != nullptr)   //while there are nodes in
    {                          //the list
        temp = first;        //set temp to the current node
        first = first->link; //advance first to the next node
        delete temp;   //deallocate the memory occupied by temp
    }
    last = nullptr; //initialize last to nullptr; first has
               //already been set to nullptr by the while loop
    count = 0;
}


void linkedListType::initializeList()
{
        destroyList(); //if the list has any nodes, delete them
}


void linkedListType::print() const
{
    nodeType *current; //pointer to traverse the list


    current = first;    //set current so that it points to
                        //the first node
    while (current != nullptr) //while more data to print
    {
        cout << current->info << " ";
        current = current->link;
    }
}//end print




int linkedListType::length() const
{
    return count;
}  //end length




int linkedListType::front() const
{
    assert(first != nullptr);


    return first->info; //return the info of the first node
}//end front




int linkedListType::back() const
{
    assert(last != nullptr);


    return last->info; //return the info of the last node
}//end back




void linkedListType::copyList(const linkedListType& otherList)
{
    nodeType *newNode; //pointer to create a node
    nodeType *current; //pointer to traverse the list


    if (first != nullptr) //if the list is nonempty, make it empty
       destroyList();


    if (otherList.first == nullptr) //otherList is empty
    {
        first = nullptr;
        last = nullptr;
        count = 0;
    }
    else
    {
        current = otherList.first; //current points to the
                                   //list to be copied
        count = otherList.count;


            //copy the first node
        first = new nodeType;  //create the node


        first->info = current->info; //copy the info
        first->link = nullptr;        //set the link field of
                                   //the node to nullptr
        last = first;              //make last point to the
                                   //first node
        current = current->link;     //make current point to
                                     //the next node


           //copy the remaining list
        while (current != nullptr)
        {
            newNode = new nodeType;  //create a node
            newNode->info = current->info; //copy the info
            newNode->link = nullptr;       //set the link of
                                        //newNode to nullptr
            last->link = newNode;  //attach newNode after last
            last = newNode;        //make last point to
                                   //the actual last node
            current = current->link;   //make current point
                                       //to the next node
        }//end while
    }//end else
}//end copyList


linkedListType::~linkedListType() //destructor
{
   destroyList();
}//end destructor


linkedListType::linkedListType(const linkedListType& otherList)
{
    first = nullptr;
    copyList(otherList);
}//end copy constructor


         //overload the assignment operator
const linkedListType& linkedListType::operator=(const linkedListType& otherList)
{
    if (this != &otherList) //avoid self-copy
    {
        copyList(otherList);
    }//end else


     return *this;
}


bool search(const int& searchItem){}


void insert(const int& newItem){}


void deleteNode(const int& deleteItem){}

---------------------------------------------------------------------------------------------------

Unordered list function implementation file:

bool linkedListType::search(const int& searchItem)
{
    nodeType *current; //pointer to traverse the list
    bool found = false;
    
    current = first; //set current to point to the first 
                     //node in the list


    while (current != nullptr && !found)    //search the list
        if (current->info == searchItem) //searchItem is found
            found = true;
        else
            current = current->link; //make current point to
                                     //the next node
    return found; 
}//end search




void linkedListType::insert(const int& newItem)
{
    nodeType *newNode; //pointer to create the new node


    newNode = new nodeType; //create the new node


    newNode->info = newItem;    //store the new item in the node
    newNode->link = first;      //insert newNode before first
    first = newNode;            //make first point to the
                                //actual first node
    count++;                    //increment count


    if (last == nullptr)   //if the list was empty, newNode is also 
                        //the last node in the list
        last = newNode;
}//end insert (at front)




void linkedListType::deleteNode(const int& deleteItem)
{
    nodeType *current; //pointer to traverse the list
    nodeType *trailCurrent; //pointer just before current
    bool found;


    if (first == nullptr)    //Case 1; the list is empty. 
        cout << "Cannot delete from an empty list."
             << endl;
    else
    {
        if (first->info == deleteItem) //Case 2 
        {
            current = first;
            first = first->link;
            count--;
            if (first == nullptr)    //the list has only one node
                last = nullptr;
            delete current;
        }
        else //search the list for the node with the given info
        {
            found = false;
            trailCurrent = first;  //set trailCurrent to point
                                   //to the first node
            current = first->link; //set current to point to 
                                   //the second node


            while (current != nullptr && !found)
            {
                if (current->info != deleteItem) 
                {
                    trailCurrent = current;
                    current = current-> link;
                }
                else
                    found = true;
            }//end while


            if (found) //Case 3; if found, delete the node
            {
                trailCurrent->link = current->link;
                count--;


                if (last == current)   //node to be deleted 
                                       //was the last node
                    last = trailCurrent; //update the value 
                                         //of last
                delete current;  //delete the node from the list
            }
            else
                cout << "The item to be deleted is not in "
                     << "the list." << endl;
        }//end else
    }//end else
}//end deleteNode

SUMMARY OF DNA-RELATED CHANGES DURING MITOSIS & MEIOSIS

(fill in the blanks with the correct number)

-------------------------------------------------Meiosis I ---------Meiosis II -------------------------- ----- Mitosis

chromatids/chromosome:      ____    -->    _____       --> _____ ........................ _____     --> _____

# chromosome sets:               ____n     --> _____n    -->   ____n................... .... _____n   -->  ____n

(1n = haploid)

change in cell #                        _____ --> _____    --> _____ ............................... _____     --> _____

The following are various changes in audit circumstances.

Audit Circumstance

1. The client began experiencing an increase in returns due to product changes that resulted in increased defects.

2. You found several pricing errors in your substantive tests of transactions for sales.

3. In performing substantive tests of transactions for cash receipts, you found that receipts were promptly recorded in customer accounts, but there were delays in depositing the receipts at the bank.

4. The client entered into a new loan agreement with the bank. Accounts receivable are pledged as collateral for the loan.

5. The client did not reconcile the accounts receivable subsidiary records with the accounts receivable balance in the general ledger on a regular basis.

6. Substantive analytical procedures indicated a significant slowing in accounts receivable turnover.

7. The client entered into sales contracts with new customers that differ from the client’s standard sales contracts.

8. The client had a significant increase in sales near year end.

9. Accounts receivable confirmations were ineffective due to a very low response rate in the prior-year audit.

Match each change in audit circumstance with the most likely test of details of balances response. Each response is used once.

Required

1. Expand testing of sales returns after year end and compare the level of returns with the prior year.

2. Send positive confirmations that include requests for information on side agreements and special terms.

3. Increase the number of accounts traced from the accounts receivable trial balance to the accounts receivable subsidiary records.

4. Expand the review of cash receipts after year end to evaluate the collectibility of accounts receivable.

5. Increase the sample size for sales cutoff testing for sales recorded before year end.

6. Send a confirmation to the bank confirming amounts pledged as collateral under loan agreements.

7. Increase the sample size for positive confirmations of accounts receivable.

8. While at the client’s premises at year end, obtain information on the last few cash receipts at year end for cash receipts cutoff testing.

9. Perform alternative procedures to test the existence and accuracy of accounts receivable instead of sending positive confirmations.

This chapter discussed techniques for conversion investigations that involve searching public records to identify changes in lifestyle and the net worth of alleged fraud perpetrators. You recently became a certified fraud examiner (CFE) and have joined a local fraud examination firm. Your manager explains how he prefers to work with private sources of information and not involve local law enforcement agencies in the conversion investigation stage of his cases. You disagree and feel that local law enforcement can be an excellent resource. Discuss the advantages and disadvantages of involving law enforcement agencies in your fraud investigations.