给定一个非空的正整数数组，对其进行“递增”一次，如下所示：

• 如果所有数组元素均相等，1则将a附加到数组末尾。例如：

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

（每个->代表一个增量，这是程序需要做的所有事情。）

输出结果递增数组。

以字节为单位的最短代码获胜。

果冻，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.

Python 3，62 53 51 50字节

修改传递给它的列表的功能（meta允许）。

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

尝试repl.it！

-9字节，感谢Lynn的发现，因为数组将是正整数，所以我可以在数组的末尾附加“ 0”并使之递增。

特别感谢mbomb007打高尔夫球len(set(a))来len({*a})，和Dennis为floordiv绝招！

JavaScript（ES6），61个字节

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

通过修改其参数输出。我找不到一种方法来确定数组是否只有少于17个字节的唯一项，但是欢迎提出建议。

测试片段

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>

其他尝试

以下是确定数组是否具有多个唯一输入的几种替代方法：

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如果默认排序不是按字典顺序排序，则查找最小值的时间会更短（为什么，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]")

Mathematica，70 57 55字节

几乎所有的改进都归功于Martin Ender，他将我的屁股踢向了模式匹配方法！而且，JHM基本上在同一时间提出了基本相同的解决方案。（字节数使用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，但幸运的是Mathematica选择了第一个要执行的元素。

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

不打高尔夫球

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

这是我第一次打高尔夫球，感谢您的帮助。

编辑：忘记提及您必须至少编译 -std=c++11 -std=c++14

EDIT2：我意识到我可以省略包含中的空格 #include <list>

EDIT3：通过更换挽救了两个多字节l.begin()由begin(l)

EDIT4：由于@Quentin，又节省了19（！）字节（请参阅他的评论）

EDIT5：Quentin减少了13个字节，谢谢！

EDIT6：正如TuukkaX指出的那样，未命名的lambda /函数就足够了，因此我删除auto i=了bytecount中的

05AB1E，21 20 16字节

感谢Adnan节省了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]

从头开始，25 34块+ 7 6字节

将输入作为预定义的整数数组。请注意，数组在Scratch中为1索引。

在Python中，这看起来像：（请注意，与Scratch不同，Python的索引为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字节

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

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

Mathematica，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}

Haskell，71 70 62字节

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

@Zgarb保存了8个字节，谢谢！

当我刚开始的时候，我希望有一些优雅的打结技巧，但是@Zgarb的方式同样令人惊奇。

C＃，123 121 120 79 77个字节

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

修改传递给函数的参数。

感谢Cyoce节省了3个字节！-> !Any至All，+=1至++。

感谢TheLethalCoder节省了多达43个字节！->删除方法签名代码。删除了参数列表周围的括号。

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

果冻，9个字节

;1µ‘i¦E?Ṃ

感谢Dennis的-2个字节。

正文必须至少30个字符；你登录了 ... 。

Mathematica，53个字节57个字节 59个字节

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

R，72 66 65字节

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

在线尝试！

使用递增来which.min返回第一个匹配项。"[<-"允许替换值并在一个函数调用中返回修改后的向量。

-7个字节，感谢Giuseppe！

Ruby，46个字节

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

我觉得有一种比来检查所有元素是否相同的更好的方法a.uniq.size<2，但是我懒得找到它。

八度，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)

R，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=+1了R中不存在synthax ！

松散

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基本（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

Matlab的，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

我是打高尔夫球的新手，所以请客气！我尝试使用匿名函数，但是谷歌搜索表示您不能使用if / else语句，而matlab没有三元运算符，因此这是我能做的最好的事情。

编辑：纠正和缩短（两次！）感谢stewie-griffin。

Clojure，112100字节

不幸的是，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)))

hacky的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)))))

Java 8、85 + 38 = 123字节

空隙λ取List<Integer>（输出是突变输入）。字节数包括lambda和必需的导入。

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

在线试用

这几乎看起来像带有这些方法导入的Python ...

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

SmileBASIC 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

SmileBASIC，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

Pyth，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                    

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

取消高尔夫：

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

初步尝试，稍后将尝试提出更复杂的方法。

不可思议，44字节

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

这不是我编写这种语言时要想到的...从可读性上说，它确实比Perl差！

用法：

(@[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连接到参数。

Kotlin，75个字节

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

修改函数参数。

该死的你强打字！:MutableList<Int>仅占17个字节。不幸的是，我认为没有可以推断类型的解决方案。