Bei einem nicht leeren Array positiver Ganzzahlen "erhöhen" Sie es einmal wie folgt:

• Wenn alle Array-Elemente gleich sind, fügen Sie ein 1an das Ende des Arrays an. Zum Beispiel:

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

• Anderenfalls erhöhen Sie das erste Element im Array, das der Mindestwert des Arrays ist. Zum Beispiel:

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

(Jedes ->stellt ein Inkrement dar, was alles ist, was Ihr Programm tun muss.)

Das resultierende inkrementierte Array ausgeben.

Der kürzeste Code in Bytes gewinnt.

Gelee , 8 7 Bytes

‘;ṀỤḢṬ+

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Funktion, die die übergebene Liste ändert ( von Meta erlaubt ).

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

Versuchen Sie es mit repl.it!

-9 Bytes dank Lynn für das Erkennen, dass, da das Array positive ganze Zahlen enthält, ich '0' an das Ende des Arrays anhängen und dieses inkrementieren kann.

Besonderer Dank geht an mbomb007 für Golf spielen len(set(a))auf len({*a}), und Dennis für die floordiv Trick!

JavaScript (ES6), 61 Byte

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

Ausgabe durch Ändern des Arguments . Ich kann nicht feststellen, ob ein Array nur ein einziges Element in weniger als 17 Bytes enthält, aber Vorschläge sind willkommen.

Testschnipsel

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>

Andere Versuche

Hier einige alternative Möglichkeiten, um zu entscheiden, ob das Array mehr als eine eindeutige Eingabe enthält:

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)

Beide somes können auch durch ersetzt werden find. .sortwäre kürzer, um das Minimum zu finden, wenn die Standardsortierung nicht lexikografisch wäre (warum, JS, warum?):

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)

Ich habe versucht, durch Rekursion das Minimum zu finden, aber es hat sich als viel länger herausgestellt:

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

Und hier ist eine stringbasierte Lösung, die auf den ersten Blick eine gute Idee zu sein schien: (Die Eingabe erfolgt im Array-Format in einem String, z. B. "[1,2,3]")

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

Mathematica, 70 57 55 Bytes

Praktisch die ganze Verbesserung ist Martin Ender zu verdanken, der mir bei Pattern Matching-Ansätzen in den Hintern tritt! Auch JHM hat im Wesentlichen zur gleichen Zeit die gleiche Lösung gefunden. (Byteanzahl verwendet ASCII-Codierung)

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

Definiert eine Funktion ±mit einem Listenargument. Wenn dieses Listenargument eine bestimmte Anzahl von Kopien desselben Elements enthält (erkannt von x_..und benannt p), geben Sie die Liste mit einem 1Anhang aus. Wenn andernfalls dieses Listenargument ein spezielles Element enthält y(wobei xes sich um das Nullelement oder die mehreren Elemente davor yund zdas Nullelement oder die mehreren Elemente danach handelt y), das höchstens das Minimum der anderen Elemente ist, wird die Liste mit diesem yInkrement ausgegeben . Jede Instanz des minimalen Elements in der Liste wird von abgeglichen y, aber glücklicherweise wählt Mathematica die erste, auf die reagiert werden soll.

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

Einreichung

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

Aufruf

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

Dies ist mein erstes Mal Golf zu spielen, Hilfe wird geschätzt.

EDIT: habe vergessen zu erwähnen, dass du es mit mindestens kompilieren musst -std=c++11 -std=c++14

EDIT2: Mir wurde klar, dass ich den Platz in den Includes weglassen kann #include <list>

EDIT3: sparte zwei weitere Bytes durch Ersetzen l.begin()durchbegin(l)

EDIT4: speicherte dank @Quentin weitere 19 (!) Bytes (siehe seinen Kommentar)

EDIT5: Quentin hat 13 weitere Bytes rasiert, danke!

EDIT6: Wie TuukkaX hervorhob, genügen unbenannte Lambdas / Funktionen, so dass ich das auto i=im bytecount entfernte

05AB1E , 21 20 16 Bytes

4 Bytes gespart dank Adnan .

DÙgi0¸«}ÐWksgÝQ+

Probieren Sie es online!

Erläuterung

                      # 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 Blöcke + 7 6 Bytes

Übernimmt die Eingabe als vordefiniertes Array von Ganzzahlen. Beachten Sie, dass Arrays in Scratch 1-indiziert sind.

In Python würde dies so aussehen: (Beachten Sie, dass Python im Gegensatz zu Scratch 0-indiziert ist.)

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=#@~.

Wertet zu einem anonymen Verb aus. Probieren Sie es online!

Erläuterung

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

Probieren Sie es online! Oder überprüfen Sie alle Testfälle

Wie es funktioniert

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}

Verwendet die benannte Funktion ± . Verwendet ISO8859-1-Codierung

Alternative Lösungen (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}

Verwendungszweck

±{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 8 Bytes gespeichert, danke!

Als ich anfing, hoffte ich auf einen eleganten Trick, aber @ Zgarbs Weg ist genauso erstaunlich.

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())]++;}

Ändert das an die Funktion übergebene Argument.

Vielen Dank an Cyoce für das Speichern von 3 Bytes! -> !Anyzu All, +=1zu ++.

Vielen Dank an TheLethalCoder für die Einsparung von satten 43 Bytes! -> Methodensignaturcode entfernt. Klammern um die Parameterliste entfernt.

Perl 6 , 46 Bytes

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

(Ändert das Eingabe-Array und gibt es zurück.)

Erweitert:

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

Gelee, 9 Bytes

;1µ‘i¦E?Ṃ

Danke an Dennis für die -2 Bytes.

Der Text muss mindestens 30 Zeichen lang sein. du kamst herein ... .

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

Probieren Sie es online!

Das Inkrementieren erfolgt mit, which.minwodurch die erste Übereinstimmung zurückgegeben wird. "[<-"Ermöglicht das Ersetzen des Werts und gibt den geänderten Vektor in einem Funktionsaufruf zurück.

-7 Bytes dank Giuseppe!

Ruby, 46 Bytes

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

Ich habe das Gefühl, dass es eine bessere Möglichkeit gibt, zu überprüfen, ob alle Elemente gleich sind a.uniq.size<2, aber ich bin zu faul, um sie zu finden.

Oktave, 69 67 64 Bytes

Es war tatsächlich kürzer, dies zu einer vollständigen benannten Funktion zu machen, als beide inputund zu verwendendisp .

3 Bytes gespart dank Luis.

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

Alte Antwort ohne Verwendung einer Funktion:

[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

Schade, dass die Synthax x=+1 in R nicht existiert!

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

Ich bin relativ neu im Code Golf, sei also bitte nett! Ich habe versucht, anonyme Funktionen zu verwenden, aber Googeln besagt, dass Sie nicht verwenden können, wenn / else-Anweisungen und matlab keine ternären Operatoren haben. Dies ist also das Beste, was ich tun konnte.

Edit: Korrigiert und verkürzt (zweimal!) Dank Stewie-Griffin.

Clojure, 112 100 Bytes

Leider wird min-keyder letzte Index des kleinsten Index zurückgegeben, nicht der erste. Dies funktioniert für Integer-Eingaben und kürzere Arrays als 10 ^ 9 Elemente;)

Bearbeiten: Definieren einer anonymen Funktion mit (apply = a)anstelle von (= 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)))

Eine weniger hackige 134-Byte-Lösung kehrt den Vektor vor dem Aktualisieren um und kehrt ihn dann wieder zurück:

(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 Taking a List<Integer>(Ausgang ist mutierter Eingang). Die Byteanzahl umfasst Lambda und den erforderlichen Import.

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

Probieren Sie es online

Das sieht fast aus wie Python mit diesen Methodenimporten ...

MATLAB, 66 53 Bytes

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

Ausgabe:

Initialisieren:

a = [3 2]

Aufeinanderfolgende Läufe:

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

SmileBASIC 3, 101 Bytes

Definiert eine Anweisungsfunktion, I Abei der Aes sich um unser ganzzahliges Zahlenarray handelt. Die Ausgabe erfolgt durch Ändern der Eingabe (da Arrays Referenzen sind.)

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

Ein Programm, das eine Liste eingibt und das Ergebnis druckt.

Testsuite

Wie es funktioniert

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

Der erste Versuch wird später versuchen, etwas Raffinierteres zu finden.

Wunder , 44 Bytes

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

Dies ist nicht das, was ich gedacht habe, als ich diese Sprache geschrieben habe ... Es ist buchstäblich schlechter als Perl in Bezug auf die Lesbarkeit!

Verwendungszweck:

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

Erläuterung

Besser lesbar:

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

Prüft grundsätzlich, ob das Löschen von 1 Element aus der eindeutigen Teilmenge des Arguments die Liste leer macht. Wenn nicht, erhöhen wir das Minimum des Arrays. Ansonsten verketten wir einfach 1 mit dem Argument.

Kotlin, 75 Bytes

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

Ändert das Funktionsargument.

Verdammt du starkes Tippen! :MutableList<Int>allein 17 Bytes. Ich glaube nicht, dass es eine Lösung gibt, aus der man leider auf den Typ schließen kann.