Classificação aleatória de bloco

A classificação aleatória de bloco é um método (bastante artificial) de classificar uma lista. Funciona da seguinte maneira, ilustrado por um exemplo.

[6, 1, 0, 3, 2, 4, -2, -1]
                            Break list into contiguous blocks
[6][1, 0][3, 2, 4][-2, -1]
                            Sort each block
[6][0, 1][2, 3, 4][-2, -1]
                            Sort blocks lexicographically
[-2, -1][0, 1][2, 3, 4][6]
                            Concatenate
[-2, -1, 0, 1, 2, 3, 4, 6]

A partição em blocos contíguos pode ser escolhida arbitrariamente. No entanto, nem todas as opções de blocos produzirão uma lista classificada no final:

[6, 1, 0, 3, 2, 4, -2, -1]
[6, 1, 0][3, 2, 4][-2, -1]
[0, 1, 6][2, 3, 4][-2, -1]
[-2, -1][0, 1, 6][2, 3, 4]
[-2, -1, 0, 1, 6, 2, 3, 4]

Se todos os blocos tiverem o comprimento 1 ou se houver apenas um bloco, o resultado será naturalmente classificado. Mas esses são casos bastante extremos. Nesse desafio, sua tarefa é encontrar um equilíbrio entre o número de blocos e o comprimento máximo de um bloco.

A tarefa

Sua entrada é uma lista não vazia de números inteiros L , obtidos em qualquer formato razoável. Sua saída deve ser o menor inteiro N tal que L pode ser bloco aleatório ordenados de forma que o número de blocos eo comprimento de cada bloco são, no máximo, N .

A contagem de bytes mais baixa em cada idioma vence. Aplicam-se as regras de código-golfe padrão .

Casos de teste

[5] -> 1
[1,2] -> 2
[0,2,1,-1] -> 3
[-1,0,2,1] -> 2
[9,3,8,2,7] -> 4
[9,2,8,3,7] -> 3
[5,9,3,7,2,4,8] -> 7
[-1,-2,1,2,-1,-2,7] -> 4
[6,1,0,3,2,4,-2,-1] -> 4
[12,5,6,-6,-1,0,2,3] -> 3
[1,0,1,0,1,0,1,0,1,0] -> 6
[1,2,1,3,1,2,3,2,4,3] -> 5
[7,7,7,7,8,9,7,7,7,7] -> 4

Brachylog , 23 22 20 19 bytes

Agradecemos a Zgarb, H.PWiz e Fatalize por salvar uma quantidade de bytes.

~cᶠ{oᵐoc≤₁&≡ᵃlᵐ⌉}ˢ⌋

Experimente online!

Tenho certeza de que há mais para jogar golfe aqui ...

Explicação

~cᶠ      Find all lists that concatenate into the input, i.e. all partitions
         of the input.
{        Discard all partitions for which this predicate fails, and replace
         the rest with the output of this predicate.
  oᵐ       Sort each sublist of the partition.
  o        Sort the entire list.
  c≤₁      And require concatenation of the result to be sorted.
  &        Then:
  ≡ᵃ       Append the partition to itself.
  lᵐ       Map "length" over this list, i.e. we get the length of each block, as
           well as the length of the partition itself.
  ⌉        Take the maximum.
}ˢ
⌋        Take the minimum of all those maxima.

Geléia , 17 bytes

Ṣ€ṢF
ŒṖÇÐṂ+Z$€L€Ṃ

Experimente online!

Versão alternativa, 15 bytes, desafio pós-datas

Na versão mais recente, Ɗcombina três links em uma cadeia monádica. Isso permite o seguinte golfe.

ŒṖṢ€ṢFƊÐṂ+ZLƊ€Ṃ

Experimente online!

Como funciona

Ṣ€ṢF          Helper link. Argument: P (partitioned array)

Ṣ€            Sort each chunk.
  Ṣ           Sort the sorted chunks.
   F          Flatten.


ŒṖÇÐṂ+Z$€L€Ṃ  Main link. Argument: A (array)

ŒṖ            Generate all partitions of A.
  ÇÐṂ         Keep those for which the helper link returns the minimal array, i.e.,
              those that return sorted(A).
     +Z$€     Add each partition to its transpose.
              Due to how Jelly vectorizes, the length of the sum is the maximum of
              the length of the operands, and the length of the transpose is the
              length of the array's largest column.
         L€   Take the length of each sum.
           Ṃ  Take the minimum.

Stax , 28 26 25 24 23 bytes ^CP437

é%(>ù│ê²☻û◙T╠►╜◘íaæAtI╥

Execute e depure online!

Créditos para @recursive por salvar 3 bytes.

Stax é um pouco detalhado aqui. São necessários dois bytes para classificar uma matriz por padrão, dois bytes para obter o máximo / mínimo de uma matriz e dois bytes para achatar uma matriz. De qualquer forma, ainda estou postando a solução e espero que haja sugestões úteis sobre como melhorá-la .

Explicação

Usa a versão descompactada para explicar.

%cFxs|!F{{omo:f:^!C_Mch\%|m
%cFxs|!F                        Do for all partitions, grouped by number of sub-arrays
                                    Grouping by number of sub-arrays in this problem does not help but it's the default                    
        {{om{o                  Sort inside block then sort blocks lexicographically
              :f:^              The result when flattened is sorted
                  !C            Skip the rest of the loop if the last line is false
                    _|<         Take the current partition, pad to the longest

                       h        Take the first element, whose length is now the maximum of all sub-arrays in the original partition
                        \       Zip with the current partition, the shorter one is repeated
                         %      Number of elements
                                Which is the maximum of all sub-array sizes and the number of sub-arrays in the current partition  
                          |m    Take the minimum among all choices of partitions

Braquilog , 17 bytes

~c₎{oᵐoc≤₁&lᵐ⌉≤}ᵈ

Experimente online!

Explicação

Esta é uma resposta automática; Eu projetei esse desafio com Brachylog em mente e encontrei ~c₎{…}ᵈuma construção interessante.

O cinterno concatena uma lista de listas. Se for fornecido um subscrito N, será necessário o número de listas N. O símbolo ₎modifica um built-in para receber um par como entrada e usar o elemento correto como subscrito. Assim, c₎pega um par [L,N], requer que o número de listas em Lseja Ne retorne a concatenação de L. Quando executado em sentido inverso, ~c₎pega uma lista Le retorna um par [P,N], onde Pé uma partição de Lem Nblocos. Eles são enumerados em ordem crescente de N.

O metapredicado ᵈtransforma um predicado comum em um que verifica uma relação entre os dois elementos de um par. Mais explicitamente, {…}ᵈpega um par [A,B], verifica a A{…}Bretenção e a saída B. Uso-o para verificar se é Ppossível classificar blocos e contém apenas listas de comprimento, no máximo N.

~c₎{oᵐoc≤₁&lᵐ⌉≤}ᵈ  Input is a list, say L = [9,2,8,3,7].
~c₎                Guess the pair [P,N]: [[[9],[2],[8,3,7]],3]
   {           }ᵈ  Verify this predicate on P and N and return N:
    oᵐ              Sort each list in P: [[9],[2],[3,7,8]]
      o             Sort lexicographically: [[2],[3,7,8],[9]]
       c            Concatenate: [2,3,7,8,9]
        ≤₁          This list is nondecreasing: true.
          &lᵐ       Length of each list in P: [1,1,3]
             ⌉      Maximum: 3
              ≤     This is at most N: true.

Observe que Ppode conter listas vazias. Isso garante a correção também nos casos em que o comprimento máximo de um bloco é maior que o número de blocos.

Python 2 , 186 146 bytes

lambda l:min(max(map(len,z+[z]))for z in p(l)if sum(s(z),[])==s(l))
p=lambda l:[q+[s(l[i:])]for i in range(len(l))for q in p(l[:i])]or[l]
s=sorted

Experimente online!

A segunda função é retirada dessa dica pelo feersum .

Ruby , 158 bytes

f=->l,i=[],s=l.size,m=s{k=*l;i.sum==s&&i.map{|z|k.shift(z).sort}.sort.flatten==l.sort&&[m,[i.size,*i].max].min||i.sum<s&&(1..s).map{|z|f[l,i+[z],s,m]}.min||m}

Experimente online!

Pitão ,  24 23  20 bytes

hSmeSlMs]Bd.msSSMb./

Suíte de teste.

Como funciona

hSmeSlMs]Bd.msSSMb./ – Full program. Hereby, Q represents the input.
                  ./ – All possible partitions of Q.
           .m        – Take the partitions which yield a minimal (i.e. sorted) list over:
             sSSMb   – Sorting function. Uses the variable b.
               SMb   – Sort each list in each partition b.
              S      – Sort the partition b.
             s       – And flatten (by 1 level).
  meSlMs]Bd          – Map. Uses a function whose variable is d.
        ]Bd          – Pair d with its wrapping in a singleton list. Returns [d, [d]].
       s             – Flatten (by 1 level). Returns [*d, d], where "*" is splatting.
     lM              – Take the length of each element.
   eS                – Retrieve the maximal length.
hS                   – Return the minimum element of the list of maximal lengths.

APL (Dyalog Classic) , 71 67 bytes

{⌊/(⌈/≢,≢¨)¨T/⍨{S[⍋S]≡∊⍵[⍋↑⍵]}¨T←{⍵[⍋⍵]}¨¨⊂∘S¨(-≢S)↑¨2⊥⍣¯1¨⍳2*≢S←⍵}

⎕IO devemos ser 0

Experimente online!

Quão?

• ⌊/- Encontre o mínimo de ...
• (⌈/≢,≢¨)- ... o máximo do comprimento e número de elementos ...
• ¨- ... de cada elemento de ...
• T/⍨- ... os elementos que ...
• {S[⍋S]≡∊⍵[⍋↑⍵]}¨- ... são classificados quando achatados, de ...
• T←{⍵[⍋⍵]}¨¨- ... os elementos classificados dos elementos de ...
• ⊂∘S¨(-≢S)↑¨2⊥⍣¯1¨⍳2*≢S←⍵- ... as partições do argumento (junto com algum lixo)