Учитывая непустой массив натуральных чисел, «увеличить» его один раз следующим образом:

• Если все элементы массива равны, добавьте a 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] -> ...
  

(Каждый ->представляет один шаг, и это все, что нужно сделать вашей программе.)

Выведите результирующий увеличенный массив.

Самый короткий код в байтах побеждает.

Желе , 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 байт

Функция, которая изменяет переданный ей список ( разрешенный мета ).

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 трюка!

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 байт

Практически все улучшения связаны с Мартином Эндером, который надрывает мою задницу при подходах к сопоставлению с образцом! Также 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);

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

Я впервые играю в гольф, помощь приветствуется.

РЕДАКТИРОВАТЬ: забыл упомянуть, что вы должны скомпилировать его по крайней мере -std=c++11 -std=c++14

РЕДАКТИРОВАТЬ 2: Я понял, что я могу пропустить пространство во включенных #include <list>

EDIT3: сохранил еще два байта, заменив l.begin()наbegin(l)

EDIT4: сохранил еще 19 (!) Байтов благодаря @Quentin (см. Его комментарий)

EDIT5: Квентин сбрил еще 13 байтов, спасибо!

РЕДАКТИРОВАТЬ 6: как указал TuukkaX, безымянные лямбда-функции / функции достаточно, поэтому я удалил auto i=в bytecount

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]

Царапина, 25 34 блоков + 7 6 байт

Принимает ввод как предопределенный массив целых чисел. Обратите внимание, что массивы 1-индексированы в Scratch.

В Python это будет выглядеть так: (Обратите внимание, что в отличие от Scratch, Python имеет 0-index)

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)]++;$_}

(модифицирует входной массив и возвращает его)

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
}

Желе, 9 байт

;1µ‘i¦E?Ṃ

Спасибо Деннису за -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 байт благодаря Джузеппе!

Рубин, 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!

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 байта

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

Я относительно новичок в коде гольфа, поэтому будьте добры! Я пытался использовать анонимные функции, но поиск в Google говорит, что вы не можете использовать операторы if / else и matlab не имеет троичных операторов, так что это лучшее, что я чувствовал, что мог сделать.

Изменить: Исправлено и сокращено (дважды!) Благодаря Stewie-Griffin

Clojure, 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)))))

Java 8, 85 + 38 = 123 байта

Void лямбда принимает 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);}

Попробуйте онлайн

Это почти похоже на 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;[]#_=[]

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

Первоначальная попытка, попробуйте придумать что-то более сложное позже.

Чудо , 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 с аргументом.

Котлин, 75 байтов

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

Изменяет аргумент функции.

Черт бы тебя побрал! :MutableList<Int>составляет только 17 байт. Я не думаю, что есть решение, по которому тип может быть выведен, к сожалению.