चलो $L$ कोई विशेष आदेश के साथ धनात्मक पूर्णांक की एक सूची है, और जो डुप्लिकेट हो सकते हैं। एक कार्यक्रम या समारोह जो धनात्मक पूर्णांक की एक सूची आउटपुट लिखें $M$ (जिसका आदेश महत्वहीन है) इस तरह के विलय कि $L$ और $M$ जो पूरी तरह से पूर्णांकों का समान श्रेणियों में विभाजित कर सकते हैं सबसे छोटी सूची में परिणाम $[1..i]$ , जहां $i$ है में सबसे बड़ा तत्व $L$

उदाहरण

चलो L = [5,3,3,2,7]। का अधिकतम तत्व Lहै 7। एक विशिष्ट पूर्णांक होता है 2( 32 बार प्रकट होता है )। इसलिए, हम सूची उत्पादन करने की जरूरत है 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]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

code-golf array-manipulation integer

— Fatalize
स्रोत

बस स्पष्ट होने के लिए, जैसा कि आपके परीक्षण के मामले और बयान एक-दूसरे के विपरीत हैं, का iसबसे बड़ा तत्व है Lया M?

— क्रॉपेब

@Kroppeb iसबसे बड़ा तत्व है L, यह स्पेक्स में एक टाइपो था।

— 6

वापस जाने के लिए यह ठीक है M=[1,1,2,2,3]के लिए L=[3]है, जबकि "एक सूची है जो पूरी तरह से पूर्णांकों [1..i] के समान श्रेणियों में विभाजित कर सकते हैं में एल और एम परिणाम विलय"?

— tsh

@tsh नहीं, इसे वापस आना चाहिए [1,2]। मैं इसे स्पष्ट कर दूंगा ताकि यह स्पष्ट हो जाए कि इसका परिणाम न्यूनतम श्रेणी में होना चाहिए।

— 7

1

@digEmAll हो गया।

— घातक

5

जेली , 9 बाइट्स

जोनाथन एलन को 1 बाइट धन्यवाद दिया । पाद लेख मुख्य लिंक को कॉल करता है, परीक्षण के मामलों से मिलान करने के लिए परिणाम को सॉर्ट करता है और आउटपुट को ग्रिड के रूप में प्रारूपित करता है।

RṀẋLƙ`Ṁœ-

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट की जाँच करें!

वैकल्पिक

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

ऑनलाइन उनमें से एक की कोशिश करो!

व्याख्या

ẊRẋLṀ`Ṁœ- पूर्ण कार्यक्रम। एन = इनपुट।
ṀR की रेंज 1 से अधिकतम (N): [1 ... अधिकतम (N)]
   L` समान तत्वों द्वारा गठित समूहों पर मानचित्र की लंबाई।
  ẋ ऊपर के परिणाम में प्रत्येक T के लिए सीमा T समय को दोहराएं।
      Ṁ अधिकतम। मूल रूप से, सीमा दोहराएँ अधिकतम (^ ^) बार प्राप्त करें।
       et- एन के साथ मल्टीसेट अंतर।

— मिस्टर एक्सकोडर
स्रोत

7

पर्ल 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

— मजाक कर रहा है
स्रोत

अच्छा! आप बाग के लिए दूसरे ऑपरेंड के साथ {^.max+1 xx.Bag.values.max∖.Bag}

— जबरदस्ती

@nwellnhof आह, धन्यवाद! मुझे एहसास नहीं था कि दूसरा तर्क थैला

— जो किंग

OTOH, चुनौती के लिए आवश्यक है कि इनपुट और आउटपुट के लिए डेटा संरचना समान होनी चाहिए। इनपुट के रूप में बैग के साथ, {^.keys.max+1 xx.values.max∖$_}एक और बाइट बचाता है।

— nwellnhof

6

आर , 59 49 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— digEmAll
स्रोत

मेरे पास एक 55 बाइट का उत्तर है जो मूल रूप से दूसरे तर्क को repअलग तरीके से उत्पन्न करता है , लेकिन अन्यथा आपके जैसा ही है। मैं इसे खुद पोस्ट कर सकता था लेकिन मुझे नहीं लगता कि मैंने इसके बारे में तब तक सोचा होगा जब तक मैं आपको पहले नहीं देख लेता। मैं आपको इसे खोजने के लिए चुनौती देता हूं!

— Giuseppe

@Giuseppe: मुझे नहीं पता कि यह आपके दृष्टिकोण के समान था, लेकिन मैंने 10 बाइट्स बचाए: D

— digEmAll

हुह, नहीं, मैं उपयोग कर रहा था, splitलेकिन tabulateबहुत बेहतर है!

— Giuseppe

mmh ... अब मैं उत्सुक हूं, आपने इसके लिए विभाजन का उपयोग कैसे किया?

— डाइजेक्सिल

1

मेरे पास x=max(L<-scan());rep(1:x,1:x-lengths(split(L,c(L,1:x))))जो आगे के परीक्षण के लिए परीक्षण के मामलों की तरह काम नहीं करता है 7...

— Giuseppe

5

पायथन 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

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

4

05AB1E , 17 16 17 बाइट्स

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

-1 बाइट @ मिस्टरकोड के लिए धन्यवाद ।
बग बाइट फिक्सिंग के बाद +1 बाइट ..

शायद मैं इसे पूरी तरह से अतीत में देखता हूं, लेकिन क्या 05AB1E में सूची बी के सभी तत्वों को सूची से हटा दिया गया है .. (संपादित करें: यह वास्तव में नहीं है ..) मैं सभी को कई बार दूर करने के लिए कैसे पता है, लेकिन प्रत्येक एक बार नहीं .. (मल्टीसेट अंतर)

निश्चित रूप से गोल्फ हो सकता है। वास्तव में इसके साथ खुश नहीं है, 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'

— केविन क्रूज़सेन
स्रोत

क्या आप ढूंढ रहे हैं K a,b Push a without b's:? ओह रुको, "एक बार" ... हम्म

— जोनाथन एलन

@JonathanAllan नहीं, यह काम नहीं करेगा, यह प्रत्येक की पहली घटना के बजाय सभी घटनाओं को हटा देता है । केविन मल्टीसेट अंतर जैसे कुछ की तलाश कर रहा है

— श्री एक्सकोडर

@JonathanAllan लगभग। [1,2,3,4,5,6,7,1,2,3,4,5,6,7]और दुर्भाग्य से परिणाम के [5,3,3,2,7]साथ । यह एक मल्टीसेट अंतर करने के बजाय सभी वस्तुओं को हटा देता है। K[1,4,6,1,4,6]

— केविन क्रूज़सेन

1

¢ZIZLŠŠи1 बाइट बचाना चाहिए

— श्री Xcoder

@ Mr.Xcoder धन्यवाद, लेकिन यह वह हिस्सा नहीं था जिसे मैं गोल्फ देख रहा था। ; पी मजेदार कैसे दो ट्रिपल-स्वैप गिनती के बाद पहुंच को दूर करने की तुलना में कम है ..

— केविन क्रूज़सेन

3

आर , 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)

— J.Doe
स्रोत

2

digEmAll का उत्तर पूरी तरह से मान्य है; यह स्टड के माध्यम से इनपुट लेता है!

— Giuseppe

1

इसके अलावा, जैसा कि यह बेस आर नहीं है, इसे एक अलग भाषा "आर + वीकेट्स" माना जाना चाहिए (मुझे उसके लिए प्रासंगिक मेटा चर्चा नहीं मिल सकती है, लेकिन मुझे पता है कि यह मानक अभ्यास है)

— Giuseppe

1

यह तब विफल हो जाता है जब अधिकतम मान अधिकतम दोहराया नहीं जाता है, उदाहरण के लिएf(c(5,3,3,2,7))

— digEmAll

3

जावास्क्रिप्ट (ईएस 6), 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

— Arnauld
स्रोत

3

हास्केल, 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

— nimi
स्रोत

3

ब्रेकीलॉग , 18 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@Kroppeb को 1 बाइट धन्यवाद दिया।

व्याख्या

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

— घातक
स्रोत

1

आप ⌉इसके बजाय का उपयोग कर सकते हैंot

— क्रॉपेब

2

जावा 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

— केविन क्रूज़सेन
स्रोत

2

भूसी , 12 बाइट्स

BWO के लिए 1 बाइट धन्यवाद सहेजा गया ।

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

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत

2

MATL , 24 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— sundar - मोनिका को बहाल करना
स्रोत

2

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]

— लुइस मेंडो
स्रोत

1

पायथ , 13 बाइट्स

.-*SeSQeSlM.g

यहाँ यह कोशिश करो! या एक परीक्षण सूट की जाँच करें!

— मिस्टर एक्सकोडर
स्रोत

1

चारकोल , 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

— नील
स्रोत

1

एपीएल (डायलॉग क्लासिक) , 18 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

का उपयोग करता है ⎕io←1

— NGN
स्रोत

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

— अदनान
स्रोत

1

हैरानी की बात है कि लंबे समय तक नहीं!

— घातक

1

क्लोजर, 94 बाइट्स

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

— NikoNyrh
स्रोत

1

सी ++, 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;
}

— मैक्स येखलाकोव
स्रोत

1

गैया , 12 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत

1

सी (जीसीसी) , 177 बाइट्स

इनपुट और आउटपुट स्टड और स्टडआउट के माध्यम से किया जाता है। दोनों सरणियों को 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);
}

इसे ऑनलाइन आज़माएं!

— कर्टिस Bechtel
स्रोत

डुप्लिकेट पर्वतमाला तक भरें

उदाहरण

इनपुट और आउटपुट

परीक्षण के मामलों

स्कोरिंग

जेली , 9 बाइट्स

वैकल्पिक

व्याख्या

पर्ल 6 , 37 33 बाइट्स

स्पष्टीकरण:

आर , 59 49 48 बाइट्स

पायथन 2 , 86 83 80 72 बाइट्स

05AB1E , 17 16 17 बाइट्स

आर , 59 55 बाइट्स

जावास्क्रिप्ट (ईएस 6), 98 बाइट्स

कैसे?

हास्केल, 72 बाइट्स

ब्रेकीलॉग , 18 17 बाइट्स

व्याख्या

जावा 10, 186 बाइट्स

भूसी , 12 बाइट्स

MATL , 24 21 बाइट्स

MATL , 14 बाइट्स

व्याख्या

पायथ , 13 बाइट्स

चारकोल , 19 बाइट्स

एपीएल (डायलॉग क्लासिक) , 18 17 बाइट्स

प्रस्तावना (SWI) , 211 बाइट्स

कोड

अनप्लग्ड संस्करण

क्लोजर, 94 बाइट्स

सी ++, 234 बाइट्स

गैया , 12 बाइट्स

सी (जीसीसी) , 177 बाइट्स