Jaki jest najlepszy sposób na podzielenie łańcucha, aby uzyskać wszystkie podciągi przez Ruby?

Question

Na przykład słowa "stos", chcę uzyskać tablicę jak:

['s', 'st', 'sta', ... 'stack', 't', 'ta', ... , 'c', 'ck', 'k'] 

Robiłam to przez takiego kodu:

def split_word(str) 
    result = [] 
    chas = str.split("") 
    len = chas.size 
    (0..len-1).each do |i| 
    (i..len-1).each do |j| 
     result.push(chas[i..j].join) 
    end 
    end 
    result.uniq 
end 

Czy istnieje lepszy i czysty sposób to zrobić? Dzięki.

Answer 1

def split_word s 
    (0..s.length).inject([]){|ai,i| 
    (1..s.length - i).inject(ai){|aj,j| 
     aj << s[i,j] 
    } 
    }.uniq 
end 

Można również rozważyć użycie Set zamiast Array dla wyniku.

PS: Oto kolejny pomysł, oparty na produkcie tablicy:

def split_word s 
    indices = (0...s.length).to_a 
    indices.product(indices).reject{|i,j| i > j}.map{|i,j| s[i..j]}.uniq 
end 

Answer 2

Nie sądzę.

Oto moja próba wersja:

def split_word(str) 
    length = str.length - 1 
    [].tap do |result| 
    0.upto(length) do |i| 
     length.downto(i) do |j| 
     substring = str[i..j] 
     result << substring unless result.include?(substring) 
     end 
    end 
    end 
end 

Answer 3

bym napisać:

def split_word(s) 
    0.upto(s.length - 1).flat_map do |start| 
    1.upto(s.length - start).map do |length| 
     s[start, length] 
    end 
    end.uniq 
end 

groups = split_word("stack") 
# ["s", "st", "sta", "stac", "stack", "t", "ta", "tac", "tack", "a", "ac", "ack", "c", "ck", "k"] 

To zwykle bardziej przejrzyste i bardziej kompaktowy używać map (funkcjonalne) zamiast wzór init pusty + każdy + dołącz + powróć (imperatyw).

Answer 4

Sposób później, ale to jest to, co otrzymałem od ponownego formatowania twojego kodu.

def substrings(string) 
    siz = string.length 
    answer = [] 

    (0..siz-1).each do |n| 
    (n..siz-1).each do |i| 
     answer << string[n..i] 
    end 
    end 
    answer 
end 

Answer 5

def substrings(str) 
    output = [] 
    (0...str.length).each do |i| 
    (i...str.length).each do |j| 
     output << str[i..j] 
    end 
    end 
    output 
end 

to tylko oczyścić wersję swojej metody i działa z mniejszą ilością kroków =)

Answer 6

def substrings(str) 
    (0...str.length).map do |i| 
    (i...str.length).each { |j| str[i..j]} 
    end 
end 

Jeszcze jeden sposób na to, że brzmi trochę jaśniejsze do mnie.