cadenas de Normalización de Saltee() y .Tomar() llama

Question

Estoy tratando de normalizar las cadenas arbitrarias de .Skip() y .Take() llamadas a una sola llamada .Skip() seguido de una sola opcional .Take() llamada.

Éstos son algunos ejemplos de los resultados esperados, pero no estoy seguro de si estos son correctos:

.Skip(5)      => .Skip(5) 
.Take(7)      => .Skip(0).Take(7) 

.Skip(5).Skip(7)    => .Skip(12) 
.Skip(5).Take(7)    => .Skip(5).Take(7) 
.Take(7).Skip(5)    => .Skip(5).Take(2) 
.Take(5).Take(7)    => .Skip(0).Take(5) 

.Skip(5).Skip(7).Skip(11)  => .Skip(23) 
.Skip(5).Skip(7).Take(11)  => .Skip(12).Take(11) 
.Skip(5).Take(7).Skip(3)  => .Skip(8).Take(4) 
.Skip(5).Take(7).Take(3)  => .Skip(5).Take(4) 
.Take(11).Skip(5).Skip(3)  => .Skip(8).Take(3) 
.Take(11).Skip(5).Take(7)  => .Skip(5).Take(6) 
.Take(11).Take(5).Skip(3)  => .Skip(3).Take(2) 
.Take(11).Take(5).Take(3)  => .Skip(0).Take(3) 

Alguien puede confirmar estos son los resultados correctos se pueden esperar?

---

Aquí está el algoritmo básico que deriva de los ejemplos:

class Foo 
{ 
    private int skip; 
    private int? take; 

    public Foo Skip(int value) 
    { 
     if (value < 0) 
      value = 0; 

     this.skip += value; 

     if (this.take.HasValue) 
      this.take -= value; 

     return this; 
    } 

    public Foo Take(int value) 
    { 
     if (value < 0) 
      value = 0; 

     if (!this.take.HasValue || value < this.take) 
      this.take = value; 

     return this; 
    } 
} 

Alguna idea de cómo puedo confirmar si este es el algoritmo correcto?

Answer 1

Este es un escenario perfecto para TDD. Dado que ha definido su especificación anterior, debe ser cake para implementar como una serie de solo un par de pruebas.

"Correcto" es bastante subjetivo, pero esos ejemplos parecen cuerdos.

Además, yo normalizaría las llamadas .Skip(0).

Asegúrese de definir claramente las cajas de borde. Por ejemplo,

.Take(11).Skip(12).Take(1) 

probablemente se debe normalizar en una edición .Take(0)

---

:

La definición oficial de salto:

no pasa por un número determinado de elementos en una secuencia y luego devuelve los elementos restantes.

y tomar:

devuelve un número especificado de elementos contiguos desde el principio de la secuencia.

Según sus ejemplos, creo que sus casos de prueba están siguiendo las especificaciones.