ให้เป็นรายการของจำนวนเต็มบวกที่ไม่มีการเรียงลำดับเฉพาะและสามารถมีรายการซ้ำได้ เขียนโปรแกรมหรือฟังก์ชั่นที่แสดงรายการของจำนวนเต็มบวกM (ซึ่งเรียงลำดับไม่สำคัญ) เช่นการรวมผลลัพธ์LและMลงในรายการที่เล็กที่สุดซึ่งสามารถแบ่งออกเป็นช่วงจำนวนเต็มเหมือนกัน[ 1 .. i ]โดยที่ฉันคือ องค์ประกอบที่ใหญ่ที่สุดใน$L$$M$$L$$M$$[1..i]$$i$$L$

ตัวอย่าง

L = [5,3,3,2,7]ให้ องค์ประกอบที่สูงสุดของการมีL 7จำนวนครั้งที่มากที่สุดที่เฉพาะเจาะจงเกิดขึ้นคือ2( 3ปรากฏขึ้น 2 ครั้ง) ดังนั้นเราจำเป็นต้องแสดงรายการMที่จะอนุญาตให้เสร็จสมบูรณ์Lเพื่อให้เราสามารถสร้าง2ช่วงของจำนวนเต็มจาก1ถึง7ไป

ดังนั้นเราจำเป็นต้องแสดงผลลัพธ์M = [1,1,2,4,4,5,6,6,7]เพื่อให้จำนวนเต็มแต่ละค่าจาก1ถึง7ปรากฏขึ้น2ครั้ง

อินพุตและเอาต์พุต

• ใช้อะไรก็ได้ในภาษาของคุณที่คล้ายกับรายการ โครงสร้างข้อมูลที่ใช้สำหรับอินพุตและเอาต์พุตต้องเหมือนกัน
• รายการอินพุตจะมีจำนวนเต็มบวกเท่านั้น
• รายการอินพุตจะไม่ว่างเปล่า
• คุณไม่สามารถถือว่ารายการอินพุตถูกเรียงลำดับ
• การเรียงลำดับในรายการเอาท์พุทไม่สำคัญ

กรณีทดสอบ

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]

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

เยลลี่ขนาด 9 ไบต์

ที่บันทึกไว้ 1 ขอบคุณไบต์โจนาธานอัลลัน ส่วนท้ายจะเรียกลิงก์หลักเรียงลำดับผลลัพธ์เพื่อให้ตรงกับเคสทดสอบและจัดรูปแบบเอาต์พุตเป็นกริด

RṀẋLƙ`Ṁœ-

ลองออนไลน์! หรือตรวจสอบชุดทดสอบ!

ทางเลือก

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

ลองหนึ่งในนั้นออนไลน์!

คำอธิบาย

ṀRẋLƙ`Ṁœ-โปรแกรมเต็มรูปแบบ N = อินพุต
ṀRช่วงจาก 1 ถึงสูงสุด (N): [1 ... สูงสุด (N)]
   L Map` แผนที่ความยาวเหนือกลุ่มที่เกิดจากองค์ประกอบที่เหมือนกัน
  ẋทำซ้ำช่วง T ครั้งสำหรับแต่ละ T ตามผลลัพธ์ข้างต้น
      Ṁสูงสุด โดยทั่วไปรับช่วงทำซ้ำสูงสุด (^^) ครั้ง
       difference- ผลต่างหลายค่าด้วย N

Perl 6 , 37 33 ไบต์

-4 ไบต์ต้องขอบคุณ nwellnhof!

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

ลองออนไลน์!

บล็อคโค้ดแบบไม่ระบุชื่อที่รับกระเป๋าและส่งกลับค่าถุง

คำอธิบาย:

{                             } # 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 ไบต์

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

ลองออนไลน์!

Python 2 , 86 83 80 72 ไบต์

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

ลองออนไลน์!

05AB1E , 17 16 17 ไบต์

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

-1 ขอบคุณไบต์@ Mr.Xcoder
+1 ไบต์หลังจากแก้ไขข้อผิดพลาดในการแก้ปัญหา ..

บางทีฉันอาจมองข้ามอย่างสิ้นเชิง แต่ไม่ 05AB1E แม้จะมีการลบองค์ประกอบทั้งหมดของรายการbออกจากรายการa .. (แก้ไข: ไม่แน่นอน .. ) ฉันรู้วิธีลบทั้งหมดหลายครั้ง แต่ไม่ใช่แต่ละครั้ง .. (ความแตกต่างของมัลติเซ็ต)

สามารถเล่นกอล์ฟได้อย่างแน่นอน ไม่ค่อยมีความสุขกับมัน tbh .. จะดูว่าฉันสามารถตีกอล์ฟเพิ่มอีกก่อนที่จะเพิ่มคำอธิบายได้ไหม แก้ไข: เพิ่มคำอธิบาย ..

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

¢         # 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 ไบต์

ใช้vecsetsแพคเกจที่เราสามารถลดความยาวคำตอบบางอย่าง ด้วยglเราสามารถรับเอาท์พุทสั่ง สิ่งนี้ไม่ทำงานใน TIO การทำตามสไตล์ของ @ digEmAll ของโซลูชัน (ค่อนข้างฉลาด) โดยไม่มีคำจำกัดความของฟังก์ชั่นนี่ถือได้ว่าเป็นโซลูชันขนาด 55 ไบต์

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 ไบต์

เรื่องนี้กลายเป็นเรื่องยากที่จะตีกอล์ฟต่ำกว่า 100 ไบต์ อาจมีวิธีการที่ดีกว่า

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)

ลองออนไลน์!

อย่างไร?

ก่อนอื่นเราจะเดินเข้าไปในอาร์เรย์อินพุตa[]เพื่อรวบรวมข้อมูลต่อไปนี้:

• M = องค์ประกอบสูงสุดที่พบในอาร์เรย์อินพุต
• m = จำนวนครั้งสูงสุดขององค์ประกอบเดียวกัน
• o[n] = จำนวนครั้งของ n

โปรดทราบว่าoมีการกำหนดเป็นฟังก์ชันเป็นหลัก แต่วัตถุต้นแบบยังใช้ในการจัดเก็บจำนวนที่เกิดขึ้น

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

จากนั้นเราใช้ฟังก์ชั่นวนซ้ำg()เพื่อสร้างเอาต์พุต

(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 ไบต์

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

ลองออนไลน์!

            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 ไบต์

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

ลองออนไลน์!

บันทึกแล้ว 1 ไบต์ขอบคุณ @Kroppeb

คำอธิบาย

⌉                  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 ไบต์

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

ลองออนไลน์

คำอธิบาย:

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

แกลบขนาด 12 ไบต์

ที่บันทึกไว้ 1 ไบต์ขอบคุณที่BWO

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

ลองออนไลน์!

MATL , 24 21 ไบต์

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

ลองออนไลน์!

MATL , 14 ไบต์

อินพุตเป็นเวกเตอร์คอลัมน์โดยมี;ตัวคั่น

llXQtn:yX>b-Y"

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด (จะแสดงขึ้น--หลังจากแต่ละเอาต์พุตเพื่อให้สามารถระบุเอาต์พุตว่างได้)

คำอธิบาย

พิจารณาอินพุต[5; 2; 4; 5; 5]เป็นตัวอย่าง

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 ไบต์

.-*SeSQeSlM.g

ลองที่นี่! หรือตรวจสอบชุดทดสอบ!

ถ่านขนาด 19 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด จะเป็น 16 ไบต์ถ้าจำนวนเต็มไม่ใช่ลบแทนที่จะเป็นบวก คำอธิบาย:

     θ              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 ไบต์

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

ลองออนไลน์!

การใช้งาน ⎕io←1

อารัมภบท (SWI) 211 ไบต์

เป็นเวลานานแล้วที่ฉันตั้งโปรแกรมใน Prolog สามารถเล่นกอล์ฟต่อไปได้แน่นอน แต่ฉันต้องสอบเพื่อเรียนฮ่าฮ่าฮ่า

รหัส

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

ลองออนไลน์!

เวอร์ชันที่ไม่ดี

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 ไบต์

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

C ++, 234 ไบต์

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

(บรรทัดใหม่ในฟังก์ชั่นสำหรับการอ่าน)

ฟังก์ชันใช้และส่งคืนเวกเตอร์ของ ints มันใช้std::mapสำหรับการค้นหาองค์ประกอบสูงสุดของรายการอินพุตและสำหรับการนับการเกิดขึ้นของแต่ละองค์ประกอบที่แตกต่างกัน

คำอธิบาย:

// 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 ไบต์

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

ลองออนไลน์!

C (gcc) , 177 ไบต์

อินพุตและเอาต์พุตทำผ่าน stdin และ stdout อาร์เรย์ทั้งสองนั้นต่อยอดที่องค์ประกอบ 2 ^ 15 แต่อาจมีขนาดใหญ่เท่ากับ 2 ^ 99 องค์ประกอบ

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

ด้วยการจัดรูปแบบบางอย่าง:

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

ลองออนไลน์!