Đưa ra một loạt các số nguyên dương, "tăng" nó một lần như sau:

• Nếu tất cả các phần tử mảng bằng nhau, nối a 1vào cuối mảng. Ví dụ:

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

• Khác, tăng phần tử đầu tiên trong mảng là giá trị tối thiểu của mảng. Ví dụ:

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

(Mỗi ->đại diện cho một mức tăng, đó là tất cả các chương trình của bạn cần làm.)

Xuất ra mảng tăng kết quả.

Mã ngắn nhất tính bằng byte thắng.

Thạch , 8 7 byte

‘;ṀỤḢṬ+

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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

Hàm sửa đổi danh sách được truyền cho nó ( được cho phép bởi meta ).

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

Hãy thử trên repl.it!

-9 byte nhờ Lynn phát hiện ra rằng, vì mảng sẽ có số nguyên dương, tôi có thể nối '0' vào cuối mảng và tăng dần.

Đặc biệt cảm ơn mbomb007 cho chơi golf len(set(a))đến len({*a}), và Dennis cho lừa floordiv!

JavaScript (ES6), 61 byte

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

Đầu ra bằng cách sửa đổi đối số của nó . Tôi không thể tìm cách xác định xem một mảng chỉ có một mục duy nhất trong ít hơn 17 byte hay không, nhưng các đề xuất đều được chào đón.

Kiểm tra đoạn

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>

Những nỗ lực khác

Dưới đây là một vài cách khác nhau để quyết định xem mảng có nhiều hơn một đầu vào duy nhất hay không:

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)

Cả hai đều somecó thể được thay thế bằng find. .sortsẽ ngắn hơn để tìm mức tối thiểu, nếu loại mặc định không phải là từ vựng (tại sao, JS, tại sao?):

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)

Tôi đã thử đệ quy để tìm mức tối thiểu, nhưng hóa ra lâu hơn:

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

Và đây là một giải pháp dựa trên chuỗi lúc đầu có vẻ như là một ý tưởng hay: (đầu vào được đưa ra ở định dạng mảng trong một chuỗi, ví dụ "[1,2,3]")

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

Toán học, 70 57 55 byte

Hầu như tất cả các cải tiến là do Martin Ender, người đá vào mông tôi theo cách tiếp cận phù hợp với mô hình! Ngoài ra, JHM đã đưa ra giải pháp cơ bản giống nhau về cơ bản cùng một lúc. (số byte sử dụng mã hóa ASCII)

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

Xác định một hàm ±lấy một đối số danh sách. Nếu đối số danh sách đó chứa một số bản sao của cùng một phần tử (được phát hiện bởi x_..và được đặt tên p), thì hãy xuất danh sách có 1gắn thêm. Mặt khác, nếu đối số danh sách đó có một phần tử đặc biệt y(với xsố 0 hoặc nhiều phần tử trước yvà zlà phần tử 0 hoặc nhiều phần tử sau y), tối thiểu là các phần tử khác, sau đó xuất danh sách với mức ytăng đó . Bất kỳ trường hợp nào của phần tử tối thiểu của danh sách sẽ được khớp với y, nhưng may mắn thay, Mathematica chọn cái đầu tiên để hành động.

C ++ 14, 178 176 174 155 142 135 byte

nộp hồ sơ

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

cầu khẩn

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

vô dụng

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

Đây là lần đầu tiên tôi chơi golf, sự giúp đỡ được đánh giá cao.

EDIT: quên đề cập đến việc bạn phải biên dịch nó với ít nhất -std=c++11 -std=c++14

EDIT2: Tôi nhận ra rằng tôi có thể bỏ không gian trong bao gồm #include <list>

EDIT3: đã lưu thêm hai byte bằng cách thay thế l.begin()bằngbegin(l)

EDIT4: đã lưu thêm 19 byte (!) Nhờ @Quentin (xem bình luận của anh ấy)

EDIT5: Quentin đã loại bỏ thêm 13 byte, cảm ơn!

EDIT6: như TuukkaX đã chỉ ra, lambdas / chức năng chưa được đặt tên là đủ vì vậy tôi đã loại bỏ auto i=trong bytecount

05AB1E , 21 20 16 byte

Đã lưu 4 byte nhờ Adnan .

DÙgi0¸«}ÐWksgÝQ+

Hãy thử trực tuyến!

Giải trình

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

Cào, 25 34 khối + 7 6 byte

Lấy đầu vào là một mảng số nguyên được xác định trước. Lưu ý rằng các mảng được lập chỉ mục 1 trong Scratch.

Trong Python, điều này sẽ giống như: (Lưu ý rằng không giống như Scratch, Python được lập chỉ mục 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)

J, 25 22 byte

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

Đánh giá một động từ ẩn danh. Dùng thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm

Làm thế nào nó hoạt động

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

Toán học, 56 byte

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

Sử dụng chức năng được đặt tên ±. Sử dụng mã hóa ISO8859-1

Giải pháp thay thế (58 byte)

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

Sử dụng

±{1, 1}

{1, 1, 1}

±{3, 4, 5}

{4, 4, 5}

Haskell, 71 70 62 byte

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

@Zgarb đã lưu 8 byte, cảm ơn!

Khi tôi bắt đầu, tôi đã hy vọng vào một số mánh khóe buộc dây thanh lịch, nhưng cách của @ Zgarb cũng tuyệt vời như vậy.

C #, 123 121 120 79 77 byte

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

Sửa đổi đối số được truyền cho hàm.

Cảm ơn Cyoce vì đã tiết kiệm 3 byte! -> !Anyđến All, +=1đến ++.

Cảm ơn TheLethalCoder vì đã tiết kiệm được 43 byte! -> Xóa mã chữ ký phương thức. Loại bỏ dấu ngoặc quanh danh sách tham số.

Perl 6 , 46 byte

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

(sửa đổi Mảng đầu vào và trả về nó)

Mở rộng:

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

Thạch, 9 byte

;1µ‘i¦E?Ṃ

Cảm ơn Dennis cho -2 byte.

Cơ thể phải có ít nhất 30 ký tự; bạn đã nhập ....

Mathicala, 53 byte 57 byte 59 byte

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

R , 72 66 65 byte

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

Hãy thử trực tuyến!

Tăng được thực hiện bằng cách sử dụng which.mintrả về trận đấu đầu tiên. "[<-"cho phép thay thế giá trị và trả về vectơ đã sửa đổi trong một lệnh gọi hàm.

-7 byte nhờ Giuseppe!

Ruby, 46 byte

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

Tôi cảm thấy như có một cách tốt hơn để kiểm tra xem tất cả các yếu tố có giống nhau không a.uniq.size<2, nhưng tôi quá lười để tìm thấy nó.

Octave, 69 67 64 byte

Nó thực sự ngắn hơn để làm cho điều này một chức năng được đặt tên hoàn chỉnh hơn là sử dụng cả hai inputvà disp.

Lưu được 3 byte nhờ Luis.

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

Câu trả lời cũ, không sử dụng chức năng:

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

R, 97 byte

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

Thật tệ là synthax x=+1không tồn tại trong R!

Ung dung:

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 byte

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 byte

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

Tôi còn khá mới với môn đánh gôn nên hãy tử tế! Tôi đã cố gắng sử dụng các hàm ẩn danh nhưng googling nói rằng bạn không thể sử dụng các câu lệnh if / other và matlab không có toán tử tạm thời, vì vậy đây là điều tốt nhất tôi cảm thấy có thể làm.

Chỉnh sửa: Đã sửa và rút ngắn (hai lần!) Nhờ stewie-griffin.

Clojure, 112 100 byte

Thật không may min-keytrả về chỉ số cuối cùng của chỉ số nhỏ nhất, không phải là chỉ số đầu tiên. Điều này hoạt động cho đầu vào số nguyên và mảng ngắn hơn 10 ^ 9 phần tử;)

Chỉnh sửa: Xác định một chức năng ẩn danh, sử dụng (apply = a)thay vì (= 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)))

Nguyên:

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

Một giải pháp 134 byte ít hacky đảo ngược vectơ trước khi cập nhật nó và sau đó đảo ngược lại:

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

Void lambda mất một List<Integer>(đầu ra là đầu vào đột biến). Số lượng byte bao gồm lambda và nhập khẩu bắt buộc.

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

Dùng thử trực tuyến

Điều này gần giống như Python với các phương thức nhập khẩu ...

MATLAB, 66 53 byte

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

Đầu ra:

Khởi tạo:

a = [3 2]

Chạy liên tiếp:

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

SmileBASIC 3, 101 byte

Xác định hàm câu lệnh I Atrong đó Alà mảng số nguyên của chúng ta. Đầu ra đạt được bằng cách sửa đổi đầu vào (vì mảng là tham chiếu.)

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 byte

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

Bình thường, 16 byte

?tl{QXxQhSQQ1+Q1

Một chương trình lấy đầu vào của một danh sách và in kết quả.

Bộ kiểm tra

Làm thế nào nó hoạt động

?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 byte

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

Ung dung:

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

Nỗ lực ban đầu, sẽ cố gắng đưa ra một cái gì đó tinh vi hơn sau này.

Kỳ quan , 44 byte

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

Đây không phải là điều tôi nghĩ khi tôi tạo ra ngôn ngữ này ... Nó thực sự tệ hơn Perl về khả năng đọc!

Sử dụng:

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

Giải trình

Dễ đọc hơn:

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

Về cơ bản kiểm tra nếu bỏ 1 mục từ tập hợp con duy nhất của đối số sẽ làm cho danh sách trống. Nếu không, sau đó chúng tôi tăng tối thiểu của mảng. Mặt khác, chúng ta chỉ cần nối 1 với đối số.

Kotlin, 75 byte

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

Sửa đổi đối số chức năng.

Chết tiệt bạn gõ mạnh! :MutableList<Int>chỉ chiếm 17 byte. Tôi không nghĩ rằng có một giải pháp mà loại có thể được suy ra, thật không may.