Auch Splitters.rb

Question

Geben Sie ein Array von Zeichen zurück, auf dem wir eine Eingabezeichenfolge teilen können, um Teilzeichenfolgen derselben Länge zu erzeugen.

Zählen Sie keine leeren Zeichenfolgen nach der Teilung.

Hier ist ein Beispiel für "Banane":

def even_splitters(str) 
    count = Hash.new(0) 
    new_arr = [] 
    str.chars.map do |e| 
    arr = str.split(e) 
    if arr == [] || arr.length == 1 
     new_arr << e 
    else 
     arr.each {|x| count[x] = x.length } 
     if count.values.uniq.length == 1 
     new_arr << e 
     end 
    end 
    end 
    p new_arr 
end 

puts "-----Even Splitters----" 
puts even_splitters("") == [] 
puts even_splitters("t") == ["t"] 
puts even_splitters("jk") == ["j", "k"] 
puts even_splitters("xoxo") == ["x", "o"] 
puts even_splitters("banana") == ["b","a"] 
puts even_splitters("mishmash") == ["m","h"] 

Answer 1

hier einige Vorschläge, wo Sie falsch gehen ...

def even_splitters(str) 
    new_arr = [] 
    # use #uniq here... you don't need to test every 'a' in 'banana' 
    str.chars.uniq.each do |e| 
    # initialize the hash **inside** the loop, otherwise count is just accumulating as each letter is tested 
    count = Hash.new(0) 
    # exclude empty strings 
    arr = str.split(e).reject(&:empty?) 
    arr.each {|x| count[x] = x.length } 
     # handle single character strings like "t"which have no values by saving if count.values.empty? 
     if count.values.uniq.length <= 1 
     new_arr << e 
     end 
    end 
    p new_arr 
end 

puts even_splitters("") == [] 
puts even_splitters("t") == ["t"] 
puts even_splitters("jk") == ["j", "k"] 
puts even_splitters("xoxo") == ["x", "o"] 
puts even_splitters("banana") == ["b","a"] 
puts even_splitters("mishmash") == ["m","h"] 

:

"banana".split("a") # => ["b", "n", "n"] (all elements same length) 
"banana".split("b") # => ["", anana"] 
(all elements same length - there's only 
one element "anana" because the empty string doesn't count) 
"banana".split("n") # => ["ba", "a", "a"] (all elements NOT same length) 

result: ["b", "a"] 

Hier ist mein Code

Hier ist eine kompaktere Lösung ...

def even_splitters(str) 
    str.chars.uniq.map do |e| 
    str.split(e).reject(&:empty?).map(&:length).uniq.count <= 1 ? e : nil 
    end.compact 
end 

Answer 2

Edit: nachdem ich ein paar Änderungen an meinem Code vorgenommen habe, sehe ich, dass es jetzt sehr nah an @ Steves "kompakter Lösung" ist. Ich werde meine Antwort für den Abschnitt "Erläuterung" hinterlassen.

@SteveTurczyn hat Ihre Frage beantwortet und schlug auch eine alternative Methode vor. Hier ist ein anderer.

-Code

def even_splitters(str) 
    str.chars. 
     uniq. 
     select do |c| (str.split(c)-[""]). 
        map(&:size). 
        uniq. 
        size == 1 
     end 
end 

Beispiele

Beispiele Steves Verwendung,

even_splitters("") 
    #=> [] 
even_splitters("t") 
    #=> [] 
even_splitters("jk") 
    #=> ["j", "k"] 
even_splitters("xoxo") 
    #=> ["x", "o"] 
even_splitters("banana") 
    #=> ["b","a"] 
even_splitters("mishmash") 
    #== ["m","h"] 

Erklärung

Angenommen

str = "xoxo" 

Die Schritte sind wie folgt:

a = str.chars 
    #=> ["x", "o", "x", "o"] 
b = a.uniq 
    #=> ["x", "o"] 
b.select do |c| (str.split(c)-[""]). 
       map(&:size). 
       uniq. 
       size == 1 
end 
    #=> ["x", "o"] 

ist genauer an b.select aussehen lassen. Das erste Element des b wird an den Block übergeben und an die Blockvariable zugewiesen:

c = "x" 

und der Block Berechnung durchgeführt:

d = str.split(c) 
    #=> str.split("x") 
    #=> ["", "o", "o"] 
e = d - [""] 
    #=> ["o", "o"] 
f = e.map(&:size) 
    #=> [1, 1] 
g = f.uniq 
    #=> [1] 
g.size == 1 
    #=> true 

Da g.size==1 #=> true, "x" ausgewählt ist.

Als nächstes wird die zweite und letzte Element der b wird an den Block übergeben, und die Berechnungen werden durchgeführt:

c = "o" 
d = str.split(c) 
    #=> str.split("o") 
    #=> ["x", "x"] 
e = d - [""] 
    #=> ["x", "x"] 
f = e.map(&:size) 
    #=> [1, 1] 
g = f.uniq 
    #=> [1] 
g.size == 1 
    #=> true 

so "o" ist ebenfalls enthalten.