Dada uma matriz não vazia de números inteiros positivos, "aumente" uma vez da seguinte maneira:

• Se todos os elementos da matriz forem iguais, anexe 1a ao final da matriz. Por exemplo:

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

• Senão, incremente o primeiro elemento na matriz que é o valor mínimo da matriz. Por exemplo:

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

(Cada ->um representa um incremento, que é tudo o que seu programa precisa fazer.)

Saída da matriz incrementada resultante.

O código mais curto em bytes vence.

Geléia , 8 7 bytes

‘;ṀỤḢṬ+

Experimente online! ou verifique todos os casos de teste .

Como funciona

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

Função que modifica a lista passada a ela ( permitida por meta ).

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

Experimente repl.it!

-9 bytes graças a Lynn por detectar que, como a matriz terá números inteiros positivos, eu posso acrescentar '0' ao final da matriz e aumentá-la.

Um agradecimento especial a mbomb007 para jogar golfe len(set(a))para len({*a}), e Dennis para o truque floordiv!

JavaScript (ES6), 61 bytes

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

Saídas modificando seu argumento . Não consigo encontrar uma maneira de determinar se uma matriz possui apenas um item exclusivo em menos de 17 bytes, mas sugestões são bem-vindas.

Snippet de teste

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>

Outras tentativas

Aqui estão algumas maneiras alternativas de decidir se a matriz possui mais de uma entrada exclusiva:

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)

Ambos os somes também podem ser substituídos findpor. .sortseria mais curto para encontrar o mínimo, se a classificação padrão não fosse lexicográfica (por que, JS, por que?):

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)

Tentei recursão para encontrar o mínimo, mas acabou por muito mais tempo:

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

E aqui está uma solução baseada em string que parecia uma boa idéia no início: (a entrada é fornecida no formato de array em uma string, por exemplo "[1,2,3]")

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

Mathematica, 70 57 55 bytes

Praticamente toda a melhoria se deve a Martin Ender, que me dá um chute nas abordagens de correspondência de padrões! Além disso, a JHM apresentou essencialmente a mesma solução, essencialmente ao mesmo tempo. (a contagem de bytes usa codificação ASCII)

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

Define uma função que ±aceita um argumento da lista. Se esse argumento da lista contiver algum número de cópias do mesmo elemento (detectado x_..e nomeado p), emita a lista com um 1anexo. Caso contrário, se esse argumento da lista tiver um elemento especial y(com xzero ou mais elementos antes ye zzero ou mais elementos depois y) que for no máximo o mínimo dos outros elementos, emita a lista com esse yincremento. Qualquer instância do elemento mínimo da lista será correspondida y, mas felizmente o Mathematica escolhe a primeira a agir.

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

submissão, obediência, inscrição, candidatura

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

invocação

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

destroçado

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

Esta é a minha primeira vez jogando golfe, a ajuda é apreciada.

EDIT: esqueci de mencionar que você deve compilá-lo com pelo menos -std=c++11 -std=c++14

EDIT2: eu percebi que posso deixar de fora o espaço no inclui #include <list>

EDIT3: salvou mais dois bytes substituindo l.begin()porbegin(l)

EDIT4: salvou outros 19 (!) Bytes graças a @Quentin (veja seu comentário)

EDIT5: Quentin raspou mais 13 bytes, obrigado!

EDIT6: como TuukkaX apontou, lambdas / funções sem nome são suficientes, então eu removi o auto i=no bytecount

05AB1E , 21 20 16 bytes

Guardado 4 bytes graças a Adnan .

DÙgi0¸«}ÐWksgÝQ+

Experimente online!

Explicação

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

Scratch, 25 34 blocos + 7 6 bytes

Recebe a entrada como uma matriz predefinida de números inteiros. Observe que as matrizes são indexadas 1 no Scratch.

No Python, isso seria parecido com: (Observe que, ao contrário do Scratch, o Python é indexado em 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 bytes

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

Avalia para um verbo anônimo. Experimente Online!

Explicação

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

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

Experimente online! Ou verifique todos os casos de teste

Como funciona

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 bytes

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

Usa a função nomeada ±. Usa codificação ISO8859-1

Soluções alternativas (58 bytes)

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

Uso

±{1, 1}

{1, 1, 1}

±{3, 4, 5}

{4, 4, 5}

Haskell, 71 70 62 bytes

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

O @Zgarb salvou 8 bytes, obrigado!

Quando comecei, eu esperava alguns truques elegantes de amarrar os nós, mas o jeito de @ Zgarb é igualmente incrível.

C #, 123 121 120 79 77 bytes

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

Modifica o argumento passado para a função.

Agradecimentos a Cyoce por economizar 3 bytes! -> !Anypara All, +=1para ++.

Agradecemos a TheLethalCoder por salvar 43 bytes! -> Código de assinatura do método removido. Parênteses removidos ao redor da lista de parâmetros.

Perl 6 , 46 bytes

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

(modifica a matriz de entrada e a retorna)

Expandido:

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

Geléia, 9 bytes

;1µ‘i¦E?Ṃ

Obrigado a Dennis pelos -2 bytes.

O corpo deve ter pelo menos 30 caracteres; você entrou ...

Mathematica, 53 bytes 57 bytes 59 bytes

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

R , 72 66 65 bytes

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

Experimente online!

O incremento é feito usando o which.minque retorna a primeira correspondência. "[<-"permite substituir o valor e retorna o vetor modificado em uma chamada de função.

-7 bytes graças a Giuseppe!

Ruby, 46 bytes

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

Sinto que há uma maneira melhor de verificar se todos os elementos são iguais a.uniq.size<2, mas estou com preguiça de encontrá-lo.

Oitava, 69 67 64 bytes

Na verdade, era mais curto tornar essa uma função nomeada completa do que usar as teclas inpute disp.

Economizou 3 bytes graças a Luis.

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

Resposta antiga, sem usar uma função:

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

R, 97 bytes

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

Pena que a sintaxe x=+1não existe no 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 bytes

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 bytes

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

Eu sou relativamente novo em codificar golfe, por favor, seja gentil! Tentei usar funções anônimas, mas o Google diz que você não pode usar as instruções if / else e o matlab não possui operadores ternários, portanto, esse é o melhor que senti que poderia fazer.

Edit: Corrigido e encurtado (duas vezes!), Graças a stewie-griffin.

Clojure, 112 100 bytes

Infelizmente, min-keyretorna o último índice do menor, não o primeiro. Isso funciona para entradas inteiras e matrizes menores que 10 ^ 9 elementos;)

Editar: definindo uma função anônima, usando em (apply = a)vez de (= 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)))

Original:

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

Uma solução menos invasiva de 134 bytes inverte o vetor antes de atualizá-lo e depois inverte-o novamente:

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

Void lambda usando a List<Integer>(saída com entrada modificada). A contagem de bytes inclui lambda e importação necessária.

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

Experimente Online

Isso quase se parece com o Python com as importações de métodos ...

MATLAB, 66 53 bytes

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

Resultado:

Inicializar:

a = [3 2]

Execuções sucessivas:

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

SmileBASIC 3, 101 bytes

Define uma função de instrução I Aonde Aestá nossa matriz inteira de números. A saída é obtida modificando a entrada (como matrizes são referências).

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 bytes

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

Pitão, 16 bytes

?tl{QXxQhSQQ1+Q1

Um programa que recebe a entrada de uma lista e imprime o resultado.

Suíte de teste

Como funciona

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

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

Tentativa inicial, tentará criar algo mais sofisticado posteriormente.

Maravilha , 44 bytes

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

Não era isso que eu tinha em mente quando criei essa linguagem ... É literalmente pior que o Perl em termos de legibilidade!

Uso:

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

Explicação

Mais legível:

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

Basicamente, verifica se a remoção de 1 item do subconjunto exclusivo do argumento torna a lista vazia. Caso contrário, incrementamos o mínimo da matriz. Caso contrário, simplesmente concatenamos 1 ao argumento.

Kotlin, 75 bytes

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

Modifica o argumento da função.

Porra, você digitando forte! :MutableList<Int>responde por 17 bytes sozinho. Não acho que exista uma solução em que o tipo possa ser inferido, infelizmente.