Ruby chaque question logique

Question

Je suis en train de résoudre un problème simple Ruby de Seven Languages in Seven Weeks

Imprimer le contenu d'un tableau de seize numéros, quatre numéros à la fois , en utilisant seulement each

Voici ce que j'ai trouvé, cela peut-il être fait d'une manière simple ou le rendre meilleur?

a = (1..16).to_a 

i = 0 
j = [] 
a.each do |item| 
    i += 1 
    j << item 
    if(i % 4 == 0) 
    p j 
    j = [] 
    end 
end 

Il peut faire en utilisant each_slice dans une ligne

a.each_slice(4){|x| p x}

Answer 1

Teja, votre solution est ok. Comme vous avez besoin d'utiliser chacun, la complexité de l'algorithme va être limitée à la taille de votre tableau.

J'ai trouvé la solution ci-dessous. C'est la même idée que la vôtre sauf qu'elle n'utilise pas un var (j) pour stocker les résultats partiels.

i = 0 
a.each do |item| 
    p a[i, 4] if(i % 4 == 0) 
    i +=1 
end 

Answer 2

Essayez ceci:

(1..16).each do |item| 
    print "#{item} " 
    print "\n" if item % 4 == 0 
end 

Answer 3

Le problème n'a pas précisé que le tableau de seize numéros étaient séquentielle ou a commencé à un ... nous allons créé une solution qui fonctionne pour tous les 16 numéros.

########## 
# Method 1 - Store chunks of 4 and print at the end 
########## 
a = (1..16).to_a 
b = [] 
a.each do |item| 
    b << [] if b.size == 0 
    b << [] if b[-1].size == 4 
    b[-1] << item 
end 

# choose your desired printing method 
print b 
b.each{|c| puts c.join(",")} 

########## 
# Method 2 - print the chunks as they are encountered 
########## 

# Note: "p" was specifically chosen over "print" because it returns the value printed instead of nil. 
#  If you use a different printing function, make sure it returns a value otherwise the 'b' array will not clear. 


# Note: This implementation only prints out all array entries if a multiple of 4 
#  If 'b' contains any items outside the loop, they will not be printed 
a = (1..16).to_a 
b = [] 
a.each do |item| 
    b << item 
    b = [] if b.size == 4 and puts b 
end 


# Note: This implementation will print all array elements, even if number of elements is not multiple of 4. 
a = (1..16).to_a 
b = [] 
a.each do |item| 
    b = [] if b.size == 4 and p b 
    b << item 
end 
p b 

Answer 4

Je pense que cela devrait fonctionner pour tout tableau de taille et de tout x morceau de taille:

x = 4 
(0...(a.size/x.to_f).ceil).each {|i| p a.slice(x*i,x)} 

Answer 5

J'utilise quelque chose de similaire à Miguel de, bien que son est plus propre:

array = (1..16).to_a 
i = 0 
array.each do 
    puts array[i...i+4].to_s if i % 4 == 0 and i+4 <= array.size 
    i+=4 
end 

Answer 6

Est-il interdit d'utiliser each_with_index? Sinon, la construction sur @ réponse de Miguel:

a.each_with_index do |item, i| 
    p a[i, 4] if i.modulo(4).zero? 
end 

J'ai également remplacé i % 4 == 0 avec quelque chose qui ressemble à l'anglais ("i modulo 4 est égal à zéro")

Answer 7

Un one-liner sans tranche:

a.each {|i| p a[i,4] if (i+3) % 4 == 0} 

Answer 8

Glenn Macdonald's est court, mais il utilise une tranche qui n'est pas autorisée (seulement chacun, rappelez-vous). Voici le mien:

(0...a.size).each {|index| p a[index, 4] if index % 4 == 0} 

qui fonctionne aussi bien pour d'autres tailles de tableau, ici appliqué à une 18 gamme de taille:

>> a = (113..150).to_a.insert(5,55).insert(10,66666).shift(18) 
=> [113, 114, 115, 116, 117, 55, 118, 119, 120, 121, 66666, 122, 123, 124, 125, 126, 127, 128] 
>> (0...a.size).each {|index| p a[index, 4] if index % 4 == 0} 
[113, 114, 115, 116] 
[117, 55, 118, 119] 
[120, 121, 66666, 122] 
[123, 124, 125, 126] 
[127, 128] 
=> 0...18