Đặt là danh sách các số nguyên dương không có thứ tự cụ thể và có thể chứa các bản sao. Viết chương trình hoặc hàm tạo ra danh sách các số nguyên dương M (có thứ tự không quan trọng) sao cho hợp nhất kết quả L và M vào danh sách nhỏ nhất có thể tách thành các phạm vi số nguyên giống nhau [ 1 .. i ] , trong đó i là yếu tố lớn nhất trong $L$$M$$L$$M$$[1..i]$$i$$L$

Thí dụ

Hãy để L = [5,3,3,2,7]. Các yếu tố tối đa Llà 7. Hầu hết các số nguyên cụ thể xảy ra là 2( 3xuất hiện 2 lần). Do đó, chúng ta cần xuất danh sách Msẽ cho phép hoàn thành Lđể có thể xây dựng 2phạm vi số nguyên từ 1đến 7.

Do đó, chúng ta cần phải đầu ra M = [1,1,2,4,4,5,6,6,7], vì vậy mà mỗi số nguyên từ 1để 7xuất hiện 2lần.

Đầu vào và đầu ra

• Sử dụng bất cứ điều gì trong ngôn ngữ của bạn tương tự như danh sách. Cấu trúc dữ liệu được sử dụng cho đầu vào và đầu ra phải giống nhau.
• Danh sách đầu vào sẽ chỉ chứa các số nguyên dương.
• Danh sách đầu vào sẽ không trống.
• Bạn không thể giả sử danh sách đầu vào được sắp xếp.
• Thứ tự trong danh sách đầu ra là không quan trọng.

Các trường hợp thử nghiệm

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]

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Thạch , 9 byte

Lưu được 1 byte nhờ Jonathan Allan . Chân trang gọi liên kết chính, sắp xếp kết quả để khớp với các trường hợp thử nghiệm và định dạng đầu ra dưới dạng lưới.

RṀẋLƙ`Ṁœ-

Hãy thử trực tuyến! hoặc Kiểm tra một bộ thử nghiệm!

Lựa chọn thay thế

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

Hãy thử một trong số họ trực tuyến!

Giải trình

RẋLƙ`Ṁœ- Chương trình đầy đủ. N = Đầu vào.
R Phạm vi từ 1 đến tối đa (N): [1 ... max (N)]
   L` Độ dài bản đồ trên các nhóm được hình thành bởi các yếu tố giống hệt nhau.
  Lặp lại phạm vi T lần, cho mỗi T trong kết quả của các điều trên.
      Tối đa. Về cơ bản, có được phạm vi lặp lại tối đa (^^) lần.
       -Chênh lệch nhiều điểm với N.

Perl 6 , 37 33 byte

-4 byte nhờ nwellnhof!

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

Hãy thử trực tuyến!

Khối mã ẩn danh nhận Túi và trả về Túi giá trị.

Giải trình:

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

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

Hãy thử trực tuyến!

Python 2 , 86 83 80 72 byte

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

Hãy thử trực tuyến!

05AB1E , 17 16 17 byte

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

-1 byte nhờ @ Mr.Xcoder .
+1 byte sau khi sửa lỗi xung quanh ..

Có thể tôi hoàn toàn nhìn qua nó, nhưng 05AB1E thậm chí có loại bỏ tất cả các yếu tố của danh sách b khỏi danh sách a .. (EDIT: Nó thực sự không ..) Tôi biết cách loại bỏ tất cả nhiều lần, nhưng không phải một lần mỗi .. (sự khác biệt nhiều)

Chắc chắn có thể được chơi golf. Không thực sự hài lòng với nó, tbh .. Sẽ xem liệu tôi có thể đánh gôn thêm nữa không trước khi thêm lời giải thích. EDIT: Đã thêm một lời giải thích ..

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Sử dụng vecsetsgói chúng ta có thể giảm độ dài câu trả lời. Với glchúng tôi có thể nhận được đầu ra đặt hàng. Điều này không hoạt động trong TIO. Theo kiểu giải pháp (khá thông minh) của @ digEmAll mà không có định nghĩa hàm, đây có thể được coi là giải pháp 55 byte.

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 byte

Điều này hóa ra khá khó để chơi golf dưới 100 byte. Có thể có một cách tiếp cận tốt hơn.

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)

Hãy thử trực tuyến!

Làm sao?

Trước tiên chúng tôi đi qua mảng đầu vào a[]để thu thập dữ liệu sau:

• M = phần tử cao nhất được tìm thấy trong mảng đầu vào
• m = số lần xuất hiện cao nhất của cùng một yếu tố
• o[n] = số lần xuất hiện của n

Lưu ý rằng ochủ yếu được định nghĩa là một hàm, nhưng đối tượng cơ bản cũng được sử dụng để lưu trữ số lần xuất hiệ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()

Sau đó chúng ta sử dụng hàm đệ quy g()để xây dựng đầu ra.

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

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

Hãy thử trực tuyến!

            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 byte

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

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ @Kroppeb.

Giải trình

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

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

Hãy thử trực tuyến.

Giải trình:

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

Husk , 12 byte

Đã lưu 1 byte nhờ vào BWO .

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

Hãy thử trực tuyến!

MATL , 24 21 byte

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

Hãy thử trực tuyến!

MATL , 14 byte

Đầu vào là một vectơ cột, với ;dấu phân cách.

llXQtn:yX>b-Y"

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp kiểm tra (điều này hiển thị --sau mỗi đầu ra để có thể xác định đầu ra trống).

Giải trình

Hãy xem xét đầu vào [5; 2; 4; 5; 5]là một ví dụ.

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]

Bình thường , 13 byte

.-*SeSQeSlM.g

Hãy thử nó ở đây! hoặc Kiểm tra một bộ thử nghiệm!

Than , 19 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sẽ là 16 byte nếu số nguyên không âm thay vì dương. Giải trình:

     θ              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 byte

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

Hãy thử trực tuyến!

sử dụng ⎕io←1

Prolog (SWI) , 211 byte

Đã được một thời gian kể từ khi tôi lập trình trong Prolog. Chắc chắn có thể chơi gôn hơn nữa, nhưng tôi có một kỳ thi để học hahaha.

Mã

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

Hãy thử trực tuyến!

Phiên bản ung dung

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 byte

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

C ++, 234 byte

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

(Dòng mới trong thân hàm là để dễ đọc).

Hàm lấy và trả về một vectơ ints. Nó sử dụngstd::map để tìm phần tử tối đa của danh sách đầu vào và cũng để đếm số lần xuất hiện của từng phần tử riêng biệt.

Giải trình:

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

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

Hãy thử trực tuyến!

C (gcc) , 177 byte

Đầu vào và đầu ra được thực hiện thông qua stdin và stdout. Cả hai mảng được giới hạn ở 2 ^ 15 phần tử, nhưng chúng có thể lớn bằng 2 ^ 99 phần tử.

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

Với một số định dạng:

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

Hãy thử trực tuyến!