新普金娱乐网址


趣语诗谜

俺们的远足,6上5后的三亚游

天文书香洒满人生路

  • 十月 13, 2018
  • 天文
  • 没有评论

天文 1

 

前面几乎天陪爱人去打家电,看到店里新到了几个书架,或简大方,或精美精致,便起想念购买一个回的冲动,因为直接惦记使一个书架,自己的爱书也确实用一个初舍。但考虑到房屋空间少,实在无处安放,犹豫再三,还是没有购置下,心中不免有点遗憾。

正文:

骨子里一直希望有一个属自己之书架,里面装满好喜好的各种书籍,从天文地理到传统。从社会名流故事到百姓生活,从阳春白雪到下里巴人,闲来无事,便约达到三五恩爱,捧一海清茶,读几页诗书,谈几句子心得体会。徜徉书海,品味人生,该是平等起多么惬意的行。

在编程中,无论是OC还是C亦或者C++语言,所声明的整数变量都见面以内存中据为己有一定的囤积空间,而这些囤积空间都是原则性的。

书架既然没有买来,那便只能让好书还需要在橱柜里.桌子上。看在朝夕相伴的图书,思绪纷飞,想到自己三十岁的身里,竟有二十几近年之流年是其一直与自相伴,似乎我真该写点啊了!

比如我们掌握的int、long、short、unsigend
int、unsigend long、unsigend long
long等等,都发出定位的囤积空间,而即使是64位系统下之变量unsigend long
long,能积存的极其老范围仅来1844674407370955161。

记忆跟书第一糟做,是在姐姐的小学校课堂上,那时姐姐7载,我5岁。我兄弟姐妹们几近,父母又得错过地里干活,实在看不恢复,只好大之带小之。姐姐读了,我无处可去,只好跟着姐姐一起赶到该校,我以教室的过道上,学在姐姐把亲手背在身后,端端正正的坐在姐姐的书包上,认认真真的放先生教学,还受了名师的表扬。当惯玩泥巴的双手碰触着书本,学在那些哥哥姐姐们振奋的将在开大声朗读,幼小的内心第一浅来了一致栽悸动和开心,于是自己欢喜上了书,喜欢上了读时之饱满,与书的缘分自此便一发不可收拾。但那时候,实在没啊课外书而读,于是课本就成为了朝夕相伴的读物。自己的、姐姐的,凡是能够收看的写,我都念了以读,却为要命觉有趣。

下面复习一下基础项目的仓储范围与所占据字节:

高中时,终于不再为无开而读发愁,也是在这时开始拥有了团结之第一批判藏书。那时候开始住校,一个月份回家用一样潮生活费。我饭量小,可以起生活费里看有一些来,就还拿来市了书。从汪国真、徐志摩及泰戈尔,从《花间词》到《现代诗句》,从文学名著到军队杂志,几乎什么都进。学校里还有图书馆及阅览室,自己再次为未用也无书而读发愁。教室、图书馆,到处都养了自己伏案读书之人影。

编程语言的根底项目速查表

大学时,我决然的抉择了中文系,因为那表示来再多之题而读。至今记得见到学校里更是巨大之图书馆时之不亦乐乎;记得在宿舍里从早安至晚、连门都非起,八天读了九本书的壮举;记得租书的师姐读研前且不忘却给好留没读了的几本开之缓。更记得在微机前等待连载书籍更新时之苦苦守候!

char -128 ~ +127 (1 Byte)
short -32767 ~ + 32768 (2 Bytes)
unsigned short 0 ~ 65536 (2 Bytes)
int -2147483648 ~ +2147483647 (4 Bytes)
unsigned int 0 ~ 4294967295 (4 Bytes)
long == int
long long -9223372036854775808 ~ +9223372036854775807 (8 Bytes)
double 1.7 * 10^308 (8 Bytes)

今手里可控制的钱更多,买的书也越来越少,不是不再爱了,而是开始阅读电子书。电子书让看变得简单好,电子书方便携带,容量还老,但也有失了纸质书的书香和质感,我则在朗诵,却再度为查找不至那种初读书时的悸动和愉快。读书,不也利益的拿走知识或者增强更,读书实在读之无非是同种心态,让浮躁的良心获得几许恬静。这辈子,有涉猎就等同爱好实际算一老好事。

unsigned int 0~4294967295  
long long的卓绝酷价值:9223372036854775807
long long的无比小值:-9223372036854775808
unsigned long long的无限充分价值:1844674407370955161

自还是想只要一个属自己的书架,里面装满好喜爱的各种图书。闲来无事,便约达到三五贴心,捧一盏清茶,读几页诗书,谈几句心得体会。徜徉浩瀚书海,品味书香人生,

__int64的极其老价值:9223372036854775807
__int64的极端小值:-9223372036854775808
unsigned __int64的极度酷价值:18446744073709551615

 

详细:

====================

符性 长度属性 基本型 所占各类数 取值范围 输入符举例 输出符举例 
    — — char                            8 -2^7 ~ 2^7-1 %c
%c 、 %d 、 %u

    signed — char                    8 -2^7 ~ 2^7-1 %c
%c 、 %d 、 %u

    unsigned — char                8 0 ~ 2^8-1 %c %c 、 %d 、 %u
    [signed] short [int]            16 -2^15 ~ 2^15-1 %hd
    unsigned short [int]           16 0 ~ 2^16-1
%hu 、 %ho 、 %hx

    [signed] — int                    32 -2^31 ~ 2^31-1 %d
    unsigned — [int]                 32 0 ~ 2^32-1
%u 、 %o 、 %x

    [signed] long [int]              32 -2^31 ~ 2^31-1 %ld
    unsigned long [int]             32 0 ~ 2^32-1
%lu 、 %lo 、 %lx

    [signed] long long [int]       64 -2^63 ~ 2^63-1 %I64d
    unsigned long long [int]      64 0 ~ 2^64-1
%I64u 、 %I64o 、 %I64x

    — — float                            32 +/- 3.40282e+038
%f 、 %e 、 %g

    — — double                        64 +/- 1.79769e+308
%lf 、 %le 、 %lg %f 、 %e 、 %g

    — long double                    96 +/- 1.79769e+308
%Lf 、 %Le 、 %Lg

几乎碰说明: 

1. 注意 ! 表中之各一样推行,代表一样栽基本型。 “[]” 代表可粗略。 
    例如: char 、 signed char 、 unsigned
char 是三栽互不相同的品类; 
    int 、 short 、 long 也是三种互不相同的门类。 

  1. char/signed char/unsigned char 型数据长度也 1 字节;
        char 为来符号型,但跟 signed char 是殊之花色。 
        注意 ! 并无是拥有编译器都如此处理, char 型数据长度不肯定也 1 字节, char 也未必然也来符号型。 

3. 用 char/signed
char 转换为 int 时,会针对高符号位 1 展开扩张,从而致使运算问题。 
    所以 , 如果要处理的数被留存字节值大于 127 的状,使用 unsigned
char 较为稳妥。 
    程序中若涉各类运算,也当使 unsigned 型变量。 

  1. char/signed char/unsigned
    char 输出时,使用格式符 %c (按字符方式);  或使 %d 、 %u 、 %x/%X 、 %o ,按整数方式出口; 输入时,应使用 %c ,若用整数方式, Dev-C++ 会给来警示,不建议如此以。 

  2. int 的长短,是 16 位还是 32 位,与编译器字长有关。 
       
    16 各项编译器(如 TC 使用的编译器)下, int 为 16 位; 32 位编译器(如 VC 使用的编译器 cl.exe )下, int 为 32员。 

6. 整型数据可以以 %d (有号子 10 进制)、 %o (无符号 8 进制)或 %x/%X (无符号 16 进制)方式输入输出。 而格式符 %u ,表示 unsigned ,即无符号 10 进制方式。 

7. 整型前缀 h 表示 short , l 表示 long 。 
    输入输出 short/unsigned
short 时,不建议直接动用 int 的格式符 %d/%u 等,要加前缀 h 。这个习惯性错误,来源于 TC 。 TC 下, int 的长度以及默认符号性,都同 short 一致,于是就管当时简单种类型当成是均等之,都为此 int 方式进行输入输出。 

8. 有关 long long 类型的输入输出: 
    “%lld” 和 “%llu” 是 linux 下 gcc/g++ 用于 long long int 类型 (64
bits) 输入输出的格式符。 
    而 “%I64d” 和 “%I64u” 则是 Microsoft
VC++ 库里用来输入输出 __int64 类型的格式说明。 

    Dev-C++ 使用的编译器是 Mingw32 , Mingw32 是 x86-win32
gcc 子项目有,编译器核心还是 linux 下的 gcc 。
    进行函数参数类型检查的是以编译阶段, gcc 编译器对格式字符串进行检讨,显然她不认得 “%I64d” , 
    所以将于出警告 “unknown conversion type character `I’ in
format” 。对于 “%lld” 和 “%llu” , gcc 理所当然地承受了。 
    
   
Mingw32 在编译期间采取 gcc 的条条框框检查语法,在一连和运转时用的却是 Microsoft 库。 
    这个库里的 printf 和 scanf 函数当然不认识 linux
gcc 下 “%lld” 和 “%llu” ,但对 “%I64d” 和 “%I64u” ,它虽然是 乐意接受,并能健康干活的。 

9. 浮点型数据输入时不过利用 %f 、 %e/%E 或 %g/%G , scanf 会根据输入数据形式,自动处理。 
    输出时不过使 %f (普通方式)、 %e/%E (指数方式)或 %g/%G (自动选择)。 

10. 浮点参数压栈的条条框框: float(4 字节 ) 类型扩展成 double(8 字节 ) 入栈。 
    所以在输入时,需要区分 float(%f) 与 double(%lf) ,而于出口时,用 %f 即可。 
   
printf 函数将本 double 型的平整对压入堆栈的 float( 已扩大成 double) 和 double 型数据开展输出。 
    如果当出口时指定 %lf 格式符, gcc/mingw32 编译器将给出一个告诫。 

  1. Dev-C++(gcc/mingw32) 可以选择 float 的长度,是否和 double 一致。 

12. 前缀 L 表示 long ( double )。 
    虽然 long
double 比 double 长 4 个字节,但是代表的数值范围可是一样的。 
    long
double 类型的尺寸、精度和代表范围以及所运用的编译器、操作系统等关于。

咱见到上面有基础数据类型都是零星的,如果要是计算天文数字级的、哪怕是无比简便的相加算法,也会见导致数溢出。

比如:

描绘了单以年龄转为秒的顺序,前126年还足以,但是打127起便overflow了……

每当处理器被,当要表示的数超出计算机所运用的数目的象征范围时,则有多少的泛滥起。具体的自己网上可查看下资料,很好查

 

漫起由
数据类型超过了电脑字长的限就会现出数溢起的动静。导致内存溢出问题之缘由产生很多,比如:
(1)
使用非类型安全(non-type-safe)的语言如 C/C++ 等。
(2)
以不可靠的章程存取或者复制内存缓冲区。
(3)编译器设置的内存缓冲区太近关键数据结构。

素分析
1.内存溢出题目是 C 语言或 C++
语言所固有之弱点,它们既是不检讨数组边界,又未检查类可靠性(type-safety)。众所周知,用
C/C++
语言开发的先后由目标代码非常相近机器内核,因而能直接访问内存和寄存器,这种特性大大升级了
C/C++
语言代码的性质。只要合理编码,C/C++应用程序在执行效率及一定优于外高级语言。然而,C/C++
语言致内存溢出题目的可能性为使杀过多。其他语言也设有内存溢起题目,但它数不是程序员的错,而是应用程序的运作时环境差所给。
2.
当应用程序读取用户(也或是黑心攻击者)数据,试图复制到应用程序开辟的内存缓冲区中,却力不从心确保缓冲区的空间足够时(换言之,假要代码申请了
N 字节大小的外存缓冲区,随后以望中复制超过 N
字节的数据)。内存缓冲区就可能会见漫起。想同一相思,如果您往 12
盎司的玻璃杯中翻腾 16 盎司和,那么基本上下的 4
盎司和怎么收拾?当然会充满到玻璃杯外面了!
3.
最好根本之是,C/C++编译器开辟的内存缓冲区常常临重要之数据结构。假设有函数的库房紧接在在内存缓冲区后面时,其中保存之函数返回地址便会跟内存缓冲区相邻。此时,恶意攻击者就好于内存缓冲区复制大量数量,从而让内存缓冲区溢起并掩盖原先保存于堆栈中之函数返回地址。这样,函数的返地址便深受攻击者换成了外指定的数值;一旦函数调用完毕,就会见继续执行“函数返回地址”处之代码。非但如此,C++
的一些其他数据结构,比如 v-table
、例外事件处理程序、函数指针等,也或遭逢类似的攻击。

 

然,针对这种景象,该怎么防止数据溢起?

如出一辙、创建结构体,将溢起之多少易至外一个变量中存储;

仲、创建或者设计一个存储器,将有着巨大的数值存储在斯存储器中,算法类似于时钟算法,满小进同各类。再规划一个取出器,将易后底变量转换成为巨大的数值,边转移边算;

老三、创建数组来以个数来囤数据;

 

确定性第三种植办法简便便捷,比如我们而存储一个123(一百二十三)的数据类型,则创造一个数组int【3】,数组中每个元素对应一号数,怎么统筹得自己失去设定,在此地我们使用OC的NSMutableArray数组来测算,在这谈话一下C数组和OC数组的界别:

OC 数组是一个对象,有恢宏之主意,c 没有还待协调写

C 数组删除是亟需后面往前头挪,oc 数组自动处理

OC中之数组算是一个封装好的靶子,一般的操作基本就能够满足了,但是C里面的虽惟有是只连的内存空间而已。一个凡是目标一个空中,另外一个C里面的数组是一旦以概念的时刻将要初始化个数,但是OC里面的个数较动态。

 

立即吗便是胡涉及到算法或者比较底层的数目处理一般下C语言,第一:执行效率高;其次:算法接近初级易于理解与保障,并且大量术与函数运算规律可完全从定义。

就此OC涉及到算法极其少,一般逻辑居多。OC来开简单的演算也不是勿得以,优点在对频繁组的拍卖比较轻便,以下简述一下运算逻辑:

如出一辙:多各类数相乘,第一个数的个位依次向第二各数的每人依次相乘,个位数和只个数相就用int来运算,如果结果是只位数,那么将他放上一个array数组中;

其次:如果结果是亚各数,则存储个位数,十个数上加至进位变量中,等待下一致破相乘时与生同样糟的结果相加,然后继续展开相同步骤;

老三:将最后array数组中之要素首尾调换,因为数组元素存储方是由个位到极致高位,与需要数相反;

季:将以此数组对象存储到另外一个数组中,形成OC二维数组;

五:经过上述运算,会得一个梯形数据:

        1234

      1234

    1234

  1234

急需对二维数组中的前位数组进行补0,为下一致步方便运算做准备;

六:补0后数吧:

0001234

0012340

0123400

1234000

之后从上向下依次相加,同样的:

1.首先个数的个位依次往亚位数之每位依次相加,个位数和单号数相就以int来运算,如果结果是单位数,那么将他放上一个array数组中;

2.而结果是第二位数,则存储个位数,十号数上加到进位变量中,等待下同样不成相乘时与下一样次于的结果相加,并且实施1手续;

七:最后会得一个说到底结出的数组,同样的,里面数据结构依然和需要数相反,需要首尾调换;

八:返回这个累组,这个数组的各一个要素(从第一位从至第N位)都是者最终结出(超大数)从个位到无限高位的对应数值:

据是超大数是:1231443256827659485683297465789236578263857658265892561856138456938

那是数组的因素依次是:1、2、3、1、4、4、3、2、5、6、8、…….5、6、9、3、8

 

OC虽然好展开拍卖算法和数据类型,但是相对于C来说,它所占用的内存还是比较高的,因为这个数组所开发的内存空间远远超越相应C数组的空间,它好储存多个目标,自带各种数码处理方法,灵活多变对于C数组来说操作性很强,毕竟NSArray用于支付。

以下我拿OC超大数算法的代码贴出,仅供参考。。如产生未对望指正:

 

 

 

 

#import “Multiplication.h”

 

@implementation
Multiplication

 

-(NSString *)MulOfOneString:(NSString *)strOne
AndString:(NSString *)strTwo{

    

    NSString *a = [NSString stringWithFormat:@”%lu”,(unsigned long)strOne.length];

    NSString *b = [NSString stringWithFormat:@”%lu”,(unsigned long)strTwo.length];

    int oneLength =
[a intValue];

    int twoLength =
[b intValue];

    NSMutableArray *arrOne = [[NSMutableArray
alloc]init];

    NSMutableArray *arrTwo = [[NSMutableArray
alloc]init];

    for (int i = 0;i < oneLength;i++)
{

        unichar c = [strOne
characterAtIndex:i];

        NSString *c1 = [NSString
stringWithFormat:@”%c”,c];

        [arrOne addObject:c1];

    }

    for (int i = 0;i < twoLength;i++)
{

        unichar c = [strTwo
characterAtIndex:i];

        NSString *c1 = [NSString
stringWithFormat:@”%c”,c];

        [arrTwo addObject:c1];

    }

    NSMutableArray *arrShi = [[NSMutableArray
alloc]init];

    if (oneLength
> twoLength) {

        for (int i = twoLength – 1 ;i >= 0;i–)
{

            NSMutableString *strJ =
[[NSMutableString alloc]init];

            int jin =
0;

            int btwo
= [arrTwo[i] intValue];

            for
(int j = oneLength – 1; j >= 0;j–)
{

                int
aone = [arrOne[j] intValue];

                int c
= aone * btwo + jin;

                int z
= c%10;

                jin = c/10;

                if (j
!= 0)
{

                    [strJ appendFormat:@”%d”,z];

                }else{

                    [strJ appendFormat:@”%d”,c%10];

                    if (c/10!=0)
{

                        [strJ appendFormat:@”%d”,c/10];

                    }

                }

            }

            NSMutableString *zheng =
[[NSMutableString alloc]init];

            for
(NSInteger i = strJ.length-1
;i>=0;i–)
{

                unichar s = [strJ
characterAtIndex:i];

                [zheng appendFormat:@”%c”,s];

            }

            [arrShi addObject:zheng];

        }

    }else if(oneLength <
twoLength){

        for (int i = oneLength – 1 ;i >= 0;i–)
{

            NSMutableString *strJ =
[[NSMutableString alloc]init];int
jin = 0;

            int aone
= [arrOne[i] intValue];

            for
(int j = twoLength – 1; j >= 0;j–)
{

                int
btwo = [arrTwo[j] intValue];

                int c
= aone * btwo + jin;

                int z
= c%10;

                jin = c/10;

                if (j
!= 0)
{

                    [strJ appendFormat:@”%d”,z];

                }else{

                    [strJ appendFormat:@”%d”,c%10];

                    if (c/10!=0)
{

                        [strJ appendFormat:@”%d”,c/10];

                    }                     }

            }

            NSMutableString *zheng =
[[NSMutableString alloc]init];

            for
(NSInteger i = strJ.length-1
;i>=0;i–)
{

                unichar s = [strJ
characterAtIndex:i];

                [zheng appendFormat:@”%c”,s];

            }

            [arrShi addObject:zheng];

        }

    }else if (oneLength ==
twoLength){

        for (int i = oneLength – 1 ;i >= 0;i–)
{

            NSMutableString *strJ =
[[NSMutableString alloc]init];int
jin = 0;

            int aone
= [arrOne[i] intValue];

            for
(int j = twoLength – 1; j >= 0;j–)
{

                int
btwo = [arrTwo[j] intValue];

                int c
= aone * btwo + jin;

                int z
= c%10;

                jin = c/10;

                if (j
!= 0)
{

                    [strJ appendFormat:@”%d”,z];

                }else{

                    [strJ appendFormat:@”%d”,c%10];

                    if (c/10!=0)
{

                        [strJ appendFormat:@”%d”,c/10];

                    }

                }

            }

            NSMutableString *zheng =
[[NSMutableString alloc]init];

            for
(NSInteger i = strJ.length-1
;i>=0;i–)
{

                unichar s = [strJ
characterAtIndex:i];

                [zheng appendFormat:@”%c”,s];

            }

            [arrShi addObject:zheng];

        }

    }

    NSMutableArray *arrBF = [[NSMutableArray
alloc]init];

    if (arrShi.count
== 1)
{

        NSString *res = arrShi[0];

        return
res;

    }else{

        for (int i = 0;i<arrShi.count;i++)
{

            NSMutableString *str0 =
arrShi[i];

            for
(int j = 1;j<=i;j++)
{

                [str0 appendFormat:@”0″];

            }

            arrBF[i] = str0;

        }

        for (int i =1;i<arrBF.count;i++)
{

            int J =
0;

            NSMutableString *strConst =
[[NSMutableString alloc]init];

            NSString *strC = arrBF[i-1];

            NSString *strB = arrBF[i];

            if
(strC.length == strB.length) {

                for
(NSInteger j = strB.length-1 ;j >=
0;j–)
{

                    unichar b = [strB
characterAtIndex:j];

                    unichar c = [strC
characterAtIndex:j];

                    int B = [[NSString stringWithFormat:@”%c”,b]
intValue];

                    int C = [[NSString stringWithFormat:@”%c”,c]
intValue];

                    int counst = B + C + J;

                    int z = counst %10;

                    J = counst /10;

                    if (j != 0)
{

                        [strConst appendFormat:@”%d”,z];

                    }else{

                        [strConst appendFormat:@”%d”,counst %10];

                        if (counst /10!=0)
{

                            [strConst
appendFormat:@”%d”,counst /10];

                        }

                    }

                }

                NSMutableString *Lin =
[[NSMutableString alloc]init];

                for
(NSInteger i = strConst.length-1
;i>=0;i–)
{

                    unichar s = [strConst
characterAtIndex:i];

                    [Lin appendFormat:@”%c”,s];

                }

                arrBF[i] = Lin;

            }else{

                NSUInteger a = strC.length;

                for
(NSInteger j = strB.length-1 ;j >=
0;j–)
{

                    unichar b = [strB
characterAtIndex:j];

                    unichar c = [strC
characterAtIndex:a-1];

                    int B = [[NSString stringWithFormat:@”%c”,b]
intValue];

                    int C = [[NSString stringWithFormat:@”%c”,c]
intValue];

                    a–;

                    int counst = B + C + J;

                    int z = counst %10;

                    J = counst /10;

                    if (j != 0)
{

                        [strConst appendFormat:@”%d”,z];

                    }else{

                        [strConst appendFormat:@”%d”,counst %10];

                        if (counst /10!=0)
{

                            [strConst
appendFormat:@”%d”,counst /10];

                        }

                    }

                }

                NSMutableString *Lin =
[[NSMutableString alloc]init];

                for
(NSInteger i = strConst.length-1
;i>=0;i–)
{

                    unichar s = [strConst
characterAtIndex:i];

                    [Lin appendFormat:@”%c”,s];

                }

                arrBF[i] = Lin;

            }

        }

        NSString *res = arrBF[arrBF.count-1];

        return
res;

    }

    return @”输入有误”;

}

 

 

@end

 

 

 

超大数相加算法思路与相乘算法后半段落思路相似,相对简单多

 

以下是超大数相加算法的代码:

 

 

#import “Addition.h”

 

@implementation Addition

 

  • (NSString *)additionOfString:(NSString *)strOne
    AndString:(NSString *)strTwo{

    

    NSMutableString *One = [NSMutableString
stringWithFormat:@”%@”,strOne
];

    NSMutableString *Two = [NSMutableString
stringWithFormat:@”%@”,strTwo
];

    

    if (One.length
> Two.length) {

        NSInteger t = One.length – Two.length;

        for
(NSInteger i = 0;i < t;i++)
{

            [Two insertString:[NSString
stringWithFormat:@”0″] atIndex:0];

        }

        int jin =
0;

        NSMutableString *strJ = [[NSMutableString
alloc]init];

        for
(NSInteger i = One.length -1 ; i >=
0 ;i–)
{

            unichar onenum = [One
characterAtIndex:i];

            unichar twonum = [Two
characterAtIndex:i];

            int onum
= [[NSString stringWithFormat:@”%c”,onenum] intValue];

            int tnum
= [[NSString stringWithFormat:@”%c”,twonum] intValue];

            int c =
onum + tnum +jin;

            int z =
c%10;

            jin = c/10;

            if (i
!=0 )
{

                [strJ appendFormat:@”%d”,z];

            }else{

                [strJ appendFormat:@”%d”,c%10];

                if
(c/10 != 0) {

                    [strJ appendFormat:@”%d”,c/10];

                }

            }

        }

        NSMutableString *zheng = [[NSMutableString
alloc]init];

        for
(NSInteger i = strJ.length-1;
i>=0;i–)
{

            unichar k = [strJ
characterAtIndex:i];

            [zheng appendFormat:@”%c”,k];

        }

        return
zheng;

    }else if(One.length <
Two.length){

        NSInteger t = Two.length – One.length;

        for
(NSInteger i = 0;i < t;i++)
{

            [One insertString:[NSString
stringWithFormat:@”0″] atIndex:0];

        }

        int jin =
0;

        NSMutableString *strJ = [[NSMutableString
alloc]init];

        for
(NSInteger i = Two.length – 1; i >=
0 ;i–)
{

            unichar onenum = [One
characterAtIndex:i];

            unichar twonum = [Two
characterAtIndex:i];

            int onum
= [[NSString stringWithFormat:@”%c”,onenum] intValue];

            int tnum
= [[NSString stringWithFormat:@”%c”,twonum] intValue];

            int c =
onum + tnum +jin;

            int z =
c%10;

            jin = c/10;

            if (i
!=0 )
{

                [strJ appendFormat:@”%d”,z];

            }else{

                [strJ appendFormat:@”%d”,c%10];

                if
(c/10 != 0) {

                    [strJ appendFormat:@”%d”,c/10];

                }

            }

        }

        NSMutableString *zheng = [[NSMutableString
alloc]init];

        for
(NSInteger i = strJ.length-1;
i>=0;i–)
{

            unichar k = [strJ
characterAtIndex:i];

            [zheng appendFormat:@”%c”,k];

        }

        return
zheng;

    }else if(One.length ==
Two.length){

        int jin =
0;

        NSMutableString *strJ = [[NSMutableString
alloc]init];

        for
(NSInteger i = One.length – 1; i >=
0 ;i–)
{

            unichar onenum = [One
characterAtIndex:i];

            unichar twonum = [Two
characterAtIndex:i];

            int onum
= [[NSString stringWithFormat:@”%c”,onenum] intValue];

            int tnum
= [[NSString stringWithFormat:@”%c”,twonum] intValue];

            int c =
onum + tnum +jin;

            int z =
c%10;

            jin = c/10;

            if (i
!=0 )
{

                [strJ appendFormat:@”%d”,z];

            }else{

                [strJ appendFormat:@”%d”,c%10];

                if
(c/10 != 0) {

                    [strJ appendFormat:@”%d”,c/10];

                }

            }

        }

        NSMutableString *zheng = [[NSMutableString
alloc]init];

        for
(NSInteger i = strJ.length-1;
i>=0;i–)
{

            unichar k = [strJ
characterAtIndex:i];

            [zheng appendFormat:@”%c”,k];

        }

        return
zheng;

    }

  

    return @”您的输入有无意!”;

}

 

 

 

 

@end

 

 

 

 

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图