কোনও নির্দিষ্ট ক্রম ছাড়াই ধনাত্মক পূর্ণসংখ্যার একটি তালিকা হতে দিন এবং এতে সদৃশগুলি থাকতে পারে। একটি প্রোগ্রাম বা ফাংশন যা ধনাত্মক পূর্ণসংখ্যা একটি তালিকা আউটপুট লিখুন (যার ক্রম গুরুত্বহীন) যেমন মার্জ যে এবং যা সম্পূর্ণভাবে পূর্ণসংখ্যার অভিন্ন রেঞ্জ বিভক্ত করতে ক্ষুদ্রতম তালিকায় ফলাফল , যেখানে নেই বৃহত্তম উপাদান $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]

স্কোরিং

এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর ins

code-golf array-manipulation integer

— Fatalize
সূত্র

আপনার স্পষ্টতই বলা যায় যে আপনার পরীক্ষার মামলা এবং বিবৃতি একে অপরের সাথে বিরোধিতা করছে, iএর বৃহত্তম উপাদানটি Lনাকি M?

— ক্রপ্পেব

@ ক্রপপেব iহ'ল সবচেয়ে বড় উপাদান L, এটি ছিল চশমাগুলির একটি টাইপো।

— 13:58

ফিরে যাওয়ার ঠিক আছে M=[1,1,2,2,3]জন্য L=[3]যেখানে "একটি তালিকা যা সম্পূর্ণভাবে পূর্ণসংখ্যার [1..i] এর অভিন্ন রেঞ্জ বিভক্ত করতে পারেন এল এবং M ফলাফল মার্জ"?

— tsh

@ এসটি না, এটি ফিরে আসা উচিত [1,2]। আমি এটিকে স্পষ্ট করে বলব যাতে এটি স্পষ্ট হয় যে এর ফলাফলের সর্বনিম্ন সংখ্যা হওয়া উচিত।

— 13:58

1

@ DigEmAll সম্পন্ন হয়েছে।

— অঘটন ঘটাবেন

5

জেলি , 9 বাইট

জনাথন অ্যালানকে 1 বাইট সংরক্ষণ করা হয়েছে । পাদলেখ মূল লিঙ্কটি কল করে, পরীক্ষার কেসগুলির সাথে মেলে ফলাফলগুলি সাজায় এবং আউটপুটকে গ্রিড হিসাবে ফর্ম্যাট করে।

RṀẋLƙ`Ṁœ-

এটি অনলাইন চেষ্টা করুন! বা একটি পরীক্ষা স্যুট পরীক্ষা করে দেখুন!

বিকল্প

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

এর মধ্যে একটি অনলাইন চেষ্টা করে দেখুন!

ব্যাখ্যা

ẊRẋLƙ`Ṁœ- সম্পূর্ণ প্রোগ্রাম। এন = ইনপুট।
1R 1 থেকে সর্বোচ্চ (এন) এর ব্যাপ্তি: [1 ... সর্বোচ্চ (এন)]
   Lƙ` অভিন্ন উপাদান দ্বারা গঠিত গোষ্ঠীর উপর মানচিত্রের দৈর্ঘ্য।
  T উপরের ফলাফলের জন্য প্রতিটি টিয়ের জন্য টিয়ের পরিসীমা টি পুনরাবৃত্তি করুন।
      । সর্বোচ্চ। মূলত, সীমাটি সর্বোচ্চ (^^) বার পুনরাবৃত্তি করুন।
       œ- মাল্টিসেট পার্থক্য এন এর সাথে

— মিঃ এক্সকোডার
সূত্র

7

পার্ল 6 , 37 33 বাইট

-4 বাইট ধন্যবাদ নওহেলহোফকে!

{^.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}

— জোর করে

@ ননহ্নহফ, আহ! আমি বুঝতে পারিনি যে দ্বিতীয় যুক্তিটি ব্যাগ হতে পারে

— জো কিং

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ভিন্নভাবে উত্পন্ন করে তবে অন্যথায় আপনার মতো। আমি নিজে এটি পোস্ট করতে পারতাম তবে আমি মনে করি না যে আমি যদি আপনার প্রথমটি না দেখতাম তবে আমি এটি সম্পর্কে ভাবতাম। আমি আপনাকে এটি চ্যালেঞ্জ!

— জিউসেপ

@ জিউসেপ: আমি জানি না যে এটি আপনার পদ্ধতির অনুরূপ ছিল কিনা তবে আমি 10 বাইট সংরক্ষণ করেছি: ডি

— ডিগএমএল

হু, না, আমি ব্যবহার করছিলাম splitতবে tabulateআরও ভাল!

— জিউসেপে

মিমি ... এখন আমি কৌতূহলী, আপনি কীভাবে এর জন্য বিভাজনটি ব্যবহার করেছেন?

— digEmAll

1

আমার কাছে x=max(L<-scan());rep(1:x,1:x-lengths(split(L,c(L,1:x))))যা ছিল আরও পরীক্ষার পরে পরীক্ষার ক্ষেত্রে যেমন কাজ করে না 7...

— জিউসেপ

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

05 এ বি 1 ই , 17 16 17 বাইট

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

@ মিস্টার এক্সকোডারকে -1 বাইট ধন্যবাদ ।
কার্য-চারপাশে বাগ-ফিক্সিংয়ের পরে +1 বাইট ..

হয়তো আমি সম্পূর্ণরূপে গত চেহারা কিন্তু 05AB1E এমনকি একটি অপসারণ তালিকার সব উপাদান আছে খ তালিকা থেকে একটি .. (সম্পাদনা: এটা প্রকৃতপক্ষে না ..) আমি সব একাধিক বার মুছে ফেলার জন্য কিভাবে জানি, কিন্তু প্রতিটি একবার না .. (বহুবিধ পার্থক্য)

অবশ্যই গল্ফ করা যেতে পারে। এটিতে সত্যই খুশি নয়, টিবিএইচ .. ~~ব্যাখ্যা যুক্ত করার আগে আমি আরও কিছু গল্ফ করতে পারি কিনা তা দেখতে পাবে।~~সম্পাদনা: একটি ব্যাখ্যা যুক্ত করা হয়েছে ..

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

¢         # 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? ওহ অপেক্ষা করুন, "একবার প্রত্যেক" ... হুঁ

— জোনাথন অ্যালান

@ জোনাথান অ্যালান না, এটি কাজ করবে না, এটি প্রতিটি ঘটনার পরিবর্তে সমস্ত ঘটনা সরিয়ে দেয় । কেভিন মাল্টিসেট পার্থক্যের মতো কিছু খুঁজছেন

— মিঃ এক্সকডার

@ জোনাথান অ্যালান প্রায় [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 বাইট সাশ্রয় করা উচিত

— মিস্টার এক্সকোডার

@ মিঃ এক্সকোডার ধন্যবাদ, তবে আমি যে অংশটি গল্ফের দিকে চেয়েছিলাম সেটি ছিল না। ; p মজার কথা কীভাবে গণনার পরে অ্যাক্সেস অপসারণের চেয়ে দুটি ট্রিপল-অদলবদল সংক্ষিপ্ত হয় ..

— কেভিন ক্রুইজসেন

3

আর , 59 55 বাইট

vecsetsপ্যাকেজটি ব্যবহার করে আমরা উত্তরের দৈর্ঘ্য কিছুটা বাদ দিতে পারি। সঙ্গে glআমরা আদেশ আউটপুট পেতে পারেন। এটি টিআইওতে কাজ করে না। কোনও ফাংশন সংজ্ঞা ছাড়াই @ ডিজাইমএল এর সমস্ত স্টাইল (বরং চতুর) সমাধান অনুসরণ করে এটি 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 এর উত্তর পুরোপুরি বৈধ; এটি স্টিনের মাধ্যমে ইনপুট লাগে!

— জিউসেপ

1

এছাড়াও, এটি আর ভিত্তিক নয়, এটিকে একটি পৃথক ভাষা "আর + ভিসেটস" হিসাবে বিবেচনা করা উচিত (আমি এর জন্য প্রাসঙ্গিক মেটা আলোচনাটি খুঁজে পাই না, তবে আমি জানি এটি প্রমিত অনুশীলন)

— জিউসেপ

1

এটি ব্যর্থ হয় যখন সর্বাধিক মান সর্বাধিক পুনরাবৃত্তি না হয়, উদাহরণস্বরূপ চেষ্টা করুনf(c(5,3,3,2,7))

— digEmAll

3

জাভাস্ক্রিপ্ট (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

— 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∧

এটি অনলাইন চেষ্টা করুন!

@ ক্রপপ্যাবকে ধন্যবাদ 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)

— Fatalize
সূত্র

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 বাইট

বিডব্লিউও- তে 1 বাইট সংরক্ষণ করা হয়েছে ।

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

এটি অনলাইন চেষ্টা করুন!

— মিঃ এক্সকোডার
সূত্র

2

এমএটিএল , 24 21 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— সুন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র

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

প্রোলোগ (এসডাব্লুআই) , 211 বাইট

প্রোলগে প্রোগ্রাম করার পরে কিছুটা সময় হয়ে গেল। অবশ্যই আরও গল্ফ করা যেতে পারে, তবে আমি হাাহাহা পড়াশুনার জন্য একটি পরীক্ষা আছে।

কোড

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

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

(ফাংশন বডিতে নিউলাইনগুলি পাঠযোগ্যতার জন্য)।

ফাংশনটি আর্টগুলির একটি ভেক্টর গ্রহণ করে এবং ফেরত দেয়। এটি 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);
}

এটি অনলাইন চেষ্টা করুন!

— কার্টিস বেচটেল
সূত্র

সদৃশ ব্যাপ্তিগুলি পূরণ করুন

উদাহরণ

ইনপুট এবং আউটপুট

পরীক্ষার মামলা

স্কোরিং

জেলি , 9 বাইট

বিকল্প

ব্যাখ্যা

পার্ল 6 , 37 33 বাইট

ব্যাখ্যা:

আর , 59 49 48 বাইট

পাইথন 2 , 86 83 80 72 বাইট

05 এ বি 1 ই , 17 16 17 বাইট

আর , 59 55 বাইট

জাভাস্ক্রিপ্ট (ES6), 98 বাইট

কিভাবে?

হাস্কেল, 72 বাইট

ব্র্যাচল্যাগ , 18 17 বাইট

ব্যাখ্যা

জাভা 10, 186 বাইট

তুষ , 12 বাইট

এমএটিএল , 24 21 বাইট

MATL , 14 বাইট

ব্যাখ্যা

পাইথ , 13 বাইট

কাঠকয়লা , 19 বাইট

এপিএল (ডায়ালগ ক্লাসিক) , 18 17 বাইট

প্রোলোগ (এসডাব্লুআই) , 211 বাইট

কোড

উদার সংস্করণ

Clojure, 94 বাইট

সি ++, 234 বাইট

গাইয়া , 12 বাইট

সি (জিসিসি) , 177 বাইট