Incrementar uma matriz

44

Dada uma matriz não vazia de números inteiros positivos, "aumente" uma vez da seguinte maneira:

  • Se todos os elementos da matriz forem iguais, anexe 1a ao final da matriz. Por exemplo:

    [1] -> [1, 1]
    [2] -> [2, 1]
    [1, 1] -> [1, 1, 1]
    [3, 3, 3, 3, 3] -> [3, 3, 3, 3, 3, 1]
    
  • Senão, incremente o primeiro elemento na matriz que é o valor mínimo da matriz. Por exemplo:

    [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 ->um representa um incremento, que é tudo o que seu programa precisa fazer.)

Saída da matriz incrementada resultante.

O código mais curto em bytes vence.

Hobbies de Calvin
fonte
O 0 conta como número inteiro positivo
Downgoat 28/11
20
@Downgoat 0 nem sempre é positivo no PPCG. Se 0 foi permitido, o termo seria "não negativo"
ETHproductions

Respostas:

13

Geléia , 8 7 bytes

‘;ṀỤḢṬ+

Experimente online! ou verifique todos os casos de teste .

Como 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
fonte
11

Python 3, 62 53 51 50 bytes

Função que modifica a lista passada a ela ( permitida por meta ).

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

Experimente repl.it!

-9 bytes graças a Lynn por detectar que, como a matriz terá números inteiros positivos, eu posso acrescentar '0' ao final da matriz e aumentá-la.

Um agradecimento especial a mbomb007 para jogar golfe len(set(a))para len({*a}), e Dennis para o truque floordiv!

FlipTack
fonte
Hmm. "Saída da matriz incrementada resultante". Isso se qualifica?
Yytsi
Não me lembro onde, mas lembro de ver uma meta post que modificar uma determinada lista no local é permitido por padrão. Vou dar uma olhada nele @TuukkaX
FlipTack 28/11
@TuukkaX Não tenho muita certeza. Parece ok, mas vou adiar para o meta-consenso sobre a modificação de matrizes, se houver uma.
Calvin's Hobbies
1
No Python 3, você pode len({*L})<2descobrir se todos os elementos de uma lista são iguais.
mbomb007
1
a+=1//len({*a})*[0]deve salvar um byte.
Dennis
9

JavaScript (ES6), 61 bytes

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

Saídas modificando seu argumento . Não consigo encontrar uma maneira de determinar se uma matriz possui apenas um item exclusivo em menos de 17 bytes, mas sugestões são bem-vindas.

Snippet de teste

Outras tentativas

Aqui estão algumas maneiras alternativas de decidir se a matriz possui mais de uma entrada exclusiva:

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 os somes também podem ser substituídos findpor. .sortseria mais curto para encontrar o mínimo, se a classificação padrão não fosse lexicográfica (por que, JS, por que?):

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)

Tentei recursão para encontrar o mínimo, mas acabou por muito mais tempo:

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

E aqui está uma solução baseada em string que parecia uma boa idéia no início: (a entrada é fornecida no formato de array em uma string, por exemplo "[1,2,3]")

a=>a.replace(m=/(\d+),(?!\1)/.test(a)?Math.min(...eval(a)):']',+m+1||",1]")
ETHproductions
fonte
O uso de a.find (n => n == Math.min (... a)) é mais curto?
Downgoat 28/11/16
@Downgoat Eu não sei como eu usaria que, como ele retorna o item em vez do índice
ETHproductions
, yeah> _> gritos, eu perdi o seu ++ e não sabia que você precisava de uma referência
Downgoat
7

Mathematica, 70 57 55 bytes

Praticamente toda a melhoria se deve a Martin Ender, que me dá um chute nas abordagens de correspondência de padrões! Além disso, a JHM apresentou essencialmente a mesma solução, essencialmente ao mesmo tempo. (a contagem de bytes usa codificação ASCII)

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

Define uma função que ±aceita um argumento da lista. Se esse argumento da lista contiver algum número de cópias do mesmo elemento (detectado x_..e nomeado p), emita a lista com um 1anexo. Caso contrário, se esse argumento da lista tiver um elemento especial y(com xzero ou mais elementos antes ye zzero ou mais elementos depois y) que for no máximo o mínimo dos outros elementos, emita a lista com esse yincremento. Qualquer instância do elemento mínimo da lista será correspondida y, mas felizmente o Mathematica escolhe a primeira a agir.

Greg Martin
fonte
Por ±ser um caractere de 2 bytes, seu código tem 59 bytes. Além disso, deve haver um espaço entre x_e ..porque o Mathematica interpreta x_..como x_. .(o que gera erros). Além disso, a forma infix de Min( x~Min~z) tornaria esses 2 bytes mais curtos (o que torna essa solução idêntica a uma das minhas: p ...) Bem, você pode receber o crédito, porque minha edição foi posterior à sua ....
JungHwan Min
Martin Ender recebe a maior parte do meu crédito de qualquer maneira. Por que é de ± dois bytes?
Greg Martin
@GregMartin ±em UTF-8 (o Mathematica usa UTF-8 por padrão; try $CharacterEncoding) é um caractere de dois bytes (U + 00B1).
JungHwan Min
@JHM UTF-8 não é a codificação de caracteres padrão no Windows. O Mathematica pode ler arquivos de origem em uma página de código de byte que inclui ±.
Martin Ender
1
@ASimmons Minha nova instalação do Mathematica no Windows, $CharacterEncodingdefinida como WindowsANSICP1252 (que é suficientemente compatível com a ISO 8859-1 ±e ·pode ser usada por um único byte).
Martin Ender
7

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

submissão, obediência, inscrição, candidatura

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

invocação

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

destroçado

#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 é a minha primeira vez jogando golfe, a ajuda é apreciada.

EDIT: esqueci de mencionar que você deve compilá-lo com pelo menos -std=c++11 -std=c++14

EDIT2: eu percebi que posso deixar de fora o espaço no inclui #include <list>

EDIT3: salvou mais dois bytes substituindo l.begin()porbegin(l)

EDIT4: salvou outros 19 (!) Bytes graças a @Quentin (veja seu comentário)

EDIT5: Quentin raspou mais 13 bytes, obrigado!

EDIT6: como TuukkaX apontou, lambdas / funções sem nome são suficientes, então eu removi o auto i=no bytecount

Neop
fonte
5
Não posso ajudá-lo com C ++, mas posso dizer: Bem-vindo ao PPCG!
Zgarb
1
Eu acho que você não precisa dos espaços nas #includelinhas.
Christian Sievers
Oh obrigado Eu só percebi que eu mesmo :)
neop
1
Substituir a função por uma lambda ( auto i=[](auto&l){...};) economiza um byte (mais se contarmos o tipo de retorno que você esqueceu;)), usar em ^ vez de ==e trocar os operandos salva outro. std::listOs iteradores são certamente std::classes, portanto você pode abandonar os std::dois std::counte std::min_elementagradecer a ADL (-10). l.front()também é *b(-7). Acabo com um 120-byte 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
Enquanto estamos nisso, a documentação parastd::min_element afirma que ele retorna o primeiro elemento menor, então find()é supérfluo, ou seja, 11 bytes. No condicional, usar um par de parênteses e o operador de vírgula para coagir a expressão correta inté mais curto do que converter a esquerda em void2 bytes. Isso leva 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 graças a Adnan .

DÙgi0¸«}ÐWksgÝQ+

Experimente online!

Explicação

                      # 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
fonte
Eu acho que isso DÙgi0¸«}ÐWksgÝQ+também funciona.
Adnan
@ Adnan: Aah, boa idéia usando ÝQcom k. Obrigado!
Emigna
5

Scratch, 25 34 blocos + 7 6 bytes

Programa

Recebe a entrada como uma matriz predefinida de números inteiros. Observe que as matrizes são indexadas 1 no Scratch.

No Python, isso seria parecido com: (Observe que, ao contrário do Scratch, o Python é indexado em 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
fonte
Comentários de golfe, por favor?
OldBunny2800
por que você declara fval?
Christoph
Parece-me que Scratch é apenas Python em texto simples com cores ...
Stewie Griffin
E matrizes 1-indexadas e nenhuma declaração elif!
OldBunny2800
1
Bom ponto @Christoph! Fazia parte de uma versão anterior que foi jogada fora. Edição.
OldBunny2800
4

J, 25 22 bytes

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

Avalia para um verbo anônimo. Experimente Online!

Explicação

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

MATL , 16 bytes

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

Experimente online! Ou verifique todos os casos de teste

Como 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
fonte
3

Mathematica, 56 bytes

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

Usa a função nomeada ±. Usa codificação ISO8859-1

Soluções 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
fonte
3

Haskell, 71 70 62 bytes

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

O @Zgarb salvou 8 bytes, obrigado!

Quando comecei, eu esperava alguns truques elegantes de amarrar os nós, mas o jeito de @ Zgarb é igualmente incrível.

Peneiradores cristãos
fonte
Alguma reestruturação, 62 bytes:f(a:b)|(x,y:z)<-span=<<(<).minimum$a:b++[0|all(a==)b]=x++y+1:z
Zgarb 29/11
@Zgarb Apenas uau!
Christian Sievers
Ugh, meu cérebro não consegue inferir o tipo para a instância mônada de funções
Angs
@ Angs A Mônada é (->)r, aplicada a um tipo é (->)r a = r->a. Então, dos tipos return:: a->r->ae (>>=)::(r->a)->(a->r->b)->(r->b)sua implementação é (ouso dizer?) Óbvio: return=conste m>>=f = \r->f(m r)r. O último é exatamente o que é necessário para expressar algo como, span(predicate_depending_on l)lenquanto menciona lapenas uma vez. Agora eu só preciso me lembrar quando precisar.
Christian Sievers
@ Angs Você pode encontrar esse truque e muito mais em nossa coleção de dicas de golfe em 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 o argumento passado para a função.

Agradecimentos a Cyoce por economizar 3 bytes! -> !Anypara All, +=1para ++.

Agradecemos a TheLethalCoder por salvar 43 bytes! -> Código de assinatura do método removido. Parênteses removidos ao redor da lista de parâmetros.

Yytsi
fonte
você poderia substituir !l.Any(o=>o!=l[0]))com l.All(o=>o==l[0])?
Cyoce
@ Cyy Realmente faz. Pensei na mesma coisa, mas escrevi em Anyvez de Alle estava pensando que não funciona: D Obrigado!
Yytsi
2
C # não tem ++?
Cyoce
Você pode compilar a um Action<List<int>>para remover todo o código assinatura do método
TheLethalCoder
1
@Stefan Hmm. Também já vi muitas pessoas eliminando os usings necessários com C #, então não confio que seja legal desistir using System.Linq. A menos que eu veja uma declaração explícita que diga que isso não é necessário, eu continuarei com isso. Obrigado pela sugestão! :)
Yytsi 01/12/16
2

Perl 6 , 46 bytes

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

(modifica a matriz de entrada e a retorna)

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
fonte
2

Geléia, 9 bytes

;1µ‘i¦E?Ṃ

Obrigado a Dennis pelos -2 bytes.

O corpo deve ter pelo menos 30 caracteres; você entrou ...

Zacharý
fonte
Se você tiver caracteres extra para entrar no corpo, é sempre vale a pena explicar o código, o que ajuda a todos para compreendê-lo e torna a resposta mais interessante :)
Alfie Goodacre
2

Mathematica, 53 bytes 57 bytes 59 bytes

If[Equal@@#,#~Join~{1},x=#;x[[#~FirstPosition~Min@#]]++;x]&
ngenisis
fonte
7
Isso é 57 bytes. e são caracteres de 3 bytes. Além disso, seu código não funciona porque {##,1}parte implica que a entrada é um número inteiro separado (ie f[1, 2, 3]), mas a x=#parte implica que a entrada é um List(ie f[{1, 2, 3}]). Uma solução rápida seria mudar x=#para x={#}e aceito inteiros brutos como entrada, tornando o seu código de 59 bytes de comprimento.
JungHwan Min
Boa pegada! Não percebi a distinção entre bytes e contagem de caracteres, apenas vi essa sugestão e achei que era válida. Parece que existem muitas respostas que fornecem a contagem de caracteres, mas se eu as salvar no Notepad ++, recebo uma contagem de bytes mais alta (por exemplo, a resposta Jelly). Vejo que sua resposta especifica uma codificação. Há algum lugar que você recomendaria para eu aprender sobre isso?
Ngenisis
1
Eu acho que você quer dizer Equal@#, embora #==##seja mais curto.
Martin Ender
Você está certo. Fiz uma alteração por @JHM para aceitar vários argumentos em vez de uma lista, mas não propaguei a alteração em todos os lugares. Voltei a aceitar uma lista, uma vez que está mais de acordo com o prompt.
Ngenisis
2

R , 72 66 65 bytes

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

Experimente online!

O incremento é feito usando o which.minque retorna a primeira correspondência. "[<-"permite substituir o valor e retorna o vetor modificado em uma chamada de função.

-7 bytes graças a Giuseppe!

JayCe
fonte
@Giuseppe Tentei IsTrue e IsFalse com sd não é Golfier :(
Jayce
heh, 65 bytes substituindo !=por -!
Giuseppe
@Giuseppe, é claro!
Jayce
1

Ruby, 46 bytes

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

Sinto que há uma maneira melhor de verificar se todos os elementos são iguais a.uniq.size<2, mas estou com preguiça de encontrá-lo.

Lee W
fonte
6
a.uniq[1]será verdade se houver valores distintos.
histocrat
Você pode salvar um byte, transformando-o a[a.index(a.min)]ema[a.index a.min]
Cyoce 29/11
1

Oitava, 69 67 64 bytes

Na verdade, era mais curto tornar essa uma função nomeada completa do que usar as teclas inpute disp.

Economizou 3 bytes graças a Luis.

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

Resposta antiga, sem usar uma função:

[a,b]=min(x=input(''));if any(x-a),x(b)++;else x(end+1)=1;end;disp(x)
Stewie Griffin
fonte
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

Pena que a sintaxe x=+1não existe no 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
Frédéric
fonte
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
fonte
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

Eu sou relativamente novo em codificar golfe, por favor, seja gentil! Tentei usar funções anônimas, mas o Google diz que você não pode usar as instruções if / else e o matlab não possui operadores ternários, portanto, esse é o melhor que senti que poderia fazer.

Edit: Corrigido e encurtado (duas vezes!), Graças a stewie-griffin.

Owen Morgan
fonte
Bem-vindo ao PPCG! Existem algumas falhas neste código. sum(a)/length(a)==a(1)não garante que todos os elementos sejam iguais, apenas mostra que a média é igual a a(1). Uma maneira mais simples de fazer isso seria mean(a)==a(1). numelé um byte menor que length, mas como você sabe que todos os valores são positivos, é possível usar o nnzque é ainda mais curto (ainda não daria o resultado correto nesse desafio, mas é mais curto pelo menos: P). Se você atender a min(a)chamada na frente do loop, poderá usar ambas as saídas e verificar se os allelementos de asão iguais a min(a).
Stewie Griffin
Você está certo! falha quando a média é igual ao número no primeiro elemento. Eu acho que o meu novo está correto e também mais curto. A lógica é que, se os elementos restantes não forem iguais ao primeiro, a (a ~ = a (1)) retornará os elementos restantes que, por definição, são maiores que 0 em uma matriz diferente da mesma. Então contar e não deve dar a lógica correta, eu acho. Se ainda estiver errado, avise-me, só codifico há alguns anos e ainda tenho um longo caminho a percorrer.
Owen Morgan
~nnz(a(a~=a(1)))é simplesmente ~nnz(a-a(1)). Além disso, você não precisa dos parênteses. if ~nnz(a-a(1));a=[a,1];else[~,I]=min(a);a(I)=a(I)+1;end. Isso deve ser 5 bytes mais curto (nota: eu não testei).
Stewie Griffin
Você pode salvar 3 bytes usando em range(a)vez dennz(a-a(1))
MattWH 9/16/16
@boboquack, esse código verifica se o número de elementos aé igual ao menor valor nesse vetor. Um vetor a = [3 4 6]resultará em truee um vetor a = [4 4 6]resultará em false. Eu não acho que será útil aqui ...?
Stewie Griffin
1

Clojure, 112 100 bytes

Infelizmente, min-keyretorna o último índice do menor, não o primeiro. Isso funciona para entradas inteiras e matrizes menores que 10 ^ 9 elementos;)

Editar: definindo uma função anônima, usando em (apply = a)vez 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)))

Uma solução menos invasiva de 134 bytes inverte o vetor antes de atualizá-lo e depois inverte-o novamente:

(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
fonte
1

Java 8, 85 + 38 = 123 bytes

Void lambda usando a List<Integer>(saída com entrada modificada). A contagem de bytes inclui lambda e importação necessária.

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

Experimente Online

Isso quase se parece com o Python com as importações de métodos ...

Jakob
fonte
1

MATLAB, 66 53 bytes

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

Resultado:

Inicializar:

a = [3 2]

Execuções sucessivas:

[3 2] -> [3 3] -> [3 3 1] -> [3 3 2] -> [3 3 3] -> [3 3 3 1] ...
Pon pon holla mon
fonte
2
Você não pode codificar as entradas, seria necessário fazer algo parecido @(x) ….
ბიმო
1

SmileBASIC 3, 101 bytes

Define uma função de instrução I Aonde Aestá nossa matriz inteira de números. A saída é obtida modificando a entrada (como matrizes são referências).

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_
fonte
Você pode salvar 2 bytes substituindo BREAKpor M=0, porque Anão pode conter 0isso M==A[C]nunca será verdade.
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
fonte
0

Pitão, 16 bytes

?tl{QXxQhSQQ1+Q1

Um programa que recebe a entrada de uma lista e imprime o resultado.

Suíte de teste

Como 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
fonte
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;[]#_=[]

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

Tentativa inicial, tentará criar algo mais sofisticado posteriormente.

sudee
fonte
1
Por que não criar uma função separada em vez de usar where?
Michael Klein
0

Maravilha , 44 bytes

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

Não era isso que eu tinha em mente quando criei essa linguagem ... É literalmente pior que o Perl em termos de legibilidade!

Uso:

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

Explicação

Mais legível:

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

Basicamente, verifica se a remoção de 1 item do subconjunto exclusivo do argumento torna a lista vazia. Caso contrário, incrementamos o mínimo da matriz. Caso contrário, simplesmente concatenamos 1 ao argumento.

Mama Fun Roll
fonte
0

Kotlin, 75 bytes

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

Modifica o argumento da função.

Porra, você digitando forte! :MutableList<Int>responde por 17 bytes sozinho. Não acho que exista uma solução em que o tipo possa ser inferido, infelizmente.

Tyler MacDonell
fonte