精华内容
下载资源
问答
  • 32系统sizeof(int)=4,也就是32二进制,内存中是以32二进制补码形式存放这个数的,int为符号,最前面一数字是符号,0表示正数,1表示负数。 也就是31存储这个数的大小。 正数补码就是他...

    应该也是我们班的,比我学的好多了啊!!!

     

    32位系统sizeof(int)=4,也就是有32位二进制数,内存中是以32位二进制补码的形式存放这个数的,int为有符号数,最前面一个数字是符号位,0表示正数,1表示负数。

    也就是31位存储这个数的大小。

    正数的补码就是他的原码本身,也就是num%2  ,余数倒叙排列,不够32位的前面补0,

    例如,

    00000000 00000000 00000000 00000001   表示1,

    00000000 00000000 00000011 00000000   表示的是2的9次方+2的8次方=768。

    最大int 

    01111111 11111111 11111111 11111111   表示2的31次方-1=2147483647

    负数的补码是他对应正数的原码的反码,再+1得到的。

    如-1,对应的1的原码 

    00000000 00000000 00000000 00000001

    1的反码    

    11111111 11111111 11111111 11111110

    反码加1为           

    11111111 11111111 11111111 11111111   这也就是内存中-1的存储方式。

    int表示的最大正整数2147483647对应的负数-2147483647的二进制为

    2147483647原码        

    01111111 11111111 11111111 11111111

     反码    

    10000000 00000000 00000000 00000000

    反码+1       

    10000000 00000000 00000000 00000001

    那么int表示的最小的负数也就是 

    10000000 00000000 00000000 00000000  也就是 -2147483648

    知道原理了如何打印一个数的32位二进制码呢?

    1,先用原始的取余倒序排列,设要打印的数位num,

    对于正数,num%2的值也就是第32位,(num/2)%2取余也就是第31位,((num/2)/2)%2也就是第30位……

    定义一个有32个元素的数组a[32]来存放余数,用一个for循环来将余数赋给数组,

    for (i=0;i<32;i++ )

    {

    a[i]=num%2;

    num/=2;

    }

    a[0]存放第32位,a[1]存放第31位 ,  a[2]存放第30位……   打印只要用下面语句倒序打印数组a,就可以了。a[31]a[30].......a[1]a[0]

    for (j=31;j>=0;j--)

    printf ( "%d",a[j] );

    对于负数,他的存储方式也可以看做是,对应正数减去1之后的反码,如-1对应的正数1 减去1也就是0,

    0的原码 

    00000000 00000000 00000000 00000000

       反码    

    11111111 11111111 11111111 11111111  也就是-1的存储方式

    if(num<0)

    {

    num = -num-1;

    for (i=31;i>=0;i-- )

    {

    a[i]=num%2;

    num/=2;

    }

    }

    这里我改变了一下赋值顺序,先将正整数第32位赋给a[31]……也就是a[0]存放第一位,打印的时候顺序打印数组就可以了(对于正数)。我们最终是要打印负数的二进制表示,所以还要取反,可以用下面的语句。

    for (j=0;j<32;j++)

    b[i] = (a[i]+1)%2;

    那么,顺序打印数组b就可以了。

    以下是这种方法的实验图:




    2 用位操作打印。

    用位的左移右移,我们可以将其他位都置0,

    如  10100000 00001100 00000000 00000000我们左移2位再右移31位,就可以直接得到

          00000000 00000000 00000000 00000001       也就是上面的第2个1移到了最后一位,可以得到第30位的值

    每一位都如此操作,我们就可以得到每一位的值0或1,依次打印即可。

     但是对于一个有符号的数,位的操作会使符号一起移动,但是如果符号位为1,你右移之后,符号位会自动补1,

    如10000000 00001111 11110000 00001111  ,我们为了得到第1位的1,直接右移31位,我们预想的结果是

        00000000 00000000 00000000 00000001 ,但实际上,由于符号位为1,每次右移符号位都会自动补1,右移1位

        11000000 00000000 00000000 00000000,右移31位之后会变成

        11111111 11111111 11111111 11111111。

    为了得到想要的结果,我们可以把int赋值给一个unsigned int,这样,就可以用这个方法了。



    可以看到,我用了3种位操作的方法来打印,第3种是我上面讲的,

    第2种也是转换为无符号数,进行了一次位操作;

    第1种是在不转换为无符号数的情况下,进行位操作打印。结果都是正确的。


    展开全文
  • 将两位十进制相减,要求被减数,减数均以 ASCII码形式按顺序存放在以DATA1和DATA2为首5内存单元中(低位在前),结果送回DATA1处。 1.这程序就是实现两位数相减功能,经过查阅资料分析得到,两种...

    将两个多位十进制数相减,要求被减数,减数均以 ASCII码形式按顺序存放在以DATA1和DATA2为首的5个内存单元中(低位在前),结果送回DATA1处。
    1.这个程序就是实现两个多位数相减功能,经过查阅资料分析得到,有两种方法有一位位相减和合成一个整体后再相减。一位位相减要利用sbb带借位的减法实现功能,这样计算得到的结果就是正确的了。其次这种方法,要进行分类讨论,比较被减数和减数的大小才能得到正确的结果。如果减数比被减数大的话要先显示一个负号,再输出结果。
    2.合成一个整体麻烦的难点在于要合成一个数,利用汇编语言合成一个数的思路其实是很类似的,只要学会一个其余都问题不大了。
    我写了三种,第一种最简单,无符号数,不输入。

    DATAS SEGMENT
        ;此处输入数据段代码 
        A db 4 dup(?)
        length_A equ $-A
        B db 4 dup(?)
        buf1 db '-','$'
        buf2 db '=','$'
        buf3 db 'Please input two number:',0dh,0ah,'$'
        buf4 db 'A=','$'
        buf5 db 'B=','$'
    DATAS ENDS
    
    STACKS SEGMENT
        ;此处输入堆栈段代码
        dw 50 dup(?)
        top label byte
    STACKS ENDS
    
    CODES SEGMENT
        ASSUME CS:CODES,DS:DATAS,SS:STACKS
    START:
    	mov ax,stacks
    	mov ss,ax
    	mov sp,offset top
        MOV AX,DATAS
        MOV DS,AX
        ;此处输入代码段代码
        ;A部分
    	;显示A中的数据
    	lea dx,buf4
    	mov ah,09h
    	int 21h
    	mov cx,length_A
    	lea si,A
    	call input
    	call hui_che
    	lea dx,buf5
    	mov ah,09h
    	int 21h
    	mov cx,length_A
    	
    	lea si,B
    	call input
    	call hui_che
    	mov cx,length_A
    	lea di,A
    	
    Loop_show_A:
    	mov al,[di]
    	call show_ascii
    	inc di
    	loop Loop_show_A
    	lea dx,buf1
    	mov ah,09h
    	int 21h
    	;B部分
    	;显示B中的数据
    	mov cx,length_A
    	lea di,B
    	
    Loop_show_B:
    	mov al,[di]
    	call show_ascii
    	inc di
    	loop Loop_show_B
    	lea dx,buf2
    	mov ah,09h
    	int 21h
    	
    	;减法运算部分
    	mov si,offset A
    	mov di,offset B	
    	mov cx,length_A
    compare:;比较a和b哪一个数据更大
    	mov al,[si]
    	cmp al,[di]
    	ja a_b;大于的话直接比较
    	jb b_a;小于的话b-a
    	je keep_compare;继续比较下一位
    keep_compare:
    	dec cx
    	inc si
    	inc di
    	jmp compare
    b_a:
    	mov dl,'-';显示负号
    	mov ah,02h
    	int 21h
    	;应该是b-a
    	call sub_B_A
    	mov si,offset A
    	mov cx,length_A
    	jmp Loop_show_result
    a_b:
    	call sub_A_B
    	mov si,offset A
    	mov cx,length_A	
    	
    Loop_show_result:
    	mov al,[si]
    	call show_ascii
    	inc si
    	loop Loop_show_result
    	;结束部分
    	jmp end_pro
    	
    input proc near
    input_loop:
    	mov ah,01h
    	int 21h
    	mov [si],al
    	inc si
    	loop input_loop
    exit:
    	ret
    input endp
    	
    show_ascii proc near;显示ascii码
    	mov dl,al
    	mov ah,02h
    	int 21h
    	ret
    show_ascii endp	
    
    sub_A_B proc near
    	mov bx,length_A
    su1:
    	sub byte ptr[si+bx-1],30h;最后一位数据,转换为十进制
    	sub byte ptr[di+bx-1],30h
    	dec bx
    	jnz su1
    	mov si,offset A
    	add si,length_A-1
    	mov di,offset B	
    	add di,length_A-1
    	mov cx,length_A;包括进位一共有位数
    	clc
    su2:
    	mov al,[si]
    	mov bl,[di]
    	sbb al,bl;带借位相减
    	aas;非压缩BCD码格式的调整
    	mov [si],al;结果被送到di作为被减数被减数区域
    	dec si
    	dec di;指向下一位
    	loop su2;循环
    	mov bx,length_A
    	mov si,offset A
    	mov di,offset B	
    su3:
    	add byte ptr [si+bx-1],30h
    	;add byte ptr [di+bx-1],30h
    	dec bx
    	jnz su3
    	ret
    sub_A_B endp
    
    sub_B_A proc near
    	mov bx,length_A
    su1:
    	sub byte ptr[si+bx-1],30h;最后一位数据,转换为十进制
    	sub byte ptr[di+bx-1],30h
    	dec bx
    	jnz su1
    	mov si,offset B
    	add si,length_A-1
    	mov di,offset A	
    	add di,length_A-1
    	mov cx,length_A;包括进位一共有位数
    	clc
    su2:
    	mov al,[si]
    	mov bl,[di]
    	sbb al,bl;带借位相减
    	aas;非压缩BCD码格式的调整
    	mov [di],al;结果被送到被减数区域
    	dec si
    	dec di;指向下一位
    	loop su2;循环
    	mov bx,length_A
    	mov si,offset B
    	mov di,offset A	
    su3:
    	add byte ptr [di+bx-1],30h
    	;add byte ptr [di+bx-1],30h
    	dec bx
    	jnz su3
    	ret
    sub_B_A endp
    
    hui_che proc near
    	mov dl,0ah
    	mov ah,02h
    	int 21h
    	ret
    hui_che endp
    
    end_pro:
        MOV AH,4CH
        INT 21H
    CODES ENDS
        END START
    

    在这里插入图片描述
    第二种和第一种唯一的区别是加入了输入:

    DATAS SEGMENT
        ;此处输入数据段代码 
        A db 33h,38h,39h,36h;3896
        length_A equ $-A
        B db 31h,32h,33h,35h;1235
        buf1 db '-','$'
        buf2 db '=','$'
    DATAS ENDS
    
    STACKS SEGMENT
        ;此处输入堆栈段代码
        dw 50 dup(?)
        top label byte
    STACKS ENDS
    
    CODES SEGMENT
        ASSUME CS:CODES,DS:DATAS,SS:STACKS
    START:
    	mov ax,stacks
    	mov ss,ax
    	mov sp,offset top
        MOV AX,DATAS
        MOV DS,AX
        ;此处输入代码段代码
        ;A部分
    	;显示A中的数据
    	mov cx,length_A
    	lea di,A
    	
    Loop_show_A:
    	mov al,[di]
    	call show_ascii
    	inc di
    	loop Loop_show_A
    	lea dx,buf1
    	mov ah,09h
    	int 21h
    	;B部分
    	;显示B中的数据
    	mov cx,length_A
    	lea di,B
    	
    Loop_show_B:
    	mov al,[di]
    	call show_ascii
    	inc di
    	loop Loop_show_B
    	lea dx,buf2
    	mov ah,09h
    	int 21h
    	
    	;减法运算部分
    	mov si,offset A
    	mov di,offset B	
    	mov cx,length_A
    compare:;比较a和b哪一个数据更大
    	mov al,[si]
    	cmp al,[di]
    	jg a_b;大于的话直接比较
    	jb b_a;小于的话b-a
    	je keep_compare;继续比较下一位
    keep_compare:
    	dec cx
    	inc si
    	inc di
    	jmp compare
    b_a:
    	mov dl,'-';显示负号
    	mov ah,02h
    	int 21h
    	;应该是b-a
    	call sub_B_A
    	mov si,offset A
    	mov cx,length_A
    	jmp Loop_show_result
    a_b:
    	call sub_A_B
    	mov si,offset A
    	mov cx,length_A	
    	
    Loop_show_result:
    	mov al,[si]
    	call show_ascii
    	inc si
    	loop Loop_show_result
    	;结束部分
    	jmp end_pro
    	
    show_ascii proc near;显示ascii码
    	mov dl,al
    	mov ah,02h
    	int 21h
    	ret
    show_ascii endp	
    
    sub_A_B proc near
    	mov bx,length_A
    su1:
    	sub byte ptr[si+bx-1],30h;最后一位数据,转换为十进制
    	sub byte ptr[di+bx-1],30h
    	dec bx
    	jnz su1
    	mov si,offset A
    	add si,length_A-1
    	mov di,offset B	
    	add di,length_A-1
    	mov cx,length_A;包括进位一共有位数
    	clc
    su2:
    	mov al,[si]
    	mov bl,[di]
    	sbb al,bl;带借位相减
    	aas;非压缩BCD码格式的调整
    	mov [si],al;结果被送到di作为被减数被减数区域
    	dec si
    	dec di;指向下一位
    	loop su2;循环
    	mov bx,length_A
    	mov si,offset A
    	mov di,offset B	
    su3:
    	add byte ptr [si+bx-1],30h
    	;add byte ptr [di+bx-1],30h
    	dec bx
    	jnz su3
    	ret
    sub_A_B endp
    
    sub_B_A proc near
    	mov bx,length_A
    su1:
    	sub byte ptr[si+bx-1],30h;最后一位数据,转换为十进制
    	sub byte ptr[di+bx-1],30h
    	dec bx
    	jnz su1
    	mov si,offset B
    	add si,length_A-1
    	mov di,offset A	
    	add di,length_A-1
    	mov cx,length_A;包括进位一共有位数
    	clc
    su2:
    	mov al,[si]
    	mov bl,[di]
    	sbb al,bl;带借位相减
    	aas;非压缩BCD码格式的调整
    	mov [di],al;结果被送到被减数区域
    	dec si
    	dec di;指向下一位
    	loop su2;循环
    	mov bx,length_A
    	mov si,offset B
    	mov di,offset A	
    su3:
    	add byte ptr [di+bx-1],30h
    	;add byte ptr [di+bx-1],30h
    	dec bx
    	jnz su3
    	ret
    sub_B_A endp
    
    
    end_pro:
        MOV AH,4CH
        INT 21H
    CODES ENDS
        END START
    

    在这里插入图片描述
    最后一种是加入了对于有符号数的处理,可以输入并且输出有符号数,直接将减数和被减数相减即可。

    DATAS SEGMENT
        ;此处输入数据段代码 
       	buf dw 2 dup(?)
       	tmp db 10 dup(?)
        buf1 db '-','$'
        buf2 db '=','$'
        buf3 db 'Please input two number:',0dh,0ah,'$'
        buf4 db 'A=','$'
        buf5 db 'B=','$'
        buf6 db 0ah,'The character is out of range, Try again:',0dh,0ah,'$'
    DATAS ENDS
    
    STACKS SEGMENT
        ;此处输入堆栈段代码
        dw 50 dup(?)
        top label byte
    STACKS ENDS
    
    CODES SEGMENT
        ASSUME CS:CODES,DS:DATAS,SS:STACKS
    START:
    	mov ax,stacks
    	mov ss,ax
    	mov sp,offset top
        MOV AX,DATAS
        MOV DS,AX
        ;此处输入代码段代码
        ;A部分
    	;显示A中的数据
    	lea dx,buf4
    	mov ah,09h
    	int 21h
    	mov si,0;si作为下标
        call prepare_input
    	call input
    	add si,02h
    	lea dx,buf5
    	mov ah,09h
    	int 21h
    	call prepare_input
    	call input
    	;显示计算数据
    	mov si,0
    	mov ax,buf[si]
    	add si,02h
    	call show_ascii
    	mov dl,'-'
    	mov ah,02h
    	int 21h
    	mov ax,buf[si]
    	call show_ascii
    	mov dl,'='
    	mov ah,02h
    	int 21h
    	;减法运算部分
    	mov si,0
    	mov ax,buf[si]
    	add si,02h
    	mov dx,buf[si]
    	sub ax,dx
    	call show_ascii
    	jmp end_pro
    	
    prepare_input proc near
    	mov bx,10
    	mov bp,0
    	mov dx,0
    	ret
    prepare_input endp
    
    input proc near
    	push cx
    get_char:
    	mov ah,01h
    	int 21h
    	cmp al,'-';判断是否为负数
    	jz nagetive
    	cmp al,0dh;判断是否为回车
    	jz process_1
    	cmp al,' ';判断是否为空格
    	jz process_1
    	cmp al,30h
    	jl mistake
    	cmp al,39h;大于9
    	ja judge1
    	jmp process_2
    judge1:
    	cmp al,41h;表示在39<x<41的数
    	jb mistake
    	cmp al,80h;表示>46即超过F的数
    	ja mistake
    	jmp process_2
    mistake:
    	mov dx,offset buf6
        mov ah,9h
        int 21h 
        jmp get_char
    nagetive:
    	mov bp,1;bp作为符号位
    	jmp get_char
    process_2:
    	push ax;
    	mov ax,dx
    	mul bx;乘以10,以十进制存储
    	mov dx,ax;数据保存在dx中
    	pop ax
    	sub al,30h
    	mov ah,0
    	add dx,ax
    	jmp get_char
    process_1:
    	cmp bp,1
    	jnz save
    	neg dx;取负命令0-原数据
    save:
    	mov buf[si],dx;将处理好的数据存入num中去
    	mov bp,0;bp位清零	
    	mov dl,0dh;回车换行重新输入
    	mov ah,2
    	int 21h
    	mov dl,0ah
    	int 21h
    exit:
    	pop cx
    	ret
    input endp
    
    show_ascii proc near
    	test ax,1000h;与命令
    	jz pre_show;不是负数
    	push ax
    	mov dl,'-';是负数的情况,先显示负号
    	mov ah,02h
    	int 21h
    	pop ax
    	neg ax
    pre_show:
    	mov di,0
    	mov dx,0
    	mov bx,10
    mid_show:
    	div bx;十六进制转十进制
    	add dl,30h;余数部分作为结果
    	mov tmp[di],dl
    	inc di
    	cmp ax,0;判断商是否为0,是则表示转换完成
    	jz last_show
    	mov dx,0;余数部分清零
    	jmp mid_show
    last_show:
    	mov dl,tmp[di-1];dl为待输出字符的ascii码
    	mov ah,2
    	int 21h
    	dec di
    	jnz last_show
    	ret
    show_ascii endp
    
    end_pro:
        MOV AH,4CH
        INT 21H
    CODES ENDS
        END START
    

    在这里插入图片描述
    用汇编实现一个简单的多位数相减起始挺复杂的,第一种方法的缺点在于,首先减数和被减数的位数要相同,优点在于不用受位数的限制可以输入任意多位而不会发生溢出。方法二的缺点在于输入位数不能超过有符号数的范围,优点相减结果不需要讨论,可以直接输出结果。这个程序也是在一步步的改进中更加完善,起始功能是很简单的,后来增加了输入输出,后面发现没有对有符号数的处理,同样后面也改进了。我默认是输入4位数,后续可以改进的功能是输入任意多位数,以及输入保护。

    展开全文
  • 世界真 一下午就耗在这个数位DP上了 全怪原来讲时候没有认真听。。 然后稍微研究了一下,起上一道水题稍微一点进阶了吧? 大概,,, ... + A2 * 2 + A1 * 1,Ai是进制数位,然后

    这里写图片描述
    世界真的很大
    一下午就耗在这个数位DP上了
    全怪原来讲的时候没有认真听。。
    然后稍微研究了一下,比起上一道水题稍微有一点进阶了吧?
    大概,,,
    这道题涉及的是关乎于记忆化数组状态的设计,为了方便储存答案

    看题先:

    description:

    题目给了个f(x)的定义:F(x) = An * 2n-1 + An-1 * 2n-2 + ... + A2 * 2 + A1 * 1,Ai是十进制数位,然后给出a,b求区间[0,b]内满足f(i)<=f(a)的i的个数。

    input:

    The first line has a number T (T <= 10000) , indicating the number of test cases. 
    For each test case, there are two numbers A and B (0 <= A,B < 10 9)

    output:

    For every case,you should output " Case #t: " at first, without quotes. The t is the case number starting from 1. Then output the answer.

    这道题算是略微的进阶了一点吧
    f(a)是给出的,需要计算的就是小于b的满足f(i)小于等于f(a)的数的个数
    由于基于f数组的定义就和数位有关,我们就考虑用数位dp来搜索答案
    那么由于数位DP是从高位DP到低位的,而到了最后一位判断满不满足条件的关键就是通过按位搜索得到的f值小不小于f(a)
    那么DFS需要保存的状态就是当前数位,有无限制,和前几位的f值

    本来是没问题的,但是如果我们想要优化的话,就是考虑把memset放在多组数据的外面的话,就要求dp数组保存的一定是数自己的性质,而保存前几位的tot值,这显然根据每组数据b值的不同的答案是不同的

    考虑想要把状态映射在数自己身上
    那么如果当前的数位是pos,前几位的f值是sum。的时候,不管a值如何变化,怎样才能表示出后继状态呢?
    DFS的本质是从前往后找,当记忆化之后,如果当前状态已经找过就直接返回,就是说,记忆化记录的其实是后几位的状态
    而这道题是因为f值是从前几位推得的,所以没法作为”后几位“的状态来记忆化保存

    考虑怎么把前几位的答案映射到后几位上去,当然就是保存后几位能得到的答案,就是后几位能凑出的数

    f[i][j] 表示当前数位第i位,后i位凑出j的方案数
    这就是后几位的答案,也就是数本身的答案了

    可以memset外放优化

    完整代码:

    #include<stdio.h>
    #include<cstring>
    using namespace std;
    
    int T,tot,a[20],f[20][5050];
    
    int dfs(int pos,int ste,int lim)
    {
        int ans=0;
        if(pos==-1) return ste<=tot;
        if(ste>tot) return 0; 
        if(!lim && f[pos][tot-ste]!=-1) return f[pos][tot-ste];
        int up= lim ? a[pos] : 9;
        for(int i=0;i<=up;i++)
            ans+=dfs(pos-1,ste+i*(1<<pos),lim && i==a[pos]);
        if(!lim) f[pos][tot-ste]=ans;
        return ans;
    }
    
    int F(int n)
    {
        int cnt=0,bns=0,cns=1;
        while(n)
        {
            bns+=cns*(n%10);
            n/=10;
            cns*=2;
        }
        return bns;
    }
    
    int solve(int n)
    {
        int cnt=0;
        memset(a,0,sizeof(a));
        while(n)
        {
            a[cnt++]=n%10;
            n/=10;
        }
        return dfs(cnt-1,0,1);
    }
    
    int main()
    {
        scanf("%d",&T);
        memset(f,-1,sizeof(f));
        for(int e=1;e<=T;e++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            tot=F(a);
            printf("Case #%d: %d\n",e,solve(b));
        }
        return 0;
    }
    /*
    Whoso pulleth out this sword from this stone and anvil is duly born King of all England
    */

    嗯,就是这样

    展开全文
  • 例如:当Q0~Q3输出个位的BCD码时,DS1端输出低电平;当Q0~Q3输出十位的BCD码时,DS2端输出低电平;当Q0~Q3输出百位BCD码时,DS3端输出低电平时,周而复始、循环不止。 图3-5 CD4553芯片引脚图 表3-1 CD4553...
  • 计算机里二进制运算,往往比十进制运算来的快。 首先了解下转换规则(相互转换): 转码之前,一些名词概念: 1、原码 一正数,按照绝对值大小转换成二进制,称为原码 2、反码 将二进制取反,所得...

    要讲java一些奇奇怪怪的运算符号之前,必须先了解二进制,因为这些看不懂的运算符都是基于二进制运算的

    计算机里二进制的运算,往往比十进制运算来的快。
    首先了解下转换规则(相互转换):

    转码之前,有一些名词概念:

    1、原码
    一个正数,按照绝对值大小转换成二进制数,称为原码
    2、反码
    将二进制数按位取反,所得的新二进制数称为原二进制数的反码
    其实就是把原码中的0变为1,1变为0
    例如:0000 0101 和1111 1010就是互为反码
    3、补码
    在反码的基础上加1称为补码,一般在算负数的时候会用到

    十进制转二进制:

    1、正整数转换二进制


    2、负整数转换二进制


    3、小数转换二进制


    重点掌握前面两个:
    1、正整数转换二进制
    除二取余,然后倒序排列,高位补零。

    如下图:三步操作(字丑勿喷)

    2、负整数转换二进制
      先将对应的正整数转换成二进制
      对二进制取反,这边有个不一样的地方,原来那个正数的补位都是0,但是你取反了,那就证明负数补位的时候,要补1
      然后对结果再加1(这里的1,是十进制的1,但是十进制的1对应的二进制就是00000001)

      如下图:

    3、小数转化二进制
      先对小数部分*2,乘到小数部分为0
      然后再对整数部分计算

      最后合起来
      如下图:
      

    二进制转十进制:

    这里会有两种情况,有符号数,和无符号数
    1、无符号数的话就是直接转换成正整数

    如下图:

    2、有符号数的话,就把第一个数字看成符号,1就是负数,0就是正数
      1)如果是正数,那就是第一位不用做计算,把后面的7位拿起来计算,
      比如0111 1111 结果就是127
      2)如果是负数,那算法就是先对结果(这个结果是补码)减1获得反码,然后取反(获得原码),然后计算,跟负十进制的数转换成二进制的数的操作是相反的
      比如1111 1111,结果就是-1
      转换过程:1111 1111 -1 = 1111 1110
    取反:1111 1110 =》 0000 0001

    转换:1*2的0次方=1,那因为我们一开始就定义它为负数,所以就是-1


    ======================================华丽的分割线============================================

    明白了上面的相互转换之后
    就开始来理解java中一些奇特的符号:

    1、&(按位与)


    2、|(按位或)


    3、^(按位异或)


    4、~ (按位取反)


    5、>> (右移运算符)


    6、<< (左移运算符)


    这些就是java中对二进制数字的计算,别的语言应该还有些其他的符号

    本人水平有限所以。。。。


    1、& 与
    规则:先将两个数字转换为二进制,然后每一位进行匹配
         只有当两个位置上都是1的时候,才会返回1
    例子:9&12
    9:1001
    12:1100
    所以结果应该是:1000=》转换为十进制:8
    这个符号也有个例子,在Hadoop的MapReduce中默认实现的HashPartitioner类中的分区方法
    public int getPartition(K2 key, V2 value, int numReduceTasks) {  
    return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;  

    就是使用这个符号。


    2、| 或
    规则:先将两个数字转换为二进制,然后每一位进行匹配
     两个位只要有一个为1,那么结果就是1,否则就为0。
    例子:9|12
    9:1001
    12:1100

    所以结果应该是:1101=》转换为十进制:13


    3、^ 异或
    规则:先将两个数字转换为二进制,然后每一位进行匹配
    两个操作数的位,相同则结果为0,不同则结果为1。
    0 ^ 1 =1,1 ^ 1 = 0,0 ^ 0 = 0,1 ^ 0 = 1
    例子:9^12
    9:1001
    12:1100

    所以结果应该是:0101=》转换为十进制:5


    4、~ 取反
    规则:这个是对一个数字的操作
     先将这个数字转换为二进制
     然后每个位上的数字,0变成1,1变成0
    例子:~9
    9:1001
    ~9:0110
    所以结果应该是0110=》转换为十进制:6
    呵呵,你自己试试,答案是错的。。不是6,答案是-10
    为什么?
    先说一个概念int类型是4字节,1字节是8位,所以int类型有32位
    然后,9的值是1001,其实你全部写出来应该是0000 0000 000...(前面有28个0)然后1001
    所以对9取反,不能简单的写成0110,因为0110代表的是0000 0000 000...(前面有28个0)然后0110
    ~9:1111 1111 1111 1111 1111 1111 1111 0110
    接着你可以在代码中试试:
    String i = Integer.toBinaryString(-10);
    System.out.println(i);
    System.out.println(i.length());
    打印出来的就是:
    11111111111111111111111111110110
    32
    结论:所以这里就要说到,在上文中提到的二进制的有符号数和无符号数
    再重新阐述一次:简单来说,例如byte长度是8位,无符号数的情况下,1111 1111 =》255

    有符号数的情况下,因为最高位1代表负号,0代表正号,所以 0111 1111 =》127,所以1000 0000 =》-128

    所以你还记得byte类型能表示的长度是-128---127吗,就是这个原因
    那么在java中几乎所有的正数取反,会得到负数,负数取反会得到正数!
    比如1000 0001 这个二进制的有符号数,他代表的值就是-127
    所以这是取反操作的一个坑,也是不少网络给出的什么二进制转换器输入1000 0000得到的值为128的原因(因为他识别成无符号二进制数字)
    如果你还不太懂,而且又想继续了解的话:http://www.cnblogs.com/ASPNET2008/archive/2009/04/29/1446471.html

    这篇别人的文章,应该可以帮到你,作者我也不知道是谁(因为他也是转载的),如对原作者有所冒犯,实在抱歉,请给我留言,我标注作者!!


    5、>> (右移运算符)和<< (左移运算符)
    这两个东西,放在一起记录,是因为这两个操作是一样的,就是一个位移操作
    1、举例1、12>>2
    操作:
    先将12转换为二进制 ==》1100
    然后把整体向右移动两位 ==》0011
    最后转换为十进制 ==》 1*2的0次方+1*2的1次方=3
    所以答案:3
    2、举例2、12<<2
    操作:
    先将12转换为二进制 ==》1100
    然后把整体向左移动两位 ==》110000
    最后转换为十进制 ==》 1*2的4次方+1*2的5次方=48
    所以答案:3
    结论:所以也能简单的理解为>>3就是原来的数字除以2的3次方,<<3就是乘以2的3次方

    好的,本人菜鸟一只,整理就到这里,如果还有什么疑问,可以给我留言,如果有说的不对的地方,请各路大神指出!!
    展开全文
  • 运算

    2018-07-09 22:21:00
    要讲java一些奇奇怪怪运算符号之前,...1、原码一正数,按照绝对值大小转换成二进制,称为原码2、反码将二进制取反,所得新二进制称为原二进制数的反码其实就是把原码中0变为1,1变为0例如:0000 ...
  • 第二章 数据分析 知识点题型归纳 实验中学 马贵荣 PAGE ... 权理解:反映了某个数据在整个数据中重要程度 权表示方法百分比频数人数个数次数等 2.中位数将一组数据按照由小到或由到小顺序排列如果数据
  • 若一个三位数的十位数字比个位数字和百位数字都,称这个为“伞”. 现从1,2,3,4,5,6…N,这N个数字中取3个,组成无重复数字三位, 问其中多少个伞 Input 一行,给出数字N,N<=9 Output 如题 Sample...
  • 这条街一共 2020 住户,门牌号从 1 到 2020 编号。 小蓝制作门牌方法是先制作 0 到 9 这几数字字符,最后根据需要将字 符粘贴到门牌上,例如门牌 1017 需要依次粘贴字符 1、 0、 1、 7,即需要 1 字符 0...
  • 虽然说学习ASP.NET不需要任何ASP基础,但是我觉得如果大家ASP不会,还是先看一下【天学会ASP教程】,大家所需要了解不是ASP程序怎么写,而是怎么构建服务器,怎么使用HTML表单,同时对SQL语句基础和理解...
  • # 十六进制(等于进制数的18) $a = 1.234; # 浮点数"双精度数" $a = 1.2e3; # 双精度数指数形式 字符串 字符串可以由单引号或双引号引出字段定义。注意不同是被单引号引出字符串是以字面定义,而双...
  • 2,别把钱看得太重 不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一很长锻炼过程,社会永远是一所最博大大学,它让你学到知识远...
  • 猜数字游戏规则: 1. 电脑随机产生100—999之间数字(包括100、999); 提示:用rand函数,该函数在stdlib.h库中,并保证多次运行产生...7. 两个数,其中一十位数? ——当前分数减20 8. 之和 ——当前分数减33
  • 本书主要适用于希望快速掌握Excel函数相关知识,并使用公式和函数解决办公中实际问题用户,适用于不同年龄段办公人员、文秘、财务人员、公务员,尤其对刚进入职场工作人员,在解决实际问题上大的指导作用...
  • 不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一很长锻炼过程,社会永远是一所最博大大学,它让你学到知识远你在学校...
  • 男人三岁之前必须完成事1,事业永远第一 虽然金钱不是万能,但没有钱是万万不能,虽然这句话很俗,但绝对道理,所以30岁之前,请把你部分精力放在你事业上. 2,别把钱看得太重 不要抱怨自己现在工资低,银行...
  • 2、别把钱看得太重 不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一很长锻炼过程,社会永远是一所最博大大学,它让你学到知识远...
  • 男人三岁以前必须知道

    千次阅读 2008-09-19 13:17:00
    1.事业永远第一 虽然金钱不是万能,但没有钱是万万不能,虽然这句话很俗,但绝对道理,所以30岁之前,请把你部分精力放在你事业上. 2.别把钱看得太重 不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,...
  • 2,别把钱看得太重不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一很长锻炼过程,社会永远是一所最博大大学,它让你学到知识远...
  • 此外,它的进制表示的每个位的数经过重新排列后能形成回文序列。在这里给定某个数n(进制下长度不超过2*1e5),求小于它的最大BN。(题目数据保证解且n不含前导零)思路:贪心。首先,n的长度可能很,这里...
  • oracle varchar2排序问题

    2020-08-12 20:25:56
    在oracle中假如你排序字段是varchar2类型,碰到9和10,11,12..比较,这时就凉凉了,今天我就碰到这...oracle认为910,11,12,因为9是和位数先一次,再和十位数比一次,9肯定1,这时候就问题 ...
  • 2.6.8 DECIMAL——将给定基数文本转换为进制 116 第3章 日期和时间函数 117 3.1 了解Excel日期系统 118 3.1.1 Excel提供两种日期系统 118 3.1.2 了解日期和时间序列号 119 3.1.3 输入与设置日期和时间 ...
  • 问题是它累加到一三维空间,意味着霍夫线变换需要更多计算消耗。 Opencv霍夫圆变换对标准霍夫圆变换做了运算上优化。 它采用是“霍夫梯度法”。它检测思路是去遍历累加所有非零点对应圆心,对...
  • 加深解题思路以及对python的熟悉程度01 数学问题1F第一题题目:个位数字比十位数字大2的两位数有哪些?解题思路:因为是两位数,所以十位只能从1到9变化。把十位从1到9依次遍历,依据个位=十位+2来计算个位,但是...
  • 男人三岁前

    2008-07-23 20:35:52
    2,别把钱看得太重 不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一很长锻炼过程,社会永远是一所最博大大学,它让你学到知识远...
  • 蓝桥杯网友年龄

    2020-07-04 20:49:18
    “我年龄是个2位数,我儿子27岁, 如果把我年龄数字交换位置,刚好就是我儿子年龄” 请你计算:网友年龄一共多少种可能情况? 提示:30岁就是其中一种可能哦. 请填写表示可能情况。 注意:...
  • 2一个三位个位数字比百位数字,而百位数字又比十位数字,并且各位数字之和等于各位数字相乘之积,求此三位。3、蜘蛛8条腿,蜻蜓6条腿和2对翅,蝉6条腿和1对翅。三种虫子共18共,共有118条腿和20...
  • d是幸运数字,如果一的数位上至少d,则是幸运数,现需判断q是不是幸运数? 假设d为7 >=70的数都是幸运数。只需要按分解为7a+b7的两数相加。例 q=86,86-77=9,因此a=9,b=0,86=79+7。 q=103,103-...
  • 事先建立一个有2050大的数组,然后把所有年份按下标数字对应,如果是闰年,此数组项值就是1,如果不是就是0。这样,所谓判断某一年是否是闰年就变成了查找这数组某一项值是多少问题。 2.13总结回顾 37 ...
  • DDR2Layout指导手册

    2018-04-20 16:10:59
    DDR2Layout指导手册 DDR布线通常是一款硬件产品设计中重要环节,也正是因为其重要性,网络上也有大人在探讨DDR布线规则,很多同行故弄玄虚,把DDR布线说得很难,我在这里要反其道而行之,讲一讲DDR...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 145
精华内容 58
关键字:

个位比十位大2的数有