<< Anterior Siguiente >>

Gracias a la comunidad PPCG, Santa logró ordenar sus regalos en el orden correcto para mudarse al muelle de transporte. ¡Desafortunadamente, las señales del muelle de transporte están rotas, por lo que no sabe dónde poner todos los regalos! Los regalos están todos agrupados y no por sus gamas, lo que Santa admite que habría sido una mejor idea.

Ahora, dados los presentes en el orden ordenado, determine todas las configuraciones posibles de rango mínimo que resulten en el presente en el orden correcto. Es decir, encuentre todas las configuraciones de rango mínimo de tal manera que ordenar los regalos de acuerdo con el algoritmo en el Desafío # 5 no cambie el orden.

Desafío

Una configuración de rango mínimo es una lista de rangos de modo que los rangos sean lo más pequeños posible. Es decir, si un rango está designado para cubrir un subconjunto específico de regalos, entonces el mínimo y el máximo del rango deben ser los mismos que los del subconjunto. En otras palabras, reducir cualquier rango en la cubierta haría que ya no sea una cubierta.

El desafío es encontrar todas las configuraciones de rango mínimo posibles que se apliquen a los tamaños actuales. Tomemos un ejemplo:[3, 1, 2, 5, 4, 7, 6]

Hay un caso trivial, que consiste en tomar el rango de toda la configuración actual. En este caso, [[1, 7]]sería una solución.

Para ejemplos con elementos únicos, sería otro caso trivial [[3], [1], [2], [5], [4], [7], [6]](porque no es necesario ordenar los rangos).

Para este ejemplo, también vemos eso [[1, 3], [4, 7]]y [[1, 3], [4, 5], [6, 7]]funcionaría, así como [[1, 3], [5], [4], [6, 7]]y [[1, 3], [4, 5], [7], [6]].

La respuesta final para [3, 1, 2, 5, 4, 7, 6]sería [[[3], [1], [2], [5], [4], [7], [6]], [[3], [1], [2], [5], [4], [6, 7]], [[3], [1], [2], [4, 5], [7], [6]], [[3], [1], [2], [4, 5], [6, 7]], [[3], [1], [2], [4, 7]], [[3], [1, 2], [5], [4], [7], [6]], [[3], [1, 2], [5], [4], [6, 7]], [[3], [1, 2], [4, 5], [7], [6]], [[3], [1, 2], [4, 5], [6, 7]], [[3], [1, 2], [4, 7]], [[1, 3], [5], [4], [7], [6]], [[1, 3], [5], [4], [6, 7]], [[1, 3], [4, 5], [7], [6]], [[1, 3], [4, 5], [6, 7]], [[1, 3], [4, 7]], [[1, 5], [7], [6]], [[1, 5], [6, 7]], [[1, 7]]].

Especificaciones de formato

La entrada se proporcionará como una lista plana de enteros positivos dentro del rango de números admitido razonable de su idioma en cualquier formato razonable. La entrada puede contener elementos duplicados. La salida debe darse como una lista 3D de enteros positivos en cualquier formato razonable.

Cada rango en su salida (que está en la segunda capa) se puede representar como [min, max], [num]si es un rango de valor único, o como el rango completo en sí, pero su formato de salida debe ser consistente. Especifique si desea utilizar un formato de salida razonable ligeramente diferente.

Los valores duplicados deben estar cubiertos por un único rango en la salida; es decir, no hay dos rangos en la salida que puedan tener superposición.

Su solución puede devolver los rangos en cualquier orden y esto no tiene que ser determinista.

Reglas

• Se aplican lagunas estándar
• Este es el código de golf, por lo que gana la respuesta más corta en bytes
• No se aceptarán respuestas.

Caso de prueba para una lista con elementos duplicados:

2 3 2 4 -> [[[2, 3], [4]], [[2, 4]]]

Implementación de referencia

El encabezado es el enlace.

^{Nota: Me inspiré para esta serie de desafíos de Advent Of Code . No estoy afiliado a este sitio}

Puede ver una lista de todos los desafíos de la serie mirando la sección 'Vinculados' del primer desafío aquí .

¡Feliz golf!

Mathematica, 106 bytes

sSelect[MinMax/@s~TakeList~#&/@Join@@Permutations/@IntegerPartitions@Tr[1^s],Unequal@@Join@@Range@@@#&]

Pruébalo en línea!

Martin ahorró 16 bytes

Brachylog , 17 16 bytes

{~c⟨⌋⟦₂⌉⟩ᵐ.c≠∧}ᶠ

Funciona en listas con duplicados también. Los rangos están representados por las listas de elementos que contienen. Pruébalo en línea!

Explicación

La idea es dividir la lista en bloques y transformar los bloques en rangos, luego verificar que no se superpongan.

{~c⟨⌋⟦₂⌉⟩ᵐ.c≠∧}ᶠ  Input is a list.
{             }ᶠ  Compute all possible outputs for this predicate:
 ~c                Break the list into contiguous blocks.
   ⟨    ⟩ᵐ         For each block,
    ⌋  ⌉           take its minimum and maximum,
     ⟦₂            and create the range between them.
          .        This is the output.
           c       Also, if you concatenate the output,
            ≠      its elements are distinct.
             ∧     Prevent the interpreter from thinking this is also the output.

JavaScript (ES6), 166 164 bytes

Editar: versión actualizada que ahora admite duplicados

Imprime los resultados directamente en la consola en formato [min, max] .

f=(a,r=[],l=0)=>a[l++]?f([...a],r,l,f(a,[...r,[Math.min(...x=a.splice(0,l)),Math.max(...x)]])):a[0]|r.some(([x,y],i)=>r.some(([z])=>i--&&z>=x&z<=y))||console.log(r)

Casos de prueba

f=(a,r=[],l=0)=>a[l++]?f([...a],r,l,f(a,[...r,[Math.min(...x=a.splice(0,l)),Math.max(...x)]])):a[0]|r.some(([x,y],i)=>r.some(([z])=>i--&&z>=x&z<=y))||console.log(r)

consoleLog = console.log;
console.log = s => consoleLog(JSON.stringify(s))

consoleLog('Test case: [3, 1, 2, 5, 4, 7, 6]')
f([3, 1, 2, 5, 4, 7, 6])
consoleLog('Test case: [2, 3, 2, 4]')
f([2, 3, 2, 4])

Python 2 , 179 bytes

lambda l:[l for l in[[range(min(x),max(x)+1)for x in P]for P in p(l)]if len(sum(l,[]))==len(set(sum(l,[])))]
p=lambda l:[[l[:i]]+a for i in range(1,len(l))for a in p(l[i:])]+[[l]]

Pruébalo en línea!

Emite una lista de rangos completos.

Muy inspirado por la implementación de referencia.

Construye todas las particiones, luego rangos de min / max para cada partición. Una lista de rangos es válida si ningún valor aparece más de una vez en la lista.

sum(l,[]) aplana una lista de listas y me permite verificar si hay duplicados:

l=[[1, 2], [2, 3]]
sum(l,[]) = [1,2,2,3]
len([1,2,2,3] == len(set([1,2,2,3]))  -> False (duplicates)

Pyth , 17 bytes

f{IsTmm}hSkeSkd./

Pruébalo aquí!

Ahora eso está mucho mejor. Emite los rangos completos. Consulte el historial de revisiones de la versión anterior (con 31 bytes asombrosos).

Cómo funciona

f {IsTmm} hSkeSkd./ ~> Programa completo.

               ./ ~> Partición de lista.
     m ~> Mapa usando una variable d.
      md ~> Mapa sobre d usando una variable k.
        hSk ~> El mínimo de k.
           eSk ~> El máximo de k.
       } ~> Rango entero inclusivo.
f ~> Filtrar esos ...
   sT ~> Que, cuando se aplana,
 {I ~> son invariantes sobre la deduplicación.