Ruby'de bir dizeyi belirli bir uzunluktaki parçalara ayırmanın en iyi yolu nedir?

Ruby'de belirli bir uzunluktaki alt dizelere bir dizge eklemenin zarif ve verimli bir yolunu arıyordum.

Şimdiye kadar bulabildiğim en iyi şey şudur:

def chunk(string, size)
  (0..(string.length-1)/size).map{|i|string[i*size,size]}
end

>> chunk("abcdef",3)
=> ["abc", "def"]
>> chunk("abcde",3)
=> ["abc", "de"]
>> chunk("abc",3)
=> ["abc"]
>> chunk("ab",3)
=> ["ab"]
>> chunk("",3)
=> []

Bunun yerine chunk("", n)geri dönmek isteyebilirsiniz . Öyleyse, bunu yöntemin ilk satırı olarak eklemeniz yeterlidir:[""][]

return [""] if string.empty?

Daha iyi bir çözüm önerir misiniz?

Düzenle

Bu zarif ve etkili çözüm için Jeremy Ruten'e teşekkürler: [düzenleme: Verimli DEĞİL!]

def chunk(string, size)
    string.scan(/.{1,#{size}}/)
end

Düzenle

String.scan çözümü, yalnızca 2,4 saniye süren orijinal dilim tabanlı çözüme kıyasla 512 bin parçayı 10000 kez 1 bin parçaya ayırmak yaklaşık 60 saniye sürer.

Kullanım String#scan:

>> 'abcdefghijklmnopqrstuvwxyz'.scan(/.{4}/)
=> ["abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx"]
>> 'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,4}/)
=> ["abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx", "yz"]
>> 'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,3}/)
=> ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz"]

İşte bunu yapmanın başka bir yolu:

"abcdefghijklmnopqrstuvwxyz".chars.to_a.each_slice(3).to_a.map {|s| s.to_s }

=> ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz"]

Dizinizin yığın boyutunun katları olduğunu biliyorsanız, bunun en etkili çözüm olduğunu düşünüyorum.

def chunk(string, size)
    (string.length / size).times.collect { |i| string[i * size, size] }
end

ve parçalar için

def parts(string, count)
    size = string.length / count
    count.times.collect { |i| string[i * size, size] }
end

Burada, büyük dizeleri işlerken biraz farklı durum için başka bir çözüm var ve bir seferde tüm parçaları depolamaya gerek yok. Bu şekilde, bir seferde tek parçayı depolar ve dizeleri dilimlemekten çok daha hızlı performans gösterir:

io = StringIO.new(string)
until io.eof?
  chunk = io.read(chunk_size)
  do_something(chunk)
end

Yaklaşık 593MB veriyi 18991 32KB parçalara bölen küçük bir test yaptım. Dilim + harita sürümünüz ctrl + C'ye basmadan önce% 100 CPU kullanarak en az 15 dakika çalıştı. String # unpack kullanan bu sürüm 3.6 saniyede tamamlandı:

def chunk(string, size)
  string.unpack("a#{size}" * (string.size/size.to_f).ceil)
end

test.split(/(...)/).reject {|v| v.empty?}

Red, aksi takdirde setler arasındaki boş alanı içerdiği için gereklidir. Benim regex-fu'm, bunu aklıma getirmeden nasıl düzelteceğimi görmekle yetinmiyor.

Dizenin yığın boyutundan daha küçük olabilecek son bölümünü hesaba katan daha iyi bir çözüm:

def chunk(inStr, sz)  
  return [inStr] if inStr.length < sz  
  m = inStr.length % sz # this is the last part of the string
  partial = (inStr.length / sz).times.collect { |i| inStr[i * sz, sz] }
  partial << inStr[-m..-1] if (m % sz != 0) # add the last part 
  partial
end

Aklınızda bulunan başka kısıtlamalar var mı? Aksi takdirde, şunun gibi basit bir şey yapma konusunda son derece cazip olurdum

[0..10].each {
   str[(i*w),w]
}

Sadece text.scan(/.{1,4}/m)sorunu çözer