blocks|key|2792533|text|你所建议的是可能的，但这样做是没有意义的。下面是以位为单位的值表示(仅显示相关位，左边的所有值都是零)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2792534|2:+000010+%7C%7C+123:+1111011+%7C%7C+13:+001101|2792535|没有逻辑的方法可以通过位运算将123转换为13。最好将其转换为字符串或字符数组，删除这两个数组，然后将其转换回int。|2792536|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

What you're suggesting is possible, but wouldn't really make sense to do. Below are the values representations in bits (only showing relevant bits, everything further left is a zero):

2: 000010 || 123: 1111011 || 13: 001101

There's no logical way to change 123 into 13 with bitwise operations. It would better to turn it into a string or character array, remove the two then cast it back to an int.

blocks|key|2706312|text|还有其他的情况吗？如果存在某种类型的模式，则可以将其推广到整数级别，否则，您实际上只是在寻找字符串替换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2706313|123中的2实际上是2E1+(10100)，而1234中的2将是2E2+(11001000)，这两者都与2+(10)无关，至少在位形式上是这样。此外，需要将已删除号码右侧的“数字”添加到已删除号码/+10左侧的数字。|offset|length|style|CODE|2706314|也就是说，从123到13：|2706315|Located+"2".
Number+on+left+(x):+100
Number+on+right+(y):+3
y+%2B+(x+/+10)+=+13|code-block|syntax|javascript|2706316|从1324到134|2706317|Located+"2"
Number+on+left+(x):+1300
Number+on+right+(y):+4
y+%2B+(x+/+10)+=+134|2706318|除非有某种模式(即你知道数字的位置)，否则在对结果进行.ToString()之前，你只需要先对数字进行int.Parse()，然后进行.Replace("2",+"")。|2706319|编辑：有人对这个答案投了赞成票，我意识到我之前的实现不必要地复杂。在一个以10为基数的数中“迭代”数字相对简单，不应该需要递归。|BOLD|2706320|下面是新的解决方案，性能更好，但这是一个巨大的微优化：|2706321|static+int+OmitDigit(int+number,+int+digit)+{
++++var+output+=+0;
++++var+multiplier+=+1;
++++
++++while+(number+>+0)+{
++++++++var+n+=+number+%25+10;
++++++++number+/=+10;
++++++++
++++++++if+(n+!=+digit)+{
++++++++++++output+%2B=+(n+*+multiplier);
++++++++++++multiplier+*=+10;
++++++++}
++++}
++++
++++return+output;
}|2706322|结果：1554443|2706323|entityMap^0|0|0|3|5|1|A|B|N|4|T|1|W|E|1G|6|0|0|0|0|0|R|B|1F|B|1V|H|0|0|3|0|0|0|3|7|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@$D|17|E|18|F|G]|$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1L|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1M|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1N|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1O|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1P|8|@$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1W|8|@$D|1X|E|1Y|F|W]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Z|3|10|5|L|7|20|8|@]|9|@]|A|$M|N]]|$1|11|3|12|5|6|7|21|8|@$D|22|E|23|F|G]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|14|$]]

What other cases are there? It may be possible to generalize this at an integer level if there is some sort of pattern, otherwise you're really just looking at string replacement.
The <code>2</code> in <code>123</code> is actually <code>2E1 (10100)</code>, and the <code>2</code> in <code>1234</code> would be <code>2E2 (11001000)</code> neither of which are related to <code>2 (10)</code>, at least in bitwise form. Also, the &quot;number&quot; on the right side of the removed number would need to be added to the number on the left side of the removed number / 10.
i.e, to go from 123 to 13:
<pre><code>Located &quot;2&quot;.
Number on left (x): 100
Number on right (y): 3
y + (x / 10) = 13
</code></pre>
and to go from 1324 to 134
<pre><code>Located &quot;2&quot;
Number on left (x): 1300
Number on right (y): 4
y + (x / 10) = 134
</code></pre>
Unless there's some pattern (i.e you know what positions the numbers are in), you'll just have to <code>.ToString()</code> the number, then do a <code>.Replace(&quot;2&quot;, &quot;&quot;)</code>, before doing an <code>int.Parse()</code> on the result.
EDIT: Someone upvoted this answer and I realised my previous implementation was unnecessarily complicated. It is relatively straightforward to 'iterate' over the digits in a base-10 number and shouldn't require recursion.
New solution below, performance is better but this is a huge micro-optimisation:
<pre><code>static int OmitDigit(int number, int digit) {
 var output = 0;
 var multiplier = 1;
 
 while (number &gt; 0) {
 var n = number % 10;
 number /= 10;
 
 if (n != digit) {
 output += (n * multiplier);
 multiplier *= 10;
 }
 }
 
 return output;
}
</code></pre>
Result:
<code>1554443</code>

blocks|key|1587119|text|因为我们使用的是以10为基数的数字，所以至少可以说，以2为基数的操作是丑陋的。使用一些数学方法，从k中删除第n位数字，并将其移位为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1587120|(k/pow(10,n))*pow(10,+n-1)+%2B+k%25pow(10,+n-1)|code-block|syntax|javascript|1587121|在基数2中，<<和>>运算符的作用类似于乘以pow(2,+n)，而带有掩码的&执行%25的工作，但在基数10中，位不对齐。|offset|length|style|CODE|1587122|entityMap^0|0|0|6|2|9|2|M|9|12|1|15|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

Since we're working with base 10 numbers, manipulation in base 2 is ugly to say the least. Using some math, removing the nth digit from k, and shifting over is

<pre><code>(k/pow(10,n))*pow(10, n-1) + k%pow(10, n-1)
</code></pre>

In base 2, the <code>&lt;&lt;</code> and <code>&gt;&gt;</code> operator acts like multiplying by a <code>pow(2, n)</code>, and <code>&amp;</code> with a mask does the work of <code>%</code>, but in base 10 the bits don't line up.

blocks|key|1587453|text|这是非常尴尬的，但如果你真的必须只有位操作，我建议你convert+the+number+to+BCD。在BCD中，基本上有一个数字介于0和9之间的十六进制数字，因此删除数字非常简单。一旦你完成了，转换回二进制。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1587454|我不相信任何人会想要这样做。|1587455|entityMap|0|LINK|mutability|MUTABLE|url|http://people.ee.duke.edu/~dwyer/courses/ece52/Binary_to_BCD_Converter.pdf^0|Q|P|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

This is very awkward, but if you really do must have bitwise operations only, I suggest you <a href="http://people.ee.duke.edu/~dwyer/courses/ece52/Binary_to_BCD_Converter.pdf" rel="nofollow">convert the number to BCD</a>. Once in BCD, you basically have an hexadecimal numbers with digits between 0 and 9, so removing a digit is very simple. Once you're done, convert back to binary.

I don't believe anybody would want to do that.

How do I remove for example <code>2</code> from <code>123</code> and returns <code>13</code>, by using bitwise operators? I have no idea how to do this.. it's possible? Thanks in advance.

How to remove a number from another number using bitwise operators?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

例如，我如何使用位运算符从123中删除2并返回13？我不知道该怎么做..有可能吗？提前谢谢。

问如何使用按位运算符将一个数字从另一个数字中移除？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用按位运算符将一个数字从另一个数字中移除？EN