Incrémenter un tableau


44

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.


Est-ce que 0 est considéré comme un entier positif
Downgoat

20
@Downgoat 0 n'est pas positif sur PPCG. Si 0 était autorisé, le terme serait "non négatif"
ETHproductions

Réponses:


13

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.

11

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


Hmm. "Affiche le tableau incrémenté résultant". Est-ce que cela est admissible?
Yytsi

Je ne me souviens plus très bien où, mais je me souviens d'avoir vu une méta-publication selon laquelle la modification d'une liste donnée à la place est autorisée par défaut. J'y jetterai un coup d'oeil @TuukkaX
FlipTack

@ TuukkaX Je ne suis pas tout à fait sûr. Cela semble correct, mais je vais laisser tomber le consensus quant à la modification des tableaux en place, le cas échéant.
Les passe-temps de Calvin

1
En Python 3, vous pouvez len({*L})<2rechercher si tous les éléments d’une liste sont égaux.
mbomb007

1
a+=1//len({*a})*[0]devrait sauver un octet.
Dennis

9

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

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

L'utilisation de a.find (n => n == Math.min (... a)) est-elle plus courte?
Downgoat

@Downgoat Je ne suis pas sûr de savoir comment l'utiliser, car il renvoie l'élément plutôt que l'index
ETHproductions

yeah> _> whoops, votre ++ m'a manqué et je ne savais pas que vous aviez besoin d'une référence
Downgoat

7

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.


Parce que ±est un caractère de 2 octets, votre code est long de 59 octets. De plus, il doit y avoir un espace entre x_et ..parce que Mathematica interprète x_..comme x_. .(ce qui jette des erreurs). De plus, la forme infixe de Min( x~Min~z) rendrait ces 2 octets plus courts (ce qui rend cette solution identique à l'une des miennes: p ...). Welp, vous pouvez prendre le crédit car mon édition était postérieure à la vôtre ....
JungHwan Min

Nah, Martin Ender obtient le plus de mon crédit de toute façon. Pourquoi ± deux octets?
Greg Martin

@GregMartin ±dans UTF-8 ( Mathematica utilise UTF-8 par défaut; try $CharacterEncoding) est un caractère à deux octets (U + 00B1).
JungHwan Min

@JHM UTF-8 n'est pas l'encodage de caractères par défaut sous Windows. Mathematica peut lire les fichiers source dans une page de code à un octet incluant ±.
Martin Ender

1
Mon @ASimmons nouvelle installation Mathematica sous Windows, qui a $CharacterEncodingmis à ce WindowsANSIqui est CP1252 (qui est suffisamment compatible avec la norme ISO 8859-1 pour ±et ·d'être utilisable pour un seul octet).
Martin Ender

7

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


5
Je ne peux pas vous aider avec C ++, mais je peux dire: Bienvenue à PPCG!
Zgarb

1
Je pense que vous n'avez pas besoin d'espaces dans les #includelignes.
Christian Sievers

Oh merci, je viens de m'en rendre compte :)
Neop

1
Remplacer la fonction par un lambda ( auto i=[](auto&l){...};) enregistre un octet (plus si nous comptons le type de retour que vous avez oublié;)), utiliser ^ au lieu de ==et échanger les opérandes en enregistre un autre. std::listLes itérateurs de sont des std::classes, vous pouvez donc vous échapper std::des deux std::countet std::min_elementgrâce à ADL (-10). l.front()est aussi *b(-7). Je me retrouve avec un 120 octets 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
Pendant que nous y sommes, la documentation pour lesstd::min_element états qui renvoie le premier élément le plus petit, find()est donc superflue, c'est-à-dire 11 octets. Dans les conditions, l'utilisation d'une paire de parenthèses et de l'opérateur de virgule pour contraindre l'expression correcte à intest plus courte que la conversion de l'extrême gauche sur void2 octets. Cela mène à 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 octets :)
Quentin

6

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]

Je pense que ça DÙgi0¸«}ÐWksgÝQ+marche aussi.
Adnan

@Adnan: Aah, bonne idée d'utiliser ÝQavec k. Merci!
Emigna

5

Scratch, 25 34 blocs + 7 6 octets

Programme

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)

Commentaires de golf s'il vous plaît?
OldBunny2800

pourquoi déclarez-vous fval?
Christoph

Il me semble que Scratch n'est que du Python en texte clair avec des couleurs ...
Stewie Griffin

Et tableaux à 1 index et pas de déclarations elif!
OldBunny2800

1
Bon point @Christoph! Cela faisait partie d'une version antérieure qui avait été golfée. Édition.
OldBunny2800

4

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.

3

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

3

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}


3

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.


Quelques restructurations, 62 octets:f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1:z
Zgarb

@Zgarb Ouah!
Christian Sievers

Ugh, mon cerveau ne parvient pas à déduire le type pour l'instance de monade de fonctions
Angs

@Angs Le Monad est (->)r, ce qui est appliqué à un type est (->)r a = r->a. Ensuite, à partir des types return:: a->r->aet de (>>=)::(r->a)->(a->r->b)->(r->b)leur mise en œuvre (est-ce que j'ose le dire?): return=constEt m>>=f = \r->f(m r)r. Ce dernier est exactement ce qui est nécessaire pour exprimer quelque chose comme span(predicate_depending_on l)len lne mentionnant qu’une fois. Maintenant, je dois seulement m'en souvenir quand j'en ai besoin.
Christian Sievers

@Angs Vous pouvez trouver cette astuce, et bien d’autres, dans notre collection d’astuces pour le golf Haskell .
Zgarb

3

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.


pourriez-vous remplacer !l.Any(o=>o!=l[0]))par l.All(o=>o==l[0])?
Cyoce

@ Cyoce C'est le cas. J'ai pensé à la même chose, mais j'ai écrit à la Anyplace Allet j'étais dans la pensée que ça ne marche pas: D Merci!
Yytsi

2
C # n'a pas ++?
Cyoce

Vous pouvez compiler un Action<List<int>>
fichier

1
@ Stefan Hmm. J'ai aussi vu beaucoup de gens déposer les usings nécessaires avec C #, donc je ne crois pas qu'il soit légal de les déposer using System.Linq. À moins que je ne voie une déclaration explicite disant que cela n'est pas nécessaire, je vais rester sur ce sujet. Merci pour la suggestion cependant! :)
Yytsi

2

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
}


2

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


Si vous avez des caractères supplémentaires à entrer dans le corps, cela vaut toujours la peine d'expliquer le code, ce qui aide tout le monde à le comprendre et rend la réponse plus intéressante :)
Alfie Goodacre

2

Mathematica, 53 octets 57 octets 59 octets

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

7
C'est 57 octets. et sont des caractères de 3 octets. En outre, votre code ne fonctionne pas car une {##,1}partie implique que l'entrée est un entier séparé (c'est-à-dire f[1, 2, 3]) mais la x=#partie implique que l'entrée est un List(c'est-à-dire f[{1, 2, 3}]). Une solution rapide serait de changer x=#pour x={#}et accepter les entiers premières en entrée, ce qui rend votre code 59 octets.
JungHwan Min

Bonne prise! Je n'avais pas compris la distinction entre octets et nombre de caractères, j'ai juste vu cette suggestion et pensé qu'elle était valide. Il semble que beaucoup de réponses donnent le nombre de caractères, mais si je les enregistre dans Notepad ++, le nombre d'octets est plus élevé (par exemple, la réponse à la gelée). Je vois que votre réponse spécifie un encodage, y a-t-il un endroit que vous me recommanderiez d'apprendre à ce sujet?
ngenisis

1
Je pense que vous voulez dire Equal@#, même si #==##c'est plus court.
Martin Ender

Tu as raison. J'ai modifié @JHM pour accepter plusieurs arguments plutôt qu'une liste, mais je n'ai pas propagé la modification partout. J'ai recommencé à accepter une liste, car elle correspond davantage à l'invite.
ngenisis

2

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!



@ Giuseppe J'ai essayé isTRUE et isFALSE avec sd ce n'est pas plus golfeur :(
JayCe

hé, 65 octets remplaçant !=par -!
Giuseppe

@ Giuseppe bien sûr!
JayCe

1

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.


6
a.uniq[1]sera la vérité ssi il y a des valeurs distinctes.
Histocrat

Vous pouvez économiser un octet en vous transformant a[a.index(a.min)]ena[a.index a.min]
Cyoce

1

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)

1

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

1

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

1

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.


Bienvenue chez PPCG! Il y a quelques failles dans ce code. sum(a)/length(a)==a(1)ne garantit pas que tous les éléments sont égaux, cela montre seulement que la moyenne est égale à a(1). Une façon plus simple de faire cela serait mean(a)==a(1). numelest un octet plus court que length, mais puisque vous savez que toutes les valeurs sont positives, vous pouvez utiliser nnzce qui est encore plus court (cela ne donnerait toujours pas le résultat correct dans ce défi, mais il est au moins plus court: P). Si vous prenez l' min(a)appel en face de la boucle, vous pouvez utiliser les deux sorties et vérifier que les alléléments asont égaux à min(a).
Stewie Griffin

Vous avez raison! il échoue lorsque la moyenne est égale au nombre du premier élément. Je pense que mon nouveau est correct mais aussi plus court. La logique est que si les éléments restants ne sont pas égaux au premier élément, a (a ~ = a (1)) renvoie les éléments restants qui, par définition, sont supérieurs à 0 dans un tableau différent. Ensuite, compter et ne pas donner la bonne logique, je pense. Si c'est toujours faux, faites-le-moi savoir, je ne code que depuis quelques années et il me reste encore beaucoup de chemin à parcourir.
Owen Morgan

~nnz(a(a~=a(1)))est simplement ~nnz(a-a(1)). En outre, vous n'avez pas besoin des parenthèses. if ~nnz(a-a(1));a=[a,1];else[~,I]=min(a);a(I)=a(I)+1;end. Cela devrait être plus court de 5 octets (note: je ne l’ai pas testé).
Stewie Griffin

Vous pouvez économiser 3 octets en utilisant à la range(a)place dennz(a-a(1))
MattWH

@boboquack, ce code vérifie si le nombre d'éléments dans aest égal à la valeur la plus basse de ce vecteur. Un vecteur a = [3 4 6]en résultera true, et un vecteur a = [4 4 6]en résultera false. Je ne pense pas que cela sera utile ici ...?
Stewie Griffin

1

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

1

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


1

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

2
Vous ne pouvez pas coder les entrées en dur, vous devez faire quelque chose comme @(x) ….
ბიმო

1

SmileBASIC 3, 101 octets

Définit une fonction d'instruction I AAest 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

Vous pouvez économiser 2 octets en remplaçant BREAKpar M=0, car Ane pouvant pas contenir 0, M==A[C]il ne sera jamais vrai.
12m21 le

1

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

0

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                    

0

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.


1
Pourquoi ne pas créer une fonction séparée au lieu d'utiliser where?
Michael Klein

0

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.


0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.