UVa 12596 - Recursive Texting

Problem E

Recursive Texting

All of you have typed in mobile phones. In this problem, you will have to do a similar thing.

You are given a word. You will have to process it. There are two phases in each step.

Type the given word using standard mobile keyboard, that is, press the digit containing the required letter once.

Convert each digit found in the first phase into word, concatenate those words, and produce a new word.

For example, if you are asked to type DHAKA.

Step 1, phase 1:

34252

Step 1, phase 2:

THREEFOURTWOFIVETWO

Step 2, phase 1:

8473336878963483896

Step 2, phase 2:

EIGHTFOURSEVENTHREETHREETHREESIXEIGHTSEVENEIGHTNINESIXTHREEFOUREIGHTTHREEEIGHTNINESIX

And so on….

Your job is to find the kthcharacter after nth step.

Input

First line of input will consist of number of test cases, T (1 <= T <= 1000). Each of the next T lines contains the initial word, W (1 <= |W| <= 100), n(1<=n<=20), k (1 <= k <= 10^9), separated by a space. n will be such that kth character is always found. The initial word will contain only uppercase letter of English alphabet and no space within it.

Output

For each test case, first print the test case number, followed by the kth character after processing the initial word up to nth step.

Sample Input

Output for Sample Input

4

DHAKA 1 1

DHAKA 2 1

DHAKA 1 5

DHAKA 2 10

Case 1: T

Case 2: E

Case 3: E

Case 4: S

Note

Spellings of the digits:

0 – ZERO, 1 – ONE, 2 – TWO, 3 – THREE, 4 – FOUR, 5 – FIVE, 6 – SIX, 7 – SEVEN, 8 – EIGHT, 9 – NINE

Problemsetter: Anna Fariha, Shiplu Hawlader

Special Thanks: Md. Mahbubul Hasan

    刚开始做这题的时候,真是一点思路也没有,后来想到搜,但是总是超时,找解题报告也找不到,这是一道近段时间Uva比赛中的题目,做过的人很少。过了几天后,突然搜到国内网站有的oj 加了这道题,并且有人过了,有人的代码是可以share的,我就看了一下, 看完之后我感觉这道题目好经典啊,这可能是我做过的中的最高端的了啊。思想懂了以后就开始弄代码,最后还是调了好久,从昨天一直调到现在,终于ac了。
 好了,这下可以安心睡觉了。 acmer们晚安。
#include <stdio.h>
#include <string.h>
#include <math.h>
long long int dp[20][30];
char s1[200],c;
int n,m,pt[30],flag;
char s2[10][10]={"ZERO","ONE","TWO","THREE","FOUR","FIVE","SIX",
                     "SEVEN","EIGHT","NINE"};
int main()
{
    void Init();
    void solve(char str[100],int devel);
    void deal_dp(int x, int y);
    int i,j,t,tem=1;
    Init();
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s %d %d",s1,&n,&m);
        flag=0;
        solve(s1,n);
        printf("Case %d: %c\n",tem++,c);
    }
    return 0;
}
void deal_dp(int x,int y)
{
    int l,i;
    if(dp[x][y]>0)
    {
      return ;
    }
    l=strlen(s2[x]);
    if(y==1)
    {
        dp[x][y]=(long long int)l;
        return ;
    }
    for(i=0;i<=l-1;i++)
    {
        deal_dp(pt[s2[x][i]-'A'+1],y-1);
        dp[x][y]+=dp[pt[s2[x][i]-'A'+1]][y-1];
    }
}
void Init()
{
    char str;
    int i,j;
    for(i='A';i<='Z';i++)
    {
        str=(char)i;
        if(str>='A'&&str<='C')
        {
            pt[str-'A'+1]=2;
        }else if(str>='D'&&str<='F')
        {
            pt[str-'A'+1]=3;
        }else if(str>='G'&&str<='I')
        {
            pt[str-'A'+1]=4;
        }else if(str>='J'&&str<='L')
        {
            pt[str-'A'+1]=5;
        }else if(str>='M'&&str<='O')
        {
            pt[str-'A'+1]=6;
        }else if(str>='P'&&str<='S')
        {
            pt[str-'A'+1]=7;
        }else if(str>='T'&&str<='V')
        {
            pt[str-'A'+1]=8;
        }else if(str>='W'&&str<='Z')
        {
            pt[str-'A'+1]=9;
        }
    }
    memset(dp,0,sizeof(dp));
    for(i=2;i<=9;i++)
    {
        for(j=1;j<=21;j++)
        {
            deal_dp(i,j);
        }
    }
}

void solve(char str[100],int devel)
{
    int i,j,l;
    int Str;
    if(flag)
    {
        return ;
    }
    if(devel==0)
    {
        c=str[m-1];
        flag=1;
        return ;
    }
    l=strlen(str);
    for(i=0;i<=l-1;i++)
    {
        Str=str[i]-'A'+1;
        if(dp[pt[Str]][devel]>=m)
        {
            solve(s2[pt[Str]],devel-1);
        }else
        {
            m-=dp[pt[Str]][devel];
        }
    }
}

### 使用 `--recursive` 参数的方法及作用 #### 1. **Git 中的 `--recursive` 参数** `--recursive` 是 Git 提供的一个重要参数,主要用于处理子模块(submodules)。当一个仓库依赖于其他独立的 Git 仓库时,这些外部仓库被称为子模块。为了确保主仓库与其子模块同步更新并正常工作,`--recursive` 参数发挥了重要作用。 - 如果在克隆仓库时使用了 `git clone --recursive <repository-url>` 命令,则会递归地初始化并克隆所有的子模块[^4]。 - 若未使用该参数而仅运行普通的 `git clone`,则只会下载主仓库的内容,而不包含其子模块中的文件。这可能导致后续操作失败,因为缺少必要的资源[^3]。 #### 2. **具体应用场景** 对于某些复杂的开源项目来说,它们可能由多个相互关联的小型库组成。例如 DORIS 数据库系统就需要先完成基础环境搭建后再引入额外组件支持功能扩展;此时如果忽略掉 `--recursive` 配置项就很容易遇到错误提示像 "fatal: No such ref..." 这样的情况发生[^2]。 因此,在实际开发过程中应当养成良好习惯即始终记得加上这个标志位来保障整个工程结构完整无缺: ```bash $ git clone --recursive https://example.com/repo.git ``` 另外值得注意的是,即使已经完成了初始阶段的操作之后再次面对新增加或者修改过的子模块定义表单也需要重新执行相应指令才能生效: ```bash $ git submodule update --init --recursive ``` 此命令能够帮助开发者及时获取最新版次级存储单元内的变动信息以便继续推进下一步骤的工作流程[^5]。 --- ### 示例代码展示 以下是关于如何正确运用 `--recursive` 参数的具体实例演示: 假设存在这样一个名为 MyProject 的大型软件工程项目,并且它内部集成了几个第三方插件作为辅助工具包形式存在的话,那么我们可以按照下面的方式来进行完整的复制过程: ```bash # 正确方式:一次性完全拷贝包括所有子模块在内的全部内容 $ git clone --recursive https://github.com/user/MyProject.git # 错误示范(不推荐): 只能获得顶层目录下的东西而已 $ git clone https://github.com/user/MyProject.git ``` 假如后来得知官方维护者又向其中添加了一些新特性对应的附加模块怎么办呢?没关系,只需简单补充一句就能轻松搞定啦! ```bash # 更新现有的子模块至最新的状态 $ cd MyProject/ $ git pull origin main $ git submodule update --init --recursive ``` 以上步骤可以保证无论何时何地都能保持与上游源一致的状态! ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值