Question

作为练习，在输入中我得到2个非常大的字符串，其中包含长二进制表示，这里有一个短的但可能有超过100位：

实施例

11100
00011

输出按位OR（作为字符串）

我的方法是解析每个字符串字符并进行按位OR并构建一个新字符串，但是它太长而无法处理大条目而且无效。

然后ParseInt方法被限制为64位长度

num1, err:= strconv.ParseInt("11100", 2, 64)
num2, err:= strconv.ParseInt("00011", 2, 64)
res := num1 | num2

如何处理2字符串二进制表示之间的按位OR？

Answer 1

您可以通过进行字符比较来创建生成的按位OR字符串，或者您可以使用math/big执行任意大型数字操作。以下是此类操作的示例：

package main

import "fmt"
import "math/big"

func main() {
    num1 := "11100"
    num2 := "00011"

    var bigNum1 big.Int
    var bigNum2 big.Int
    var result big.Int

    if _, ok := bigNum1.SetString(num1, 2); !ok {
        panic("invalid num1")
    }
    if _, ok := bigNum2.SetString(num2, 2); !ok {
        panic("invalid num2")
    }
    result.Or(&bigNum1, &bigNum2)

    for i := result.BitLen() - 1; i >= 0; i-- {
        fmt.Print(result.Bit(i))
    }
    fmt.Println()
}

Go Playground

Answer 2

虽然您可以将这些转换为数字来执行按位操作，但如果您的唯一目标是对两个字符串执行单个按位OR，则将字符串解析为数字将比简单地迭代字符串以实现结束效率低结果。只有在对二进制形式的数字执行大量操作时，这样做才有意义。

对下面的字符串执行OR运算的示例代码。请注意，此代码假定字符串的长度与问题中的示例相同，如果它们的长度不同，您也需要处理它们。

package main

import "fmt"

func main() {
    n1 := "1100"
    n2 := "0011"

    fmt.Printf("Input: %v | %v\n", n1, n2)

    if len(n1) != len(n2) {
        fmt.Println("Only supports strings of the same length")
        return
    }

    result := make([]byte, len(n1))

    for i := 0; i < len(n1); i++ {
        switch n1[i] {
        case '0':
            switch n2[i] {
            case '0':
                result[i] = '0'
            case '1':
                result[i] = '1'
            }
        case '1':
            switch n2[i] {
            case '0':
                result[i] = '1'
            case '1':
                result[i] = '1'
            }
        }
    }

    fmt.Println("Result: ", string(result))
}

http://play.golang.org/p/L3o6_jYdi1

Answer 3

这个怎么样：

package main

import "fmt"

func main(){
    a :=   "01111100"
    b := "1001000110"

    var longest, len_diff int 

    if len(a) > len(b) {
        longest = len(a)
        len_diff = len(a) - len(b)
    } else {
        longest = len(b)
        len_diff = len(b) - len(a)
    }

    temp_slice := make([] byte, longest)

    var a_start, b_start int

    if len(a) > len(b) {
        for i := 0; i < len_diff; i++ {
            temp_slice[i] = a[i]
        }
        a_start = len_diff

    } else {
        for i := 0; i < len_diff; i++ {
            temp_slice[i] = b[i]
        }
        b_start = len_diff
    }

    for i := 0; i < (longest - len_diff); i++ {
        if a[a_start + i] == '1' ||  b[b_start + i] == '1' {
            temp_slice[len_diff + i] = '1'
        } else {
            temp_slice[len_diff + i] = '0'
        }
    }

    fmt.Println(string(temp_slice))
}

goplayground

golang：对非常长的二进制位串表示的按位运算

3 个答案: