hello cor hang repeated exit p s -o inpu ans

A - Problem A

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

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!

傳送門：點擊打開鏈接

解題思路：

進制轉換。小模擬。

代碼：

#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;
}

C - Problem C

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

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

傳送門：點擊打開鏈接

解題思路：

水題，小模擬。

代碼：

#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) SubmitStatus

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

傳送門：點擊打開鏈接

解題思路：

水題。插入排序。

代碼：

#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) SubmitStatus

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) 題解