Wann und Warum die Verwendung von Loop-Do-Konstrukt in Ruby

Ich kam vor kurzem über ein problem/- Lösung, verwendet Loop Tun. Ich habe selten gesehen habe, so weit dies in meinem lernen Ruby-Programmierung (ich bin ein Anfänger mit keine CS Erfahrung).

# Write a function, `nearest_larger(arr, i)` which takes an array and an
# index.  The function should return another index, `j`: this should
# satisfy:
#
# (a) `arr[i] < arr[j]`, AND
# (b) there is no `j2` closer to `i` than `j` where `arr[i] < arr[j]`.
#
# In case of ties (see example beow), choose the earliest (left-most)
# of the two indices. If no number in `arr` is largr than `arr[i]`,
# return `nil`.
#
# Difficulty: 2/5

describe "#nearest_larger" do
  it "handles a simple case to the right" do
    nearest_larger([2,3,4,8], 2).should == 3
  end

  it "handles a simple case to the left" do
    nearest_larger([2,8,4,3], 2).should == 1
  end

  it "treats any two larger numbers like a tie" do
    nearest_larger([2,6,4,8], 2).should == 1
  end

  it "should choose the left case in a tie" do
    nearest_larger([2,6,4,6], 2).should == 1
  end

  it "handles a case with an answer > 1 distance to the left" do
    nearest_larger([8,2,4,3], 2).should == 0
  end

  it "handles a case with an answer > 1 distance to the right" do
    nearest_larger([2,4,3,8], 1).should == 3
  end

  it "should return nil if no larger number is found" do
    nearest_larger( [2, 6, 4, 8], 3).should == nil
  end
end

LÖSUNG

def nearest_larger(arr, idx)
  diff = 1
  loop do
    left = idx - diff
    right = idx + diff

    if (left >= 0) && (arr[left] > arr[idx])
      return left
    elsif (right < arr.length) && (arr[right] > arr[idx])
      return right
    elsif (left < 0) && (right >= arr.length)
      return nil
    end

    diff += 1
  end
end
 nearest_larger([2,4,3,8], 1)

Kann mir jemand bitte erklären, Wann ist die beste Zeit, um eine "Schleife " do" konstruieren statt der üblichen "während" oder "es sei denn" oder "jeder" zu konstruieren?

InformationsquelleAutor JaTo | 2013-05-29

12

In einer Sprache, die ohne loop könnten Sie einen while Konstrukt wie:
```
while( true ) {
  # Do stuff until you detect it is done
  if (done) break;
}
```
Der Punkt ist, dass Sie beginnen, die Schleife ohne zu wissen, wie viele Iterationen durchzuführen (oder es ist schwer im Voraus berechnen), aber es ist leicht zu erkennen, Wann die Schleife enden soll. Zusätzlich, für einen bestimmten Fall finden Sie vielleicht das äquivalent while (! done) { # do stuff } syntax ungeschickt, weil die fertig-Zustand, kann passieren, auf halbem Weg durch den loop, oder an mehreren stellen.

Ruby ' s loop ist im Grunde das gleiche wie die while( true ) - in der Tat können Sie while( true ) fast Synonym mit.

In dem gegebenen Beispiel gibt es folgende Punkte bei der Rücksendung innerhalb jeder iteration:
```
if (left >= 0) && (arr[left] > arr[idx])
  return left   # <-- HERE
elsif (right < arr.length) && (arr[right] > arr[idx])
  return right  # <-- HERE
elsif (left < 0) && (right >= arr.length)
  return nil    # <-- HERE
end 
```
Gibt es auch eine implizite "anders weiter looping" hier, wenn keine Bedingungen erfüllt sind.

Diese mehrere mögliche exit-Punkte sind vermutlich, warum der Autor wählte die loop konstruieren, obwohl es gibt viele Möglichkeiten, dieses problem zu lösen, in der Praxis mit Ruby. Die gegebene Lösung code ist nicht unbedingt besser als alle anderen Möglichkeiten.
- verwenden Sie nur eine Weile, wenn Sie nicht wissen, Wann es endet.
- Guter Punkt. Es ist schwer zu differenzieren, warum Sie können wählen zwischen while (condition) {} und while(1) { if (condition) break; } syntax in eine kurze Antwort.
- in der Tat :), ich mag es until Konstrukt als gut.
InformationsquelleAutor Neil Slater
24

Addition zu den vorherigen Antworten,

Die "Schleife " do" Konstrukt bietet auch eine sauberere syntax beim arbeiten mit externen Iteratoren, e.g

Keine "Schleife " do"
```
my_iterator = (1..9).each
begin
  while(true)
    puts my_iterator.next
  end
rescue StopIteration => e
  puts e
end
```
Und jetzt mit "Schleife " tun" das würde
```
my_iterator = (1..9).each
loop do
  puts my_iterator.next
end
```
Und die Ausnahme ist für Sie verarbeitet. Es erlaubt Ihnen auch, um eine Schleife durch zwei Sammlungen in der gleichen Zeit, und sobald einer von Ihnen läuft out-of-Elemente, wird die Schleife verlassen anmutig,
```
iterator = (1..9).each
iterator_two = (1..5).each

loop do
  puts iterator.next
  puts iterator_two.next
end
```
Gedruckt: 1,1,2,2,3,3,4,4,5,5,6.

Mehr info auf: ruby-docs.org

InformationsquelleAutor radyz
2

Mithilfe der loop do Konstrukt ermöglicht es Ihnen zu brechen, auf eine bedingte.

zum Beispiel:
```
i=0
loop do
  i+=1
  print "#{i} "
  break if i==10
end 
```
Würden Sie dies nutzen wollen, wenn Sie wissen, dass die Anzahl der Elemente, die verarbeitet werden, ähnlich wie die for each Schleife
- Würden mit dem "bis" - Konstrukt die gleiche wie die?
- ist das Gegenteil von while soweit Sie sich für die negation der Variablen verwiesen wird, die von bis. Das ist: while(true) vice, bis false
- Können Sie brechen aus innerhalb einer Schleife, nicht nur ein loop do.
- hat jemand sagen Sie nicht?
InformationsquelleAutor Woot4Moo
2

loop mit dem loop-Konstrukt führt den block endlos
bis der code im block bricht auf die bestimmte Bedingung.

es kann verwendet werden, wenn Sie nicht haben, eine Sammlung zu Durchlaufen, die
Orte, an denen 'jeder' und 'für' nicht funktionieren kann.

den Unterschied zwischen loop-und while/until ist, dass, während/solange bis
führen Sie den block, wenn bestimmte Bedingung erfüllen, wo, wie in
bei loop gibt es keine Bedingung, um zu starten, Bedingung liegt innerhalb der
loop-block.

für besseres Verständnis Lesen Sie doc.

http://www.ruby-doc.org/core-1.9.2/Kernel.html#method-i-loop

InformationsquelleAutor Sachin Singh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.