精华内容
下载资源
问答
  • 主要为大家详细介绍了python实现整数的二进制循环移位,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 【题目】如何在python中实现整数的二进制循环移位(附代码) 概述 在python中,可以通过<<以及>>运算符实现二进制的左移位以及右移位,然而并没有实现循环移位的运算符,暂时也找不到...

    【时间】2018.11.03

    【题目】如何在python中实现整数的二进制循环移位(附代码)

    概述

    在python中,可以通过<<以及>>运算符实现二进制的左移位以及右移位,然而并没有实现循环移位的运算符,暂时也找不到可以实现循环移位的函数,所以在本文中,主要介绍了如何使用字符的切片运算实现循环位移。

     

    一、实现思路

    1。利用字符串的format函数将int整数值转化为特定位数的二进制值

    2、利用字符的切片操作实现循环位移

    二、实现代码

    # left circular shift
    
    #int_value是输入的整数,k是位移的位数,bit是整数对应二进制的位数
    
    def circular_shift_left (int_value,k,bit = 8):
    
        bit_string = '{:0%db}' % bit
    
        bin_value = bit_string.format(int_value) # 8 bit binary
    
        bin_value = bin_value[k:] + bin_value[:k]
    
        int_value = int(bin_value,2)
    
        return int_value
    
    
    
    # right circular shift
    
    def circular_shift_right (int_value,k,bit = 8):
    
        bit_string = '{:0%db}' % bit
    
        bin_value = bit_string.format(int_value) # 8 bit binary
    
        bin_value = bin_value[-k:] + bin_value[:-k]
    
        int_value = int(bin_value,2)
    
        return int_value
    
    
    
    if __name__ == "__main__":
    
        A=1
    
        B=circular_shift_right(A, 1, 8)
    
        print(A,"右循环位移1位的结果是",B)
    
        C = 128
    
        D =circular_shift_left(C,1,8)
    
        print(C, "左循环位移1位的结果是", D)

    三、运行结果

     

    展开全文
  • 二进制循环移位问题

    千次阅读 2017-10-21 07:40:48
    循环移位 Time Limit: 3000ms, Memory Limit: 10000KB , Accepted: 2516, Total Submissions: 3693 Description 编写函数实现value左右循环移位(即移出的位在另一端填入)。函数原型为int move(int value,int n...

    循环移位

    Time Limit: 3000ms, Memory Limit: 10000KB , Accepted: 2516, Total Submissions: 3693

    Description

    编写函数实现value左右循环移位(即移出的位在另一端填入)。函数原型为int move(int value,int n);其中value为要循环移位的数,n为移位的位数,n的绝对值不大于16,整型为16位。如果n<0表示左移,n>0表示右移,n=0表示不移位。在主函数中输入数据并调用该函数输出结果。

    Input

    输入value和n,均为整型,用空格隔开

    Output

     

    • Sample Input 
      134744064 -8
    • Sample Output
      134742024


    #include<stdio.h>
    int main()
    {
    long int n,a[50],b[50],c[50],i=0,sum=0,d,j,k,m;
    scanf("%ld%ld",&n,&m);
        while(n)
    {
    d=n%2;
    a[i]=d;
    n=n/2;
    i++;
    }
    if(a==0)
    {
    printf("%ld",n);
    return 0;
        }
        for(j=0;j<i;j++)
        {
        c[j]=a[i-1-j];
        } 
        if(m>0)
        {
             for(j=0;j<i;j++)
        {
            if(j<m)b[j]=c[j+i-m];
    if(j>=m)b[j]=c[j-m];
        }  
        d=1;
        for(k=0;k<i;k++)
    {
      sum=sum+d*b[i-1-k];
      d=d*2;
    }
    printf("%ld",sum);
        return 0;
        }
        if(m<0)
        {
            m=-m;
       for(j=0;j<i;j++)
       {
       if(j<i-m)b[j]=c[j+m];
       if(j>=i-m)b[j]=c[j-i+m];
       }
       d=1;
       for(k=0;k<i;k++)
       {
       
      sum=sum+d*b[i-1-k];
      d=d*2;
       }
    printf("%ld",sum);
       return 0;
        }
        
    }

    展开全文
  • // Author: Yuan Zhu #include #include #include #include #define ll long long using namespace std; int t; char a[40], b[40]; int toint(char c) { if(c >= '0' && c ) return c - '0';... e
    // Author: Yuan Zhu
    #include <iostream>
    #include <cstdio>
    #include <algorithm>
    #include <cstring>
    #define ll long long
    using namespace std;
    
    int t;
    char a[40], b[40];
    
    int toint(char c) {
        if(c >= '0' && c <= '9') return c - '0';
        else return c - 'A' + 10;
    }
    
    int main() {
        scanf("%d", &t);
        for (int ca = 1; ca <= t; ca++) {
            scanf("%s%s", a, b);
            ll A = 0, B = 0, rA = 0, rB = 0;
            for (int i = 0; a[i]; i++) A = A * 16 + toint(a[i]);
            for (int i = 0; b[i]; i++) B = B * 16 + toint(b[i]);
            ll AA = A, BB = B;
            int cA = 0, cB = 0;
            while (AA) cA++, AA /= 2;
            while (BB) cB++, BB /= 2;
            ll tmpA = A;
            int l = -1, r = -1;
            for (int i = 1; i < 32; i++) {
                ll c = tmpA & 1;
                tmpA >>= 1;
                if (c) tmpA += (1LL << 31);
                if (tmpA == B) {
                    r = i;
                    break;
                }
            }
            tmpA = A;
            for (int i = 1; i < 32; i++) {
                ll c = tmpA & (1LL << 31);
                tmpA <<= 1;
                if (c) tmpA -= (1LL << 32), tmpA++;
                if (tmpA == B) {
                    l = i;
                    break;
                }
            }
            printf("Case #%d: ", ca);
            if (A == B) printf("0 Any\n");
            else if (l == -1 && r == -1) printf("Not possible\n");
            else if (l == r) printf("%d Any\n", l);
            else if (r < l) printf("%d Right\n", r);
            else printf("%d Left\n", l);
        }
        return 0;
    }

    展开全文
  • 字节数组(byte[])实现二进制串的循环移位 最近去公司实习了。公司的主业是网络安全,先说一个:密码学中的移位都是循环移位。现在用字节数组byte[]存储二进制串,1024个二进制数字就是128个字节,byte[128],如何...

    循环移位:字节数组(byte[])实现二进制串的循环移位

    最近去公司实习了。公司的主业是网络安全,先说一个:密码学中的移位都是循环移位。现在用字节数组byte[]存储二进制串,1024个二进制数字就是128个字节,byte[128],如何实现这样的二进制串的循环移位呢?
    网上只有对数组的移位,比如int[],char[],string,但直接套用byte[]是不符合要求的!我自己感觉这套东西是我全网首发哈哈哈哈哈哈哈哈哈哈哈!(因为我自己已经翻来覆去百度过很久了哈哈哈哈哈哈)
    感谢徐利军老师提供的算法框架和王啸赟同学的提点。已通过手算验证!


    算法核心Java代码如下:(屏蔽掉的代码就是原本出问题的地方,大家注意右移运算中补1/0的问题)
    【2018年3月16日17:25:08】原来的算法前的判断逻辑一直隐约觉得不对,今天算了一下午改正了bug,现在全部放上来……

    import java.util.Arrays;
    
    public class Byte_SHIFT {   //循环移位
    
        public static void main(String[] arg) { //测试
            byte[] test = new byte[128];
            test[0] = 0;
            for (int i = 1; i < 128; i++) {
                test[i] = 1;
            }
            System.out.println(Arrays.toString(test));
            test = leftShift(test, 250);
            System.out.println(Arrays.toString(test));
        }
    
        public static byte[] hexStringToByte(String hex) {
            int len = (hex.length() / 2);
            byte[] result = new byte[len];
            char[] achar = hex.toCharArray();
            for (int i = 0; i < len; i++) {
                int pos = i * 2;
                result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
            }
            return result;
        }
    
        private static int toByte(char c) {
            return (byte) "0123456789ABCDEF".indexOf(c);
        }
    
        private static void RotateRightOne(byte[] bytes) {
            byte valBit;
            valBit = (byte) (bytes[bytes.length - 1] << (byte) (7));
            for (int i = bytes.length - 1; i > 0; i--) {
                bytes[i] = (byte) ((bytes[i] >> (byte) (1)) | (bytes[i - 1] << (byte) (7)));
            }
            bytes[0] = (byte) ((bytes[0] >> (byte) (1)) | valBit);
        }
    
        public static byte[] rightShift(byte[] bytes, int X) {  //X<bytes.length
            int byte_move;
            int binary_move;
            if (X % 1024 == 0) {
                return bytes;
            } else {
                if (X > 1024) {
                    while (X > 1024) {
                        X -= 1024;
                    }
                }
                byte_move = (X - X % 8) / 8;
                byte[] new_bytes = new byte[128];
                System.arraycopy(bytes, 0, new_bytes, byte_move, bytes.length - byte_move);
                System.arraycopy(bytes, bytes.length - byte_move, new_bytes, 0, byte_move);
                binary_move = X % 8;
                if (binary_move == 0) {
                    return new_bytes;
                } else {
                    cyclic_right_shift(new_bytes, binary_move);
                    return new_bytes;
                }
            }
        }
    
        public static byte[] leftShift(byte[] bytes, int X) {  //X<bytes.length
            int byte_move;
            int binary_move;
            if (X % 1024 == 0) {
                return bytes;
            } else {
                if (X > 1024) {
                    while (X > 1024) {
                        X -= 1024;
                    }
                }
                byte_move = (X - X % 8) / 8;
                byte[] new_bytes = new byte[128];
                System.arraycopy(bytes, byte_move, new_bytes, 0, bytes.length - byte_move);
                System.arraycopy(bytes, 0, new_bytes, bytes.length - byte_move, byte_move);
                binary_move = X % 8;
                if (binary_move == 0) {
                    return new_bytes;
                } else {
                    cyclic_left_shift(new_bytes, binary_move);
                    return new_bytes;
                }
            }
        }
    
        private static void cyclic_left_shift(byte[] bytes, int X) {
    /*        byte first_byte_begin_bit = (byte) (bytes[0] >> (byte) (8 - X));
            if (first_byte_begin_bit < 0) {
                byte temp = (byte) ((byte) (-128) >> (byte) (8 - X - 1));
                first_byte_begin_bit = (byte) (first_byte_begin_bit ^ temp);
            }
            for (int i = 0; i < bytes.length - 1; i++) {
                byte A = (byte) (bytes[i] << (byte) (X));
                byte B = (byte) (bytes[i + 1] >> (byte) (8 - X));
                if (B < 0) {
                    byte temp = (byte) ((byte) (-128) >> (byte) (8 - X - 1));
                    B = (byte) (B ^ temp);
                }
                bytes[i] = (byte) (A | B);
            }
            byte A = (byte) (bytes[bytes.length - 1] << (byte) (X));
            bytes[bytes.length - 1] = (byte) (A | first_byte_begin_bit);*/
            int first_byte_begin_bit =  bytes[0] >>> 8 - X;
            for (int i = 0; i <bytes.length-1; i++)
            {
                int A=(bytes[i]&0xff)<<  X;
                int B=bytes[i + 1] >>> (8 - X);
                bytes[i] = (byte) (A|B);
            }
            bytes[bytes.length-1]=(byte)((bytes[bytes.length-1]&0xff)<<X);
            bytes[bytes.length-1] = (byte)(bytes[bytes.length-1]|first_byte_begin_bit);
        }
    
        private static void cyclic_right_shift(byte[] bytes, int X) {
    /*        byte end_byte_final_bit = (byte) (bytes[bytes.length - 1] << (byte) (8 - X));
            for (int i = bytes.length - 1; i > 0; i--) {
                byte A = (byte) (bytes[i] >> (byte) (X));
                byte B = (byte) (bytes[i - 1] << (byte) (8 - X));
                if (A < 0) {
                    byte temp = (byte) ((byte) (-128) >> (byte) (X - 1));
                    A = (byte) (A ^ temp);
                }
                bytes[i] = (byte) (A | B);
    //            bytes[i] = (byte) ((byte) ((bytes[i] >> (byte) (X))) | (byte) ((bytes[i - 1] << (byte) (8 - X))));
            }
            byte A = (byte) (bytes[0] >> (byte) (X));
            if (A < 0) {
                byte temp = (byte) ((byte) (-128) >> (byte) (X - 1));
                A = (byte) (A ^ temp);
            }
            bytes[0] = (byte) (A | end_byte_final_bit);*/
            //bytes[0] = (byte) ((byte) ((bytes[0] >> (byte) (X))) | end_byte_final_bit);
            int end_byte_end_bit =  bytes[bytes.length - 1] << 8 - X;
            for (int i = bytes.length - 1; i > 0; i--)
            {
                int A=(bytes[i]&0xff)>>>  X;
                int B=bytes[i - 1] << 8 - X;
                bytes[i] = (byte) (A|B);
            }
            bytes[0]=(byte)((bytes[0]&0xff)>>>X);
            bytes[0] = (byte)(bytes[0]|end_byte_end_bit);
        }
    }
             
    
    展开全文
  • ’都是实现的二进制移位,但是这个不能对二进制进行循环,我们有时需要这种循环操作,但是有没有提供,因此可以自己写一个函数,实现该功能。 def cycle(num, step): from collections import deque num = deque...
  • 大多数计算机处理器提供了机器级的循环命令,但在C和C++中,不直接支持循环,因此需要创建自己的循环命令。下面是实现左旋和右旋的函数:
  • 今天,和大家分享一道关于进制问题中的循环移位,大家应该知道,系统语言中提供的按位左移 《 和按位右移 》都是非循环的。那什么叫循环移位呢?所谓循环移位是指在移位时不丢失移位前原范围的位,而是将它们作为另...
  • int b = 0, c = 0;// b 输入的0~255之间的数 c 移动位数  printf("请输入一个整数和移动位数\n");... //循环移位  right = a >> c;  left = a (8 - c);  printf("%d\n", left | right);
  • System.out.println("int var="+s + "=" + i + ", 其二进制代码如下: "); ** **for (int j = 31; j >= 0; j--) if (((1 ) & i) != 0) { // 判断变量b左移一位与a变量做"与"操作,看是否不等于0 ...
  • 如下面的循环,需要把 buf 中所有的元素都向左或向右移动指定二进制位,寻求大神指点。 ``` unsigned char buf[4096]; for (;;) { recv(s, buf, sizeof(buf), 0); } ```
  • (1)矩阵循环移位:circshift  例如:b = circshift(a,[x,y]) 其中a为待移位的矩阵,x表示上下移位位数(正数表示向下移位),y表示左右移位位数(正数表示向右移位) >> x = [1,2,3;4,5,6;7,8,9] x = ...
  • 二进制形式输出一个十进制数 利用for循环移位以及&amp;运算   import java.util.Scanner; public class ToBinary { private int number; public void setNumber(int number) { this.number=number...
  • 二进制形式输出一个十进制数利用for循环移位以及&amp;运算: &amp; 和 &gt;&gt; 的计算方式想必大家都知道,&gt;&gt; 相当于将数进行 /2 运算,&amp;,1&amp;1=1,0&amp;*...
  • 整数在内存中二进制中1的个数(常规循环+移位技巧) 一、循环 int OneCount(int num){ int count = 0; while (num){ if (num % 2 == 1){ count++; } num /= 2; } return count; }   利用简单的短...
  • 1 //转二进制 2 char *ConvertTo2String(long number); 3 //转十六进制 4 char *ConvertTo16String(long number); 思路:  转换二进制很简单,二步操作即可完成, 1:循环对数字1左移31-i(i={0,31})位...
  • “来解决问题,例如定义一个int型整数将其转换为二进制,由于int型整数占内存长度为4字节(32b),可以进行32次循环,首次循环用定义的整数>>31运算后&1输出此时的结果,然后后面每次循环时”>>"运算...
  • 循环位移二进制

    2014-07-25 20:48:56
    输入一个字节内的数(0~255)和移动位数。输出移位结果(要求循环移位)提示:系统自带的移位都是非循环的
  • 循环位移加密二进制数据#include "stdafx.h" void encode(char * p, int n) { for (int i = 0; i&lt;n; i++) { unsigned char ch = p[i];//将值赋给无符号的变量,方便之后移位的操作 (首位移动...
  • 编写输出子程序,把AX中的数以二进制形式显示输出,并在主程序中验证。(需要使用循环移位指令,逻辑与指令。) 编译工具:Masm for Windows 集成实验环境2012.5 (附带一个工具下载地址...
  • 循环移位补码.rar

    2021-02-06 17:02:50
    选择结果类型,如果选择循环移位,输入循环移位数值(正数右移,负数左移),针对 [a, b]区间内的每个数值n,先将十进制变成二进制,按照指定数值(正数右移,负数左移)循环移位,再将二进制结果转换成十进制,输出...
  • 二进制位操作的支持不是很好,比如没有了移位运算等,用的时候确实很不方便,所以在闲暇之余我重新封装了一个用于C#、VB.NET的位操作类库,通过该类库可以实现数据移位、循环移位、转换为二进制、将二进制转换为...
  • 左旋转二进制

    2019-08-13 09:00:17
    位旋转 -—— 旋转(或循环移位)是类似于移位的操作, 不同的是一端脱落的那一位会被放回到另一端 在左旋转中, 左端掉下来的那一位会放在右端 假设 n 用 8 位二进制来存. 对 n =11100101左旋转3位, 得到 n =00101111...
  • 支持与、或、非、异或、移位(循环、逻辑、算术),直接读写二进制位,指定位段读、写、置1、清0、反转。 支持常用位运算、数学运算、关系运算、常用转换运算,以运算符或函数方式调用。 支持类C语言库函数调用。 运算...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 414
精华内容 165
关键字:

二进制循环移位