我需要对一个整数 a
与整数数组 q
(最大值为 100,000)进行异或运算。即如果我在循环,我会
异或q[0]
异或q[1]
.....
异或 q[100000]
(100,000 次)
我将对一系列这样的 a
进行异或运算。
我正在编写一个控制台应用程序,它将传递所需的输入。
我正在使用内置的 C# ^
运算符来执行 XOR 运算。还有其他办法吗?
将整数转换为字节数组,然后对每个位进行异或运算并计算出最终结果是否是个好主意?
输入(不要保留两行之间的空格)
1
15 8
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
10 6 10
1023 7 7
33 5 8
182 5 10
181 1 13
5 10 15
99 8 9
33 10 14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace XOR
{
class Solution
{
static void Main(string[] args)
{
List<TestCase> testCases = ReadLine();
//Console.WriteLine(DateTime.Now.ToLongTimeString());
CalculationManager calculationManager = new CalculationManager();
foreach (var testCase in testCases)
{
var ints = testCase.Queries.AsParallel().Select(query => calculationManager.Calculate(query, testCase.SequenceOfIntegers)).ToList();
ints.ForEach(Console.WriteLine);
}
//Console.WriteLine(DateTime.Now.ToLongTimeString());
//Console.ReadLine();
}
private static List<TestCase> ReadLine()
{
int noOfTestCases = Convert.ToInt32(Console.ReadLine());
var testCases = new List<TestCase>();
for (int i = 0; i < noOfTestCases; i++)
{
string firstLine = Console.ReadLine();
string[] firstLineSplit = firstLine.Split(' ');
int N = Convert.ToInt32(firstLineSplit[0]);
int Q = Convert.ToInt32(firstLineSplit[1]);
var testCase = new TestCase
{
Queries = new List<Query>(),
SequenceOfIntegers = ReadLineAndGetSequenceOfIntegers()
};
for (int j = 0; j < Q; j++)
{
var buildQuery = ReadLineAndBuildQuery();
testCase.Queries.Add(buildQuery);
}
testCases.Add(testCase);
}
return testCases;
}
private static List<int> ReadLineAndGetSequenceOfIntegers()
{
string secondLine = Console.ReadLine();
List<int> sequenceOfIntegers = secondLine.Split(' ').ToArray().Select(x => Convert.ToInt32(x)).ToList();
return sequenceOfIntegers;
}
private static Query ReadLineAndBuildQuery()
{
var query = Console.ReadLine();
List<int> queryIntegers = query.Split(' ').ToArray().Select(x => Convert.ToInt32(x)).ToList();
Query buildQuery = ReadLineAndBuildQuery(queryIntegers[0], queryIntegers[1], queryIntegers[2]);
return buildQuery;
}
private static Query ReadLineAndBuildQuery(int a, int p, int q)
{
return new Query { a = a, p = p, q = q };
}
}
class CalculationManager
{
public int Calculate(Query query, List<int> sequenceOfIntegers)
{
var possibleIntegersToCalculate = FindPossibleIntegersToCalculate(sequenceOfIntegers, query.p, query.q);
int maxXorValue = possibleIntegersToCalculate.AsParallel().Max(x => x ^ query.a);
return maxXorValue;
}
private IEnumerable<int> FindPossibleIntegersToCalculate(List<int> sequenceOfIntegers, int p, int q)
{
return sequenceOfIntegers.GetRange(p - 1, (q - p) + 1).Distinct().ToArray();
}
}
class TestCase
{
public List<int> SequenceOfIntegers { get; set; }
public List<Query> Queries { get; set; }
}
class Query
{
public int a { get; set; }
public int p { get; set; }
public int q { get; set; }
}
}
最佳答案
使用 ^
按位异或运算符是对整数进行异或运算的最快方法。
该操作被转换为单个原子处理器操作。
正如您在反汇编中看到的那样:
int i = 4;
00000029 mov dword ptr [ebp-3Ch],4
i ^= 3;
00000030 xor dword ptr [ebp-3Ch],3
所以如果你想让你的代码运行得更快,你应该改变算法/方法(正如 Marc Gravell 所建议的那样),而不是 xor 方法。
关于c# - 在 C# 中异或两个整数的最快方法是什么?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/10568042/