Mezclar parte de un ArrayBuffer en contexto

Question

Necesito mezclar parte de un ArrayBuffer, preferiblemente en el lugar, por lo que no se requieren copias. Por ejemplo, si un ArrayBuffer tiene 10 elementos, y quiero mezclar elementos 3-7:

// Unshuffled ArrayBuffer of ints numbered 0-9 
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 

// Region I want to shuffle is between the pipe symbols (3-7) 
0, 1, 2 | 3, 4, 5, 6, 7 | 8, 9 

// Example of how it might look after shuffling 
0, 1, 2 | 6, 3, 5, 7, 4 | 8, 9 

// Leaving us with a partially shuffled ArrayBuffer 
0, 1, 2, 6, 3, 5, 7, 4, 8, 9 

que he escrito algo como se muestra a continuación, pero requiere de copias y la iteración en bucles de un par de veces. Parece que debería haber una manera más eficiente de hacer esto.

def shufflePart(startIndex: Int, endIndex: Int) { 

    val part: ArrayBuffer[Int] = ArrayBuffer[Int]() 

    for (i <- startIndex to endIndex) { 
    part += this.children(i) 
    } 

    // Shuffle the part of the array we copied 
    val shuffled = this.random.shuffle(part) 
    var count: Int = 0 

    // Overwrite the part of the array we chose with the shuffled version of it 
    for (i <- startIndex to endIndex) { 
    this.children(i) = shuffled(count) 
    count += 1 
    } 
} 

No pude encontrar nada acerca de mezclar parcialmente un ArrayBuffer con Google. Supongo que tendré que escribir mi propio método, pero al hacerlo me gustaría evitar copias.

Answer 1

No estoy del todo seguro de por qué debe estar en su lugar, es posible que desee pensar en eso. Sin embargo, asumiendo que es lo que hay que hacer, esto podría hacerlo:

import scala.collection.mutable.ArrayBuffer 

implicit def array2Shufflable[T](a: ArrayBuffer[T]) = new { 
    def shufflePart(start: Int, end: Int) = { 
    val seq = (start.max(0) until end.min(a.size - 1)).toSeq 
    seq.zip(scala.util.Random.shuffle(seq)) foreach { t => 
     val x = a(t._1) 
     a.update(t._1, a(t._2)) 
     a(t._2) = x 
    } 
    a 
    } 
} 

Usted puede usarlo como:

val a = ArrayBuffer(1,2,3,4,5,6,7,8,9) 
println(a) 
println(a.shufflePart(2, 7)) 

edición: Si usted está dispuesto a pagar el coste adicional de una secuencia intermedia, esto es más razonable, hablando de forma algorítmica:

def shufflePart(start: Int, end: Int) = { 
    val seq = (start.max(0) until end.min(a.size - 1)).toSeq 
    seq.zip(scala.util.Random.shuffle(seq) map { i => 
     a(i) 
    }) foreach { t => 
     a.update(t._1, t._2) 
    } 
    a 
    } 
} 

Answer 2

Si puede utilizar un subtipo de ArrayBuffer se puede acceder a la matriz subyacente miembro directamente, ya que ResizableArray tiene una protegida array:

import java.util.Collections 
import java.util.Arrays 
import collection.mutable.ArrayBuffer 


val xs = new ArrayBuffer[Int]() { 
    def shuffle(a: Int, b: Int) { 
    Collections.shuffle(Arrays.asList(array: _*).subList(a, b)) 
    } 
} 

xs ++= (0 to 9) // xs = ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 
xs.shuffle(3, 8) // xs = ArrayBuffer(0, 1, 2, 4, 6, 5, 7, 3, 8, 9) 

Notas:

• El límite superior para java.util.List#subList es exclusiva
• Es razonablemente eficiente porque Arrays#asList no crea un nuevo conjunto de elementos: está respaldado por la matriz misma (de ahí que no se agreguen o eliminen métodos)
• Si se usa de forma real, es probable que desee agregar límites-cheques en a y b