Here's the answer.
The first one is equivalent.
The reason for that is we have our code here that has "if False."
"False" will never be true, so we'll never actually run the "break"Ã¢ÂÂ
we'll never reach that code.
We'll just run the statement again and we'll have the same thing that we started with.
Every time the test is true, we execute the statement.
The second one is not equivalent, and the reason for that is the "break" will
stop the loop.
If the loop would execute more than once in this version,
and if we go through the loop twice,
in this case we can only ever go through the statement once,
since after we go through the statement once, we reach the "break" and then we're done.
The third one is not equivalent, so here we're having a "while true" that will run
forever except for we have the "break" and that would stop it.
The problem is the test condition for the break is the same as the
test condition for the "while," but it should really be the opposite.
In the "while" we keep going as long as the test condition is true.
The way I have written in the code here, if the test condition is true, we stop.
For this to be equivalent, what we should have written instead
would've taken the opposite of the test condition, so if we had "if" not"Ã¢ÂÂ
which changes true to false and false to true, then the test condition,
then the breakÃ¢ÂÂthis would be equivalent to the original loop.
What we have is not.
The final one is the most complicated.
This one is actually always equivalent to the original loop.
The reason for that is if we think through the execution, so in the
original loop, if the test condition is true, we ask to give the statement "S,"
and then we keep going.
If the test condition is true the second time, we execute "S" again
and we keep going.
If we look at what happens hereÃ¢ÂÂwell, if the test condition is true, we
execute "S."
Then if the test condition is true again, we execute S and we keep going.
That has the same behavior.
We should trace it through the case where the test condition is
not true.
HereÃ¢ÂÂif the test condition was true, we execute "S."
If it's not true the second time, then we're done with the loop
and we continue.
In this case if the test condition is true the first time, we'll execute "S."
If it's not true the second time, then we would go to the "else."
So if it's not true, we go to the "else" and then we go to the "break" and
the "break" gets out of the loop.
We have the same exact behavior where we executed "T" once, then
we executed "S," and then we executed "T."
We didn't execute "S" again, and we broke out of the loop to continue.
So these two are equivalent and the other two are different.
Aquí está la respuesta.
La primera es equivalente.
La razón para esto es que nuestro código tiene aquí If false.
Falso nunca será verdadero, entonces realmente nunca se ejecutará el break,
bueno, nunca llega a ese código.
Simplemente ejecutaremos la sentencia de nuevo y obtendremos la misma cosa con la que empezamos.
Cada vez que la prueba es verdadera ejecutaremos la sentencia.
El segundo no es equivalente, y la razón para esto que el break
detendrá el bucle.
Si el bucle se ejecutaría mas de una vez en esta versión,
y si vamos a traves del bucle dos veces,
en este caso sólo podemos ir a través de la sentencia una sola vez,
dado de que despues de que pasamos por la sentencia una vez, alcanzamos el break y entonces terminamos.
La tercera no es equivalente, aquí tenemos un while true que se ejecutará
para siempre excepto para el break que tenemos aquí y lo detendría.
El problema es que la condicion de prueba para el break es la misma que
la condición de prueba para el while, pero en realidad debería ser lo opuesto.
En el while continuamos ejecutando mientras la condición de prueba es verdadera.
La forma en que he escrito el código aquí, si la condición de prueba es verdadera nos detemos.
Para que esto sea equivalente, lo que deberíamos haber escrito en lugar de eso
es que la condición de prueba opuesta, osea si tenemos if not
lo cual cambia verdadero a falso y falso a verdadero, entonces la condición de prueba,
y luego el break, esto sería equivalente al bucle original.
Lo que tenemos aquí no lo es.
La última es más complicada.
Esta es realmente siempre equivalente al bucle original.
La razón de esto es si pensamos a través de la ejecución. En el bucle
original, si la condición de prueba es verdadera, requerimos dar la sentencia S
y luego continuamos.
Si la condición de prueba es verdadera la segunda vez, ejecutamos S de nuevo
y seguimos.
Si nos fijamos en lo que sucede aquí, bueno, si la condición de prueba es verdadera
ejecutamos S
Luego si la condición de prueba es verdadera de nuevo, ejecutamos S y continuamos.
Eso tiene el mismo comportamiento.
Deberíamos seguir el caso donde la condición de prueba
no es verdadera.
Aquí, si la condición de prueba fue verdadera, ejecutamos S.
Si no es verdadera la segunda vez, hemos terminado con el bucle
y continuamos.
En este caso si la condición de prueba es verdad la primera vez, ejeuctaremos S
si no es verdad la segunda vez, entonces vamos al else
Entoces si no es verdadera vamos al else y luego vamos al break y
el break sale del bucle.
Tenemos exactamente el mismo comportamiento donde ejecutamos T una vez, luego
ejecutamos S y luego ejecutamos T
No ejecutamos S de nuevo y terminamos fuera del bucle para continuar
Entonces estas dos son equivalentes y las otras dos son diferentes.
Questa è la risposta.
La prima è equivalente.
La ragione di ciò è che abbiamo il nostro codice qui che ha "if false".
False non sarà mai True, così non eseguiremo mai la "break",
non raggiungeremo mai quel codice.
Eseguiremo semplicemente l'istruzione nuovamente e avremo la stessa cosa con cui siamo partiti.
Ogni volta il test è vero, eseguiamo l'istruzione.
La seconda non è equivalente, e la ragione è che la "break"
fermerà il loop.
Se il ciclo sarà eseguito più di una volta in questa versione,
e se andiamo attraverso il ciclo due volte.
In questo caso possiamo solo e unicamente andare attraverso l'istruzione una sola volta,
dal momento che attraversiamo l'istruzione la prima volta, raggiungiamo la "break" e abbiamo finito.
La terza non è equivalente, qui abbiamo un "while true" che eseguirà
per sempre eccetto che abbiamo la "break" e questa lo stopperebbe.
Il problema è che la condizione di test per la break è la stessa della
condizione di test per la "while", ma dovrebbe essere veramente l'opposto.
Nella "while" andiamo avanti tanto a lungo quanto la condizione di test è vera.
Il modo in cui ho scritto il codice qui, se la condizione di test è vera, ci fermiamo.
Per questa per essere equivalente, quello che invece dovremmo aver scritto
dovrebbe aver preso l'opposto della condizione di test, così se avessi avuto "if not"
-- il quale cambia vero a falso e falso a vero, nella la condizione di test,
e nella break -- sarebbe stato equivalente al ciclo originale.
Quello che abbiamo non lo è.
L'ultimo è il più complicato.
Questo è realmente sempre equivalente al ciclo originale.
La ragione di ciò è che se pensiamo all'esecuzione,
nel loop originale, se la condizione di test è vera, domandiamo il codice dell'istruzione "S"
e andiamo avanti.
Se la condizione di test è vera la seconda volta, eseguiamo "S" nuovamente
e andiamo avanti.
Se guardiamo a quello che succede qui -- se la condizione di test è vera,
eseguiamo "S".
Se la condizione di test è vera ancora, eseguiamo "S" e andiamo avanti.
Questo è lo stesso comportamento.
Dovremmo tracciarlo nel caso dove la condizione di test sia
non vera.
Qui -- se la condizione di test è vera, eseguiamo "S"
Se non è vera la seconda volta, allora abbiamo finito col loop
e continuiamo.
In questo caso se la condizione di test è vera a prima volta, eseguiremo "S".
Se non è vera la seconda volta, allora andremo nella "else".
Così se essa non è vera, andiamo alla "else" e andremo alla "break" e
la "break" ci porterà fuori dal loop.
Abbiamo lo stesso esatto comportamento dove eseguiamo "T" una sola volta, allora
eseguiamo "S", e poi eseguiamo "T".
Non eseguiamo "S" di nuovo, e saltiamo fuori dal ciclo per continuare.
Così queste due sono equivalenti e le altre due diverse.
1つ目の選択肢は同等です
if Falseのあるコードがここにあるからです
FalseはTrueにならず breakを実際に実行することはありません
このコードに達することはありません
もう一度文を実行しても 開始時と同じものを得るでしょう
テストがTrueになる時は常に文を実行します
breakがループを止めるため 2つ目の選択肢は同等ではありません
このループを1回以上実行するとします
元のバージョンでループを2度行う場合
こちらでは文を一度しか通過しません
一度通過したらbreakに達して終了します
3つ目の選択肢は同等ではありません ここにwhile Trueがありますが
breakで停止する場合を除いて延々に実行します
問題はbreakのテスト条件が whileのテスト条件と同じであることです
本来は正反対のものになるはずです
whileでテスト条件がTrueになる限り継続します
このコードに書いたように テスト条件がTrueの場合に停止します
これを同等にするためには正反対のもの
つまりif notを書くべきでした
TureからFalseにそしてFalseからTrueに変わります
そしてbreakと書きます これで元のループと同等になります
notがありますね
最後の選択肢は最も複雑でした
これは常に元のループと同等になります
理由は元のループの実行を考えた場合
テスト条件がTrueならSを実行し そのあと継続します
2回目のテスト条件がTrueなら もう一度Sを実行し継続します
つまりテスト条件がTrueならSを実行します
そしてもう一度テスト条件がTrueになる時に Sを実行し継続します
これも同じ働きをします テスト条件が Trueでない場合トレースしなければなりません
テスト条件がTrueならSを実行します
2回目がTrueでなかった場合 ループを終了して続けます
この場合1回目のテスト条件がTrueの場合 Sを実行します
2回目がTrueでない場合はelseに進みます
そしてbreakに移りループから抜け出します
Tを実行したあとSを実行し
さらにTを実行したらまったく同じ動作になりました
再度Sを実行せずに 継続するためにループから抜け出しました
つまり同等だった選択肢は2つでした
Aqui está a resposta.
A primeira é equivalente.
A razão para isso é que temos nosso código aqui, que tem if False.
False nunca será True -- então, nunca executaremos o break de fato --
nunca executamos este código.
Simplesmente executamos o comando novamente e teremos a mesma coisa com que tínhamos antes:
toda vez que o teste for True, executamos o comando.
A segunda não é equivalente, e a razão é que o break irá
interromper o loop.
Se o loop executa mais de uma vez, nesta versão --
se passamos pelo loo 2 vezes --
neste caso, podemos passar pelo comando apenas uma vez,
já que, depois de executar o comando uma vez, chegamos ao break, e então terminamos.
A teerceira não é equivalente. Aqui temos while True, que irá executar
indefinidamente, exceto que temos o break, e isso iria pará-lo.
O problema é que a condição e teste para o break é a mesma que
a condição de teste para o while, mas ela deveria ser o oposto.
No while, continuamos executando enquanto a condição de teste é True.
Da maneira como escrevemos o código aqui, se a comdição de teste for True, nós paramos.
Para que isso fosse equivalente, o que deveríamos ter escrito, ao in'ves disso,
seria a condição de teste oposta: se tivéssemos if not,
que muda True para False e False para True, depois a condição de teste,
depois o break, isso seria equivalente ao loop original.
O que temos não é.
A última é mais complicada.
Esta é, de fato, sempre equivalente ao loop original.
A razão para isso é que, se pensamso na execução,
no loop original, se a condição de teste for True, nós temos que executar o comanso S,
e depois continuar o loop.
Se a condição de teste for True uma segunda vez, executamos S de novo,
e continuamos assim.
Se olharmos para o que acontece aqui -- bem, se a condição de teste for Tru,
nós excutamos S;
se a condição e teste for True novamente, nós executamos o teste, e continuamos assim.
Isso tem o mesmo comportamento.
Podemos verificar isso também no caso em que a condição de teste
não é True.
Aqui, se a condição de teste for True, executamos S,
e se ela não for True na segunda vez, então terminamos o loop,
e continuamos.
Neste caso, se a condição de teste for Trur na primeira vez, nós executamos S;
e se ela não é True na segunda vez, então vamos para o else.
Portanto, se ela não é True, nós vamos para o else e então executamos o break,
e o break desvia para fora do loop.
Nós temos exatamente o mesmo comportamento no qual exectamos T uma vez, depois
executamos S, e então executamos T.
Nós não executamos S de novo, e saímos para fora do loop, para continuar.
Então, essas duas são equivalente e as outras duas são diferentes.
Вот правильный ответ.
Первый вариант эквивалентен нашей записи,
поскольку в этом коде содержится условие if False.
Значение False никогда не будет истинным, поэтому мы никогда не доберемся до команды break,
этот код для нас недосягаем.
Вместо этого мы выполним инструкцию и вернемся к началу цикла.
Каждый раз, когда условие истинно, мы будем выполнять инструкцию .
Второй вариант не подходит нам, поскольку инструкция break
остановит цикл.
В нашей записи цикл может выполниться более одного раза,
к примеру, дважды,
то в данном варианте инструкция выполнится лишь один раз,
поскольку после первого ее выполнения мы достигнем команды break, и цикл завершится.
Третий вариант также неверен, поскольку условие while True позволит циклу выполняться
вечно, если только мы не выйдем из него командой break.
Проблема в том, что условие выхода из цикла идентично
условию продолжения цикла в исходной записи, хотя должно быть противоположным по смыслу.
while-цикл продолжает выполняться, пока проверяемое условие истинно.
А мой код в этом варианте наоборот остановится, если проверяемое условие истинно.
Для того, чтобы они были эквивалентными, мы должны были заменить
это условие на противололожное; так, если бы мы записали условие if not ,
которое ложно если условие истинно и наоборот,
а затем поставим break, тогда это будет эквивалентом цикла в исходной записи.
А первоначальный вариант – нет.
Последний вариант самый запутанный.
И он тоже всегда эквивалентен исходному циклу,
Если мы мысленно проследим выполнение кода, то
в исходном цикле при истинности условия , мы выполняем инструкцию
и продолжаем.
Если условие истинно и на втором проходе, мы снова выполняем
и идем дальше.
Если же мы посмотрим на этот вариант – ну, если условие истинно, мы
выполняем .
Если условие снова истинно, мы еще раз выполняем и продолжаем.
В этом случае поведение такое же.
Мы должны проследить выполнение и в том случае, когда условие
ложно.
Если здесь условие истинно, то мы выполняем .
Если на втором проходе оно ложно, мы выходим из цикла
и выполняем код дальше.
В этом случае если условие на первом проходе истинно, то мы выполним .
Если на втором проходе оно становится ложно, мы переходим к блоку else.
Если условие ложно, мы переходим к блоку else и выполняем команду break,
которая выводит нас из цикла.
Получается точно такой же сценарий, в котором мы один раз проверяем ,
затем выполняем и снова проверяем .
При этом мы не выполняем во второй раз и выходим из цикла.
Итак, эти два варианта эквивалентны данной записи, а эти два – нет.
下面是答案
选项一是等同的
因为这里的代码是“if False”（如果 假）
“假”永远不会为真 所以“break”永远不会真正运行
我们永远不会执行那些编码
我们只会再次运行该语句 和开始时一样
每次测试为真 我们就执行该语句
选项二不等同
因为这个“break”会中断循环
如果该循环在这种情况下执行超过一次
在这里 我们可以运行该循环两次
但在这里 我们只能执行该语句一次
因为执行该语句一次后 我们就到了“break” 然后就结束了
选项三不是等同的 这里的“while true”会永远运行下去
除非我们有“break”来中断该循环
问题是 这里break的测试条件和“while”的是一样的
但却应该是相反的
只要测试条件为真 “while”就不断继续
但根据这里的编码 如果测试条件为真 循环就中断
要让选项三等同于题干所给循环
我们应该写一个相反的测试条件
也就是说 如果这里写的是“if not”（如果不） 然后是测试条件
然后是break——这就等同于原来的循环了
但是选项三并不是这样的
最后一个选项是最复杂的
事实上 该选项总是等同于原来的循环
我们来看一下执行的过程
在原来的循环中 如果测试条件为真 我们执行语句“S”
然后继续
如果测试条件再次为真 我们就再次执行“S”
然后继续
再来看选项四——如果测试条件为真
我们就执行“S”
如果测试条件再次为真 我们执行“S” 然后继续
这和原来的循环是一样的
下面我们来看
测试条件不为真时的情况
这里——如果测试条件为真 我们就执行“S”
如果第二次不为真 循环就中断
然后继续
在这里 如果第一次测试条件为真 我们执行“S”
如果第二次不为真 我们就执行“else”（否则）
然后执行“break”
循环中断
这和原来的循环是完全一致的
先执行“T” 然后执行“S” 然后再执行“T”
然后就不再执行“S” 而是中断循环 继续后面的编码
所以这两个是等同的 而那两个不是
答案是
選項一是相等的
因為這裡的程式碼是 'if False'
False 永遠不會是 True，所以永遠不會執行 break
我們永遠不會執行到那些程式碼
我們只會再次執行陳述，和開始的時候一樣
每次測試是 True，我們就執行陳述
選項二是不相等的，原因是
這個 break 會中斷 loop
在這個版本，如果 loop 在這種情況下執行超過一次
如果我們想執行 loop 兩次
在這裡，我們只能執行陳述一次
因為執行陳述一次後，我們就到了 break ，然後結束
選項三是不相等的，這裡的 'while true' 會永遠執行下去
除非我們有 break 來將它停止
問題在於 break 的測試條件 和 while 的測試條件是一樣的
但它應該是相反的才對
while 的測試條件只要是 True，就會繼續下去
但根據這裡的程式碼，如果測試條件是 True ，就會停止
想要讓選項三相等，我們應該
改寫為相反的測試條件
如果是 'if not'，True 變 False，False 變 True， 然後是測試條件
然後是 break，這就和原來的 loop 相等了
但是選項三並不是這樣的
最後一個選項是最複雜的
事實上，它總是相等於原來的 loop
我們來思考一下執行的過程
在原來的 loop 中， 如果測試條件為 True，我們執行陳述 S
然後繼續下去
如果第二次的測試條件是 True，我們就再次執行 S
然後繼續下去
再來看選項四，如果測試條件是 True
我們執行 S
如果測試條件再次是 True，我們執行 S，然後繼續下去
它有同樣的作用
我們必須追蹤這個情況
測試條件不是 True
如果測試條件為 True，我們執行 S
如果第二次不是 True，loop 就結束
然後繼續
在這裡，如果第一次測試條件是 True，我們執行 S
如果第二次不是 True，我們就執行 else
所以如果不是 True，會執行 else，然後來到 break
break 跳出了 loop
這和原來的 loop 的作用是完全一致的
先執行 T 一次，然後執行 S ，然後執行 T
我們不再執行 S ，而是中斷，跳出 loop，然後繼續
所以這兩個是相等的，那兩個不相等