学步园

Little Bobby Roberts (son of Big Bob, of Problem G) plays this solitaire memory game called Flipper. He starts with
n cards, numbered 1 through n, and lays them out in a row with the cards in order left-to-right. (Card 1 is on the far left; card
n is on the far right.) Some cards are face up and some are face down. Bobby then performs
n - 1 flips — either right flips or left flips. In a right flip he takes the pile to the far right and flips it over onto the card to its immediate left. For example, if the rightmost pile has cards A, B, C (from top to bottom) and card D is to the
immediate left, then flipping the pile over onto card D would result in a pile of 4 cards: C, B, A, D (from top to bottom). A left flip is analogous.

The very last flip performed will result in one pile of cards — some face up, some face down. For example, suppose Bobby deals out 5 cards (numbered 1 through 5) with cards 1 through 3 initially face up and cards 4 and 5 initially face down. If Bobby performs
2 right flips, then 2 left flips, the pile will be (from top to bottom) a face down 2, a face up 1, a face up 4, a face down 5, and a face up 3.

Now Bobby is very sharp and you can ask him what card is in any position and he can tell you!!! You will write a program that matches Bobby’s amazing feat.

Each test case will consist of 4 lines. The first line will be a positive integer
n (2 ≤ n ≤ 100) which is the number of cards laid out. The second line will be a string of
n characters. A character U indicates the corresponding card is dealt face up and a character D indicates the card is face down. The third line is a string of
n - 1 characters indicating the order of the flips Bobby performs. Each character is either R, indicating a right flip, or L, indicating a left flip. The fourth line is of the form
m q₁ q₂ . . . q_m, where m is a positive integer and 1 ≤
q_i ≤ n. Each q_i is a query on a position of a card in the pile (1 being the top card,
n being the bottom card). A line containing 0 indicates end of input.

Each test case should generate m + 1 lines of output. The first line is of the form

Pile t

where t is the number of the test case (starting at 1). Each of the next
m lines should be of the form

Card qi is a face up k.

or

Card qi is a face down k.

accordingly, for i = 1, ..,m, where k is the number of the card.
For instance, in the above example with 5 cards, if q_i = 3, then the answer would be

Card 3 is a face up 4.

5
UUUDD
RRLL
5 1 2 3 4 5
10
UUDDUUDDUU
LLLRRRLRL
4 3 7 6 1
0

Pile 1
Card 1 is a face down 2.
Card 2 is a face up 1.
Card 3 is a face up 4.
Card 4 is a face down 5.
Card 5 is a face up 3.
Pile 2
Card 3 is a face down 1.
Card 7 is a face down 9.
Card 6 is a face up 7.
Card 1 is a face down 5.

题意：其实这题并不难，只是题意有点难理解
首先给出每张牌的初始状态，U为面朝上，D为面朝下，然后跟着几个操作，L代表从左边翻，R代表从右边翻
例如第一个样例，前两个R，代表最右边的5翻转，叠放到4上，然后这两张叠放的一起翻转，叠放到3上
剩下的两个L，代表最左边的1翻转，叠峰到2上，然后这两张再一起翻转，叠放到3,4,5形成的堆上，然后他们就成为了一堆
最后给出n询问，询问这一堆的第几张牌是什么状态
例如Card 1 is a face down 2.就是说这个堆的第一张牌是面朝下的,数字为2。
#include<stdio.h>
struct card
{
    int data;
    char dir;//面向上或下
};
struct card stack[105][105];
int had,end,top[105];

void Turn(char turn[],int n)
{
    int i=0,tp;
    while(i<n)//每一步
    {
        if(turn[i]=='R')//从右往左翻一个堆
        {
            tp=top[end];//当前要翻的栈里面有多少张
            while(tp>0)//按顺序从上到下把全部的放入下一个栈里
            {
                if(stack[end][tp].dir=='U')
                stack[end][tp].dir='D';
                else
                stack[end][tp].dir='U';

                stack[end-1][++top[end-1]]=stack[end][tp];
                tp--;
            }
            top[end]=0; end--;//end是指向最右边的一个栈
        }
        else
        {
            tp=top[had];
            while(tp>0)
            {
                if(stack[had][tp].dir=='U')
                stack[had][tp].dir='D';
                else
                stack[had][tp].dir='U';

                stack[had+1][++top[had+1]]=stack[had][tp];
                tp--;
            }
            top[had]=0; had++;//had是指向最左边的一个栈
        }
        i++;//执行下一步
    }
}

int main()
{
    int n,i,m,a[105],t=1,k;
    char turn[105];
    while(scanf("%d",&n)>0&&n)
    {
        getchar();
        for(i=1;i<=n;i++)//首先每个栈中只有一张card
        {
            scanf("%c",&stack[i][1].dir);
            stack[i][1].data=i;
            top[i]=1;
        }
        getchar();
        scanf("%s",turn);//输入要执行的步骤
        scanf("%d",&m);
        for(i=1;i<=m;i++)//输入要在最后一堆中查找的位置
        scanf("%d",&a[i]);
        had=1;end=n;//初始指的位置

        Turn(turn,n-1);//执行

        printf("Pile %d\n",t++);
        for(i=1;i<=m;i++)
        {
            k=top[end]-a[i]+1;
            if(stack[end][k].dir=='U')
            printf("Card %d is a face up %d.\n",a[i],stack[end][k].data);
            else
            printf("Card %d is a face down %d.\n",a[i],stack[end][k].data);
        }
    }
}