blocks|key|4099551|text|您可以尝试将算法分成两部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4099552|4099553|首先完成5x5内部3x3数组中的所有情况，该5x5没有边情况|unordered-list-item|4099554|完成所有剩余的边|4099555|4099556|在每种情况下，你都知道自己处于什么状态，所以你可以最小化检查|4099557|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|P|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|L|$]]

You can try splitting the algorithm in two parts: 

<ul>
<li>first do all the cases in the 3x3 array inside the 5x5 which doesn't have the edge cases</li>
<li>finish up with all the remaining edges</li>
</ul>

In each situation you know in what condition you are, so you can minimise ìf` checks

blocks|key|4099569|text|您可以使用布尔逻辑和短路评估|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4099570|if+((i+==+0+%7C%7C+array[i-1][j]+!=+'A')+&&
++++(j+==+0+%7C%7C+array[i][j-1]+!=+'A')+&&
++++(i+==+4+%7C%7C+array[i%2B1][j]+!=+'A')+&&
++++(j+==+4+%7C%7C+array[i][j%2B1]+!=+'A'))
{
++++...
}|code-block|syntax|javascript|4099571|我假设你想把array[-1][j]+!=+'A'等认为是真的。如果不是，则表达式将更改。|offset|length|style|CODE|4099572|entityMap^0|0|0|6|J|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]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can use boolean logic, and short circuit evaluation

<pre><code>if ((i == 0 || array[i-1][j] != 'A') &amp;&amp;
 (j == 0 || array[i][j-1] != 'A') &amp;&amp;
 (i == 4 || array[i+1][j] != 'A') &amp;&amp;
 (j == 4 || array[i][j+1] != 'A'))
{
 ...
}
</code></pre>

I'm assuming that you want to consider <code>array[-1][j] != 'A'</code> etc as true. If not then the expression would change.

blocks|key|5567834|text|这是图像处理中的一个常见问题。正如molbdnilo在评论中指出的那样，一种常见的解决方案是添加一些填充；由于您使用的是3x3邻域，因此您需要在所有边只添加一个像素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5567835|有时使用的另一种解决方案是镜像超出图像界限的访问。也就是说，如果是x>bound，你就用(2*bound-x)代替，y也一样，或者你也可以用if+(x>bound)+x=bound。这里的一个共同因素是通过分别处理x和y来限制if语句的数量。|offset|length|style|CODE|5567836|entityMap^0|0|X|7|18|B|1Y|K|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|I|$]]

This is a common problem in image processing. As molbdnilo notes in the comments, a common solution is to add some padding; since you use a 3x3 neighborhood you need to add just a single pixel on all sides.

Another solution that's sometimes used is to mirror accesses beyond the image bound. That is to say, if <code>x&gt;bound</code> you use <code>(2*bound-x)</code> instead, and the same for y. Alternatively, you can use <code>if (x&gt;bound) x=bound</code>. A common factor here is that you limit the number of if-statements by handling x and y separately.

blocks|key|4099670|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4099671|有没有一种干净的方法可以做到这一点，而不需要嵌套一堆if语句来检查if+...|blockquote|4099672|4099673|4099674|是。这就是所谓的不嵌套。关注checking部分，注意您不需要嵌套。对于要完成的测试的任何部分，部分结果可以定义总结果，您可以使用它将代码分解为多个部分。|offset|length|style|CODE|4099675|而不是|4099676|//+using+short-cut+evaluation+to+build+a+HUGE+if
if(x+>+0+&&+y+>+0+&&+data[x][y-1]+!=+'A'+...)
{
+++do+something1;
+++do+something2;
}|code-block|syntax|javascript|4099677|或|4099678|//+using+nesting+to+guarantee+some+conditions+"from+now+onwards"
if(x+>+0+&&+y+>+0)
{
++++do+something1;
++++if(data[x][y-1]+!=+'A'+...)
++++++++do+something2;
}|4099679|只需写|4099680|bool+Check1(...)
{
++++if(x+<+0)+return+false;+//+A*
++++if(y+<+0)+return+false;
++++...

++++return+true;
}

bool+Check2(...)
{
++++if(data[x][y-1]+!=+'A')+return+false;+//+A*
++++...

++++return+true;
}|4099681|在原来的地方|4099682|bool+sidesOk+=+Ćheck1(....);
bool+neighboursOk+=+Ćheck2(....);

//+first+case
if(sidesOk+&&+neighboursOk)
{
+++do+something1;
+++do+something2;
}

//+second+case
if(sidesOk)
+++do+something1;

if(sidesOk+&&+neighboursOk)
+++do+something2;

//+or+even+-+depending+on+your+algorithm
if(!sidesOk)
+++return;|4099683|但是，这取决于美学和你的个人喜好。这段代码和你的代码都可以工作。可能会有细微的性能差异(如果需要，可以进行测量！)但总体逻辑和结果是相同的。|4099684|Notabene+-+A*+-请注意，有一些“好的编码规则”不鼓励构造具有多个返回路径的代码，并提倡“单一函数单一返回”规则。似乎跟踪函数存在的时间/位置是一件很难的事情。如果你听说过这条规则，忘记它，你的生活将会更容易。这条规则是在我们手工编写程序集时发明的，当程序集处于预宏汇编阶段时，它不包含宏和函数，您可以通过条件和跳转手动编写类似函数的代码。让这条规则适应当前的工具和需求，它应该是“保持分支和返回路径易于理解”。是的，当你使用快捷求值if(x&&y&&..)时，编译器会做if(x)return+false块，“所以我们为什么不让它只有一行”--更重要的是代码易于人类阅读。|BOLD|4099685|entityMap^0|0|0|0|0|E|8|0|0|0|0|0|0|0|0|0|0|3F|3|67|C|6Q|H|0^^$0|@$1|2|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1C|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1D|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1E|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1F|7|@$H|1G|I|1H|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|1I|7|@]|8|@]|9|$]]|$1|N|3|O|4|P|6|1J|7|@]|8|@]|9|$Q|R]]|$1|S|3|T|4|5|6|1K|7|@]|8|@]|9|$]]|$1|U|3|V|4|P|6|1L|7|@]|8|@]|9|$Q|R]]|$1|W|3|X|4|5|6|1M|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|P|6|1N|7|@]|8|@]|9|$Q|R]]|$1|10|3|11|4|5|6|1O|7|@]|8|@]|9|$]]|$1|12|3|13|4|P|6|1P|7|@]|8|@]|9|$Q|R]]|$1|14|3|15|4|5|6|1Q|7|@]|8|@]|9|$]]|$1|16|3|17|4|5|6|1R|7|@$H|1S|I|1T|J|18]|$H|1U|I|1V|J|K]|$H|1W|I|1X|J|K]]|8|@]|9|$]]|$1|19|3|-4|4|5|6|1Y|7|@]|8|@]|9|$]]]|1A|$]]

<blockquote>
 Is there a clean way to do this without nesting a bunch of if statements to check if ...
</blockquote>

Yes. That is called NOT nesting.
Focus on the <code>checking</code> part, and notice that you don't need nesting.
For any part of the test to be done, a partial result may define the total outcome, and you can use it to break the code into parts.

Instead of

<pre><code>// using short-cut evaluation to build a HUGE if
if(x &gt; 0 &amp;&amp; y &gt; 0 &amp;&amp; data[x][y-1] != 'A' ...)
{
 do something1;
 do something2;
}
</code></pre>

or

<pre><code>// using nesting to guarantee some conditions "from now onwards"
if(x &gt; 0 &amp;&amp; y &gt; 0)
{
 do something1;
 if(data[x][y-1] != 'A' ...)
 do something2;
}
</code></pre>

just write

<pre><code>bool Check1(...)
{
 if(x &lt; 0) return false; // A*
 if(y &lt; 0) return false;
 ...

 return true;
}

bool Check2(...)
{
 if(data[x][y-1] != 'A') return false; // A*
 ...

 return true;
}
</code></pre>

and at the original place

<pre><code>bool sidesOk = Ćheck1(....);
bool neighboursOk = Ćheck2(....);

// first case
if(sidesOk &amp;&amp; neighboursOk)
{
 do something1;
 do something2;
}

// second case
if(sidesOk)
 do something1;

if(sidesOk &amp;&amp; neighboursOk)
 do something2;

// or even - depending on your algorithm
if(!sidesOk)
 return;
</code></pre>

But then, it's down to aesthetics and your personal preferences. Both this and your code works. There might be minor performance differences (measure it if you need!) but the overall logic and the result are the same.

Notabene - A* - note that there are some "good coding rules" that discourage constructing code that have multiple return paths, and that promote a "single function single return" rule. As if tracing when/where the function exists is a hard thing. If you ever heard this rule, forget it, and your life will be easier. This rule was invented when we were writing assembly by hand and when the assembly was at pre-MacroAssembler stage, and contained no macros and no functions and you wrote function-like code manually by conditions and jumps. Adapting that rule to current tools and needs, it should say "keep branching and return paths easy to comprehend". And yes, the <code>if(x)return false</code> block is what the compiler would do when you are using short-cut evaluation <code>if(x&amp;&amp;y&amp;&amp;..)</code> "so why dont we keep it one-line already" - it's more important for the code to be easy for humans to read.

Say I have a 5x5 2D Array. For a given position in the array, I need to check if the adjacent positions contains a certain value. How do I handle elements that are on the edge of the array? 

For example, my immediate thought to handle something like this would be; 

<pre><code>if(array[i-1][j] != 'A' &amp;&amp; array[i][j-1] != 'A' &amp;&amp; array[i+1][j] != 'A' &amp;&amp; array[i][j+1] != 'A')
</code></pre>

but given any element where i or j is 0/4, one (or two) of those statements will attempt to check something that is out of bounds of the dimension of the array. Is there a clean way to do this without nesting a bunch of if statements to check if the element is at the edge?

Cleanest way to avoid accessng an array out of bounds?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

假设我有一个5x5二维阵列。对于数组中的给定位置，我需要检查相邻位置是否包含某个特定值。如何处理位于数组边缘的元素？例如，我的第一个想法是处理这样的事情；if(array[i-1][j] != 'A' && array[i][j-1] != 'A' && array[i+1][j] != 'A' && array[i]...

问避免访问越界数组的最干净的方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问避免访问越界数组的最干净的方法？EN