Interview Question for Software Engineer at Google:

Well I would use a stack to hold the N-1 elements. Then pop one by one and attach it to the end of the list !

I would not use stacks because you don't have to.
this would be more memory efficient. remember to think google scale for google interview questions.
char[] appendReverse(char[] in)
{
       int n = in.length;
       char[] out = new char[n2-1];
       for(int i = 0; i < n; i++)
       {
             out[i] = in[i];
             out[n-i] = in[i];
        }
       return out;
}

Given that the original question states that we're using a singly-linked list rather than arrays, I think the stack-based solution (proposed by 'Using stacks' above) is the right one.

Actually, you don't have to use stack or any other data structure. What you can do is have to pointers one is pointing the last element (in this case 'D') and the other one is the head of the list. Add the first element at the end of the list. It becomes A', 'B', 'C', 'D' 'A' then move the head pointer next element and add it to after 'D' :A', 'B', 'C', 'D' 'B' 'A'. Finally add 'C'
 'D' :A', 'B', 'C', 'D' 'C' 'B' 'A'

You can do everything on the fly by creating an auxiliary reversed list. Then just append this list to the last element of the original list

struct List {
    List * next;
    char val;
};
void modify( List * node ) {
    if (node == NULL)
        return;
    List * rev = NULL ;
    while (node->next != NULL) {
        List * newNode = new List;
        newNode->next = rev;
        newNode->val = node->val;
        rev = newNode;
        node = node->next;
    }
    node->next = rev;
}

Followed MB's suggested algorithm. O(1) space required (for two pointers), O(n) runtime (two loops of n):

void modify (Node * node) {
    Node * last = node;
    while (last->next != NULL) {
        last = last->next;
    }
    Node * curr = node;
    while (curr != last) {
        Node * duplicate = new Node;
        duplicate->key = curr->key;
        duplicate->next = last->next;
        last->next = duplicate;
        curr = curr->next;
    }
}

I bet they just want to see your implementation using recursion.
void foo(node *p)
{
  if(p->next == 0)
    return p;
  node * end = foo(p->next);
  end->next = p->copy();
  return end->next;
}

One loop can provide O(n) time and O(2n-1) space.

def modify(root):
    s = root
    last = node(root.v)
    while root.n.n:
        root = root.n
        n = node(root.v)
        n.n = last
        last = n
    root.n.n = last
    return s

how about this

Node createList(Node n) {
    if(n.next == null) return n;
    else {
        Node n1= createList(n.next);
        Node n2 =new Node( n.value);
        n2.next = null;
        n1.next = n2;
        return n2;
    }
}