There is a host of sociological and cultural research that paints a robust picture of the effects of globalization on culture. This Application focuses on the flows of culture between Western and developing nations. As a practitioner in this global environment, you should be familiar with these culture effects. Use newspapers, magazines, and the Internet to research cultural changes in both Western and developing countries due to globalization. Then perform the following tasks: Outline the cultural aspects of globalization. Take an anthropological, rather than a business, perspective. Explain how you think understanding culture helps in doing business in today\'s global economy. Cite resources to justify your response. Solution Information technology has penetrated almost every aspect of our lives, “shrinking” our world into a global village. Economies and cultures have come closer. People are now aware of the cultures, traditions, lifestyle, living conditions prevailing in almost every corner of the world. Interestingly, this is going beyond awareness and into a state of integration that is a result of cross-pollinated views, ideologies, products and services. This evolution is termed as “globalization.” Culture has many definitions. My own definition is that culture is our collective experience as a society, and its impact on our reaction and decision-making relative to every-day facts and circumstances. Why is cross-cultural competence critical to your professional future and the viability of your company? It’s omnipresent in every business interaction and strategic decision.It is not feasible to be an expert on all the world’s cultures. It is possible, however, to incorporate a cross-cultural framework that improves cross-cultural understanding and interactions. Multinational firms whose operations are borderless have to consider the cultural variability of different regions of the world and develop cultural understanding. Major cultural constraints encountered by businesses include local attitudes, taste preferences, language, religion, management style, gender discrimination, skills, personalities, education, etc. To be successful, they need to mold their business actions in accordance with the local cultural models, they need to establish a global mindset. Let’s consider an example of the food giant, McDonald’s. The company enjoys a global presence; operating in more than 100 countries serving 70 million people every day. Their headquarters and senior management are U.S.-based but they entrust their local operations to local managers of the countries they operate in. Operations in more than 50 percent of their outlets are franchised. Furthermore, their menus are customized according to cultural habits and local taste preferences in every country. It is without a doubt that global thinking and cultural understanding are both powerful business tools which allow multinational firms to dominate the local markets and establish a global pres.

1. This is problem is same problem which i submitted on 2/20/17, I just modify
TestCirCularLinkedList1
import java.util.Iterator;
class CircularLinkedList implements Iterable {
// Your variables
// You can include a reference to a tail if you want
Node head;
int size; // BE SURE TO KEEP TRACK OF THE SIZE
// implement this constructor
public CircularLinkedList() {
head=null;
}
// writing helper functions for add and remove, like the book did can help
// but remember, the last element's next node will be the head!
// attach a node to the end of the list
// Be sure to handle the adding to an empty list
// always returns true
public boolean add(E e) {
Node newNode=new Node(e);
if(size==0){
head=newNode;
}
else{
Node last=getNode(size-1);
last.next=newNode;
}
newNode.next=head; //last element node is set to head
size++;
return true;
}
// need to handle

2. // out of bounds
// empty list
// adding to front
// adding to middle
// adding to "end"
// REMEMBER TO INCREMENT THE SIZE
public boolean add(int index, E e){
if(index>size) return false;
Node tmp=new Node(e);
if(index==0){
tmp.next=head;
Node last=getNode(size-1);
head=tmp;
last.next=head;
}
else {
Node curr=getNode(index-1);
tmp.next=curr.next;
curr.next=tmp;
}
size++;
return true;
}
// I highly recommend using this helper method
// Return Node found at the specified index
// be sure to handle out of bounds cases
private Node getNode(int index ) {
Node prev=head;
for(int i=0;isize) {
e=null;
}
else if(index==0){
e = head.getElement();
Node last=getNode(size-1);
head=head.next;
last.next=head;

3. size--;
}
else{
Node prev=getNode(index-1);
Node curr=getNode(index);
e=curr.getElement();
prev.next=curr.next;
size--;
}
return e;
}
// Turns your list into a string
// Useful for debugging
public String toString(){
Node current = head;
StringBuilder result = new StringBuilder();
if(size == 0){
return "";
}
if(size == 1) {
return head.getElement().toString();
}
else{
do{
result.append(current.getElement());
result.append(" ==> ");
current = current.next;
} while(current != head);
}
return result.toString();
}

4. public Iterator iterator() {
return new ListIterator();
}
// provided code
// read the comments to figure out how this works and see how to use it
// you should not have to change this
// change at your own risk!
private class ListIterator implements Iterator{
Node nextItem;
Node prev;
int index;
@SuppressWarnings("unchecked")
//Creates a new iterator that starts at the head of the list
public ListIterator(){
nextItem = (Node) head;
index = 0;
}
// returns true if there is a next node
// this is always should return true if the list has something in it
public boolean hasNext() {
// TODO Auto-generated method stub
return size != 0;
}
// advances the iterator to the next item
// handles wrapping around back to the head automatically for you
public E next() {
// TODO Auto-generated method stub
prev = nextItem;
nextItem = nextItem.next;
index = (index + 1) % size;

5. return prev.getElement();
}
// removed the last node was visted by the .next() call
// for example if we had just created a iterator
// the following calls would remove the item at index 1 (the second person in the ring)
// next() next() remove()
public void remove() {
int target;
if(nextItem == head) {
target = size - 1;
} else{
target = index - 1;
index--;
}
CircularLinkedList.this.remove(target); //calls the above class
}
}
}
class Node {
E element;
Node next;
public Node() {
this.element = null;
this.next = null;
}
public Node(E e) {
this.element = e;
this.next = null;
}

6. public E getElement() {
return this.element;
}
public void setElement(E element) {
this.element= element;
}
}
import java.util.Iterator;
public class TestCircularLinkedList1 {
// Solve the problem in the main method
// The answer of n = 13, k = 2 is
// the 11th person in the ring (index 10)
public static void main(String[] args){
CircularLinkedList l = new CircularLinkedList();
// int n;
int k;
for (int n = 0; n<5; n++){
l.add(n);
}
l.add(1);
l.add(2);
l.add(3);
l.add(4);
System.out.println(l.toString());
l.add(3,5);
// System.out.println(l.toString());
// l.add(0,16);
System.out.println(l.toString());
l.remove(2);
System.out.println(l.toString());

7. // use the iterator to iterate around the list
Iterator iter = l.iterator();
while(l.size >1){
for(int i=0; i<2; i++){
iter.next();
}
System.out.println("Element:"+iter.next());
iter.remove();
}
}
}
this code is print like this way CircularLinkedlist
0 ==> 1 ==> 2 ==> 3 ==> 4 ==> 1 ==> 2 ==> 3 ==> 4 ==>
0 ==> 1 ==> 2 ==> 5 ==> 3 ==> 4 ==> 1 ==> 2 ==> 3 ==> 4 ==>
0 ==> 1 ==> 5 ==> 3 ==> 4 ==> 1 ==> 2 ==> 3 ==> 4 ==>
But i need to print like down
For a ring of n = 5 and the count k = 2:1 1 ==> 2 ==> 3 ==> 4 ==> 5 ==>
1 ==> 3 ==> 4 ==> 5 ==>
1 ==> 3 ==> 5 ==>
3 ==> 5 ==>
3
Solution
import java.util.Iterator;
class CircularLinkedList implements Iterable {
// Your variables
// You can include a reference to a tail if you want
Node head;
int size; // BE SURE TO KEEP TRACK OF THE SIZE

8. // implement this constructor
public CircularLinkedList() {
head = null;
}
// writing helper functions for add and remove, like the book did can help
// but remember, the last element's next node will be the head!
// attach a node to the end of the list
// Be sure to handle the adding to an empty list
// always returns true
public boolean add(E e) {
Node newNode = new Node(e);
if (size == 0) {
head = newNode;
} else {
Node last = getNode(size - 1);
last.next = newNode;
}
newNode.next = head; // last element node is set to head
size++;
return true;
}
// need to handle
// out of bounds
// empty list
// adding to front
// adding to middle
// adding to "end"
// REMEMBER TO INCREMENT THE SIZE
public boolean add(int index, E e) {
if (index > size)
return false;
Node tmp = new Node(e);
if (index == 0) {
tmp.next = head;
Node last = getNode(size - 1);
head = tmp;

9. last.next = head;
} else {
Node curr = getNode(index - 1);
tmp.next = curr.next;
curr.next = tmp;
}
size++;
return true;
}
// I highly recommend using this helper method
// Return Node found at the specified index
// be sure to handle out of bounds cases
private Node getNode(int index) {
Node prev = head;
for (int i = 0; i < size && index < size; i++) {
if (i == index) {
return prev;
}
prev = prev.next;
}
return null;
}
// remove must handle the following cases
// out of bounds
// removing the only thing in the list
// removing the first thing in the list (need to adjust the last thing in
// the list to point to the beginning)
// removing the last thing (if you have a tail)
// removing any other node.
// REMEMBER TO DECREMENT THE SIZE
public E remove(int index) {
E e;
if (index > size) {
e = null;
} else if (index == 0) {
e = head.getElement();

10. Node last = getNode(size - 1);
head = head.next;
last.next = head;
size--;
} else {
Node prev = getNode(index - 1);
Node curr = getNode(index);
e = curr.getElement();
prev.next = curr.next;
size--;
}
return e;
}
// Turns your list into a string
// Useful for debugging
public String toString() {
Node current = head;
StringBuilder result = new StringBuilder();
if (size == 0) {
return "";
}
if (size == 1) {
return head.getElement().toString();
} else {
do {
result.append(current.getElement());
result.append(" ==> ");
current = current.next;
} while (current != head);
}
return result.toString();
}
public Iterator iterator() {
return new ListIterator();
}
// provided code

11. // read the comments to figure out how this works and see how to use it
// you should not have to change this
// change at your own risk!
private class ListIterator implements Iterator {
Node nextItem;
Node prev;
int index;
@SuppressWarnings("unchecked")
// Creates a new iterator that starts at the head of the list
public ListIterator() {
nextItem = (Node) head;
index = 0;
}
// returns true if there is a next node
// this is always should return true if the list has something in it
public boolean hasNext() {
// TODO Auto-generated method stub
return size != 0;
}
// advances the iterator to the next item
// handles wrapping around back to the head automatically for you
public E next() {
// TODO Auto-generated method stub
prev = nextItem;
nextItem = nextItem.next;
index = (index + 1) % size;
return prev.getElement();
}
// removed the last node was visted by the .next() call
// for example if we had just created a iterator
// the following calls would remove the item at index 1 (the second
// person in the ring)
// next() next() remove()
public void remove() {
int target;
if (nextItem == head) {

12. target = size - 1;
} else {
target = index - 1;
index--;
}
CircularLinkedList.this.remove(target); // calls the above class
}
}
}
*****************************************************************************
************************************
class Node {
E element;
Node next;
public Node() {
this.element = null;
this.next = null;
}
public Node(E e) {
this.element = e;
this.next = null;
}
public E getElement() {
return this.element;
}
public void setElement(E element) {
this.element = element;
}
}
*****************************************************************************
********************************
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
CircularLinkedList l = new CircularLinkedList();
// int n;

13. int k;
for (int n = 1; n <= 5; n++)
l.add(n);
System.out.println(l.toString());
l.remove(1);
System.out.println(l.toString());
l.remove(2);
System.out.println(l.toString());
l.remove(0);
System.out.println(l.toString());
l.remove(1);
System.out.println(l.toString());
/*
* // use the iterator to iterate around the list Iterator iter
* = l.iterator(); while (l.size > 1) {
*
* for (int i = 0; i < 2; i++) iter.next();
*
* System.out.println("Element:" + iter.next());
*
* iter.remove(); }
*/}
}
output
1 ==> 2 ==> 3 ==> 4 ==> 5 ==>
1 ==> 3 ==> 4 ==> 5 ==>
1 ==> 3 ==> 5 ==>
3 ==> 5 ==>
3