Avec un tableau d'entiers positifs non vide, "l'incrémente" une fois comme suit:

• Si tous les éléments du tableau sont égaux, ajoutez a 1à la fin du tableau. Par exemple:

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

• Sinon, incrémente le premier élément du tableau qui correspond à la valeur minimale du tableau. Par exemple:

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

(Chacun ->représente un incrément, ce que tout votre programme doit faire.)

Affiche le tableau incrémenté résultant.

Le code le plus court en octets gagne.

Gelée , 8 7 octets

‘;ṀỤḢṬ+

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

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

Fonction qui modifie la liste qui lui est transmise ( autorisée par la méta ).

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

Essayez repl.it!

-9 octets, grâce à Lynn pour avoir remarqué que, comme le tableau sera composé d'entiers positifs, je peux ajouter «0» à la fin du tableau et l'incrémenter.

Un merci spécial à mbomb007 pour jouer au golf len(set(a))à len({*a}), et Dennis pour l'astuce! Floordiv

JavaScript (ES6), 61 octets

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

Sortie en modifiant son argument . Je ne trouve pas de moyen de déterminer si un tableau ne contient qu'un seul élément sur moins de 17 octets, mais les suggestions sont les bienvenues.

Extrait de test

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>

Autres tentatives

Voici quelques manières alternatives de décider si le tableau a plusieurs entrées uniques:

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)

Les deux somepeuvent également être remplacés find. .sortserait plus court pour trouver le minimum, si le tri par défaut n'était pas lexicographique (pourquoi, JS, pourquoi?):

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)

J'ai essayé la récursivité pour trouver le minimum, mais cela s'est avéré bien plus long:

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

Et voici une solution basée sur les chaînes de caractères qui semblait être une bonne idée au début: (l'entrée est donnée sous forme de tableau dans une chaîne, par exemple "[1,2,3]")

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

Mathematica, 70 57 55 octets

La quasi-totalité de l’amélioration est due à Martin Ender, qui m’attaque aux approches du filtrage! JHM a également proposé essentiellement la même solution à peu près au même moment. (le nombre d'octets utilise l'encodage ASCII)

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

Définit une fonction ±prenant un argument de liste. Si cet argument de liste contient un certain nombre de copies du même élément (détecté par x_..et nommé p), alors exportez la liste avec un 1ajout. Sinon, si cet argument de liste a un élément spécial y( xzéro ou plusieurs éléments avant y, et après zzéro y), qui est au plus le minimum des autres éléments, affichez la liste avec cet élément yincrémenté. Tout élément de l'élément minimum de la liste sera associé y, mais heureusement, Mathematica choisit le premier sur lequel agir.

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

soumission

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

invocation

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

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

C'est la première fois que je joue au golf, l'aide est la bienvenue.

EDIT: oublié de mentionner que vous devez le compiler avec au moins -std=c++11 -std=c++14

EDIT2: J'ai réalisé que je peux laisser de l'espace dans l'inclus #include <list>

EDIT3: sauvegardé deux octets supplémentaires en les remplaçant l.begin()parbegin(l)

EDIT4: enregistré 19 (!) Octets supplémentaires grâce à @Quentin (voir son commentaire)

EDIT5: Quentin a supprimé 13 octets de plus, merci!

EDIT6: comme le fait remarquer TuukkaX, les fonctions / lambdas non nommés sont suffisants, je supprime donc le auto i=dans le bytecount

05AB1E , 21 20 16 octets

Sauvegardé 4 octets grâce à Adnan .

DÙgi0¸«}ÐWksgÝQ+

Essayez-le en ligne!

Explication

                      # 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 blocs + 7 6 octets

Prend l'entrée comme un tableau prédéfini d'entiers. Notez que les tableaux sont indexés 1 dans Scratch.

En Python, cela ressemblerait à: (Notez que contrairement à Scratch, Python est indexé sur 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 octets

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

Évalue à un verbe anonyme. Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne! Ou vérifier tous les cas de test

Comment ça marche

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 octets

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

Utilise la fonction nommée ±. Utilise le codage ISO8859-1

Solutions alternatives (58 octets)

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

Usage

±{1, 1}

{1, 1, 1}

±{3, 4, 5}

{4, 4, 5}

Haskell, 71 70 62 octets

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

@Zgarb a enregistré 8 octets, merci!

Quand j'ai commencé, j'espérais une élégante ruse qui consiste à nouer les nœuds, mais le chemin de @ Zgarb est tout aussi incroyable.

C #, 123 121 120 79 77 octets

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

Modifie l'argument transmis à la fonction.

Merci à Cyoce d' avoir économisé 3 octets! -> !Anyto All, +=1to ++.

Merci à TheLethalCoder d' avoir économisé 43 octets! -> Code de signature de méthode supprimé. Suppression des parenthèses autour de la liste de paramètres.

Perl 6 , 46 octets

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

(modifie le tableau d'entrée et le renvoie)

Étendu:

{     # 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ée, 9 octets

;1µ‘i¦E?Ṃ

Merci à Dennis pour les -2 octets.

Le corps doit comporter au moins 30 caractères. tu es entré ... .

Mathematica, 53 octets 57 octets 59 octets

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

R , 72 66 65 octets

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

Essayez-le en ligne!

L'incrément est fait en utilisant which.minqui retourne la première correspondance. "[<-"permet de remplacer la valeur et renvoie le vecteur modifié en un appel de fonction.

-7 octets grâce à Giuseppe!

Ruby, 46 octets

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

Je pense qu'il existe un meilleur moyen de vérifier si tous les éléments sont identiques que a.uniq.size<2, mais je suis trop paresseux pour le trouver.

Octave, 69 67 64 octets

En réalité, il était plus court d’en faire une fonction nommée complète que d’utiliser les deux inputméthodes disp.

3 octets sauvés grâce à Luis.

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

Ancienne réponse, n'utilisant pas de fonction:

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

R, 97 octets

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

Dommage que le synthax x=+1n'existe pas dans 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 octets

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 octets

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

Je suis relativement nouveau dans le code de golf alors soyez gentil! J'ai essayé d'utiliser des fonctions anonymes mais googler indique que vous ne pouvez pas utiliser les instructions / else et que matlab n'a pas d'opérateur ternaire, c'est donc ce que j'ai le mieux pu faire.

Edit: Correction et raccourci (deux fois!) Grâce à stewie-griffin.

Clojure, 112 100 octets

min-keyRetourne malheureusement le dernier index du plus petit index, pas le premier. Cela fonctionne pour les entrées entières et les tableaux plus courts que 10 ^ 9 éléments;)

Éditer: Définir une fonction anonyme en utilisant à la (apply = a)place 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)))

Une solution moins fastidieuse de 134 octets inverse le vecteur avant de le mettre à jour, puis l'inverse à nouveau:

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

Vide lambda prenant un List<Integer>(la sortie est une entrée mutée). Le nombre d'octets comprend lambda et l'importation requise.

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

Essayez-le en ligne

Cela ressemble presque à Python avec ces importations de méthodes ...

MATLAB, 66 53 octets

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

Sortie:

Initialiser:

a = [3 2]

Pistes successives:

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

SmileBASIC 3, 101 octets

Définit une fonction d'instruction I Aoù Aest notre tableau entier de nombres. La sortie est obtenue en modifiant l'entrée (les tableaux étant des références).

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 octets

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 octets

?tl{QXxQhSQQ1+Q1

Un programme qui prend l'entrée d'une liste et imprime le résultat.

Suite de tests

Comment ça marche

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

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

La première tentative tentera de trouver quelque chose de plus sophistiqué plus tard.

Merveille , 44 octets

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

Ce n'est pas ce que j'avais en tête quand j'ai créé ce langage ... C'est littéralement pire que Perl en termes de lisibilité!

Usage:

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

Explication

Plus lisible:

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

Vérifie en gros si supprimer un élément du sous-ensemble unique de l'argument rend la liste vide. Si ce n'est pas le cas, nous incrémentons le minimum du tableau. Sinon, nous concaténons simplement 1 à l'argument.

Kotlin, 75 octets

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

Modifie l'argument de la fonction.

Bon sang vous tapant fort! :MutableList<Int>représente 17 octets seulement. Je ne pense pas qu'il y ait une solution où le type peut être déduit, malheureusement.