Wie überprüfe ich, ob ein Element in einem Array ein Muster erfüllt, während der Rest nicht?

Question

Ich benutze Ruby 2.4. Ich weiß, wie zu überprüfen, ob eine Zeichenfolge alle, indem Sie

str == str.upcase 

aktiviert, aber wenn ich ein Array von Strings habe, was ist ein schneller Weg, um sicherzustellen, dass nur das letzte Element des Arrays während aktiviert wird, für die andere Elemente, str! = str.upcase. Ich gehe davon aus, dass es mindestens ein Element im Array gibt und wenn es nur ein Element gibt und es in Großbuchstaben geschrieben ist, möchte ich, dass meine Bedingung als wahr ausgewertet wird.

Answer 1

def only_last_upcase?(arr) 
    arr.find_index { |w| w == w.upcase } == arr.size - 1 
end 

only_last_upcase? ["word", "wOrD", "WORD"] #=> true 
only_last_upcase? ["WORD", "wOrD", "WORD"] #=> false 
only_last_upcase? ["word", "wOrD", "word"] #=> false 
only_last_upcase? ["word"]     #=> false 
only_last_upcase? ["Word"]     #=> false 
only_last_upcase? ["WORD"]     #=> true 
only_last_upcase? []      #=> false 

Answer 2

Ein Ansatz:

def check_only_last_upcase(arr) 
    return false if arr.empty? 
    arr.each_with_index do |word, index| 
     return false if word == word.upcase && index != (arr.length-1) 
    end 
    (arr.last.upcase == arr.last) 
end 

puts check_only_last_upcase(["word", "wOrD", "WORD"]) #true 
puts check_only_last_upcase(["WORD", "wOrD", "WORD"]) #false 
puts check_only_last_upcase(["word", "wOrD", "word"]) #false 
puts check_only_last_upcase(["word"]) #false 
puts check_only_last_upcase(["WORD"]) #true 
puts check_only_last_upcase([]) #false 

Eine andere Möglichkeit (sieht eher wie ein Rubin Art und Weise?):

def check_only_last_upcase(arr) 
    arr.last == arr.last.upcase && 
    arr 
     .slice(0,arr.length-1) 
     .all? { |word| word.upcase != word } 
end 

Letzter Vorschlag geht davon aus arr immer mindestens ein Element hat (nicht zurück, wenn arr ist leer), wie Sie gezeigt haben.

Answer 3

Oder vielleicht:

foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 

Und ...

2.3.1 :001 > foo = ["WORD","Word"] 
=> ["WORD", "Word"] 
2.3.1 :002 > foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 
=> false 
2.3.1 :003 > foo = ["WORD","WORD"] 
=> ["WORD", "WORD"] 
2.3.1 :004 > foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 
=> false 
2.3.1 :005 > foo = ["Word","WORD"] 
=> ["Word", "WORD"] 
2.3.1 :006 > foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 
=> true 
2.3.1 :007 > foo = ["Word","WORD","WORD"] 
=> ["Word", "WORD", "WORD"] 
2.3.1 :008 > foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 
=> false 
2.3.1 :009 > foo = ["WORD"] 
=> ["WORD"] 
2.3.1 :010 > foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 
=> true 
2.3.1 :011 > foo = ["Word"] 
=> ["Word"] 
2.3.1 :012 > foo.last == foo.last.upcase and foo.select{|e| e == foo.last}.length == 1 
=> false 

Answer 4

Die gute Sache über Ruby ist, dass es ziemlich einfach textuellen Beschreibungen von Problemen in eigentlichen Code zu aktivieren:

def only_last_upcase?(arr) 
    last_index = arr.size - 1 
    arr.find_index { |s| s =~ /^[A-Z]*$/ } == last_index 
end 

Beide von ihnen haben die folgende Ergebnisse:

only_last_upcase?(["word", "wOrD", "WORD"]) 
#=> true 
only_last_upcase?(["WORD", "wOrD", "WORD"]) 
#=> false 
only_last_upcase?(["word", "wOrD", "word"]) 
#=> false 
only_last_upcase?(["word"]) 
#=> false 
only_last_upcase?(["WORD"]) 
#=> true 
only_last_upcase?([]) 
#=> false 

Answer 5

prüfen nur ein Element erfüllt Ihre Bedingung und, dass die des Arrays letzten Element die gleiche Bedingung erfüllt:

arr.one? { |str| str == str.upcase } && arr.last == arr.last.upcase 

alle Pässe die gleichen Tests in der Antwort von Cary Swoveland.