वृद्धि एक सरणी

44

धनात्मक पूर्णांक की एक गैर-रिक्त सारणी को देखते हुए, "वृद्धि" इसे एक बार इस प्रकार है:

  • यदि सभी सरणी तत्व समान हैं, 1तो सरणी के अंत में संलग्न करें । उदाहरण के लिए:

    [1] -> [1, 1]
[2] -> [2, 1]
[1, 1] -> [1, 1, 1]
[3, 3, 3, 3, 3] -> [3, 3, 3, 3, 3, 1]

  • एल्स, एरे में पहला तत्व बढ़ाता है जो एरे का न्यूनतम मूल्य है। उदाहरण के लिए:

    [1, 2] -> [2, 2]
[2, 1] -> [2, 2]
[3, 1, 1] -> [3, 2, 1] -> [3, 2, 2] -> [3, 3, 2] -> [3, 3, 3]
[3, 4, 9, 3] -> [4, 4, 9, 3] -> [4, 4, 9, 4] -> [5, 4, 9, 4] -> [5, 5, 9, 4] -> ...

(प्रत्येक ->एक वेतन वृद्धि का प्रतिनिधित्व करता है, जो आपके सभी कार्यक्रम को करने की आवश्यकता है)

परिणामी बढ़े हुए सरणी का उत्पादन।

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  number  arithmetic  array-manipulation  integer 
— केल्विन के शौक
स्रोत
क्या 0 को सकारात्मक पूर्णांक के रूप में गिना जाता है
— डाउगाट
20
@Downgoat 0 पीपीसीजी पर कभी भी सकारात्मक नहीं है। यदि 0 की अनुमति दी गई थी, तो यह शब्द "गैर-नकारात्मक" होगा
— ETHproductions

जवाबों:

13

जेली , 8 7 बाइट्स

‘;ṀỤḢṬ+

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

‘;ṀỤḢṬ+  Main link. Argument: A

‘        Increment all elements of A.
  Ṁ      Yield the maximum of A.
 ;       Concatenate both results. Note that the appended maximum will be the 
         minimum of the resulting array if and only if all elements of A are equal.
   Ụ     Grade up; yield the indices of the resulting array, sorted by their
         corresponding values in that array.
    Ḣ    Head; extract the first index, which is the index of the first occurrence
         of the minimum. For an array of equal elements, this will be the index
         of the appended maximum.
     Ṭ   Untruth; for index i, yield an array of i-1 zeroes, followed by a 1.
      +  Add this array to A, incrementing the minimum or appending a 1.
— डेनिस
स्रोत
11

पायथन 3, 62 53 51 50 बाइट्स

फ़ंक्शन जो इसे संशोधित सूची को संशोधित करता है ( मेटा द्वारा अनुमत )।

def F(a):a+=1//len({*a})*[0];a[a.index(min(a))]+=1

Repl.it पर प्रयास करें!

-9 बाइट्स लिन को धन्यवाद कि स्पॉटिंग के लिए, क्योंकि एरे पॉजिटिव पूर्णांकों का होगा, मैं एरे के अंत में '0' को जोड़ सकता हूं और यह बढ़ा हुआ है।

गोल्फ के लिए mbomb007 को विशेष धन्यवाद len(set(a))करने के लिए len({*a})floordiv चाल के लिए, और डेनिस!

— FlipTack
स्रोत
हम्म। "परिणामी बढ़े हुए सरणी को आउटपुट करें"। क्या यह योग्यता है?
— यति
मुझे यह याद नहीं है कि मैं कहाँ याद कर सकता हूँ, लेकिन मुझे याद है कि एक मेटा पोस्ट को देखते हुए कि दी गई सूची को संशोधित करके डिफ़ॉल्ट रूप से अनुमति दी जाती है। मैं इसके लिए एक नज़र @TuukkaX
— FlipTack
@TuukkaX मैं पूरी तरह से निश्चित नहीं हूं। ऐसा लगता है कि ठीक है, लेकिन अगर एक जगह है, तो मैं सरणियों को संशोधित करने के बारे में मेटा की सहमति को टाल दूंगा।
— केल्विन के शौक
1
पायथन 3 में, आप यह len({*L})<2पता लगाने के लिए उपयोग कर सकते हैं कि किसी सूची के सभी तत्व समान हैं या नहीं।
— mbomb007 21
1
a+=1//len({*a})*[0]एक बाइट को बचाना चाहिए।
— डेनिस
9

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

a=>new Set(a).size>1?++a[a.indexOf(Math.min(...a))]:a.push(1)

इसके तर्क को संशोधित करके आउटपुट । मुझे यह निर्धारित करने का कोई तरीका नहीं मिल रहा है कि किसी सरणी में केवल 17 बाइट्स में एक अद्वितीय आइटम है, लेकिन सुझावों का स्वागत है।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

अन्य प्रयास

यहां यह तय करने के कुछ वैकल्पिक तरीके हैं कि क्या सरणी में एक से अधिक अनूठे इनपुट हैं:

a=>a.some(x=>x-a[0])?++a[a.indexOf(Math.min(...a))]:a.push(1)
a=>a.some(x=>x-m,m=Math.min(...a))?++a[a.indexOf(m)]:a.push(1)

दोनों को someसाथ findही बदला जा सकता है । .sortन्यूनतम खोजने के लिए छोटा होगा, यदि डिफ़ॉल्ट प्रकार lexicographic (क्यों, JS, क्यों?) नहीं था।

a=>new Set(a).size>1?++a[a.indexOf(a.sort()[0])]:a.push(1)
// Instead we have to do:
a=>new Set(a).size>1?++a[a.indexOf(a.sort((x,y)=>x-y)[0])]:a.push(1)

मैंने न्यूनतम खोजने के लिए पुनरावर्तन की कोशिश की, लेकिन यह अधिक लंबा हो गया:

f=(a,n=1,q=a.indexOf(n))=>~q?a.some(x=>x-n)?++a[q]:a.push(1):f(a,n+1)

और यहां एक स्ट्रिंग-आधारित समाधान है जो पहले एक अच्छे विचार की तरह लग रहा था: (इनपुट स्ट्रिंग में सरणी प्रारूप में दिया गया है, जैसे "[1,2,3]")

a=>a.replace(m=/(\d+),(?!\1)/.test(a)?Math.min(...eval(a)):']',+m+1||",1]")
— ETHproductions
स्रोत
A.find (n => n == Math.min (... a)) का उपयोग कम है?
— डाउनवेज
@Downgoat मुझे यकीन नहीं है कि मैं इसका उपयोग कैसे करूँगा, क्योंकि यह आइटम को इंडेक्स के बजाय लौटाता है
— ETHproductions
हाँ> _> वूप्स, मैंने आपका ++ मिस कर दिया और महसूस नहीं किया कि आपको एक संदर्भ की आवश्यकता है
— Downgoat
7

गणितज्ञ, 70 57 55 बाइट्स

लगभग सभी सुधार के मार्टिन Ender, जो पैटर्न मिलान दृष्टिकोण पर मेरे गधे लात मारता है की वजह से है! इसके अलावा जेएचएम अनिवार्य रूप से उसी समय अनिवार्य रूप से एक ही समाधान के साथ आया था। (बाइट काउंट ASCII एन्कोडिंग का उपयोग करता है)

±{p:x_ ..}:={p,1};±{x___,y_,z___}/;y≤x~Min~z:={x,y+1,z}

±एक सूची तर्क को लेने वाले फ़ंक्शन को परिभाषित करता है । यदि उस सूची तर्क में एक ही तत्व की कुछ संख्याएँ हैं (द्वारा x_..और नाम से पता लगाया गया है p), तो सूची को एक 1संलग्न के साथ आउटपुट करें । अन्यथा, यदि उस सूची तर्क में एक विशेष तत्व है y( xशून्य या अधिक तत्वों के होने से पहले y, और zशून्य या अधिक तत्व होने के बाद y) जो कि अन्य तत्वों में से सबसे कम से कम है, तो सूची को उस yवृद्धि के साथ आउटपुट करें । सूची के न्यूनतम तत्व के किसी भी उदाहरण का मिलान किया जाएगा y, लेकिन सौभाग्य से गणितज्ञ पहले कार्य करने के लिए पहले का चयन करता है।

— ग्रेग मार्टिन
स्रोत
क्योंकि ±एक 2-बाइट वर्ण है, आपका कोड 59 बाइट्स लंबा है। इसके अलावा, वहाँ के बीच एक स्थान होना चाहिए x_और ..क्योंकि गणितज्ञ व्याख्या x_..करता है x_. .(जो त्रुटियों को फेंकता है)। इसके अलावा, इनफ़िक्स फॉर्म Min( x~Min~z) इस 2 बाइट्स को छोटा बना देगा (जो इस घोल को मेरे एक: पी ... के समान बनाता है) वेल्प आप क्रेडिट ले सकते हैं क्योंकि मेरा एडिट बाद में आपका था ....
— जंगवान मिन
नाह, मार्टिन एंडर को वैसे भी मेरे ज्यादातर क्रेडिट मिलते हैं। By दो बाइट्स क्यों है?
— ग्रेग मार्टिन
UTG ±-8 में @GregMartin ( गणितज्ञ डिफ़ॉल्ट रूप से UTF-8 का उपयोग करता है; कोशिश करें $CharacterEncoding) एक दो-बाइट वर्ण (U + 00B1) है।
— जुंगह्वान मिन नोव
@JHM UTF-8 विंडोज पर डिफ़ॉल्ट चरित्र एन्कोडिंग नहीं है। गणितज्ञ एकल-बाइट कोड पृष्ठ में स्रोत फ़ाइलों को पढ़ सकते हैं जिसमें शामिल हैं ±।
— मार्टिन एंडर
1
@ASimmons विंडोज पर मेरा नया मैथेमेटिका इंस्टालेशन, जो कि CP1252 के $CharacterEncodingलिए सेट है WindowsANSI(जो कि आईएसओ 8859-1 के लिए पर्याप्त रूप से संगत है ±और ·एक बाइट के लिए उपयोग करने योग्य है)।
— मार्टिन एंडर
7

सी ++ 14, 178 176 174 155 142 135 बाइट्स

प्रस्तुत करने

#include<list>
#include<algorithm>
[](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?++*min_element(b,e):(l.push_back(1),0);};

मंगलाचरण

std::list<int> s = {4, 4, 9, 4};

//invoke like this
auto i = [](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?++*min_element(b,e):(l.push_back(1),0);};
i(s);

//or like that
[](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?++*min_element(b,e):(l.push_back(1),0);}(s);

ungolfed

#include <list>
#include <algorithm>
#include <iostream>
using namespace std;

void i(list<int>& l) {
    auto e = l.end(), b = l.begin();

    if (l.size() == count(b, e, l.front())) {
        l.push_back(1);
    } else {
        ++*min_element(b, e);
    }
}

int main() {
    list<int> s = {4, 4, 9, 4};

    //invoke like this
    i(s);

    for (auto o:s)
        std::cout << o << ' ';
    std::cout << std::endl;
}

यह गोल्फ खेलने का मेरा पहला मौका है, मदद की सराहना की है।

EDIT: उल्लेख करना भूल गया कि आपको इसे कम से कम संकलित करना है -std=c++11 -std=c++14

EDIT2: मुझे एहसास हुआ कि मैं इसमें शामिल जगह छोड़ सकता हूं #include <list>

EDIT3: की जगह दो और बाइट्स बचाया l.begin()द्वाराbegin(l)

EDIT4: @Quentin (उनकी टिप्पणी देखें) के लिए एक और 19 (!) बाइट्स धन्यवाद बचा लिया

EDIT5: क्वेंटिन ने 13 और बाइट्स का मुंडन किया, धन्यवाद!

EDIT6: जैसा कि TuukkaX ने बताया है, अनाम लैम्ब्डा / फ़ंक्शन पर्याप्त हैं, इसलिए मैंने auto i=इसे ओवरटेकाउंट में हटा दिया

— Neop
स्रोत
5
मैं सी ++ के साथ आपकी मदद नहीं कर सकता, लेकिन मैं कह सकता हूं: पीपीसीजी में आपका स्वागत है!
— जरगब
1
मुझे लगता है कि आपको #includeलाइनों में रिक्त स्थान की आवश्यकता नहीं है ।
— क्रिश्चियन सिवर्स
ओह, शुक्रिया, मैंने इसे खुद महसूस किया :)
— 10
1
एक लंबो ( auto i=[](auto&l){...};) के साथ फ़ंक्शन को प्रतिस्थापित करना एक बाइट बचाता है (यदि हम वापसी के प्रकार को आप भूल गए;) गिनते हैं, तो ^ इसके बजाय ==ऑपरेंड का उपयोग करके और स्वैप करने से दूसरे को बचाता है। std::listपुनरावृत्तियां निश्चित रूप से std::कक्षाएं हैं, इसलिए आप std::दोनों से गिर सकते हैं std::countऔर std::min_elementएडीएल (-10) के लिए धन्यवाद। l.front()भी है *b(-7)। मैं एक 120-बाइट के साथ अंत करता हूं auto i=[](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?void(++*find(b,e,*min_element(b,e))):l.push_back(1);};:)
— क्वेंटिन
1
जब हम इस पर होते हैं, तोstd::min_element यह कहता है कि यह पहला सबसे छोटा तत्व है, इसलिए find()यह अतिश्योक्तिपूर्ण है कि यह 11 बाइट्स है। सशर्त में, कोष्ठक और अल्पविराम ऑपरेटर की एक जोड़ी का उपयोग करके सही अभिव्यक्ति को intकम करने के लिए बाएं voidबाइट को 2 बाइट्स से कास्टिंग करने से कम है । यह auto i=[](auto&l){auto e=end(l),b=begin(l);l.size()^count(b,e,*b)?++*min_element(b,e):(l.push_back(1),0);};142 बाइट्स की ओर जाता है :)
— क्वेंटिन
6

05AB1E , 21 20 16 बाइट्स

अदनान के लिए धन्यवाद 4 बाइट्स बचाए ।

DÙgi0¸«}ÐWksgÝQ+

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

व्याख्या

                      # input = [3,2,1] used as example
D                     # duplicate input
 Ùgi                  # if all elements are equal
    0¸«}              # append 0
        Ð             # triplicate list
                      # STACK: [3,2,1], [3,2,1], [3,2,1]
         Wk           # index of minimum element
                      # STACK: [3,2,1], [3,2,1], 2
           s          # swap top 2 elements of stack
                      # STACK: [3,2,1], 2, [3,2,1]
            g         # length of list
                      # STACK: [3,2,1], 2, 3
             Ý        # range [0 ... length]
                      # STACK: [3,2,1], 2, [0,1,2,3]
              Q       # equal
                      # STACK: [3,2,1], [0,0,1,0]
               +      # add
                      # OUTPUT: [3,2,2]
— Emigna
स्रोत
मुझे लगता है कि DÙgi0¸«}ÐWksgÝQ+यह भी काम करता है।
— अदनान
@Adnan: आह, अच्छा विचार का उपयोग कर ÝQके साथ k। धन्यवाद!
— एमिग्ना
5

स्क्रैच, 25 34 ब्लॉक + 7 6 बाइट्स

कार्यक्रम

पूर्णांक के पूर्वनिर्धारित सरणी के रूप में इनपुट लेता है। ध्यान दें कि स्क्रैच में सरणियाँ 1-अनुक्रमित हैं।

पायथन में, यह इस तरह दिखेगा: (ध्यान दें कि स्क्रैच के विपरीत, पायथन 0-अनुक्रमित है)

lowval = 0
hival = 0
n = 1
for i in range(len(input)):
    if(input[i] < input[lowval]):
        lowval = i
    if(input[i] > input[hival]):
        hival = i
    # No increment statement needed because python.
if(lowval == hival):
    input.append(1)
else:
    input[lowval] += 1
print(input)
— OldBunny2800
स्रोत
गोल्फ टिप्पणी कृपया?
— OldBunny2800
आप घोषणा क्यों करते हैं?
— क्रिस्टोफ
यह मेरे लिए प्रतीत होता है कि स्क्रैच रंगों के साथ सादे पाठ में सिर्फ पायथन है ...
— स्टिव ग्रिफिन
और 1-अनुक्रमित सरणियाँ और कोई एलिफ बयान नहीं!
— ओल्डबुननी 2800
1
अच्छी बात @Christoph! यह एक पुराने संस्करण का हिस्सा था जिसे बाहर निकाला गया था। संपादन।
— ओल्डबुननी 2800
4

जे, 25 22 बाइट्स

(+~:*[=<./)@,0#~1=#@~.

एक अनाम क्रिया का मूल्यांकन करता है। यह ऑनलाइन की कोशिश करो!

व्याख्या

(+~:*[=<./)@,0#~1=#@~.  Input is y.
                  #@    Is the length of
                    ~.   deduplicated y
                1=       equal to 1?
            ,0#~        Append that many 0s to y (one or none).
(         )@            Call the result z and apply this verb to it:
      =                  take the bit array of equality
     [                   between z
       <./               and its minimum element,
    *                    multiply that element-wise by
  ~:                     the bit array of first occurrences in z
 +                       and add the result to z.
— Zgarb
स्रोत
3

MATL , 16 बाइट्स

t&=?1h}t2#X<wQw(

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

यह काम किस प्रकार करता है

t         % Take input implicitly. Duplicate
&=        % Matrix of all pairwise equality comparisons
?         % If all comparisons were true
  1h      %   Append 1 to the original copy ofthe array
}         % Else
  t       %   Duplicate array
  2#X<    %   Push minimum and index of its first occurrence
  wQw     %   Swap, increment, swap (adds 1 to the minimum)
  (       %   Assign the incremented minimum to that position
          % End if implicitly. Display implicitly
— लुइस मेंडो
स्रोत
3

मैथेमेटिका, 56 बाइट्स

±{b:a_ ..}:={b,1};±a_:=a/.{p___,b:Min@a,q___}:>{p,b+1,q}

फ़ंक्शन नाम का उपयोग करता है ±। ISO8859-1 एन्कोडिंग का उपयोग करता है

वैकल्पिक समाधान (58 बाइट्स)

±{b:a_ ..}:={b,1};±{p___,b_,q___}/;b<=p~Min~q:={p,b+1,q}
(* @GregMartin and I both independently came up with this above solution *)

±{b:a_ ..}:={b,1};±a:{p___,b_,q___}/;b==Min@a:={p,b+1,q}

प्रयोग

±{1, 1}

{1, 1, 1}

±{3, 4, 5}

{4, 4, 5}

— जंगवान मिन
स्रोत
3

हास्केल, 71 70 62 बाइट्स

f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1‌​:z

@Zgarb ने 8 बाइट्स बचाए, धन्यवाद!

जब मैंने शुरू किया था तो मुझे कुछ सुरुचिपूर्ण बांधने की चाल के लिए आशा थी, लेकिन @ ज़र्गब का तरीका उतना ही अद्भुत है।

— क्रिश्चियन सिवर्स
स्रोत
कुछ पुनर्गठन, 62 बाइट्स:f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1:z
— जर्गब
@Zgarb बस वाह!
— क्रिश्चियन सिवर्स
उघ, मेरा मस्तिष्क कार्यों के
— मोनड
@Angs मोनाड है (->)r, जो एक प्रकार पर लागू होता है (->)r a = r->a। फिर प्रकार return:: a->r->aऔर (>>=)::(r->a)->(a->r->b)->(r->b)उनके कार्यान्वयन से है (मैं इसे कहने की हिम्मत करता हूं?) स्पष्ट: return=constऔर m>>=f = \r->f(m r)r। उत्तरार्द्ध ठीक वैसा ही है, जैसा कि केवल एक बार span(predicate_depending_on l)lउल्लेख करते समय कुछ व्यक्त करने के लिए आवश्यक है l। अब मुझे केवल इसे याद रखना है जब मुझे इसकी आवश्यकता है।
— क्रिश्चियन सिवर्स
@ आंग्स आप हमारे हास्केल गोल्फ टिप्स कलेक्शन में इस ट्रिक, और कई और चीजें पा सकते हैं ।
— ज़गारब
3

सी #, 123 121 120 79 77 बाइट्स

using System.Linq;l=>{if(l.All(o=>o==l[0]))l.Add(0);l[l.IndexOf(l.Min())]++;}

फ़ंक्शन में दिए गए तर्क को संशोधित करता है।

3 बाइट बचाने के लिए Cyoce को धन्यवाद ! -> !Anyसे All, +=1को ++।

43 बाइट बचाने के लिए TheLethalCoder को धन्यवाद ! -> हटाए गए विधि हस्ताक्षर कोड। पैरामीटर सूची के आसपास कोष्ठक हटा दिया गया।

— Yytsi
स्रोत
आप के !l.Any(o=>o!=l[0]))साथ बदल सकता है l.All(o=>o==l[0])?
— साइओस
@ यह वास्तव में करता है। मैं एक ही बात के बारे में सोचा, लेकिन के Anyबजाय लिखा Allथा और सोचा था, कि यह काम नहीं करता है: धन्यवाद!
— यति
2
C # नहीं है ++?
— साइओस
आप Action<List<int>>सभी विधि हस्ताक्षर कोड को हटाने के लिए संकलन कर सकते हैं
— TheLethalCoder
1
@ सत्तेफान हम्म। मैंने कई लोगों usingको C # के साथ आवश्यक s ड्रॉप करते देखा है, इसलिए मुझे भरोसा नहीं है कि इसे छोड़ना कानूनी using System.Linqहै। जब तक मैं एक स्पष्ट कथन नहीं देखता हूं जो कहता है कि यह आवश्यक नहीं है, मैं इसके साथ रहूंगा। फिर भी सुझाव के लिए धन्यवाद! :)
— यती
2

पर्ल 6 , 46 बाइट्स

{.[[==]($_)??.elems!!.first(*==.min,:k)]++;$_}

(इनपुट एरे को संशोधित करता है, और उसे लौटाता है)

विस्तारित:

{     # bare block lambda with implicit parameter ｢$_｣

  .[      # use the following as an index into the array

      [==]( $_ )    # reduce the array with ｢&infix:<==>｣

    ??              # if they are equal

      .elems        # the value past the end ( ｢.end+1｣ would also work )

    !!              # else

      .first(       # find the first value
        * == .min,  # where the element is equal to the minimum
        :k          # return the key rather than the value
      )

  ]++;              # increment it ( auto vivifies if it doesn't exist )

  $_                # return the modified array
}

— ब्रैड गिल्बर्ट b2gills
स्रोत
2

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

;1µ‘i¦E?Ṃ

डेनिस को -2 बाइट्स के लिए धन्यवाद।

शरीर में कम से कम 30 अक्षर होने चाहिए; तुमने प्रवेश किया ... ।

— जाकारी
स्रोत
यदि आपके पास शरीर में प्रवेश करने के लिए अतिरिक्त वर्ण हैं, तो यह हमेशा कोड को समझाने के लायक है, जो हर किसी को इसे समझने में मदद करता है और उत्तर को अधिक दिलचस्प बनाता है :)
— अल्फी गुडाक्रे
2

गणितज्ञ, 53 बाइट्स 57 बाइट्स 59 बाइट्स

If[Equal@@#,#~Join~{1},x=#;x[[#~FirstPosition~Min@#]]++;x]&
— ngenisis
स्रोत
7
वह 57 बाइट्स है। 〚और 〛एक 3-बाइट वर्ण हैं। इसके अलावा, आपका कोड काम नहीं करता है क्योंकि {##,1}भाग का अर्थ है कि इनपुट अलग पूर्णांक (यानी f[1, 2, 3]) है, लेकिन x=#भाग का अर्थ है कि इनपुट एक List(यानी f[{1, 2, 3}]) है। एक त्वरित सुधार को बदलने के लिए किया जाएगा x=#करने के लिए x={#}और इनपुट के रूप में कच्चे पूर्णांकों स्वीकार करते हैं, 59 बाइट्स लंबे अपने कोड बना रही है।
— जुंगह्वान मिन नोव
अच्छी पकड़! मुझे बाइट्स और कैरेक्टर काउंट के बीच अंतर का एहसास नहीं था, मैंने सिर्फ यह सुझाव देखा और लगा कि यह मान्य है। ऐसा लगता है कि बहुत सारे उत्तर हैं जो वर्ण गणना देते हैं लेकिन अगर मैं उन्हें नोटपैड ++ में सहेजता हूं तो मुझे एक उच्च बाइट गिनती मिलती है (उदाहरण के लिए जेली उत्तर)। मैं देख रहा हूं कि आपका उत्तर एक एन्कोडिंग को निर्दिष्ट करता है, क्या इस बारे में जानने के लिए आप कहीं और सिफारिश करेंगे?
— 20
1
मुझे लगता है कि आप का मतलब है Equal@#, हालांकि #==##कम है।
— मार्टिन एंडर
आप सही हे। मैंने एक सूची के बजाय कई तर्कों को स्वीकार करने के लिए @JHM प्रति परिवर्तन किया लेकिन हर जगह परिवर्तन का प्रचार नहीं किया। मैं एक सूची को स्वीकार करने के लिए वापस चला गया हूं क्योंकि यह प्रॉम्प्ट के अनुरूप है।
— 19
2

आर , 72 66 65 बाइट्स

"if"(any((x=scan())-x[1]),"[<-"(x,u<-which.min(x),1+x[u]),c(x,1))

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

इन्क्रीमेंट का उपयोग करके किया जाता है which.minजो पहला मैच लौटाता है "[<-"मान को बदलने की अनुमति देता है और एक फ़ंक्शन कॉल में संशोधित वेक्टर लौटाता है।

Gi7ppe के लिए -7 बाइट्स धन्यवाद!

— Jayce
स्रोत
— Giuseppe
@Giuseppe मैंने isTRUE की कोशिश की और isFALSE sd के साथ यह गोल्फर नहीं है :(
— JayCe
हे, 65 बाइट्स के!= साथ की जगह -!
— Giuseppe
@Giuseppe बेशक!
— JayCe
1

रूबी, 46 बाइट्स

->a{a.uniq.size<2?a<<1:a[a.index(a.min)]+=1;a}

मुझे लगता है कि यह जांचने का एक बेहतर तरीका है कि क्या सभी तत्व समान हैं a.uniq.size<2, लेकिन मैं इसे खोजने के लिए बहुत आलसी हूं।

— ली डब्ल्यू
स्रोत
6
a.uniq[1]सत्य होगा अगर अलग-अलग मूल्य हैं।
— हिस्टोक्रैट २ '
आप बदल कर एक बाइट बचा सकता है a[a.index(a.min)]मेंa[a.index a.min]
— Cyoce
1

ऑक्टेव, 69 67 64 बाइट्स

यह वास्तव में यह दोनों का उपयोग करने से पूरी तरह से नामित समारोह बनाने के लिए कम था inputऔर disp।

लुइस की बदौलत 3 बाइट्स बचाए। 

function x=f(x)
[a,b]=min(x);if any(x-a),x(b)++;else x=[x,1];end

पुराना उत्तर, फ़ंक्शन का उपयोग नहीं करना:

[a,b]=min(x=input(''));if any(x-a),x(b)++;else x(end+1)=1;end;disp(x)
— स्टीवी ग्रिफिन
स्रोत
1

आर, 97 बाइट्स

if(all((a=scan())==a[1])){a=c(a,1)}else{while(!all(a==a[1])){a[which(a==min(a))][1]=min(a)+1}};a

बहुत बुरा है कि वाक्य रचना x=+1R में मौजूद नहीं है!

अघोषित:

if(all((a=scan())==a[1]))
{
    a=c(a,1)
}
else
{
    while(!all(a==a[1]))
    {
        a[which(a==min(a))][1]=min(a)+1
    }
a
— फ़्रेडरिक
स्रोत
1

टीआई-बेसिक, 53 बाइट्स

If min(not(ΔList(Ans
Then
Ans->L1
cumSum(1 or Ans
min(Ans+ᴇ9(L1≠min(L1
L1(Ans)+1->L1(Ans
Else
augment(Ans,{1
End
— Timtech
स्रोत
1

मतलब, 83 , 77 , 71 बाइट्स

function a=x(a)
if~nnz(a-a(1));a=[a,1];else[~,I]=min(a);a(I)=a(I)+1;end

मैं कोड गोल्फ के लिए अपेक्षाकृत नया हूं इसलिए कृपया दयालु बनें! मैंने अनाम फ़ंक्शंस का उपयोग करने की कोशिश की, लेकिन googling का कहना है कि आप इसका उपयोग नहीं कर सकते हैं / अन्यथा स्टेटमेंट और matlab में टर्नरी ऑपरेटर नहीं हैं, इसलिए यह सबसे अच्छा है जो मुझे लगा कि मैं कर सकता हूं।

संपादित करें: सही और छोटा (दो बार!) Stewie-griffin के लिए धन्यवाद।

— ओवेन मॉर्गन
स्रोत
PPCG में आपका स्वागत है! इस कोड में कुछ खामियां हैं। sum(a)/length(a)==a(1)यह गारंटी नहीं देता कि सभी तत्व समान हैं, यह केवल दिखाता है कि औसत के बराबर है a(1)। ऐसा करने का एक सरल तरीका होगा mean(a)==a(1)। numelएक बाइट से कम है length, लेकिन जब से आप जानते हैं कि सभी मान सकारात्मक हैं, आप उपयोग कर सकते हैं nnzजो कि और भी छोटा है (यह अभी भी इस चुनौती में सही परिणाम नहीं देगा, लेकिन यह कम से कम है: पी)। आप नहीं उठाते, तो min(a)पाश के सामने कॉल, आप इसे से दोनों आउटपुट का उपयोग कर सकते हैं और जांच है allके तत्वों aके बराबर हैं min(a)।
— स्टिव ग्रिफिन
तुम सही हो! यह तब विफल होता है जब माध्य पहले तत्व में संख्या के बराबर होता है। मुझे लगता है कि मेरा नया भी सही है और छोटा भी है। तर्क यह है कि यदि शेष तत्व पहले तत्व के बराबर नहीं हैं, तो एक (~ (a = a (1)) शेष तत्वों को लौटाता है, जो परिभाषा में गैर-समान सरणी में 0 से अधिक है। फिर गिनती और मुझे सही तर्क देना चाहिए जो मुझे लगता है। यदि यह अभी भी गलत है, तो कृपया मुझे बताएं, मैं केवल कुछ वर्षों के लिए कोडिंग कर रहा हूं और मेरे पास अभी भी एक लंबा रास्ता बाकी है।
— ओवेन मॉर्गन
~nnz(a(a~=a(1)))बस है ~nnz(a-a(1))। इसके अलावा, आपको कोष्ठकों की आवश्यकता नहीं है। if ~nnz(a-a(1));a=[a,1];else[~,I]=min(a);a(I)=a(I)+1;end। यह 5 बाइट्स छोटा होना चाहिए (ध्यान दें: मैंने इसका परीक्षण नहीं किया है)।
— स्टीवी ग्रिफिन
आप के range(a)बजाय 3 बाइट्स बचा सकते हैंnnz(a-a(1))
— MattWH
@boboquack, उस कोड की जाँच करता है कि तत्वों की संख्या aउस वेक्टर में सबसे कम मूल्य के बराबर है या नहीं। एक वेक्टर a = [3 4 6]में परिणाम होगा trueऔर एक वेक्टर a = [4 4 6]में परिणाम होगा false। मुझे नहीं लगता कि यहाँ उपयोगी होगा ...?
— स्टीवी ग्रिफिन
1

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

दुर्भाग्य से min-keyसबसे छोटे सूचकांक का आखिरी सूचकांक है, न कि पहला। यह पूर्णांक इनपुट और 10 ^ 9 तत्वों की तुलना में छोटी सरणियों के लिए काम करता है;)

संपादित करें: एक अनाम फ़ंक्शन को परिभाषित करना, (apply = a)इसके बजाय का उपयोग करना (= 1(count(set a)))।

(fn[a](if(apply = a)(conj a 1)(update a(apply min-key #(+(nth a %)(* % 1e-9))(range(count a)))inc)))

मूल:

(defn f[a](if(= 1(count(set a)))(conj a 1)(update a(apply min-key #(+(nth a %)(* % 1e-9))(range(count a)))inc)))

एक कम हैकेटी 134-बाइट समाधान इसे अपडेट करने से पहले वेक्टर को उलट देता है और फिर इसे फिर से उलट देता है:

(defn f[a](if(= 1(count(set a)))(conj a 1)(let[r #(vec(reverse %))a(r a)](r(update a(apply min-key #(nth a %)(range(count a)))inc)))))
— NikoNyrh
स्रोत
1

जावा 8, 85 + 38 = 123 बाइट्स

शून्य लैंबडा एक List<Integer>(आउटपुट उत्परिवर्तित इनपुट) ले रहा है। बाइट काउंट में लैम्ब्डा और आवश्यक आयात शामिल हैं।

import static java.util.Collections.*;

l->{if(min(l)==max(l))l.add(0);int i=0,n;while((n=l.get(i))>min(l))i++;l.set(i,n+1);}

यह ऑनलाइन की कोशिश करो

यह लगभग उन तरीकों के आयात के साथ अजगर की तरह दिखता है ...

— जेकब
स्रोत
1

MATLAB, 66 53 बाइट्स

if(range(a))[~,b]=min(a);a(b)=a(b)+1;else;a=[a 1];end

आउटपुट:

प्रारंभ: 

a = [3 2]

क्रमिक रन: 

[3 2] -> [3 3] -> [3 3 1] -> [3 3 2] -> [3 3 3] -> [3 3 3 1] ...
— पोन पोन होला मोन
स्रोत
2
आप इनपुट को हार्डकोड नहीं कर सकते, आपको कुछ ऐसा करने की आवश्यकता होगी @(x) …।
— ბიმო
1

स्माइलबासिक 3, 101 बाइट्स

एक स्टेटमेंट फंक्शन को परिभाषित करता है I Aजहां Aहमारी संख्याओं की पूर्णांक सरणी है। इनपुट को संशोधित करके आउटपुट प्राप्त किया जाता है (क्योंकि सरणियाँ संदर्भ हैं।)

DEF I A
M=MIN(A)IF M==MAX(A)THEN PUSH A,1RETURN
FOR C=0TO LEN(A)IF M==A[C]THEN INC A[C]BREAK
NEXT
END
— snail_
स्रोत
आप की जगह 2 बाइट्स बचा सकता है BREAKके साथ M=0है, क्योंकि Aनहीं हो सकते 0तो M==A[C]सच कभी नहीं होगा।
— 12Me21
1

स्माइलबासिक, 77 बाइट्स

DEF I A
IF MIN(A)==MAX(A)THEN PUSH A,0
WHILE A[I]>MAX(A)I=I+1WEND
INC A[I]END
— 12Me21
स्रोत
0

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

?tl{QXxQhSQQ1+Q1

एक प्रोग्राम जो किसी सूची का इनपुट लेता है और परिणाम प्रिंट करता है।

परीक्षण सूट

यह काम किस प्रकार करता है

?tl{QXxQhSQQ1+Q1  Program. Input: Q
?                 If:
  l                The length
   {Q              of Q deduplicated
 t                 - 1
                   is non-zero:
     X     Q1       Increment in Q at index:
      xQ             Index in Q of
        h            the first element
         SQ          of Q sorted (minimum)
                  else:
             +     Append
               1   1
              Q    to Q
                   Implicitly print
— TheBikingViking
स्रोत
0

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

f z|and$(==)<$>z<*>z=z++[1]|1>0=z#minimum z where(x:z)#m|x==m=x+1:z;(x:z)#m|1>0=x:z#m;[]#_=[]

Ungolfed:

incrementArray :: [Int] -> [Int]
incrementArray xs | and [x == y | x <- xs, y <- xs] = xs ++ [1]
                  | otherwise = g xs (minimum xs)
     where g (x:xs) m | x == m = (x + 1):xs
           g (x:xs) m | otherwise = x:g xs m
           g [] _ = []

प्रारंभिक प्रयास, बाद में कुछ अधिक परिष्कृत के साथ आने की कोशिश करेगा।

— sudee
स्रोत
1
उपयोग करने के बजाय एक अलग फ़ंक्शन क्यों नहीं बनाते हैं where?
— माइकल क्लेन
0

आश्चर्य है , 44 बाइट्स

@[dp1unq#0?:=#[:0(iO f\min#0)#0+1f]#0?++#0 1

जब मैंने इस भाषा को बनाया तो यह मेरे मन में नहीं था ... पठनीयता के मामले में यह पर्ल से भी बदतर है!

उपयोग:

(@[dp1unq#0?:=#[:0(iO f\min#0)#0+1f]#0?++#0 1])[3 4 9 3]

व्याख्या

अधिक पठनीय:

@[
  dp 1 unq #0
    ? set #[
            get 0 (iO f\ min #0) #0
            + 1 f
           ] #0
    ? con #0 1
 ]

मूल रूप से जाँचता है कि तर्क के अनूठे सबसेट में से 1 आइटम छोड़ने पर सूची खाली हो जाती है। यदि नहीं, तो हम सरणी के न्यूनतम में वृद्धि करते हैं। अन्यथा, हम केवल तर्क के लिए 1 संक्षिप्त करते हैं।

— मामा फन रोल
स्रोत
0

कोटलिन, 75 बाइट्स

fun a(s:MutableList<Int>){if(s.toSet().size<2)s+=0;s[s.indexOf(s.min())]++}

फ़ंक्शन तर्क को संशोधित करता है।

धिक्कार है आपको मजबूत टाइपिंग में! :MutableList<Int>अकेले 17 बाइट्स के लिए खाते। मुझे नहीं लगता कि कोई ऐसा उपाय है, जहां दुर्भाग्य से टाइप किया जा सकता है।

— टायलर मैकडोनेल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.