Dada una matriz no vacía de enteros positivos, "incremente" una vez de la siguiente manera:

• Si todos los elementos de la matriz son iguales, agregue 1a al final de la matriz. Por ejemplo:

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

• De lo contrario, incremente el primer elemento de la matriz que es el valor mínimo de la matriz. Por ejemplo:

  [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 ->uno representa un incremento, que es todo lo que su programa necesita hacer).

Salida de la matriz incrementada resultante.

El código más corto en bytes gana.

Jalea , 8 7 bytes

‘;ṀỤḢṬ+

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo 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

Función que modifica la lista que se le pasa ( permitida por meta ).

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

Prueba en repl.it!

-9 bytes gracias a Lynn por detectar eso, debido a que la matriz será de enteros positivos, puedo agregar '0' al final de la matriz y aumentar eso.

Un agradecimiento especial a mbomb007 para jugar al golf len(set(a))a len({*a}), y Dennis para el truco floordiv!

JavaScript (ES6), 61 bytes

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

Salidas modificando su argumento . No puedo encontrar una manera de determinar si una matriz tiene solo un elemento único en menos de 17 bytes, pero las sugerencias son bienvenidas.

Fragmento de prueba

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>

Otros intentos

Aquí hay algunas formas alternativas de decidir si la matriz tiene más de una entrada única:

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 somes también pueden reemplazarse find. .sortsería más corto para encontrar el mínimo, si la ordenación predeterminada no fuera lexicográfica (¿por qué, JS, por qué?):

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)

Intenté la recursividad para encontrar el mínimo, pero resultó mucho más tiempo:

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

Y aquí hay una solución basada en cadenas que parecía una buena idea al principio: (la entrada se da en formato de matriz en una cadena, por ejemplo "[1,2,3]")

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

Mathematica, 70 57 55 bytes

¡Prácticamente toda la mejora se debe a Martin Ender, quien me patea el culo en los enfoques de coincidencia de patrones! Además, a JHM se le ocurrió esencialmente la misma solución al mismo tiempo. (el recuento de bytes utiliza la codificación ASCII)

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

Define una función que ±toma un argumento de lista. Si ese argumento de la lista contiene cierto número de copias del mismo elemento (detectado x_..y nombrado p), entonces envíe la lista con un 1anexo. De lo contrario, si ese argumento de la lista tiene un elemento especial y( xsiendo el cero o más elementos antes y, y zsiendo el cero o más elementos después y) que es, como máximo, el mínimo de los otros elementos, entonces genera la lista con eso yincrementado. Cualquier instancia del elemento mínimo de la lista será igualada y, pero afortunadamente Mathematica elige la primera para actuar.

C ++ 14, 178176174155142135 bytes

sumisión

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

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

sin golf

#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 es mi primera vez jugando al golf, se agradece la ayuda.

EDITAR: olvidé mencionar que tienes que compilarlo al menos -std=c++11 -std=c++14

EDIT2: me di cuenta de que puedo dejar el espacio en el incluye #include <list>

EDITAR3: guardado dos bytes más al reemplazar l.begin()porbegin(l)

EDIT4: guardó otros 19 (!) Bytes gracias a @Quentin (vea su comentario)

EDITAR5: Quentin recortó 13 bytes más, ¡gracias!

EDIT6: como TuukkaX señaló, las funciones / lambdas sin nombre son suficientes, así que auto i=eliminé el en el bytecount

05AB1E , 21 20 16 bytes

Guardado 4 bytes gracias a Adnan .

DÙgi0¸«}ÐWksgÝQ+

Pruébalo en línea!

Explicación

                      # 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 bloques + 7 6 bytes

Toma datos como una matriz predefinida de enteros. Tenga en cuenta que las matrices están indexadas en 1 en Scratch.

En Python, esto se vería así: (Tenga en cuenta que, a diferencia de Scratch, Python tiene un índice 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=#@~.

Evalúa a un verbo anónimo. ¡Pruébelo en línea!

Explicación

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

Pruébalo en línea! O verificar todos los casos de prueba

Cómo 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}

Utiliza la función con nombre ±. Utiliza codificación ISO8859-1

Soluciones 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

@ Zgarb ahorró 8 bytes, ¡gracias!

Cuando comencé, esperaba un truco elegante para atar el nudo, pero el camino de @ Zgarb es igual de sorprendente.

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 el argumento pasado a la función.

¡Gracias a Cyoce por guardar 3 bytes! -> !Anya All, +=1a ++.

¡Gracias a TheLethalCoder por guardar la friolera de 43 bytes! -> Código de firma del método eliminado. Se eliminó el paréntesis alrededor de la lista de parámetros.

Perl 6 , 46 bytes

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

(modifica la matriz de entrada y la devuelve)

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
}

Jalea, 9 bytes

;1µ‘i¦E?Ṃ

Gracias a Dennis por los -2 bytes.

El cuerpo debe tener al menos 30 caracteres; entraste ... .

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

Pruébalo en línea!

El incremento se realiza utilizando el which.minque devuelve la primera coincidencia. "[<-"permite reemplazar el valor y devuelve el vector modificado en una llamada de función.

-7 bytes gracias a Giuseppe!

Ruby, 46 bytes

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

Siento que hay una mejor manera de verificar si todos los elementos son iguales a.uniq.size<2, pero soy demasiado vago para encontrarlo.

Octava, 69 67 64 bytes

En realidad, fue más corto hacer de esta una función completa con nombre que usar ambos inputy disp.

Guardado 3 bytes gracias a Luis.

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

Respuesta anterior, sin usar una función:

[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

¡Lástima que el sinthax x=+1no exista en R!

Sin golf:

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

Soy relativamente nuevo en el código de golf, ¡así que sé amable! Traté de usar funciones anónimas, pero Google dice que no puedes usar declaraciones if / else y matlab no tiene operadores ternarios, así que esto es lo mejor que sentí que podría hacer.

Editar: corregido y acortado (¡dos veces!) Gracias a stewie-griffin.

Clojure, 112 100 bytes

Desafortunadamente, min-keydevuelve el último índice del índice más pequeño, no el primero. Esto funciona para entradas enteras y matrices más cortas que 10 ^ 9 elementos;)

Editar: Definir una función anónima, usando en (apply = a)lugar 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)))

Una solución menos hacky de 134 bytes invierte el vector antes de actualizarlo y luego lo invierte nuevamente:

(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

La lambda vacía toma un List<Integer>(la salida es entrada mutada). El recuento de bytes incluye lambda y la importación requerida.

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

Pruébalo en línea

Esto casi parece Python con esas importaciones de métodos ...

MATLAB, 66 53 bytes

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

Salida:

Inicializar:

a = [3 2]

Carreras sucesivas:

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

SmileBASIC 3, 101 bytes

Define una función de declaración I Adonde Aestá nuestra matriz de números enteros. La salida se logra modificando la entrada (ya que las matrices son referencias).

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

Pyth, 16 bytes

?tl{QXxQhSQQ1+Q1

Un programa que toma la entrada de una lista e imprime el resultado.

Banco de pruebas

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

Sin golf:

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

Intento inicial, intentará encontrar algo más sofisticado más adelante.

Maravilla , 44 bytes

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

Esto no es lo que tenía en mente cuando hice este lenguaje ... ¡Es literalmente peor que Perl en términos de legibilidad!

Uso:

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

Explicación

Más legible:

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

Básicamente verifica si al soltar 1 elemento del subconjunto único del argumento, la lista está vacía. Si no, entonces incrementamos el mínimo de la matriz. De lo contrario, simplemente concatenamos 1 al argumento.

Kotlin, 75 bytes

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

Modifica el argumento de la función.

¡Maldita sea tipeo fuerte! :MutableList<Int>representa 17 bytes solo. Lamentablemente, no creo que haya una solución en la que se pueda inferir el tipo.