Problem Description

The decimal numeral system is composed of ten digits, which we represent as "0123456789" (the digits in a system are written from lowest to highest).

Imagine you have discovered an alien numeral system composed of some number of digits, which may or may not be the same as those used in decimal.

For example, if the alien numeral system were represented as "oF8", then the numbers one through ten would be (F, 8, Fo, FF, F8, 8o, 8F, 88, Foo, FoF).

We would like to be able to work with numbers in arbitrary alien systems.

More generally, we want to be able to convert an arbitrary number that's written in one alien system into a second alien system.

Input

The first line of input gives the number of cases, N.

N test cases follow. Each case is a line formatted as:

"alien_number source_language target_language"

Each language will be represented by a list of its digits, ordered from lowest to highest value.

No digit will be repeated in any representation, all digits in the alien number will be present in the source language, and the first digit of the alien number will not be the lowest valued digit of the source language
(in other words, the alien numbers have no leading zeroes).

Each digit will either be a number 0-9, an uppercase or lowercase letter, or one of the following symbols !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

0 ≤ alien_number (in decimal) ≤ 1000000000.

2 ≤ num digits in source_language ≤ 94.

2 ≤ num digits in target_language ≤ 94.

Output

For each test case, output one line containing "Case #x: " followed by the alien number translated from the source language to the target language.

Sample Input

4
9 0123456789 oF8
Foo oF8 0123456789
13 0123456789abcdef 01
CODE O!CDE? A? JM!.

Sample Output

Case #1: Foo
Case #2: 9
Case #3: 10011
Case #4: JAM!

传送门:

pid=1038">点击打开链接

解题思路:

进制转换。小模拟。

代码:

#include <cstdio>
#include <map>
#include <cstring>
#include <algorithm>
using namespace std; const int MAXN = 1e6+10;
char s[MAXN], sr[MAXN], to[MAXN], t[MAXN];
map<char, int> mps;
map<int, char> mpt; int main()
{
int icase, w = 1;
scanf("%d", &icase);
getchar();
while(icase--)
{
mps.clear(); mpt.clear();
scanf("%s", s);
scanf("%s", sr);
scanf("%s", to);
//puts(s); puts(sr); puts(to);
int nr = strlen(sr), ns = strlen(s);
int nt = strlen(to);
for(int i=0; i<nr; ++i)
{
mps[sr[i]] = i;
}
for(int i=0; i<nt; ++i)
{
mpt[i] = to[i];
}
int res = 0;
for(int i=0; i<ns; ++i)
{
res = res*nr + mps[s[i]];
}
// printf("%d\n", res);
if(0 == res)
{
printf("Case #%d: ", w++);
printf("%c\n", to[0]);
continue;
}
int cnt = 0;
while(res)
{
t[cnt++] = mpt[(res%nt)];
res /= nt;
}
printf("Case #%d: ", w++);
for(int i=cnt-1; i>=0; --i)
putchar(t[i]);
printf("\n");
}
return 0;
}

Problem Description

Moist has a hobby -- collecting figure skating trading cards. His card collection has been growing, and it is now too large to keep in one disorganized pile. Moist needs to sort the cards in alphabetical order,
so that he can find the cards that he wants on short notice whenever it is necessary.

The problem is -- Moist can't actually pick up the cards because they keep sliding out his hands, and the sweat causes permanent damage. Some of the cards are rather expensive, mind you. To facilitate the sorting,
Moist has convinced Dr. Horrible to build him a sorting robot. However, in his rather horrible style, Dr. Horrible has decided to make the sorting robot charge Moist a fee of $1 whenever it has to move a trading card during the sorting process.

Moist has figured out that the robot's sorting mechanism is very primitive. It scans the deck of cards from top to bottom. Whenever it finds a card that is lexicographically smaller than the previous card,
it moves that card to its correct place in the stack above.
 This operation costs $1, and the robot resumes scanning down towards the bottom of the deck, moving cards one by one until the entire deck is sorted
in lexicographical order from top to bottom.

As wet luck would have it, Moist is almost broke, but keeping his trading cards in order is the only remaining joy in his miserable life. He needs to know how much it would cost him to use the robot to sort his
deck of cards.

Input

The first line of the input gives the number of test cases, T(1 ≤ T ≤ 100).

T test cases follow.

Each one starts with a line containing a single integer, N(1 ≤ N ≤ 100).

The next N lines each contain the name of a figure skater, in order from the top of the deck to the bottom.

Each name will consist of only letters and the space character.

Each name will contain at most 100 characters.

No name with start or end with a space.

No name will appear more than once in the same test case.

Output

For each test case, output one line containing "Case #x: y", where x is the case number (starting from 1) and y is the number of dollars it would cost Moist to use the robot to sort his deck of trading cards.

Sample Input

3
2
Oksana Baiul
Michelle Kwan
3
Elvis Stojko
Evgeni Plushenko
Kristi Yamaguchi
4
Evgeni Plushenko
Kristi Yamaguchi
Elvis Stojko
Aksana Baiul

Sample Output

Case #1: 1
Case #2: 0
Case #3: 2

传送门:

pid=1146">点击打开链接

解题思路:

水题,小模拟。

代码:

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std; const int MAXN = 110;
char s[MAXN][MAXN];
vector<char *> vec; int main()
{
int w = 1, n, icase;
scanf("%d", &icase);
while(icase--)
{
scanf("%d", &n);
getchar();
vec.clear();
for(int i=0; i<n; ++i)
{
gets(s[i]);
vec.push_back(s[i]);
}
int ans = 0;
for(vector<char *>::iterator it=vec.begin()+1; it!=vec.end(); ++it)
{
if(strcmp(*it, *(it-1)) < 0)
{
vec.erase(it);
--it; ans++;
}
// printf("%s\n", *it);
}
printf("Case #%d: %d\n", w++, ans);
}
return 0;
}

D - Problem D

Time Limit: 2000/1000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others)

Problem Description

Alex and Bob are brothers and they both enjoy reading very much. They have widely different tastes on books so they keep their own books separately. However, their father thinks it is good to promote exchanges if
they can put their books together. Thus he has bought an one-row bookshelf for them today and put all his sons' books on it in random order. He labeled each position of the bookshelf the owner of the corresponding book ('Alex' or 'Bob').

Unfortunately, Alex and Bob went outside and didn't know what their father did. When they were back, they came to realize the problem: they usually arranged their books in their own orders, but the books seem to
be in a great mess on the bookshelf now. They have to sort them right now!!

Each book has its own worth, which is represented by an integer. Books with odd values of worth belong to Alex and the books with even values of worth belong to Bob. Alex has a habit of sorting his books from the
left to the right in an increasing order of worths, while Bob prefers to sort his books from the left to the right in a decreasing order of worths.

At the same time, they do not want to change the positions of the labels, so that after they have finished sorting the books according their rules, each book's owner's name should match with the label in its position.

Here comes the problem. A sequence of N values s0,
s1, ..., sN-1 is given, which
indicates the worths of the books from the left to the right on the bookshelf currently. Please help the brothers to find out the sequence of worths after sorting such that it satisfies the above description.

Input

The first line of input contains a single integer T(1 ≤ T ≤ 30), the number of test cases.

Each test case starts with a line containing an integer N(1 ≤ N ≤ 1000), the number of books on the bookshelf.

The next line contains N integers separated by spaces, representing s0,
s1, ..., sN-1(-1000 ≤ si ≤
1000), which are the worths of the books.

Output

For each test case, output one line containing "Case #X: ", followed by t0,
t1, ..., tN-1 in order, and
separated by spaces.

X is the test case number (starting from 1) and t0,
t1, ..., tN-1 forms the resulting
sequence of worths of the books from the left to the right.

Sample Input

2
5
5 2 4 3 1
7
-5 -12 87 2 88 20 11

Sample Output

Case #1: 1 4 2 3 5
Case #2: -5 88 11 20 2 -12 87

传送门:

pid=1189">点击打开链接

解题思路:

水题。插入排序。

代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std; const int MAXN = 1e3+10;
int a[MAXN], n, w=1, icase; int main()
{
scanf("%d", &icase);
while(icase--)
{
scanf("%d", &n);
for(int i=0; i<n; ++i)
{
scanf("%d", a+i);
}
for(int i=0; i<n; ++i)
{
if(0 == (a[i]&1)) continue;
int k = i;
for(int j=i+1; j<n; ++j)
{
if((a[j]&1) && a[j]<a[k])
{
k = j;
// printf("%d\n", a[j]);
}
}
swap(a[i], a[k]);
/* for(int j=0; j<n; ++j)
{
printf("%d ", a[j]);
}
printf(" %d\n", a[i]&1);*/
}
for(int i=0; i<n; ++i)
{
if(a[i]&1) continue;
int k = i;
for(int j=i+1; j<n; ++j)
{
if(0==(a[j]&1) && a[j]>a[k])
{
k = j;
// printf("%d\n", a[j]);
}
}
swap(a[i], a[k]);
}
printf("Case #%d:", w++);
for(int i=0; i<n; ++i)
{
printf(" %d", a[i]);
}
printf("\n");
}
return 0;
}

E - Problem E

Time Limit: 2000/1000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others)

Problem Description

Good programmers write fabulous comments. Igor is a programmer and he likes the old C-style comments in /* ... */ blocks. For him, it would be ideal if he could use this style as a uniform comment
format for all programming languages or even documents, for example Python, Haskell or HTML/XML documents.

Making this happen doesn't seem too difficult to Igor. What he will need is a comment pre-processor that removes all the comment blocks in /*, followed by comment text, and by another */.
Then the processed text can be handed over to the compiler/document renderer to which it belongs—whatever it is.

Igor's pre-processor isn't quite that simple, though. Here are some cool things it does:

The comments the pre-processor reads can be nested the same way brackets are nested in most programming languages. It's possible to have comments inside comments. For example, the following code block has an outer
level of comments that should be removed by the comment pre-processor. The block contains two inner comments.

printf("Hello /* a comment /* a comment inside comment */
inside /* another comment inside comment */
string */ world");

After the pre-process step, it becomes:

printf("Hello  world");

Igor recognizes comments can appear anywhere in the text, including inside a string "/*...*/", a constant number 12/*...*/34 or even in a character escape \/*...*/n

Or more formally:

text:
text-piece
text-piece remaining-text
text-piece:
char-sequence-without-/*
empty-string
remaining-text:
comment-block text comment-block:
/* comment-content */
comment-content:
comment-piece
comment-piece remaining-comment
comment-piece:
char-sequence-without-/*-or-*/
empty-string
remaining-comment:
comment-block comment-content char:
letters
digits
punctuations
whitespaces

Our pre-processor, given a text, removes all comment-block instances as specified.

Input

A text document with comment blocks in /* and */.

The input file is valid. It follows the specification of text in the problem statement.

The input file always terminates with a newline symbol.

Input contains a program of less than 100k bytes.

The input program contains only:

  • Letters: a-z, A-Z,
  • Digits: 0-9
  • Punctuation: ~ ! @ # % ^ & * ( ) - + = : ; " ' < > , . ?

    | / \ { } [ ] _

  • Whitespace characters: space, newline

Output

We only have one test case for this problem. First we need to output the following line.

Case #1:

Then, print the document with all comments removed, in the way specified in the problem statements.

Don't remove any spaces or empty lines outside comments.

Please output '\n' to finish the case.

Sample Input

//*no recursion*/* file header
***********/************
* Sample input program *
**********/*************
*/
int spawn_workers(int worker_count) {
/* The block below is supposed to spawn 100 workers.
But it creates many more.
Commented until I figure out why.
for (int i = 0; i < worker_count; ++i) {
if(!fork()) {
/* This is the worker. Start working. */
do_work();
}
}
*/
return 0; /* successfully spawned 100 workers */
} int main() {
printf("Hello /*a comment inside string*/ world");
int worker_count = 0/*octal number*/144;
if (spawn_workers(worker_count) != 0) {
exit(-1);
}
return 0;
}

Sample Output

Case #1:
/* file header
************************
*/
int spawn_workers(int worker_count) { return 0;
} int main() {
printf("Hello world");
int worker_count = 0144;
if (spawn_workers(worker_count) != 0) {
exit(-1);
}
return 0;
}

传送门:点击打开链接

解题思路:

手工模拟栈,类似括号匹配的问题。"/*"与“*/”匹配。

用一个数tot记录遇到的"/*"的数量。当tot=0。即没有凝视符,能够将字符直接放到目标数组里,当遇到“*/”而且tot>0时,用掉一个"*/"来和"/*"进行匹配,tot--。

有几个小细节须要注意一下:须要用一个pre记录之前的字符,由于我们须要比較的是连续的两个字符。当遇到"/*"和"*/"时。对pre的更新要留意,pre要更新为接下来要读取的字符;另一个就是对最后一个字符的处理,由于我们每次都是把合法字符(pre)放到结果数组里,所以须要对最后一个字符特殊处理。

几组測试数据:

測试数据:/*/*/**/*/*/

 測试数据: /**/ab

 測试数据: //**/*a*/**/**/

代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std; const int MAXN = 1e3+10;
char out[MAXN];
int m = 0; int main()
{
// freopen("E.txt", "r", stdin);
char c, pre; int tot = 0;
bool flag = false;
pre = getchar();
while((c=getchar()) != EOF)
{
flag = false;
if('/'==pre && '*'==c)
{
++tot;
pre = getchar();
continue;
}
if(0 == tot)
{
flag = true;
out[m++] = pre;
}
if('*'==pre && '/'==c && tot)
{
--tot;
pre = getchar();
continue;
}
pre = c;
}
if(flag) out[m++] = pre;
printf("Case #1:\n");
for(int i=0; i<m; ++i)
{
putchar(out[i]);
}
printf("\n");
return 0;
}

ACdream区域赛指导赛之手速赛系列(5) 题解的更多相关文章

  1. ACdream区域赛指导赛之手速赛系列(2)

    版权声明:本文为博主原创文章.未经博主同意不得转载. https://blog.csdn.net/DaiHaoC83E15/article/details/26187183        回到作案现场 ...

  2. ACdream区域赛指导赛之手速赛系列(7)

    A -Dragon Maze Time Limit: 2000/1000MS (Java/Others)Memory Limit: 128000/64000KB (Java/Others) Submi ...

  3. ACDream手速赛2

    地址:http://acdream.info/onecontest/1014   都是来自Codeforce上简单题.   A. Boy or Girl 简单字符串处理   B. Walking in ...

  4. 快速切题 acdream手速赛(6)A-C

    Sudoku Checker Time Limit: 2000/1000MS (Java/Others)Memory Limit: 128000/64000KB (Java/Others) Submi ...

  5. Acdream手速赛7

    蛋疼啊,本次只做出了一道题目...渣爆了... 妈蛋,,卡题之夜..比赛结果是1道题,比赛完哗啦哗啦出4道题.. A acdream1191 Dragon Maze 题意: 给一个迷宫,给出入口坐标和 ...

  6. ACdream区域赛指导赛之专题赛系列(1)の数学专场

    Contest : ACdream区域赛指导赛之专题赛系列(1)の数学专场 A:EOF女神的相反数 题意:n(<=10^18)的数转化成2进制.翻转后(去掉前导零)输出十进制 思路:water ...

  7. Contest - 2014 SWJTU ACM 手速测试赛(2014.10.31)

    题目列表: 2146 Problem A [手速]阔绰的Dim 2147 Problem B [手速]颓废的Dim 2148 Problem C [手速]我的滑板鞋 2149 Problem D [手 ...

  8. 手速太慢QAQ

    显然D是个细节题,但是还剩1h时看眼榜还没人过EF,只好冷静写D,大概思路是任何时候如果min(n,m)<=2,max(n,m)<=4暴搜,否则直接贪心是很对的,即第一步让S.T长度平均化 ...

  9. tensorflow笔记(四)之MNIST手写识别系列一

    tensorflow笔记(四)之MNIST手写识别系列一 版权声明:本文为博主原创文章,转载请指明转载地址 http://www.cnblogs.com/fydeblog/p/7436310.html ...

随机推荐

  1. js进行的一些判断

    表达式 "^\\d+$" //非负整数(正整数 + 0) "^[0-9]*[1-9][0-9]*$" //正整数 "^((-\\d+)|(0+))$& ...

  2. element--ui使用tab切换时如何获取当前对象的id或者其他属性

    1. 问题 当使用tab切换时,部分特殊场景需要获取当前元素的类名或者id. 2.解决思路,tab切换是绑定函数,函数会传递过去当前对象,通过当前对象获取对象属性 vue部分代码:本项目是在vue-c ...

  3. vuex如何管理需要即时更新的全局变量

    自己在使用vue练习开发的时候遇到全局变量无法即时更新的问题,查了资料之后得出结论使用vuex能够快速解决该问题,但是看了好多人讲解vuex的教程自己跟着去做都没解决自己想要的,最后找到一个比较容易理 ...

  4. show()的方向

    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content ...

  5. 安装配置Keepalived

    一.在haproxy容器安装Keepalived 1.进入haproxy容器: docker exec -it h1 bash 2.apt-get update(因为haproxy容器为Ubuntu) ...

  6. find -print0和xargs -0原理及用法

    平常我们经常把find和xargs搭配使用,例如: find . -name "*.txt" | xargs rm 但是这个命令如果遇到文件名里有空格或者换行符,就会出错.因为xa ...

  7. 集训第六周 O题

    Description Gerald got a very curious hexagon for his birthday. The boy found out that all the angle ...

  8. Springboot+dubbo+zookeeper整合

    本想自己搭建一个Spring+dubbo+zookeeper整合好的框架,想寻找个最佳实现但是遇到各种各样的问题,只好自己看看dubbo starter的源码 整理如下: 通过打上断点来看配置的对不对 ...

  9. hihoCoder#1077 RMQ问题再临-线段树

    原题地址 终于做到线段树的题了,因为建树.更新.查询都是递归操作,所以其实挺好写的. 用数组存的树,记得MAX_NODE开成两倍叶节点数大小,否则RE啊..不要问我是怎么知道的. 代码: #inclu ...

  10. ajax异步获取数据后动态向表格中添加数据(行)

    因为某些原因,项目中突然需要做自己做个ajax异步获取数据后动态向表格中添加数据的页面,网上找了半天都没有 看到现成的,决定自己写个例子 1.HTML页面 <!doctype html> ...