Es sei eine Liste positiver Ganzzahlen ohne bestimmte Reihenfolge, die Duplikate enthalten können. Schreiben Sie ein Programm oder eine Funktion, die eine Liste positiver Ganzzahlen M ausgibt (deren Reihenfolge unwichtig ist), so dass durch Zusammenführen von L und M die kleinste Liste entsteht, die sich vollständig in identische Bereiche von Ganzzahlen [ 1 .. i ] aufteilen lässt , wobei i die ist größtes Element in $L$$M$$L$$M$$[1..i]$$i$$L$

Beispiel

Lassen L = [5,3,3,2,7]. Das maximale Element von List 7. Das häufigste Vorkommen einer bestimmten Ganzzahl ist 2( 3erscheint zweimal). Daher müssen wir die Liste ausgeben M, die das Vervollständigen ermöglicht, Ldamit wir 2Bereiche von ganzen Zahlen von 1bis konstruieren können 7.

Daher müssen wir ausgeben M = [1,1,2,4,4,5,6,6,7], damit jede Ganzzahl von 1bis mal 7erscheint 2.

Eingänge und Ausgänge

• Verwenden Sie in Ihrer Sprache alles, was Listen ähnelt. Die für die Eingabe und die Ausgabe verwendete Datenstruktur muss identisch sein.
• Die Eingabeliste enthält nur positive ganze Zahlen.
• Die Eingabeliste wird nicht leer sein.
• Sie können nicht davon ausgehen, dass die Eingabeliste sortiert ist.
• Die Reihenfolge in der Ausgabeliste ist unwichtig.

Testfälle

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]

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Gelee , 9 Bytes

Dank Jonathan Allan 1 Byte gespeichert . Die Fußzeile ruft den Hauptlink auf, sortiert das Ergebnis entsprechend den Testfällen und formatiert die Ausgabe als Raster.

RṀẋLƙ`Ṁœ-

Probieren Sie es online! oder Testen Sie eine Testsuite!

Alternativen

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

Probieren Sie eines davon online aus!

Erläuterung

ṀRṀLẋ`ƙœ- Volles Programm. N = Eingabe.
ṀR Bereich von 1 bis max (N): [1 ... max (N)]
   Lƙ` Kartenlänge über Gruppen, die aus identischen Elementen bestehen.
  ẋ Wiederholen Sie den Bereich T-mal für jedes T im Ergebnis der obigen Ausführungen.
      Ṁ Maximum. Grundsätzlich sollte der Bereich maximal (^^) Mal wiederholt werden.
       œ- Multiset-Differenz mit N.

Perl 6 , 37 33 Bytes

-4 bytes dank nwellnhof!

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

Probieren Sie es online!

Anonymer Codeblock, der ein Bag nimmt und ein Bag mit Werten zurückgibt.

Erläuterung:

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

Probieren Sie es 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

Probieren Sie es online!

05AB1E , 17 16 17 Bytes

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

-1 Byte dank @ Mr.Xcoder .
+1 Byte nach Behebung des Problems

Vielleicht schaue ich komplett darüber hinweg, aber hat 05AB1E überhaupt ein Entfernen aller Listenelemente b aus Liste a . (Multiset-Unterschied)

Kann auf jeden Fall Golf gespielt werden. Nicht wirklich glücklich damit, tbh .. sehen, ob ich noch mehr Golf spielen kann, bevor ich eine Erklärung hinzufüge. EDIT: Eine Erklärung hinzugefügt ..

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Mit dem vecsetsPaket können wir die Antwortlänge ein wenig reduzieren. Mit können glwir die bestellte Ausgabe bekommen. Dies funktioniert in TIO nicht. In Anlehnung an @ digEmAlls (ziemlich clevere) Lösung ohne Funktionsdefinition kann dies als 55-Byte-Lösung betrachtet werden.

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

Dies stellte sich als ziemlich schwierig heraus, unter 100 Bytes Golf zu spielen. Es könnte einen besseren Ansatz geben.

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)

Probieren Sie es online!

Wie?

Wir gehen zuerst durch das Eingabearray a[], um die folgenden Daten zu erfassen:

• M = höchstes im Eingabearray gefundenes Element
• m = höchste Anzahl von Vorkommen desselben Elements
• o[n] = Anzahl der Vorkommen von n

Beachten Sie, dass dies oin erster Linie als Funktion definiert ist, das zugrunde liegende Objekt jedoch auch zum Speichern der Anzahl der Vorkommen verwendet wird.

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

Wir verwenden dann die rekursive Funktion g(), um die Ausgabe zu erstellen.

(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

Probieren Sie es 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

Brachylog , 18 17 Bytes

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

Probieren Sie es online!

1 Byte dank @Kroppeb gespeichert.

Erläuterung

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

Probieren Sie es online aus.

Erläuterung:

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

Schale , 12 Bytes

Dank BWO 1 Byte gespart .

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

Probieren Sie es online!

MATL , 24 21 Bytes

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

Probieren Sie es online!

MATL , 14 Bytes

Die Eingabe ist ein Spaltenvektor mit ;Trennzeichen.

llXQtn:yX>b-Y"

Probieren Sie es online! Oder überprüfen Sie alle Testfälle (dies wird --nach jeder Ausgabe angezeigt, damit leere Ausgaben identifiziert werden können).

Erläuterung

Betrachten Sie die Eingabe [5; 2; 4; 5; 5]als Beispiel.

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 Bytes

.-*SeSQeSlM.g

Probieren Sie es hier aus! oder Testen Sie eine Testsuite!

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Wäre 16 Byte gewesen, wenn die Ganzzahlen nicht negativ, sondern positiv gewesen wären. Erläuterung:

     θ              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 bis 17 Bytes

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

Probieren Sie es online!

Verwendet ⎕io←1

Prolog (SWI) , 211 Bytes

Es ist schon eine Weile her, dass ich in Prolog programmiert habe. Kann definitiv weiter golfen werden, aber ich muss eine Prüfung für hahaha ablegen.

Code

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

Probieren Sie es online!

Ungolfed-Version

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

(Zeilenumbrüche im Funktionskörper dienen der Lesbarkeit).

Die Funktion nimmt und gibt einen Vektor von Ints zurück. Es nutztstd::map um das Element max in der Eingabeliste zu finden und um die Vorkommen jedes einzelnen Elements zu zählen.

Erläuterung:

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

Probieren Sie es online!

C (gcc) 177 Bytes

Die Ein- und Ausgabe erfolgt über stdin und stdout. Beide Arrays sind auf 2 ^ 15 Elemente begrenzt, können jedoch bis zu 2 ^ 99 Elemente umfassen.

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

Mit etwas Formatierung:

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

Probieren Sie es online!