Hangman Judge(自顶而下的程序设计方法)（UVa 489）

Hangman Judge

Time Limit: 3000ms

Memory Limit: 131072KB

This problem will be judged on  UVA. Original ID:  489
64-bit integer IO format:  %lld      Java class name:  Main

Prev 

Submit  Status  Statistics  Discuss

  Next

Type: 

None

  None

 Graph Theory

      2-SAT

     Articulation/Bridge/Biconnected Component

     Cycles/Topological Sorting/Strongly Connected Component

     Shortest Path

          Bellman Ford

         Dijkstra/Floyd Warshall

     Euler Trail/Circuit

      Heavy-Light Decomposition

     Minimum Spanning Tree

     Stable Marriage Problem

      Trees

     Directed Minimum Spanning Tree

     Flow/Matching

          Graph Matching

             Bipartite Matching

             Hopcroft–Karp Bipartite Matching

             Weighted Bipartite Matching/Hungarian Algorithm

         Flow

              Max Flow/Min Cut

             Min Cost Max Flow

 DFS-like

      Backtracking with Pruning/Branch and Bound

      Basic Recursion

     IDA* Search

      Parsing/Grammar

     Breadth First Search/Depth First Search

     Advanced Search Techniques

          Binary Search/Bisection

         Ternary Search

 Geometry

      Basic Geometry

     Computational Geometry

     Convex Hull

      Pick's Theorem

 Game Theory

      Green Hackenbush/Colon Principle/Fusion Principle

      Nim

     Sprague-Grundy Number

  Matrix

     Gaussian Elimination

      Matrix Exponentiation

 Data Structures

      Basic Data Structures

     Binary Indexed Tree

     Binary Search Tree

      Hashing

     Orthogonal Range Search

      Range Minimum Query/Lowest Common Ancestor

      Segment Tree/Interval Tree

     Trie Tree

     Sorting

      Disjoint Set

 String

      Aho Corasick

     Knuth-Morris-Pratt

      Suffix Array/Suffix Tree

 Math

      Basic Math

     Big Integer Arithmetic

      Number Theory

         Chinese Remainder Theorem

         Extended Euclid

          Inclusion/Exclusion

         Modular Arithmetic

     Combinatorics

          Group Theory/Burnside's lemma

         Counting

     Probability/Expected Value

  Others

     Tricky

      Hardest

     Unusual

      Brute Force

     Implementation

      Constructive Algorithms

     Two Pointer

      Bitmask

     Beginner

      Discrete Logarithm/Shank's Baby-step Giant-step Algorithm

      Greedy

     Divide and Conquer

  Dynamic Programming

                   Tag it!

[PDF Link]

Hangman Judge

In ``Hangman Judge,'' you are to write a program that judges a series of Hangman games. For each game, the answer to the puzzle is given as well as the guesses. Rules are the same as the classic game of hangman, and are given as follows:

1. The contestant tries to solve to puzzle by guessing one letter at a time.
2. Every time a guess is correct, all the characters in the word that match the guess will be ``turned over.'' For example, if your guess is ``o'' and the word is ``book'', then both ``o''s in the solution will be counted as ``solved.''
3. Every time a wrong guess is made, a stroke will be added to the drawing of a hangman, which needs 7 strokes to complete. Each unique wrong guess only counts against the contestant once.

      ______   
      |  |     
      |  O     
      | /|\    
      |  |     
      | / \    
    __|_       
    |   |______
    |_________|

4. If the drawing of the hangman is completed before the contestant has successfully guessed all the characters of the word, the contestant loses.
5. If the contestant has guessed all the characters of the word before the drawing is complete, the contestant wins the game.
6. If the contestant does not guess enough letters to either win or lose, the contestant chickens out.

Your task as the ``Hangman Judge'' is to determine, for each game, whether the contestant wins, loses, or fails to finish a game.

Input

Your program will be given a series of inputs regarding the status of a game. All input will be in lower case. The first line of each section will contain a number to indicate which round of the game is being played; the next line will be the solution to the puzzle; the last line is a sequence of the guesses made by the contestant. A round number of -1 would indicate the end of all games (and input).

Output

The output of your program is to indicate which round of the game the contestant is currently playing as well as the result of the game. There are three possible results:

You win.
You lose.
You chickened out.

Sample Input

1
cheese
chese
2
cheese
abcdefg
3
cheese
abcdefgij
-1

Sample Output

Round 1
You win.
Round 2
You chickened out.
Round 3
You lose.

代码分析：将程序一个部分分出去变成一个函数guess（），这样增加了程序的可读性

#include<stdio.h>
#include<string.h>
#define MAXN 105

int left, chance;	//left为剩余剩下未猜到的字母数量，chance为你还剩下错误的机会 
char s1[MAXN], s2[MAXN];
int win, lose;

void guess(char ch)
{
	int find =0;	//判断是否在s1中找到ch字母 
	for(int i=0; i<strlen(s1); i++)
	{
		if(ch == s1[i])
		{
			s1[i] = ' ';	//s1中抹去ch字母，避免重复判断
			find = 1; 
			left--;
		}
	}
	if(!find) chance--;
	
	
	if(left == 0) win = 1;
	else if(chance == 0) lose = 1;
	return ;
} 

int main()
{
	int rnd;
	
	while((scanf("%d", &rnd) == 1)&&(rnd != -1))
	{
		scanf("%s %s", s1, s2); 
		win = 0, lose = 0;
		printf("Round %d\n", rnd);
		left = strlen(s1);
		chance = 7;
		for(int i=0; i<strlen(s2); i++)
		{
			guess(s2[i]);
			if(win || lose) 
			break;
		}
		
		
		if(win) printf("You win.\n");
		else if(lose) printf("You lose.\n");
		else printf("You chickened out.\n");
		
	}
	return 0;
}