, belirli bir sıralaması olmayan ve kopyaları içerebilecek pozitif tamsayıların bir listesi olsun . Pozitif tam bir listesini verir, bir program ya da işlev Yazın , örneğin birleştirme ki (sipariş önemsizdir) ve , tamamen tamsayılar aynı aralıklar halinde bölünmüş en küçük listesine sonuçları burada, olduğu deki en büyük elementM L M [ 1 .. i ] i $L$$M$$L$$M$$[1..i]$$i$$L$

Misal

Bırakın L = [5,3,3,2,7]. Maksimum elemanı Lolup 7. Belirli bir tamsayı en çok oluşur 2( 32 kez görünür). Bu nedenle, çıkışa listesi gerekir Mtamamlamanızı sağlayacak Lbiz inşa böylece 2gelen tamsayılar aralıklarını 1için 7.

Bu nedenle, M = [1,1,2,4,4,5,6,6,7]her bir tamsayının 1ila zaman arasında 7görünmesi için çıktı almamız gerekir 2.

Girdiler ve çıktılar

• Dilinizde listelere benzer herhangi bir şey kullanın. Giriş ve çıkış için kullanılan veri yapısı aynı olmalıdır.
• Giriş listesi yalnızca pozitif tamsayılar içerecektir.
• Giriş listesi boş olmayacak.
• Sen olamaz giriş listesi sıralanır varsayalım.
• Çıktı listesindeki sıralama önemsizdir.

Test senaryoları

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]

puanlama

Bu kod golf , bu yüzden bayttaki en kısa cevap kazanır.

Jöle , 9 bayt

Jonathan Allan sayesinde 1 bayt kurtardı . Altbilgi ana bağlantıyı çağırır, sonucu test senaryolarıyla eşleşecek şekilde sıralar ve çıktıyı ızgara olarak biçimlendirir.

RṀẋLƙ`Ṁœ-

Çevrimiçi deneyin! veya Bir test takımına göz atın!

Alternatifler

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

Bunlardan birini çevrimiçi deneyin!

açıklama

ṀRẋLƙ`Ṁœ- Tam program. N = Giriş.
ṀR 1 ile maks. (N) aralığı: [1 ... maks. (N)]
   Lƙ` Aynı elemanların oluşturduğu gruplar üzerinde uzunluğu eşleyin.
  above Yukarıdakilerin sonucunda her T için T aralığını tekrarlayın.
      Ṁ Maksimum. Temel olarak, aralık maksimum (^ ^) kez tekrarlayın.
       œ- N ile çoklu ayar farkı.

Perl 6 , 37 33 bayt

Nwellnhof sayesinde -4 bayt!

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

Çevrimiçi deneyin!

Bir Torba alıp Değer Torbası döndüren anonim kod bloğu.

Açıklama:

{                             } # 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 bayt

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

Çevrimiçi deneyin!

Python 2 , 86 83 80 72 bayt

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

Çevrimiçi deneyin!

05AB1E , 17 16 17 bayt

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

@ Mr.Xcoder sayesinde -1 bayt .
Etrafında hata giderildikten sonra +1 bayt ..

Belki tamamen geçmiş bakmak, ama 05AB1E bile kaldırmak için, listedeki tüm unsurları var b listesinden a .. (DÜZENLEME: Gerçekten yok ..) Bütün birden çok kez nasıl kaldırılacağı bilmiyorum, ama her kez .. (çoklu ayar farkı)

Kesinlikle golf edilebilir. Gerçekten mutlu değilim, tbh .. Bir açıklama eklemeden önce biraz golf oynayabileceğimi göreceğim. EDIT: Bir açıklama eklendi ..

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

¢         # 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 bayt

vecsetsPaketi kullanarak cevap uzunluğunu biraz bırakabiliriz. İle glsipariş çıktı alabilirsiniz. Bu TIO'da çalışmaz. @ DigEmAll'ın işlev tanımı olmadan (oldukça akıllı) çözüm stilini takiben, bu 55 baytlık bir çözüm olarak düşünülebilir.

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 bayt

Bu 100 baytın altında golf oldukça zor olduğu ortaya çıktı. Daha iyi bir yaklaşım olabilir.

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)

Çevrimiçi deneyin!

Nasıl?

a[]Aşağıdaki verileri toplamak için önce giriş dizisi boyunca ilerliyoruz :

• M = giriş dizisinde bulunan en yüksek öğe
• m = aynı elemanın en yüksek tekrar sayısı
• o[n] = gerçekleşme sayısı n

Bunun oöncelikle bir işlev olarak tanımlandığını, ancak alttaki nesnenin de olay sayısını depolamak için kullanıldığını unutmayın.

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()

Daha sonra g()çıktıyı oluşturmak için özyinelemeli işlevi kullanırız.

(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 bayt

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

Çevrimiçi deneyin!

            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

Brachylog , 18 17 bayt

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

Çevrimiçi deneyin!

@Kroppeb sayesinde 1 bayt kaydedildi.

açıklama

⌉                  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 bayt

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;}

Çevrimiçi deneyin.

Açıklama:

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

Kabuk , 12 bayt

BWO sayesinde 1 bayt tasarruf etti .

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

Çevrimiçi deneyin!

MATL , 24 21 bayt

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

Çevrimiçi deneyin!

MATL , 14 bayt

Girdi, ;ayırıcı olarak bir sütun vektörüdür .

llXQtn:yX>b-Y"

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın ( --her çıkışın ardından boş çıktının tanımlanabilmesi için görüntülenir).

açıklama

Girişi [5; 2; 4; 5; 5]örnek olarak ele alalım.

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]

Pyth , 13 bayt

.-*SeSQeSlM.g

Burada deneyin! veya Bir test takımına göz atın!

Kömür , 19 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Tamsayılar pozitif yerine negatif olmasaydı 16 bayt olurdu. Açıklama:

     θ              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 Klasik) , 18 17 bayt

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

Çevrimiçi deneyin!

kullanımları ⎕io←1

Prolog (SWI) , 211 bayt

Prolog'da programladığımdan bu yana bir süre geçti. Kesinlikle daha fazla golf olabilir, ama hahaha için çalışmak için bir sınav var.

kod

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).

Çevrimiçi deneyin!

Ungolfed sürümü

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 bayt

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

C ++, 234 bayt

#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;}

(İşlev gövdesindeki yeni satırlar okunabilirlik içindir).

Fonksiyon bir ints vektörü alır ve döndürür. Bu kullanan std::mapher bir farklı elemanının tekrarlarını sayılması için ayrıca giriş listesinin maksimum elemanı bulmak için kullanımı.

Açıklama:

// 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 bayt

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

Çevrimiçi deneyin!

C (gcc) , 177 bayt

Giriş ve çıkış stdin ve stdout ile yapılır. Her iki dizi de 2 ^ 15 öğe ile sınırlıdır, ancak 2 ^ 99 öğe kadar büyük olabilirler.

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);}

Bazı biçimlendirme ile:

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);
}

Çevrimiçi deneyin!