Seja uma lista de números inteiros positivos sem nenhuma ordem específica e que possa conter duplicatas. Escreva um programa ou função que produza uma lista de números inteiros positivos M (cuja ordem não é importante), de modo que a combinação de L e M resulte na menor lista que pode ser totalmente dividida em intervalos idênticos de números inteiros [ 1 .. i ] , onde i é o maior elemento em $L$$M$$L$$M$$[1..i]$$i$$L$

Exemplo

Let L = [5,3,3,2,7]. O elemento máximo de Lé 7. A maioria das vezes que um número inteiro específico ocorre é 2( 3aparece 2 vezes). Portanto, precisamos gerar a lista Mque permitirá concluir Lpara que possamos construir 2intervalos de números inteiros de 1até 7.

Portanto, precisamos produzir M = [1,1,2,4,4,5,6,6,7], para que cada número inteiro de 1a 7apareça 2vezes.

Entradas e saídas

• Use qualquer coisa no seu idioma que seja semelhante às listas. A estrutura de dados usada para a entrada e a saída deve ser a mesma.
• A lista de entrada conterá apenas números inteiros positivos.
• A lista de entrada não estará vazia.
• Você não pode assumir que a lista de entrada está classificada.
• A ordem na lista de saída não é importante.

Casos de teste

Input                  Output
[1]                    []
[7]                    [1, 2, 3, 4, 5, 6]
[1, 1, 1]              []
[1, 8]                 [2, 3, 4, 5, 6, 7]
[3, 3, 3, 3]           [1, 1, 1, 1, 2, 2, 2, 2]
[5, 2, 4, 5, 2]        [1, 1, 3, 3, 4]
[5, 2, 4, 5, 5]        [1, 1, 1, 2, 2, 3, 3, 3, 4, 4]
[5, 3, 3, 2, 7]        [1, 1, 2, 4, 4, 5, 6, 6, 7]

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Geléia , 9 bytes

Guardado 1 byte graças a Jonathan Allan . O rodapé chama o link principal, classifica o resultado para corresponder aos casos de teste e formata a saída como uma grade.

RṀẋLƙ`Ṁœ-

Experimente online! ou Confira uma suíte de testes!

Alternativas

ṀRẋLƙ`Ṁœ-
RṀẋṢŒɠṀƊœ-
ṀRẋṢŒɠṀƊœ-
LƙɓṀRẋṀœ-⁸
LƙɓRṀẋṀœ-⁸

Experimente um deles online!

Explicação

FullRẋLƙ`Ṁœ- Programa completo. N = entrada.
RangeR Faixa de 1 a max (N): [1 ... max (N)]
   Comprimento do mapa sobre grupos formados por elementos idênticos.
  ẋ Repita o intervalo T vezes, para cada T no resultado acima.
      Ṁ Máximo. Basicamente, obtenha o intervalo de repetição no máximo (^^) vezes.
       œ- Diferença multiset com N.

Perl 6 , 37 33 bytes

-4 bytes graças ao nwellnhof!

{^.keys.max+1 xx.values.max∖$_}

Experimente online!

Bloco de código anônimo que pega um saco e retorna um saco de valores.

Explicação:

{                             } # Anonymous code block
 ^.keys.max+1  # Create a range from 1 to the maximum value of the list
              xx  # Multiply the list by:
                .values.max      # The amount of the most common element
                           ∖$_   # Subtract the original Bag

R , 59 49 48 bytes

rep(s<-1:max(L<-scan()),max(y<-table(c(L,s)))-y)

Experimente online!

Python 2 , 86 83 80 72 bytes

def f(l):m=range(1,max(l)+1)*max(map(l.count,l));map(m.remove,l);print m

Experimente online!

05AB1E , 17 16 17 bytes

¢Z¹ZLŠŠи{ðý¹vyõ.;

-1 byte graças a @ Mr.Xcoder .
+1 byte após a correção da solução alternativa.

Talvez eu pareço completamente, mas 05AB1E ainda remove todos os elementos da lista b da lista a .. (EDIT: Realmente não ...) Eu sei como remover todas as várias vezes, mas não uma a cada .. (diferença de vários conjuntos)

Definitivamente pode ser jogado. Não estou muito feliz com isso, tbh .. Vou ver se consigo jogar mais um pouco antes de adicionar uma explicação. EDIT: Adicionado uma explicação ..

Experimente online ou verifique todos os casos de teste .

Explicação:

¢         # Get the occurrences for each item in the (implicit) input-List
          #  i.e. [5,3,3,2,7] → [1,2,2,1,1]
 Z        # And get the maximum
          #  i.e. [1,2,2,1,1] → 2
¹Z        # Also get the maximum from the input-list itself
          #  i.e. [5,3,3,2,7] → 7
  L       # And create a list in the range [1, max]
          #  i.e. 7 → [1,2,3,4,5,6,7]
ŠŠ        # Two triple-swaps so the stack order becomes:
          # trash we don't need; ranged list; occurrence max
  и       # Repeat the ranged list the occurence amount of times
          #  i.e. [1,2,3,4,5,6,7] and 2 → [1,2,3,4,5,6,7,1,2,3,4,5,6,7]

          #Now the work-around bit because 05AB1E lacks a builtin for multiset difference..
{         # Sort the list
          #  i.e. [1,2,3,4,5,6,7,1,2,3,4,5,6,7] → [1,1,2,2,3,3,4,4,5,5,6,6,7,7]
 ðý       # Join this list by spaces
          #  i.e. [1,1,2,2,3,3,4,4,5,5,6,6,7,7] → '1 1 2 2 3 3 4 4 5 5 6 6 7 7'
   ¹v     # Loop `y` over the input-List:
     yõ.; # Replace every first occurrence of `y` with an empty string
          #  i.e. '1 1 2 2 3 3 4 4 5 5 6 6 7 7' and 3 → '1 1 2 2  3 4 4 5 5 6 6 7 7'

R , 59 55 bytes

Usando o vecsetspacote, podemos diminuir o tamanho da resposta. Com glpodemos obter a saída ordenada. Isso não funciona no TIO. Seguindo o estilo de solução (bastante inteligente) do @ digEmAll sem uma definição de função, isso pode ser considerado uma solução de 55 bytes.

vecsets::vsetdiff(c(gl(m<-max(L<-scan()),sum(L==m))),L)

f=function(x){scan<-function()x
vecsets::vsetdiff(c(gl(m<-max(L<-scan()),sum(L==m))),L)
}

f(c(1))                # expected: integer(0)
f(c(7))                # expected: c(1, 2, 3, 4, 5, 6)
f(c(1, 1, 1))          # expected: integer(0)
f(c(1, 8))             # expected: c(2, 3, 4, 5, 6, 7)
f(c(3, 3, 3, 3))       # expected: c(1, 1, 1, 1, 2, 2, 2, 2)
f(c(5, 2, 4, 5, 2))    # expected: c(1, 1, 3, 3, 4)
f(c(5, 2, 4, 5, 5))    # expected: c(1, 1, 1, 2, 2, 3, 3, 3, 4, 4)

JavaScript (ES6), 98 bytes

Isso acabou sendo muito difícil de jogar abaixo de 100 bytes. Pode haver uma abordagem melhor.

a=>(a.map(o=M=m=n=>m=(c=o[M=n<M?M:n,n]=-~o[n])<m?m:c),g=k=>k?o[k]^m?[...g(k,o(k)),k]:g(k-1):[])(M)

Experimente online!

Quão?

Primeiro, percorremos a matriz de entrada a[]para reunir os seguintes dados:

• M = elemento mais alto encontrado na matriz de entrada
• m = maior número de ocorrências do mesmo elemento
• o[n] = número de ocorrências de n

Observe que isso oé definido principalmente como uma função, mas o objeto subjacente também é usado para armazenar o número de ocorrências.

a.map(                      // a[] = input array()
  o =                       // o = callback function of map()
  M = m =                   // initialize m and M to non-numeric values
  n =>                      // for each value n in a[]:
    m = (                   //   this code block will eventually update m
      c = o[                //     c = updated value of o[n]
        M = n < M ? M : n,  //     update M to max(M, n)
        n                   //     actual index into o[]
      ] = -~o[n]            //     increment o[n]
    ) < m ?                 //   if o[n] is less than m:
      m                     //     let m unchanged
    :                       //   else:
      c                     //     set it to c
)                           // end of map()

Em seguida, usamos a função recursiva g()para criar a saída.

(g = k =>                   // k = current value
  k ?                       // if k is not equal to 0:
    o[k] ^ m ?              //   if o[k] is not equal to m:
      [ ...g(k, o(k)),      //     increment o[k] and do a recursive call with k unchanged
        k ]                 //     append k to the output
    :                       //   else:
      g(k - 1)              //     do a recursive call with k - 1
  :                         // else:
    []                      //   stop recursion
)(M)                        // initial call to g() with k = M

Haskell, 72 bytes

import Data.List
f l=(last(sortOn(0<$)$group$sort l)>>[1..maximum l])\\l

Experimente online!

            sort l      -- sort input list
       group            -- group identical elements
   sortOn(0<$)          -- sort by length
 last                   -- take the last element, i.e. the list
                        -- of the most common element
      >>[1..maximum l]  -- replace each of it's elements
                        -- with the list [1..maximum l]
  \\l                   -- remove elements of the input list

Braquilog , 18 17 bytes

⌉⟦₁;Ij₎R⊇p?;.cpR∧

Experimente online!

Guardou 1 byte graças a @Kroppeb.

Explicação

⌉                  Take the largest element in the Input
 ⟦₁                 Construct the range [1, …, largest element in the Input]
   ;Ij₎R            Juxtapose that range to itself I times, I being unknown; 
                       call the result R
       R⊇p?         The Input must be an ordered subset of R, up to a permutation
          ?;.c      Concatenate the Input and the Output 
                       (the Output being unknown at this point)
              pR    This concatenation must result in R, up to a permutation
                ∧   (Find a fitting value for the Output that verifies all of this)

Java 10, 186 bytes

import java.util.*;L->{Integer m=0,f=0,t;for(int i:L){m=i>m?i:m;f=(t=Collections.frequency(L,i))>f?t:f;}var r=new Stack();for(;m>0;m--)for(t=f;t-->0;)if(!L.remove(m))r.add(m);return r;}

Experimente online.

Explicação:

import java.util.*;   // Required import for Collections and Stack
L->{                  // Method with Integer-list as both parameter and return-type
  Integer m=0,        //  Max, starting at 0
          f=0,        //  Max frequency, starting at 0
          t;          //  Temp integer
  for(int i:L){       //  Loop over the input-List
    m=i>m?i:m;        //   If the current item is larger than the max, set it as new max
    f=(t=Collections.frequency(L,i))>f?t:f;}
                      //   If the current frequency is larger than the max freq, set it as new max
  var r=new Stack();  //  Result-List
  for(;m>0;m--)       //  Loop the maximum in the range [m,0)
    for(t=f;t-->0;)   //   Inner loop the frequency amount of times
      if(!L.remove(m))//    Remove `m` from the input list
                      //    If we were unable to remove it:
        r.add(m);     //     Add it to the result-List
  return r;}          //  Return the result-List

Casca , 12 bytes

Economizou 1 byte graças ao BWO .

S-§*oḣ▲(▲Ṡm#

Experimente online!

MATL , 24 21 bytes

X>:GS&Y'X>yGhS&Y'q-Y"

Experimente online!

MATL , 14 bytes

Entrada é um vetor de coluna, com ;como separador.

llXQtn:yX>b-Y"

Experimente online! Ou verifique todos os casos de teste (isso exibe-- após cada saída para que a saída vazia possa ser identificada).

Explicação

Considere a entrada [5; 2; 4; 5; 5]como um exemplo.

llXQ     % Implicit input. Accumarray with sum. This counts occurrences
         % of each number, filling with zeros for numbers not present
         % STACK: [0; 1; 0; 1; 3]
tn:      % Duplicate, number of elements, range
         % STACK: [0; 1; 0; 1; 3], [1 2 3 4 5]
yX>      % Duplicate from below, maximum of array
         % STACK: [0; 1; 0; 1; 3], [1 2 3 4 5], 3 
b        % Bubble up
         % STACK: [1 2 3 4 5], 3, [0; 1; 0; 1; 3] 
-        % Subtract, element-wise
         % STACK: [1 2 3 4 5], [3; 2; 3; 2; 0] 
Y"       % Repelem (run-length decode). Implicit display
         % STACK: [1 1 1 2 2 3 3 3 4 4]

Pitão , 13 bytes

.-*SeSQeSlM.g

Experimente aqui! ou Confira uma suíte de testes!

Carvão , 19 bytes

Ｆ…·¹⌈θＥ⁻⌈Ｅθ№θκ№θιＩι

Experimente online! Link é a versão detalhada do código. Seriam 16 bytes se os números inteiros não fossem negativos em vez de positivos. Explicação:

     θ              First input
    ⌈               Maximum
 …·¹                Inclusive range starting at 1
Ｆ                   Loop over range
          θ         First input
         Ｅ          Loop over values
            θ       First input
             κ      Inner loop value
           №        Count occurrences
        ⌈           Maximum
               θ    First input
                ι   Outer loop value
              №     Count occurrences
       ⁻            Subtract
      Ｅ             Map over implicit range
                  ι Current value
                 Ｉ  Cast to string
                    Implicitly print on separate lines

APL (Dyalog Classic) , 18 17 bytes

∊{⊂⍳⌈/⍵}~¨∘↓∘⍉⊣¨⌸

Experimente online!

usa ⎕io←1

Prolog (SWI), 211 bytes

Já faz um tempo desde que eu programei no Prolog. Definitivamente pode ser ainda mais jogado, mas eu tenho um exame para estudar hahaha.

Código

f(L,X):-max_list(L,M),f(L,M,[],X,M).
f([],0,_,[],_).
f(L,0,_,A,M):-f(L,M,[],A,M).
f([],I,H,[I|A],M):-N is I-1,f(H,N,[],A,M).
f([I|R],I,H,A,M):-append(H,R,S),f(S,I,[],[I|A],M).
f([H|R],I,G,A,M):-f(R,I,[H|G],A,M).

Experimente online!

Versão ungolfed

f(List, Result) :- 
    max_list(List, MaxIndex), 
    f(List, MaxIndex, [], Result, MaxIndex).

f([], 0, _, [], _).

f(List, 0, _, Acc, MaxIndex) :- 
    f(List, MaxIndex, [], Acc, MaxIndex).

f([], Index, History, [Index | Acc], MaxIndex) :- 
    NewIndex is Index - 1, f(History, NewIndex, [], Acc, MaxIndex).

f([Index | Remaining], Index, History, Acc, MaxIndex) :-
    append(History, Remaining, Result),
    f(Result, Index, [], [Index | Acc], MaxIndex).

f([Head | Remaining], Index, History, Acc, MaxIndex) :- 
    f(Remaining, Index, [Head | History], Acc, MaxIndex).

Clojure, 94 bytes

#(for[F[(frequencies %)]i(range 1(+(apply max %)1))_(range(-(apply max(vals F))(or(F i)0)))]i)

C ++, 234 bytes

#include<vector>
#include<map>
using X=std::vector<int>;
X f(X x){int q,z;q=z=0;std::map<int,int>y;X o;
for(auto i:x)++y[i];for(auto i:y)q=q>i.second?q:i.second;
for(;++z<=y.rbegin()->first;)for(;y[z]++<q;)o.push_back(z);return o;}

(As novas linhas no corpo da função são para facilitar a leitura).

A função pega e retorna um vetor de ints. Utilizastd::map for finding the max element of the input list and also for counting the occurrences of each distinct element.

Explicação:

// necessary includes. Note that each of these is longer than whole Jelly program!
#include <vector>
#include <map>

// this type occurs three times in the code
using X = std::vector<int>;

// The function
X f (X x)
{
   // initialize some variables
   int q, z; // q will hold the max count
   q = z = 0;
   std::map <int, int> y; // The map for sorting
   X o; // The output vector

   // Populate the map, effectively finding the max element and counts for all of them
   for (auto i : x)
       ++y[i];

   // find the max count
   for (auto i : y)
       q = q > i.second ? q : i.second;

   // Populate the output vector

   // Iterate all possible values from 1 to the max element (which is the key at y.rbegin ())
   // Note that z was initialized at 0, so we preincrement it when checking the condition
   for (; ++z <= y.rbegin ()->first;)
       // for each possible value, append the necessary quantity of it to the output
       for(; y[z]++ < q;)
           o.push_back (z);

   return o;
}

Gaia , 12 bytes

::⌉┅¤:C¦⌉&¤D

Experimente online!

C (gcc) , 177 bytes

A entrada e a saída são feitas através de stdin e stdout. Ambas as matrizes têm um limite de 2 ^ 15 elementos, mas podem ter até 2 ^ 99 elementos.

f(j){int n=0,m=0,i=0,a[1<<15],b[1<<15]={0};for(;scanf("%i",&a[i])>0;i++)j=a[i],m=j>m?j:m,b[j-1]++;for(i=m;i--;)n=b[i]>n?b[i]:n;for(i=m;i--;)for(j=n-b[i];j--;)printf("%i ",i+1);}

Com alguma formatação:

f(j){
  int n=0, m=0, i=0, a[1<<15], b[1<<15]={0};
  for(;scanf("%i",&a[i])>0;i++) j=a[i], m=j>m?j:m, b[j-1]++;
  for(i=m;i--;) n=b[i]>n?b[i]:n;
  for(i=m;i--;) for(j=n-b[i];j--;) printf("%i ",i+1);
}

Experimente online!