Boş olmayan bir pozitif tamsayı dizisi göz önüne alındığında, bunu bir kez "artırın":

• Tüm dizi elemanları eşitse, dizinin sonuna bir a ekleyin 1. Örneğin:

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

• Aksi halde, dizideki ilk öğeyi dizinin minimum değeri olan artırın. Örneğin:

  [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] -> ...
  

(Her ->biri programınızın yapması gereken tek bir artışı temsil eder.)

Elde edilen artımlı diziyi çıkar.

Bayt cinsinden en kısa kod kazanır.

Jöle , 8 7 bayt

‘;ṀỤḢṬ+

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

‘;ṀỤḢṬ+  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.

Python 3, 62 53 51 50 bayt

Listeye değiştiren işlev ( meta tarafından izin verilen ).

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

Tekrar dene!

-9 bayt, bunu tespit ettiği için Lynn'e teşekkür eder, dizi pozitif tamsayılara sahip olacağı için dizinin sonuna '0' ekleyebilirim ve bunu artırdım.

Golf len(set(a))için len({*a})mbomb007'ye, floordiv numarası için Dennis'e özel teşekkürler !

JavaScript (ES6), 61 bayt

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

Argümanını değiştirerek çıktılar . Bir dizinin 17 bayttan daha az benzersiz bir öğeye sahip olup olmadığını belirlemenin bir yolunu bulamıyorum, ancak önerileriniz memnuniyetle karşılanıyor.

Test pasajı

f=a=>new Set(a).size>1?++a[a.indexOf(Math.min(...a))]:a.push(1)
g=a=>0 in a?console.log("Input:",`[${a}]`,"Output:",`[${f(a),a}]`):console.log("Invalid input")

g([1])
g([2])
g([1,1])
g([1,2,2,3])
g([2,2,2,3])
g([3,2,2,3])
g([3,3,2,3])
g([3,3,3,3])
g([3,3,3,3,1])

<input id=I value="1,2,2,3"><button  onclick="g(I.value.match(/\d+/g)||[])">Run</button>

Diğer girişimler

Dizinin birden fazla benzersiz girişi olup olmadığına karar vermenin birkaç alternatif yolu:

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)

Her ikisi de someaynı şekilde değiştirilebilir find. .sorteğer varsayılan sıralama sözlüksel değilse (minimum, JS, neden?):

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)

Minimum bulmak için özyinelemeyi denedim, ancak daha uzun sürdü:

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

Ve işte ilk başta iyi bir fikir gibi görünen bir dizgeye dayanan çözüm: (girdi bir dizgede dizi biçiminde verilir "[1,2,3]"),

a=>a.replace(m=/(\d+),(?!\1)/.test(a)?Math.min(...eval(a)):']',+m+1||",1]")

Mathematica, 70 57 55 bayt

Neredeyse tüm iyileşme, kalıp eşleştirme yaklaşımlarındaki kıçımı tekmeleyen Martin Ender'den kaynaklanıyor! Ayrıca JHM, esasen aynı anda esasen aynı çözümle geldi. (bayt sayısı ASCII kodlamasını kullanır)

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

±Bir liste argümanı alan bir işlevi tanımlar . Bu liste argümanı, aynı elemanın (tespit edilen x_..ve adlandırılan p) bazı kopyalarını içeriyorsa , listeyi 1eklenmiş olarak verin. Aksi takdirde, bu liste argüman özel bir elemanı vardır halinde y(birlikte xönce sıfır ya da daha fazla bileşeni olarak y, ve zsonra sıfır ya da daha fazla bileşeni olarak yen sonra diğer elemanların asgari çıkış bununla listesi) yarttırılır. Listenin minimum elemanının herhangi bir örneği tarafından eşleştirilecek y, ancak neyse ki Mathematica harekete geçecek olanı seçti.

C ++ 14,177 176 174 155 142 135 bayt

boyun eğme

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

yakarma

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

Bu benim ilk golf oynamanın, yardımın takdir edilmesini sağlıyor.

EDIT: en azından ile derlemek zorunda olduğunu söylemeyi unuttum -std=c++11 -std=c++14

EDIT2: İçerdiği alanı bırakabileceğimi fark ettim. #include <list>

EDIT3: değiştirerek iki bayt kaydedildi l.begin()tarafındanbegin(l)

EDIT4: @ Quentin sayesinde 19 (!) Bayt daha kaydetti (yorumuna bakın)

EDIT5: Quentin 13 bayta daha tıraş etti, teşekkürler!

EDIT6: TuukkaX'in işaret ettiği gibi, isimlendirilmemiş lambdas / fonksiyonlar yeterlidir, böylece auto i=bytecount değerini kaldırdım.

05AB1E , 21 20 16 bayt

Adnan sayesinde 4 byte kurtarıldı .

DÙgi0¸«}ÐWksgÝQ+

Çevrimiçi deneyin!

açıklama

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

Kazı kazan, 25 34 blok + 7 6 bayt

Girdiyi önceden tanımlanmış bir tamsayı dizisi olarak alır. Dizilerin Scratch'ta 1 indeksli olduğunu unutmayın.

Python'da şöyle görünür: (Scratch'ın aksine Python'un 0 dizinli olduğunu unutmayın)

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)

J, 25 22 bayt

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

İsimsiz bir fiili değerlendirir. Çevrimiçi Deneyin!

açıklama

(+~:*[=<./)@,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.

MATL , 16 bayt

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

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın

Nasıl çalışır

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

Mathematica, 56 bayt

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

Adlandırılmış işlevi kullanır ±. ISO8859-1 kodlamasını kullanır

Alternatif çözümler (58 bayt)

±{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}

kullanım

±{1, 1}

{1, 1, 1}

±{3, 4, 5}

{4, 4, 5}

Haskell, 71 70 62 bayt

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

@ Zgarb 8 bayt kurtardı, teşekkürler!

Başladığımda, bazı şık düğüm bağlama kandırmacalarını umuyordum, ama @ Zgarb'ın yolu bu kadar şaşırtıcı.

C #, 123 121 120 79 77 bayt

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

İşleve iletilen argümanı değiştirir.

3 byte kaydettiğin için Cyoce'ye teşekkürler ! -> !Anydan All, +=1dan ++.

Bir kuyruklu 43 byte tasarruf için TheLethalCoder teşekkürler ! -> Kaldırılan yöntem imza kodu. Parametre listesinin etrafındaki parantez kaldırıldı.

Perl 6 , 46 bayt

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

(Giriş dizisini değiştirir ve döndürür)

Expanded:

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

Jöle, 9 bayt

;1µ‘i¦E?Ṃ

-2 bayt için Dennis'e teşekkür ederiz.

Gövde en az 30 karakter olmalı; sen girdin ... .

Mathematica, 53 bayt 57 bayt 59 bayt

If[Equal@@#,#~Join~{1},x=#;x[[#~FirstPosition~Min@#]]++;x]&

R , 72 66 65 bayt

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

Çevrimiçi deneyin!

which.minİlk eşleşmeyi döndüren artış kullanılarak artış yapılır . "[<-"değerin değiştirilmesine izin verir ve değiştirilmiş vektörü bir işlev çağrısında döndürür.

Giuseppe sayesinde -7 bayt!

Ruby, 46 bayt

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

Tüm öğelerin aynı olup olmadığını kontrol etmenin daha iyi bir yolu olduğunu hissediyorum a.uniq.size<2, ancak onu bulmak için çok tembelim.

Octave, 69 67 64 bayt

İkisini de kullanarak daha komple bir adlandırılmış işlev yapmak aslında kısaydı inputve disp.

Luis sayesinde 3 bayt kurtardı.

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

Eski cevap, işlev kullanmamak:

[a,b]=min(x=input(''));if any(x-a),x(b)++;else x(end+1)=1;end;disp(x)

R, 97 bayt

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

Synthax'in R'de x=+1bulunmaması çok kötü !

Ungolfed:

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

TI-Basic, 53 bayt

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

Matlab, 83 , 77 , 71 Bayt

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

Ben golf kodları konusunda nispeten yeniyim, lütfen nazik olun! Anonim işlevleri kullanmaya çalıştım, ancak googling, / else ifadelerinde ve matlab'da üçlü operatör yoksa, kullanamayacağınızı söylüyor, bu yüzden yapabileceğimin en iyisi bu.

Düzenleme: stewie-griffin sayesinde düzeltildi ve kısaltıldı (iki kez!).

Clojure, 112 100 bayt

Ne yazık ki min-key, birinciyi değil, en küçük dizinin son dizinini döndürür. Bu tamsayı girişleri ve 10 ^ 9 öğesinden daha kısa diziler için çalışır;)

Düzenleme: Kullanmak (apply = a)yerine, adsız bir işlev tanımlamak (= 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)))

Orijinal:

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

Daha az kesen bir 134 baytlık çözüm, güncellemeden önce vektörü tersine çevirir ve ardından tekrar geri döndürür:

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

Java 8, 85 + 38 = 123 bayt

Boşlukta lambda alarak List<Integer>(çıktı mutasyona uğramış girdi). Bayt sayısı, lambda ve gerekli ithalat içerir.

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

Çevrimiçi Deneyin

Bu neredeyse Python'a benziyor ve bu yöntem ithal ediyor ...

MATLAB, 66 53 bayt

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

Çıktı:

Başlatma:

a = [3 2]

Art arda çalışanlar:

[3 2] -> [3 3] -> [3 3 1] -> [3 3 2] -> [3 3 3] -> [3 3 3 1] ...

SmileBASIC 3, 101 bayt

Tam sayı sayı dizimizin I Aolduğu bir ifade işlevi tanımlar A. Çıktı, girdi değiştirilerek elde edilir (diziler referanslar gibi).

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

SmileBASIC, 77 bayt

DEF I A
IF MIN(A)==MAX(A)THEN PUSH A,0
WHILE A[I]>MAX(A)I=I+1WEND
INC A[I]END

Pyth, 16 bayt

?tl{QXxQhSQQ1+Q1

Bir listenin girişini alan ve sonucu basan bir program.

Test odası

Nasıl çalışır

?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                    

Haskell, 93 bayt

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 [] _ = []

İlk girişim, daha sonra daha sofistike bir şey bulmaya çalışacaktır.

Wonder , 44 bayt

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

Bu dili yaptığımda aklımdaki bu değildi ... Okunabilirlik anlamında Perl'den tam anlamıyla daha kötü!

Kullanımı:

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

açıklama

Daha okunabilir:

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

Temel olarak, bağımsız değişkenin benzersiz alt kümesinden 1 öğenin bırakılmasının listenin boş olup olmadığını denetler. Eğer değilse, o zaman dizinin minimumunu arttırırız. Aksi takdirde, tartışmayı 1 ile birleştiririz.

Kotlin, 75 bayt

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

İşlev argümanını değiştirir.

Kahretsin, güçlü yazıyorsun! :MutableList<Int>tek başına 17 baytlık hesaplar. Ne yazık ki, türün çıkarım yapabileceği bir çözüm olduğunu sanmıyorum.