代码意识流——花朵数问题(七)

本文前一部分的链接
http://www.cnblogs.com/KBTiller/archive/2011/06/05/2073421.html

20.验算
   验算过程的基本思路是求出“和”中各个数字有多少个，然后与得到这个"和"的数字组合比较，如果两者一致则“和”是一个花朵数。
   例如，由一个5、一个3和一个1可以得到这三个数字的3次方的和为5^3+3^3+1^3==153,而153恰好是由一个5、一个3和一个1这三个数字构成这时就可以断定153是花朵数。
   反之，由一个5、一个3和一个2可以得到这三个数字的3次方的和为，5^3+3^3+2^3==160,160中有一个6、一个1和一个0，与求得160的三个数字的组合(5,3,2)不符，这就表明160不是花朵数。
   这种算法首先要记录求出数字N次方之和的各个数字的个数。
  
记录各数字的个数

在"2_穷举.c"定义这种数据类型

typedef unsigned int SHUZI_GESHU[JINZHI];
//SHUZI_GESHU[d]存储数字d的个数    

在xunhuan()中定义这种类型的局部变量，显然这应该是static类别的

static SHUZI_GESHU sz_gs ;

记录递归过程中各个数字的个数，并测试

static void xunhuan( const int gssx /* 个数上限 */ ,
const int sz /* 关于哪个数字 */ ,
DASHU ( * p_hang)[WEISHU + 1 ] /* 指向一行数据 */ )
{
static DASHU he = { { 0 } } ; // static DASHU he ; // =0 待完成
DASHU he_ = he ; // 记录累加前的值 // 记录累加前的值
static SHUZI_GESHU sz_gs ;

if ( sz > 0 ){
int i;
for ( i = 0 ; i <= gssx ; i ++ ){
sz_gs[sz] = i ; // 记录数字的个数
ds_jiaru ( & he , * p_hang + i ) ;
xunhuan( gssx - i , sz - 1 , p_hang + 1 );
he = he_ ; // 恢复原来的值
}
}
else {
sz_gs[sz] = gssx ; // 记录数字的个数
#ifdef CESHI
{
int i;
for ( i = 0 ; i < JINZHI ; i ++ ){
printf( " %d*%d " , sz_gs[i] , i );
}
putchar( ' \n ' );
}
#endif
// 验算<=>记录结果
}
}

测试通过。
接着在xunhuan()中写出验算的代码，判断“和”中数字出现的次数与sz_gs 中的记录是否一致

xunhuan()
{
     ……
     if( 吻合 ( & sz_gs , &he ) == 是 ){ //验算
          //<=>记录结果
      }

}

吻合 ( & sz_gs , &和 )
{
   int 和中各数字的个数[JINZHI];

   if( 超过W位(和) == 是  || 不足W位(和) == 是 ){   //#include "3_大数.h"
     return 否;
   }

   求和中各数字的个数（ &和中各数字的个数 , &和 ）；//#include "3_大数.h"

   if ( memcmp (和中各数字的个数 ,sz_gs ,sizeof 和中各数字的个数 )==0 ){ //#include <string.h>
      return 是;
   }
   return 否;
}

这段代码涉及到很多回答是或否的问题，由于讨厌在写代码时费神用0或1思考这样的问题，在工程中加入了这样一个文件

/* 常用.h */

#ifndef CHANGYONG_H
#define CHANGYONG_H

typedef enum { SHI , FOU } SF ;

#endif // CHANGYONG_H

并分别在"2_穷举.h"、"3_大数.h"中添加了
#include "常用.h"

现在，“2_穷举.h”演变成

/* 2_穷举.h */

#ifndef QIONGJU_H
#define QIONGJU_H


/* *************************类型定义************************* */
#include " 3_大数.h "
#include " 常用.h "

/* *************************函数原型************************* */

extern void qiongju( void );
#include < stdlib.h > // malloc()

#endif // QIONGJU_H

2_穷举.c演变成

/* 2_穷举.c */

#include " 2_穷举.h "
#include " 0_问题.h "

typedef unsigned int SHUZI_GESHU[JINZHI];
// SHUZI_GESHU[d]存储数字d的个数

typedef DASHU SHUJUBIAO[JINZHI - 1 ][WEISHU + 1 ];
// 0*(JINZHI-1)^N 1*(JINZHI-1)^N ……WEISHU*(JINZHI-1)^N
// 0*(JINZHI-2)^N 1*(JINZHI-2)^N ……WEISHU*(JINZHI-1)^N
// ……
// 0*(1)^N 1*(1)^N ……WEISHU*(1)^N

static void xunhuan( const int , const int , DASHU ( * )[WEISHU + 1 ] ) ;

static void jianli_sjb ( SHUJUBIAO * * ); // 建立数据表

static SF wenhe( SHUZI_GESHU * const , const DASHU * const );

static SF wenhe( SHUZI_GESHU * const p_sz_gs ,
const DASHU * const p_he )
{
int sz_gs_he[JINZHI] = { 0 }; // 和中各数字的个数

if ( chaoguo_W(p_he) == SHI // 超过W位 || 不足W位
|| buzu_W (p_he) == SHI ){
return FOU ;
}

qiu_sz_gs( & sz_gs_he , p_he ); // 求和中各数字的个数

if ( memcmp ( sz_gs_he , * p_sz_gs , sizeof sz_gs_he ) == 0 ){
return SHI ;
}
return FOU ;

}

// 建立数据表
static void jianli_sjb ( SHUJUBIAO * * p_p_sjb )
{
if ( ( * p_p_sjb = malloc( sizeof (SHUJUBIAO)) ) == NULL ){ // #include <stdlib.h>
exit( ! EXIT_SUCCESS);
}

{
int i , j ;
for ( i = 0 ; i < JINZHI - 1 ; i ++ ){
ds_fuzhi( * ( * * p_p_sjb + i ) + 0 , 0 ); // 第一列为0
ds_fuzhi( * ( * * p_p_sjb + i ) + 1 , 1 ); // 第二列先赋值为1
for ( j = 0 ; j < N ; j ++ ){ // 求N次幂
ds_chengyi( * ( * * p_p_sjb + i ) + 1 , JINZHI - 1 - i );
}
for ( j = 2 ; j <= WEISHU ; j ++ ){
( * ( * * p_p_sjb + i ))[j] = ( * ( * * p_p_sjb + i ))[j - 1 ] ;
ds_jiaru ( * ( * * p_p_sjb + i ) + j , * ( * * p_p_sjb + i ) + 1 ) ;
}
}
}
}

extern void qiongju( void )
{
SHUJUBIAO * p_sjb = NULL ;

jianli_sjb ( & p_sjb ); // 建立数据表
xunhuan( WEISHU , JINZHI - 1 , * p_sjb ) ;
free ( p_sjb );

}

static void xunhuan( const int gssx /* 个数上限 */ ,
const int sz /* 关于哪个数字 */ ,
DASHU ( * p_hang)[WEISHU + 1 ] /* 指向一行数据 */ )
{
static DASHU he = { { 0 } } ; // static DASHU he ; // =0 待完成
DASHU he_ = he ; // 记录累加前的值 // 记录累加前的值
static SHUZI_GESHU sz_gs ;

if ( sz > 0 ){
int i;
for ( i = 0 ; i <= gssx ; i ++ ){
sz_gs[sz] = i ; // 记录数字的个数
ds_jiaru ( & he , * p_hang + i ) ;
xunhuan( gssx - i , sz - 1 , p_hang + 1 );
he = he_ ; // 恢复原来的值
}
}
else {
sz_gs[sz] = gssx ; // 记录数字的个数

if ( wenhe ( & sz_gs , & he ) == SHI ){ // 验算两者是否"吻合"
#ifdef CESHI
ds_shuchu ( & he );
puts( " 吻合 " );
#endif
// <=>记录结果
}
}
}

"3_大数.h"演变为

/* 3_大数.h */

#ifndef DASHU_H
#define DASHU_H

#include " 0_问题.h " // DASHU用到了WEISHU

/* *************************类型定义************************* */
// gw_sz[0]为个位，gw_sz[WEISHU-1]为最高位
// gw_sz[WEISHU-1]的值大于等于JINZHI表示溢出
typedef struct {
int gw_sz[WEISHU] ;
}
DASHU ;
#include " 常用.h "

/* *************************函数原型************************* */

extern void ds_fuzhi ( DASHU * const , const int ) ;
extern void ds_shuchu( const DASHU * const ) ;
extern void ds_jiaru ( DASHU * const , const DASHU * const ) ;
extern void ds_chengyi( DASHU * const , const int );
extern SF chaoguo_W( const DASHU * const );
extern SF buzu_W( const DASHU * const );
extern void qiu_sz_gs( int ( * )[JINZHI] , const DASHU * const ) ;

#endif // DASHU_H

“3_大数.c”演变为

/* 3_大数.c */
#include " 3_大数.h "

static void ds_jinwei ( DASHU * const );

// 统计*p_he中的各数字个数=> *p_sz_gs
extern void qiu_sz_gs( int ( * p_sz_gs)[JINZHI] , const DASHU * const p_he )
{
int * t = p_he -> gw_sz ;
while ( t < p_he -> gw_sz + WEISHU ){
( * p_sz_gs)[ * t ++ ] ++ ;
}

}

extern SF buzu_W( const DASHU * const p_ds)
{
if (p_ds -> gw_sz[WEISHU - 1 ] == 0 ){
return SHI ;
}
return FOU ;
}
// 判断是否超过WEISHU
extern SF chaoguo_W( const DASHU * const p_ds)
{
if (p_ds -> gw_sz[WEISHU - 1 ] >= JINZHI ){
return SHI ;
}
return FOU ;
}

// * p_ds *= cs
extern void ds_chengyi( DASHU * const p_ds , const int cs )
{
int * t = p_ds -> gw_sz ;
while ( t < p_ds -> gw_sz + WEISHU ){
* t ++ *= cs ;
}
ds_jinwei ( p_ds );
}

// 进位
static void ds_jinwei ( DASHU * const p_ds )
{
int * t = p_ds -> gw_sz , * const w = t + WEISHU - 1 ;
while ( t < w ){
* ( t + 1 ) += * t / JINZHI ;
* t ++ %= JINZHI ;
}
}

// *p_he += *p_js
extern void ds_jiaru ( DASHU * const p_he , const DASHU * const p_js )
{
int * he_t = p_he -> gw_sz , * const he_w = he_t + WEISHU ; // - 1 ;
const int * js_t = p_js -> gw_sz ;
while ( he_t < he_w ){
* he_t ++ += * js_t ++ ;
}
ds_jinwei ( p_he ); // static void ds_jinwei ( DASHU * const );
}

extern void ds_shuchu( const DASHU * const p_ds )
{
int * const t = p_ds -> gw_sz , * w = t + WEISHU - 1 ;
while ( w > t && * w == 0 ){ // 高位0不输出
w -- ;
}
while ( w > t ){
printf( " %d " , * w -- );
}
printf( " %d\n " , * t ) ;
}

// 在*p_ds中写入n
extern void ds_fuzhi ( DASHU * const p_ds , const int n )
{
p_ds -> gw_sz[ 0 ] = n ;
// 可能有进位，同时把高位写为0
{
int * t = p_ds -> gw_sz , // 指向 p_ds->gw_sz[0]
* w = t + WEISHU - 1 ; // 指向 p_ds->gw_sz[WEISHU-1]
while ( t < w ){
* ( t + 1 ) = * t / JINZHI ;
* t ++ %= JINZHI ;
}
}
}

编译运行，结果为
153
吻合
370
吻合
371
吻合
407
吻合

总算看到点亮了。

转载于:https://www.cnblogs.com/KBTiller/archive/2011/06/07/2074344.html