<< Anterior Próximo >>

Graças à comunidade do PPCG, o Papai Noel conseguiu classificar seus presentes na ordem correta para se mudar para o cais de transporte. Infelizmente, os sinais do cais de transporte estão quebrados para que ele não saiba onde colocar todos os presentes! Os presentes são todos agrupados e não por faixas, o que Papai Noel admite que teria sido uma idéia melhor.

Agora, considerando os presentes na ordem classificada, determine todas as configurações possíveis de alcance mínimo que resultariam no presente na ordem correta. Ou seja, encontre todas as configurações de alcance mínimo, para que a classificação dos presentes de acordo com o algoritmo do Desafio nº 5 não mude a ordem.

Desafio

Uma configuração de intervalo mínima é uma lista de intervalos, de modo que cada intervalo seja o menor possível. Ou seja, se um intervalo for designado para cobrir um subconjunto específico de presentes, o mínimo e o máximo do intervalo deverão ser os mesmos do subconjunto. Em outras palavras, encolher qualquer faixa da capa deixaria de ser uma capa.

O desafio é encontrar todas as configurações possíveis de alcance mínimo que se aplicariam aos tamanhos atuais. Vamos dar um exemplo:[3, 1, 2, 5, 4, 7, 6]

Existe um caso trivial, que consiste em variar toda a configuração atual. Nesse caso, [[1, 7]]seria uma solução.

Para exemplos com elementos exclusivos, outro caso trivial seria [[3], [1], [2], [5], [4], [7], [6]](porque os intervalos não precisam ser pedidos).

Neste exemplo, também vemos isso [[1, 3], [4, 7]]e [[1, 3], [4, 5], [6, 7]]funcionaria, assim como [[1, 3], [5], [4], [6, 7]]e [[1, 3], [4, 5], [7], [6]].

A resposta final para [3, 1, 2, 5, 4, 7, 6]seria [[[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]]].

Especificações de formatação

A entrada será fornecida como uma lista plana de números inteiros positivos dentro do intervalo razoável de números suportados do seu idioma, em qualquer formato razoável. A entrada pode conter elementos duplicados. A saída deve ser fornecida como uma lista 3D de números inteiros positivos em qualquer formato razoável.

Cada gama na sua saída (que é na segunda camada) pode ser representado tanto como [min, max], [num]se for uma gama de valor único, ou como toda a própria gama, mas o formato de saída deve ser consistente. Especifique se deseja usar um formato de saída razoável ligeiramente diferente.

Valores duplicados devem ser cobertos por um único intervalo na saída; isto é, não há dois intervalos na saída que possam ter sobreposição.

Sua solução pode retornar os intervalos em qualquer ordem e isso não precisa ser determinístico.

Regras

• As brechas padrão se aplicam
• Isso é código-golfe, então a resposta mais curta em bytes vence
• Nenhuma resposta será aceita

Caso de teste para uma lista com elementos duplicados:

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

Implementação de referência

O cabeçalho é o link.

^{Nota: Eu me inspirei para esta série de desafios da Advent Of Code . Não tenho afiliação com este site}

Você pode ver uma lista de todos os desafios da série consultando a seção 'Vinculado' do primeiro desafio aqui .

Feliz golfe!

Mathematica, 106 bytes

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

Experimente online!

Martin salvou 16 bytes

Braquilog , 17 16 bytes

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

Funciona em listas com duplicatas também. As faixas são representadas pelas listas de elementos que elas contêm. Experimente online!

Explicação

A idéia é dividir a lista em blocos e transformar os blocos em intervalos e, em seguida, verifique se eles não se sobrepõem.

{~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: versão atualizada que agora suporta duplicatas

Imprime os resultados diretamente no console no 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 teste

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]]

Experimente online!

Mostra uma lista de faixas completas.

Fortemente inspirado pela implementação de referência.

Cria todas as partições e, em seguida, intervalos de mín / máx para cada partição. Uma lista de intervalos é válida se nenhum valor aparecer mais de uma vez na lista.

sum(l,[]) nivela uma lista de listas e permite verificar duplicatas:

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

Pitão , 17 bytes

f{IsTmm}hSkeSkd./

Experimente aqui!

Agora isso é muito melhor. Emite todos os intervalos. Veja o histórico de revisões da versão anterior (em impressionantes 31 bytes).

Como funciona

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

               ./ ~> Listar partição.
     m ~> Mapa usando uma variável d.
      md ~> Mapeie sobre d usando uma variável k.
        hSk ~> O mínimo de k.
           eSk ~> O máximo de k.
       } ~> Intervalo inteiro inclusivo.
f ~> Filtre esses ...
   sT ~> Que, quando achatada,
 {I ~> São invariantes em relação à desduplicação.