tutorial - ruby wikipedia

Reposicionar un elemento al frente de una matriz en Ruby

Question

Incluso viniendo de javascript esto me parece atroz:

irb
>> a = [''a'', ''b'', ''c'']
=> ["a", "b", "c"]
>> a.unshift(a.delete(''c''))
=> ["c", "a", "b"]

¿Hay una forma más legible de colocar un elemento en la parte frontal de una matriz?

Editar mi código actual:

if @admin_users.include?(current_user)
@admin_users.unshift(@admin_users.delete(current_user))
end

Answer 1

Agregando mis dos centavos:

array.select{ |item| <condition> } | array

Pros:

• Puede mover varios elementos al frente de la matriz

Contras:

• Esto eliminará todos los duplicados a menos que sea el resultado deseado.

Ejemplo: mueva todos los números impares al frente (y haga que la matriz sea única):

data = [1, 2, 3, 4, 3, 5, 1]
data.select{ |item| item.odd? } | data
# Short version:
data.select(&:odd?) | data

Resultado:

[1, 3, 5, 2, 4]

Answer 2

Al final, consideré que esta es la alternativa más legible para mover un elemento al frente:

if @admin_users.include?(current_user)
@admin_users.sort_by{|admin| admin == current_user ? 0 : 1}
end

Answer 3

De otra manera:

a = [1, 2, 3, 4]
b = 3
[b] + (a - [b])
=> [3, 1, 2, 4]

Answer 4

Este es un problema más complicado de lo que parece. Definí las siguientes pruebas:

describe Array do
describe ''.promote'' do
subject(:array) { [1, 2, 3] }
it { expect(array.promote(2)).to eq [2, 1, 3] }
it { expect(array.promote(3)).to eq [3, 1, 2] }
it { expect(array.promote(4)).to eq [1, 2, 3] }
it { expect((array + array).promote(2)).to eq [2, 1, 3, 1, 2, 3] }
end
end

sort_by propuesto por @Duopixel es elegante pero produce [3, 2, 1] para la segunda prueba.

class Array
def promote(promoted_element)
sort_by { |element| element == promoted_element ? 0 : 1 }
end
end

@tadman utiliza delete , pero esto elimina todos los elementos coincidentes, por lo que la salida de la cuarta prueba es [2, 1, 3, 1, 3] .

class Array
def promote(promoted_element)
if (found = delete(promoted_element))
unshift(found)
end
self
end
end

Intenté usar:

class Array
def promote(promoted_element)
return self unless (found = delete_at(find_index(promoted_element)))
unshift(found)
end
end

Pero eso falló la tercera prueba porque delete_at no puede manejar nil. Finalmente, me decidí por:

class Array
def promote(promoted_element)
return self unless (found_index = find_index(promoted_element))
unshift(delete_at(found_index))
end
end

¿Quién sabía que una idea simple como promote podría ser tan difícil?

Answer 5

Si por "elegante" quiere decir más legible incluso a costa de no ser estándar, siempre podría escribir su propio método que mejore la matriz:

class Array
def promote(value)
if (found = delete(value))
unshift(found)
end
self
end
end
a = %w[ a b c ]
a.promote(''c'')
# => ["c", "a", "b"]
a.promote(''x'')
# => ["c", "a", "b"] 

Tenga en cuenta que esto solo reposicionaría una sola instancia de un valor. Si hay varios en la matriz, los posteriores probablemente no se moverán hasta que se elimine el primero.

Answer 6

Si todos los elementos de la matriz son únicos, puede utilizar la aritmética de matriz:

> a = [''a'', ''b'', ''c'']
=> ["a", "b", "c"]
> a -= "c"
=> ["a", "b"]
> a = ["c"] + a
=> ["c", "a", "b"]

Answer 7

Tal vez Array#rotate podría funcionar para usted:

[''a'', ''b'', ''c''].rotate(-1)
#=> ["c", "a", "b"]

Answer 8

Tal vez esto te parezca mejor:

a.insert(0, a.delete(''c''))