Увеличить массив

44

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

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

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

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

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

Кальвин Хобби
источник
0 считается положительным целым числом
Downgoat
20
@Downgoat 0 никогда не был позитивным для PPCG. Если бы 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

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

FlipTack
источник
Хм. Msgstr "Вывести полученный увеличенный массив". Это подходит?
Yytsi
Я не совсем помню, где, но я помню мета-пост, в котором изменение заданного списка на месте разрешено по умолчанию. Я посмотрю на это @TuukkaX
FlipTack
@TuukkaX Я не совсем уверен. Кажется, все в порядке, но я отложу мета-консенсус о модификации массивов на месте, если таковые имеются.
Увлечения Кэлвина
1
В Python 3 вы можете использовать, len({*L})<2чтобы найти, все ли элементы списка равны.
mbomb007
1
a+=1//len({*a})*[0]должен сохранить байт.
Деннис
9

JavaScript (ES6), 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было бы короче для нахождения минимума, если бы сортировка по умолчанию не была лексикографической (почему, 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
@ Downgoat Я не уверен, как бы я использовал это, поскольку он возвращает элемент, а не индекс
ETHproductions
ага> _> упс, я скучал по твоему ++ и не понял, что тебе нужна ссылка
Downgoat
7

Mathematica, 70 57 55 байт

Практически все улучшения связаны с Мартином Эндером, который надрывает мою задницу при подходах к сопоставлению с образцом! Также JHM придумала практически такое же решение в то же время. (счетчик байтов использует кодировку ASCII)

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

Определяет функцию, ±принимающую один аргумент списка. Если этот аргумент списка содержит некоторое количество копий одного и того же элемента (обнаруженного x_..и названного p), выведите список с 1добавлением. В противном случае, если этот аргумент списка имеет специальный элемент yxнулем или несколькими элементами до yи zс нулем или несколькими элементами после y), который является не более чем минимальным из других элементов, выведите список с yувеличенным значением. Любой экземпляр минимального элемента списка будет сопоставлен y, но, к счастью, Mathematica выбирает первый, который будет действовать.

Грег Мартин
источник
Поскольку ±это 2-байтовый символ, ваш код длиной 59 байт. Кроме того, должен быть пробел между x_и ..потому что Mathematica интерпретирует x_..как x_. .(который выдает ошибки). Плюс, инфиксная форма Min( x~Min~z) сделает эти 2 байта короче (что делает это решение идентичным одному из моих: p ...) Хорошо, вы можете взять кредит, потому что мое редактирование было позже, чем у вас ....
JungHwan Min
Нет, Мартин Эндер все равно получает большую часть моего кредита. Почему ± два байта?
Грег Мартин
@GregMartin ±в UTF-8 ( Mathematica по умолчанию использует UTF-8; try $CharacterEncoding) - это двухбайтовый символ (U + 00B1).
JungHwan Мин
@JHM UTF-8 не является кодировкой символов по умолчанию в Windows. Mathematica может читать исходные файлы на однобайтовой кодовой странице, которая включает ±.
Мартин Эндер
1
@ASimmons Моя свежая установка Mathematica в Windows, для которой $CharacterEncodingустановлен WindowsANSICP1252 (который достаточно совместим с ISO 8859-1 для использования ±и ·может использоваться для одного байта).
Мартин Эндер
7

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

Neop
источник
5
Я не могу помочь вам с C ++, но я могу сказать: Добро пожаловать в PPCG!
Згарб
1
Я думаю, вам не нужны пробелы в #includeстроках.
Кристиан Сиверс
О, спасибо, я только что понял это сам :)
Neop
1
Замена функции с помощью lambda ( auto i=[](auto&l){...};) сохраняет один байт (больше, если мы посчитаем забытый вами возвращаемый тип;)), использование ^ вместо ==и замена операндов сохраняет другой. std::listИтераторы, безусловно, являются std::классами, так что вы можете отказаться std::от обоих std::countи std::min_elementблагодаря ADL (-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короче, чем приведение левого к void2 байтам. Это приводит к 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-индексированы в 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)
OldBunny2800
источник
Гольф комментарии, пожалуйста?
OldBunny2800
почему вы объявляете fval?
Кристоф
Мне кажется, что Scratch - это просто Python в виде простого текста с цветами ...
Стьюи Гриффин,
И 1-индексированные массивы, и никаких операторов elif!
OldBunny2800
1
Хороший вопрос @ Кристоф! Это было частью более ранней версии, которая вышла в гольф. Редактирование.
OldBunny2800
4

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

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}

Юнг Хван Мин
источник
3

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 такой же удивительный.

Кристиан Сиверс
источник
Некоторая реструктуризация, 62 байта:f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1:z
Згарб
@ Zgarb Просто вау!
Кристиан Сиверс
Тьфу, мой мозг не может определить тип для экземпляра функций монады
Angs
@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только один раз. Теперь мне нужно помнить это только тогда, когда мне это нужно.
Кристиан Сиверс
@Angs Вы можете найти этот трюк и многое другое в нашей коллекции советов по игре в гольф на Haskell .
Згарб
3

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 байтов! -> Удален код сигнатуры метода. Удалены круглые скобки вокруг списка параметров.

Yytsi
источник
Вы могли бы заменить !l.Any(o=>o!=l[0]))на l.All(o=>o==l[0])?
Cyoce
@Cyoce Это действительно так. Я думал о том же самом, но написал Anyвместо этого Allи подумал, что это не работает: D Спасибо!
Yytsi
2
C # не имеет ++?
Cyoce
Вы можете скомпилировать его Action<List<int>>для удаления всего кода сигнатуры метода
TheLethalCoder
1
@ Стефан Хмм. Я также видел, как многие люди отбрасывали необходимые usings с помощью C #, поэтому я не верю, что это законно, чтобы отказаться using System.Linq. Если я не увижу явного утверждения, в котором говорится, что в этом нет необходимости, я останусь с этим. Спасибо за предложение, хотя! :)
Yytsi
2

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
}

Брэд Гилберт b2gills
источник
2

Желе, 9 байт

;1µ‘i¦E?Ṃ

Спасибо Деннису за -2 байта.

Тело должно быть не менее 30 символов; вы вошли ... .

Zachary
источник
Если у вас есть дополнительные символы для ввода в теле, всегда стоит объяснить код, который поможет всем понять его и сделает ответ более интересным :)
Alfie Goodacre
2

Mathematica, 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 байт.
JungHwan Мин
Хороший улов! Я не осознавал различия между байтами и количеством символов, я просто увидел это предложение и понял, что оно действительно. Кажется, есть много ответов, которые дают количество символов, но если я сохраню их в Notepad ++, я получу большее количество байтов (например, ответ Jelly). Я вижу, в вашем ответе указана кодировка. Где-нибудь вы бы порекомендовали мне узнать об этом?
ngenisis
1
Я думаю, что вы имеете в виду Equal@#, хотя #==##короче.
Мартин Эндер
Вы правы. Я внес изменение в @JHM, чтобы принимать несколько аргументов, а не список, но не распространял это изменение везде. Я вернулся к принятию списка, так как он больше соответствует подсказке.
ngenisis
2

R , 72 66 65 байт

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

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

Инкремент выполняется с помощью which.minкоторого возвращает первое совпадение. "[<-"позволяет заменить значение и возвращает модифицированный вектор в одном вызове функции.

-7 байт благодаря Джузеппе!

Jayce
источник
tio.run/##K/r/…
Джузеппе
@Giuseppe Я попробовал isTRUE и isFALSE с sd, это не игра в гольф :(
JayCe
хех, замена 65 байт!= на -!
Джузеппе
@ Джузеппе конечно!
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

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
Фредерик
источник
1

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
Timtech
источник
1

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

Оуэн Морган
источник
Добро пожаловать в PPCG! В этом коде есть некоторые недостатки. sum(a)/length(a)==a(1)не гарантирует, что все элементы равны, это только показывает, что среднее значение равно a(1). Более простой способ сделать это был бы mean(a)==a(1). numelна один байт короче length, но, поскольку вы знаете, что все значения положительны, вы можете использовать, nnzкоторый еще короче (он все равно не даст правильного результата в этом испытании, но по крайней мере короче: P). Если вы принимаете min(a)вызов перед циклом, вы можете использовать оба выхода из него и проверить, что allэлементы aравны min(a).
Стьюи Гриффин
Вы правы! он терпит неудачу, когда среднее значение равно числу в первом элементе. Я думаю, что мой новый правильный, а также и короче. Логика заключается в том, что если оставшиеся элементы не равны первому элементу, 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 байт короче (примечание: я не проверял это).
Стьюи Гриффин
Вы можете сохранить 3 байта, используя range(a)вместоnnz(a-a(1))
MattWH
@boboquack, этот код проверяет, aравно ли количество элементов в наименьшем значении в этом векторе. Вектор a = [3 4 6]приведет к true, а вектор a = [4 4 6]приведет к false. Я не думаю, что это будет полезно здесь ...?
Стьюи Гриффин
1

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)))))
NikoNyrh
источник
1

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 с этими методами импорта ...

Jakob
источник
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

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
snail_
источник
Вы можете сохранить 2 байта, заменив BREAKс M=0, потому что Aне может содержать 0так M==A[C]никогда не будет правдой.
12Me21
1

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
12Me21
источник
0

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                    
TheBikingViking
источник
0

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

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

sudee
источник
1
Почему бы не сделать отдельную функцию вместо использования where ?
Майкл Кляйн
0

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

Mama Fun Roll
источник
0

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

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

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

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

Тайлер МакДонелл
источник