Incrementar una matriz

44

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.

Pasatiempos de Calvin
fuente
¿Cuenta 0 como entero positivo
Downgoat
20
@Downgoat 0 nunca es positivo en PPCG. Si se permitiera 0, el término sería "no negativo"
ETHproductions

Respuestas:

13

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.
Dennis
fuente
11

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!

FlipTack
fuente
Hmm "Salida de la matriz incrementada resultante". ¿Esto califica?
Yytsi
No puedo recordar dónde, pero recuerdo haber visto una meta publicación que modifica la lista en su lugar está permitido de forma predeterminada. Lo buscaré @TuukkaX
FlipTack el
@ TuukkaX No estoy completamente seguro. Parece correcto, pero diferiré al metaconcenso sobre la modificación de matrices en su lugar, si hay una.
Aficiones de Calvin
1
En Python 3, puede usar len({*L})<2para encontrar si todos los elementos de una lista son iguales.
mbomb007
1
a+=1//len({*a})*[0]Debería guardar un byte.
Dennis
9

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

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]")
ETHproducciones
fuente
¿Está usando a.find (n => n == Math.min (... a)) más corto?
Downgoat
@Downgoat No estoy seguro de cómo usaría eso, ya que devuelve el elemento en lugar del índice
ETHproductions
sí> _> whoops, me perdí tu ++ y no me di cuenta de que necesitabas una referencia
Downgoat
7

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.

Greg Martin
fuente
Debido a que ±es un carácter de 2 bytes, su código tiene una longitud de 59 bytes. Además, debe haber un espacio entre x_y ..porque Mathematica interpreta x_..como x_. .(que arroja errores). Además, la forma infija de Min( x~Min~z) acortaría estos 2 bytes (lo que hace que esta solución sea idéntica a la mía: p ...) Bueno, puedes tomar el crédito porque mi edición fue posterior a la tuya ...
JungHwan Min
No, Martin Ender obtiene la mayor parte de mi crédito de todos modos. ¿Por qué es ± dos bytes?
Greg Martin
@GregMartin ±en UTF-8 ( Mathematica usa UTF-8 por defecto; try $CharacterEncoding) es un carácter de dos bytes (U + 00B1).
JungHwan Min
@JHM UTF-8 no es la codificación de caracteres predeterminada en Windows. Mathematica puede leer archivos fuente en una página de códigos de un solo byte que incluye ±.
Martin Ender
1
@ASimmons Mi nueva instalación de Mathematica en Windows, que se ha $CharacterEncodingestablecido en WindowsANSICP1252 (que es lo suficientemente compatible con ISO 8859-1 ±y ·que se puede usar para un solo byte).
Martin Ender
7

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

Neop
fuente
55
No puedo ayudarte con C ++, pero puedo decir: ¡Bienvenido a PPCG!
Zgarb
1
Creo que no necesitas los espacios en las #includelíneas.
Christian Sievers
Oh, gracias me he dado cuenta de que yo :)
neop
1
Reemplazar la función con un lambda ( auto i=[](auto&l){...};) ahorra un byte (más si contamos el tipo de retorno que olvidó;)), usar en ^ lugar de ==e intercambiar los operandos guarda otro. std::listLos iteradores son, sin duda std::, clases, por lo que puede abandonar std::ambos std::county std::min_elementgracias a ADL (-10). l.front()es también *b(-7). Termino con una 120 bytes 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);};:)
Quentin
1
Mientras estamos en eso, la documentación parastd::min_element afirma que devuelve el primer elemento más pequeño, por lo que find()es superfluo, eso es 11 bytes. En el condicional, usar un par de paréntesis y el operador de coma para coaccionar la expresión correcta intes más corto que convertir el izquierdo en void2 bytes. Esto lleva a 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 bytes :)
Quentin
6

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]
Emigna
fuente
Creo que eso DÙgi0¸«}ÐWksgÝQ+también funciona.
Adnan
@Adnan: Aah, buena idea usarlo ÝQcon k. ¡Gracias!
Emigna
5

Scratch, 25 34 bloques + 7 6 bytes

Programa

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)
OldBunny2800
fuente
Comentarios de golf por favor?
OldBunny2800
¿Por qué declaras fval?
Christoph
Me parece que Scratch es solo Python en texto plano con colores ...
Stewie Griffin
¡Y matrices indexadas 1 y sin declaraciones elif!
OldBunny2800
1
Buen punto @ Christoph! Formaba parte de una versión anterior que se desarrolló. Edición.
OldBunny2800
4

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.
Zgarb
fuente
3

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
Luis Mendo
fuente
3

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}

JungHwan Min
fuente
3

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.

Christian Sievers
fuente
Algunas reestructuraciones, 62 bytes:f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1:z
Zgarb
@ Zgarb ¡Solo wow!
Christian Sievers
Ugh, mi cerebro no puede inferir el tipo para la instancia de funciones de mónada
Angs
@Angs The Monad is (->)r, que se aplica a un tipo es (->)r a = r->a. Entonces, de los tipos return:: a->r->ay (>>=)::(r->a)->(a->r->b)->(r->b)su implementación es (¿me atrevo a decirlo?) Obvio: return=consty m>>=f = \r->f(m r)r. Esto último es exactamente lo que se necesita para expresar algo así como span(predicate_depending_on l)lmencionar lsolo una vez. Ahora solo necesito recordarlo cuando lo necesito.
Christian Sievers
@Angs Puedes encontrar este truco, y muchos más, en nuestra colección de consejos de golf de Haskell .
Zgarb
3

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.

Yytsi
fuente
podrías reemplazar !l.Any(o=>o!=l[0]))con l.All(o=>o==l[0])?
Cyoce
@Cyoce De hecho lo hace. Pensé en lo mismo, pero escribí en Anylugar de Allpensar que no funciona: D ¡Gracias!
Yytsi
2
¿C # no tiene ++?
Cyoce
Puede compilar en a Action<List<int>>para eliminar todo el código de firma del método
TheLethalCoder
1
@Stefan Hmm. También he visto a muchas personas abandonar los usings necesarios con C #, por lo que no confío en que sea legal dejarlos using System.Linq. A menos que vea una declaración explícita que diga que esto no es necesario, me quedaré con esto. Gracias por la sugerencia sin embargo! :)
Yytsi
2

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
}

Brad Gilbert b2gills
fuente
2

Jalea, 9 bytes

;1µ‘i¦E?Ṃ

Gracias a Dennis por los -2 bytes.

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

Zacharý
fuente
Si tiene caracteres adicionales para ingresar en el cuerpo, siempre vale la pena explicar el código, lo que ayuda a todos a entenderlo y hace que la respuesta sea más interesante :)
Alfie Goodacre
2

Mathematica, 53 bytes 57 bytes 59 bytes

If[Equal@@#,#~Join~{1},x=#;x[[#~FirstPosition~Min@#]]++;x]&
ngenisis
fuente
77
Eso es 57 bytes. y son caracteres de 3 bytes. Además, su código no funciona porque {##,1}parte implica que la entrada es enteros separados (es decir f[1, 2, 3]), pero la x=#parte implica que la entrada es un List(es decir f[{1, 2, 3}]). Una solución rápida sería cambiar x=#a x={#}y aceptar enteros crudos como entrada, por lo que su código de 59 bytes de longitud.
JungHwan Min
¡Buena atrapada! No me di cuenta de la distinción entre bytes y recuento de caracteres, solo vi esta sugerencia y pensé que era válida. Parece que hay muchas respuestas que dan el recuento de caracteres, pero si las guardo en Notepad ++ obtengo un recuento de bytes más alto (por ejemplo, la respuesta Jelly). Veo que su respuesta especifica una codificación, ¿hay algún lugar que me recomiende para que aprenda sobre esto?
ngenisis
1
Creo que quieres decir Equal@#, aunque #==##es más corto.
Martin Ender
Tienes razón. Hice un cambio por @JHM para aceptar múltiples argumentos en lugar de una lista, pero no propagué el cambio en todas partes. He vuelto a aceptar una lista, ya que está más en línea con el mensaje.
ngenisis
2

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!

JayCe
fuente
@Giuseppe Probé isTRUE e isFALSE con sd, no es más golfier :(
JayCe
je, 65 bytes reemplazando !=con -!
Giuseppe
@Giuseppe por supuesto!
JayCe
1

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.

Lee W
fuente
66
a.uniq[1]será verdad si hay valores distintos.
histocrat
Puede guardar un byte convirtiéndose a[a.index(a.min)]ena[a.index a.min]
Cyoce
1

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)
Stewie Griffin
fuente
1

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
Frédéric
fuente
1

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
Timtech
fuente
1

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.

Owen Morgan
fuente
Bienvenido a PPCG! Hay algunos defectos en este código. sum(a)/length(a)==a(1)no garantiza que todos los elementos sean iguales, solo muestra que el promedio es igual a a(1). Una forma más sencilla de hacer esto sería mean(a)==a(1). numeles un byte más corto que length, pero como sabe que todos los valores son positivos, puede usar uno nnzque sea aún más corto (todavía no daría el resultado correcto en este desafío, pero al menos es más corto: P). Si toma la min(a)llamada frente al bucle, puede usar ambas salidas y verificar si los allelementos ason iguales a min(a).
Stewie Griffin
¡Tienes razón! falla cuando la media es igual al número en el primer elemento. Creo que mi nuevo es correcto y también más corto. La lógica es que si los elementos restantes no son iguales al primer elemento, a (a ~ = a (1)) devuelve los elementos restantes que, por definición, es mayor que 0 en una matriz diferente. Luego contar y no debería dar la lógica correcta, creo. Si todavía está mal, hágamelo saber, solo he estado codificando durante unos años y todavía me quedan mucho por hacer.
Owen Morgan el
~nnz(a(a~=a(1)))es simplemente ~nnz(a-a(1)). Además, no necesitas los paréntesis. if ~nnz(a-a(1));a=[a,1];else[~,I]=min(a);a(I)=a(I)+1;end. Esto debería ser 5 bytes más corto (nota: no lo he probado).
Stewie Griffin
Puede guardar 3 bytes utilizando en range(a)lugar dennz(a-a(1))
MattWH
@boboquack, ese código verifica si el número de elementos en aes igual al valor más bajo en ese vector. Un vector a = [3 4 6]dará como resultado true, y un vector a = [4 4 6]dará como resultado false. No creo que eso sea útil aquí ...?
Stewie Griffin
1

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)))))
NikoNyrh
fuente
1

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

Jakob
fuente
1

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] ...
Pon pon holla mon
fuente
2
No puede codificar las entradas, tendría que hacer algo como @(x) ….
ბიმო
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
caracol_
fuente
Puede guardar 2 bytes reemplazando BREAKcon M=0, porque Ano puede contener, 0por M==A[C]lo que nunca será cierto.
12Me21
1

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
12Me21
fuente
0

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                    
TheBikingViking
fuente
0

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.

sudee
fuente
1
¿Por qué no hacer una función separada en lugar de usar where?
Michael Klein
0

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.

Mama Fun Roll
fuente
0

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.

Tyler MacDonell
fuente