1. 程式人生 > 實用技巧 >藍橋杯2013年省賽c/c++A組題4(顛倒的價牌)

藍橋杯2013年省賽c/c++A組題4(顛倒的價牌)

題目標題: 顛倒的價牌

小李的店裡專賣其它店中下架的樣品電視機,可稱為:樣品電視專賣店。其標價都是4位數字(即千元不等)。小李為了標價清晰、方便,使用了預製的類似數碼管的標價籤,只要用顏色筆塗數字就可以了。

這種價牌有個特點,對一些數字,倒過來看也是合理的數字。如:1 2 5 6 8 9 0 都可以。這樣一來,如果牌子掛倒了,有可能完全變成了另一個價格,比如:1958 倒著掛就是:8561,差了幾千元啊!!

當然,多數情況不能倒讀,比如,1110 就不能倒過來,因為0不能作為開始數字。

有一天,悲劇終於發生了。某個店員不小心把店裡的某兩個價格牌給掛倒了。並且這兩個價格牌的電視機都賣出去了!

慶幸的是價格出入不大,其中一個價牌賠了2百多,另一個價牌卻賺了8百多,綜合起來,反而多賺了558元。

請根據這些資訊計算:賠錢的那個價牌正確的價格應該是多少?

答案是一個4位的整數,請通過瀏覽器直接提交該數字。

參考答案: 9088

解題C語言程式碼如下

/***********************************************************************************************
 ***                 藍橋杯2013年省賽c/c++A組題4(顛倒的價牌)                                  ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : -----------------                                            *
 *                                                                                             *
 *                    File Name : T4顛倒的價牌.c                                                *
 *                                                                                             *
 *                   Start Date : 2020-08-05                                                   *
 *                                                                                             *
 *                  Last Update : 2020-08-05 [JYH]                                             *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:  																				   * 
 *   main -- 主函式,找到顛倒的價牌                            				     			   * 
 *   get_all_case  --  獲得所有排列組合情況,並輸出結果                                           *
 *   pow1 -- 冪函式                                                                             * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void get_all_case(int m, int n, int **a);
int pow1(int m, int n);

/***********************************************************************************************
 * main -- 主函式,顛倒的價牌    	                                                               *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none								                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2020-08-05 JYH : Created.                                                                 *
 *=============================================================================================*/
int main()
{
	int m=7, n=4, mm;
	int **a;
	int i,j;
	mm = pow1(m,n);
	a = (int **)malloc(mm * sizeof(int *));
	for (i = 0; i < mm; ++i){
		a[i] = (int *)malloc(n*2 * sizeof(int));
	}//動態申請二維陣列 
	get_all_case(m, n, a);
}


/***********************************************************************************************
 * get_all_case -- 獲得所有排列組合情況                                                          *
 *                                                                                             * 
 *          每一位都有m種可能,共有n位                                                           *
 *                                                                                             *
 * INPUT:   m                       														   * 
 *          n                                                                                  *
 *          a    -- 所有可能性存放在二維陣列a中(包括反轉後的資料)                                  *
 *                  其中每一行為一種可能性,行數為可能性個數                                       * 
 *          num  -- 去除一定不符合要求的資料後,資料的個數                                         *
 *                                                                                             * 
 * OUTPUT:	none                                                                               * 
 *                                                                                             *
 * WARNINGS: none                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2020-08-05 JYH : Created.                                                                 *
 *=============================================================================================*/
void get_all_case(int m, int n, int **a)
{
	int i,j,k,l,num;
	int data[7] = {1, 2, 5, 6, 8, 9, 0};
	for(l=0; l<n; l++){  // 第1-4列 
		for(k=0; k<pow1(m,n-1-l); k++){   // 週期 
			for(j=0; j<m; j++){  // 每位有m種可能 
				for(i=0; i<pow1(m,l); i++){  //每種可能連續重複次數 
					a[k*pow1(m,l+1)+j*pow1(m,l)+i][l] = data[j];
				}
			}
		} 
	}
	// 去除一定不符合要求的資料後,資料的個數
	num = 0;
	for(j=0; j<pow1(m,n); j++){
		if(a[j][0]!=0&&a[j][n-1]!=0){
			num++;
		}
	}
	// 篩選資料過程 
	k=0; 
	for(j=0; j<pow1(m,n); j++){
		if(a[j][0]!=0&&a[j][n-1]!=0){
			for(i=0; i<n; i++){
				a[k][i] = a[j][i];
			}
			k++;
		}
	} 
	// 原始資料儲存在第0列中 
	// 顛倒後資料情況,儲存在第1列中 
	// 計算兩次差值,結果存放在第2列中
	// 篩選資料,虧本0行開始(3,4,5列) , 賺錢100行開始(3,4,5列) 
	k = 0;   l = 0;  
	for(i=0; i<num; i++){
		for(j=0; j<n; j++){
			if(a[i][j]==6){
				a[i][2*n-1-j] = 9;
			}
			else if(a[i][j]==9){
				a[i][2*n-1-j] = 6;
			}
			else{
				a[i][2*n-1-j] = a[i][j];
			}
		}
		a[i][0] = 1000*a[i][0] + 100*a[i][1] + 10*a[i][2] + a[i][3];
		a[i][1] = 1000*a[i][4] + 100*a[i][5] + 10*a[i][6] + a[i][7];
		a[i][2] = a[i][1] - a[i][0]; 
		// 再次篩選(-300<差價<-200) (800<差價<900)的資料
		if(a[i][2]>-300&&a[i][2]<-200){
			a[k][3] = a[i][0];
			a[k][4] = a[i][1];
			a[k][5] = a[i][2];
			k++;
		}
		else if(a[i][2]>800&&a[i][2]<900){
			a[l+100][3] = a[i][0];
			a[l+100][4] = a[i][1];
			a[l+100][5] = a[i][2];
			l++;
		}
	}
	for(i=0; i<k; i++){
		for(j=100; j<100+l; j++){
			if((a[i][5]+a[j][5])==558){
				printf("賺錢的價牌價格為:%d\t", a[j][3]);
				printf("賠錢的價牌價格為:%d\n", a[i][3]);
			}
		}
	} 
}

/***********************************************************************************************
 * pow1 -- 冪函式	                                                                           *
 *                                                                                             *
 *    計算冪函式的值,如:pow(10,5)表示10^5                                                      *
 *                                                                                             *
 * INPUT:   m     -- 底數        															   *
 *          n     -- 指數                                                                      *
 *                                                                                             *
 * OUTPUT:  m的n次方(m^n)			 			                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2020-08-05 JYH : Created.                                                                 *
 *=============================================================================================*/
int pow1(int m, int n)
{
	if(n==0) return 1;
	return m*pow1(m, n-1);
}