비어 있지 않은 양의 정수 배열이 주어지면 다음과 같이 한 번 "증가"합니다.

• 모든 배열 요소가 동일 1하면 배열 끝에 a 를 추가합니다 . 예를 들면 다음과 같습니다.

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

• 그렇지 않으면 배열의 최소값 인 배열의 첫 번째 요소를 증가시킵니다. 예를 들면 다음과 같습니다.

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

(각각 ->하나의 증분을 나타내며 모든 프로그램에서 수행해야합니다.)

결과 증분 배열을 출력합니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

젤리 , 8 7 바이트

‘;ṀỤḢṬ+

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

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

파이썬 3, 62 53 51 50 바이트

전달 된 목록을 수정하는 함수 ( meta에 의해 허용됨 ).

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

repl.it 에보십시오!

Lynn은 -9 바이트 덕분에 배열이 양의 정수이기 때문에 배열 끝에 '0'을 추가하고 증가시킬 수 있다는 점을 발견했습니다.

골프 len(set(a))를 len({*a})위한 mbomb007, floordiv 트릭을위한 Dennis 에게 특별한 감사를드립니다 !

자바 스크립트 (ES6), 61 바이트

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

인수 를 수정하여 출력합니다 . 배열에 17 바이트 미만의 고유 항목이 하나만 있는지 여부를 확인할 수있는 방법을 찾을 수 없지만 제안은 환영합니다.

테스트 스 니펫

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>

다른 시도

배열에 둘 이상의 고유 한 입력이 있는지 여부를 결정하는 몇 가지 대체 방법이 있습니다.

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)

의 두 some들로 대체 할 수 find뿐만 아니라. .sort기본 정렬이 사전식이 아닌 경우 최소값을 찾는 것이 더 짧습니다 (왜, JS, 왜?).

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)

최소를 찾기 위해 재귀를 시도했지만 더 길어졌습니다.

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

그리고 처음에는 좋은 생각처럼 보이는 문자열 기반 솔루션이 있습니다 (입력은 문자열의 배열 형식으로 제공됩니다 "[1,2,3]").

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

Mathematica, 70 57 55 바이트

거의 모든 개선 사항은 패턴 일치 접근 방식에서 내 엉덩이를 차고있는 Martin Ender에 의한 것입니다! 또한 JHM은 본질적으로 동시에 동일한 솔루션을 제시했습니다. (바이트 수는 ASCII 인코딩을 사용합니다)

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

±하나의 목록 인수를 취하는 함수 를 정의합니다 . 해당 목록 인수에 동일한 요소 (감지 x_..및 이름이 지정된 p) 의 사본이 몇 개 포함 1된 경우 추가 된 목록을 출력하십시오 . 그렇지 않으면, 그 목록 인자는 특정 요소가 있으면 y(함께 x전에 제로 이상의 원소 인 y한 z후, 0 개 이상의 원소 인 y많아야 한 다음 다른 원소의 최소 출력이 함께 목록) y증가한다. 목록의 최소 요소의 모든 인스턴스는과 일치 y하지만 다행스럽게도 Mathematica는 첫 번째 요소를 선택합니다.

C ++ 14, 178176174155142135 바이트

제출

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

기도

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

언 골프

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

이것은 골프를 처음하는 사람입니다. 도움을 주셔서 감사합니다.

편집 : 적어도 컴파일해야한다는 것을 잊어 버렸습니다. -std=c++11 -std=c++14

EDIT2 : 포함에 공백을 남길 수 있음을 깨달았습니다. #include <list>

EDIT3 :로 교체 l.begin()하여 두 바이트를 더 절약 했습니다.begin(l)

EDIT4 : @Quentin 덕분에 19 (!) 바이트를 더 절약했습니다 (댓글 참조)

EDIT5 : Quentin이 13 바이트를 더 줄였습니다. 감사합니다!

EDIT6 : TuukkaX가 지적했듯이 이름이없는 람다 / 함수로 충분하므로 바이트 수 auto i=에서

05AB1E , 21 20 16 바이트

Adnan 덕분에 4 바이트를 절약했습니다 .

DÙgi0¸«}ÐWksgÝQ+

온라인으로 사용해보십시오!

설명

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

스크래치, 25 34 블록 + 7 6 바이트

사전 정의 된 정수 배열로 입력을받습니다. Scratch에서 배열은 1- 인덱싱됩니다.

파이썬에서 이것은 다음과 같습니다 : (Scratch와는 달리, 파이썬은 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 바이트

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

익명 동사를 평가합니다. 온라인으로 사용해보십시오!

설명

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

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

작동 원리

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

매스 매 티카, 56 바이트

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

명명 된 함수를 사용합니다 ±. ISO8859-1 인코딩 사용

대체 솔루션 (58 바이트)

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

용법

±{1, 1}

{1, 1, 1}

±{3, 4, 5}

{4, 4, 5}

하스켈, 71 70 62 바이트

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

@ Zgarb는 8 바이트를 절약했습니다. 감사합니다!

내가 시작했을 때 나는 우아한 매듭 속임수를 원했지만 @Zgarb의 방법은 놀랍습니다.

C 번호, 123 (121) 120 79 77 바이트

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

함수에 전달 된 인수를 수정합니다.

3 바이트를 절약 한 Cyoce 에게 감사드립니다 ! -> !Any에 All, +=1에 ++.

무려 43 바이트를 절약 해 준 TheLethalCoder 에 감사드립니다 ! -> 메소드 서명 코드가 제거되었습니다. 매개 변수 목록에서 괄호를 제거했습니다.

펄 6 , 46 바이트

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

(입력 배열을 수정하고 반환합니다)

넓히는:

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

젤리, 9 바이트

;1µ‘i¦E?Ṃ

-2 바이트의 Dennis에게 감사합니다.

본문은 30 자 이상이어야합니다. 입력했습니다 ....

Mathematica, 53 바이트 57 바이트 59 바이트

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

R , 72 66 65 바이트

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

온라인으로 사용해보십시오!

증분은 which.min첫 번째 일치 항목을 반환 하여 사용 됩니다. "[<-"하나의 함수 호출에서 값을 바꾸고 수정 된 벡터를 반환합니다.

주세페 덕분에 -7 바이트!

루비, 46 바이트

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

모든 요소 a.uniq.size<2가과 같은지 확인하는 더 좋은 방법이 있다고 생각 하지만 찾을 수 없습니다.

옥타브, 69 67 64 바이트

실제로 input와 를 모두 사용하는 것보다 완전한 이름의 함수로 만드는 것이 더 짧았습니다 disp.

Luis 덕분에 3 바이트를 절약했습니다.

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

함수를 사용하지 않는 이전 답변 :

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

R, 97 바이트

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

synthax x=+1가 R에 존재하지 않아서 너무 나쁩니다 !

언 골프 :

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 기본, 53 바이트

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 바이트

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

저는 골프 골프를 처음 접하기 때문에 친절하세요! 익명 함수를 사용하려고했지만 인터넷 검색에 따르면 if / else 문을 사용할 수 없으며 matlab에 삼항 연산자가 없으므로 이것이 내가 할 수 있다고 생각하는 최선이라고 생각합니다.

편집 : stewie-griffin 덕분에 수정되고 단축되었습니다 (두 번!).

Clojure에서, 112 100 바이트

불행히도 min-key첫 번째 인덱스가 아닌 가장 작은 인덱스의 마지막 인덱스를 반환합니다. 이것은 정수 입력과 10 ^ 9 요소보다 짧은 배열에서 작동합니다.)

편집 : 사용, 익명 함수를 정의하는 (apply = a)대신 (= 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)))

기발한:

(defn f[a](if(= 1(count(set a)))(conj a 1)(update a(apply min-key #(+(nth a %)(* % 1e-9))(range(count a)))inc)))

덜 해킹 된 134 바이트 솔루션은 업데이트하기 전에 벡터를 뒤집은 다음 다시 뒤집습니다.

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

자바 8, 85 + 38 = 123 바이트

무효 람다는 List<Integer>(출력은 변경 입력입니다). 바이트 수에는 람다 및 필수 가져 오기가 포함됩니다.

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

온라인으로 사용해보십시오

이것은 메소드 가져 오기가있는 Python과 거의 같습니다 ...

MATLAB, 66 53 바이트

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

산출:

초기화 :

a = [3 2]

연속 실행 :

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

SmileBASIC 3, 101 바이트

성명 기능 정의 숫자의 우리의 정수 배열입니다. 출력은 입력을 수정하여 달성됩니다 (배열은 참조이므로).I AA

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 바이트

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 바이트

?tl{QXxQhSQQ1+Q1

리스트를 입력 받아 결과를 출력하는 프로그램입니다.

테스트 스위트

작동 원리

?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                    

하스켈, 93 바이트

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

언 골프 드 :

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

초기 시도는 나중에 더 정교한 것을 시도합니다.

Wonder , 44 바이트

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

이것은 내가이 언어를 만들 때 염두에 두었던 것이 아닙니다 ... 가독성 측면에서 말 그대로 Perl보다 나쁩니다!

용법:

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

설명

더 읽기 쉬운 :

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

기본적으로 인수의 고유 서브 세트에서 1 개의 항목을 삭제하면 목록이 비어 있는지 확인합니다. 그렇지 않은 경우 배열의 최소값을 증가시킵니다. 그렇지 않으면 우리는 단순히 인수에 1을 연결합니다.

코 틀린, 75 바이트

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

함수 인수를 수정합니다.

강하게 타이핑하세요! :MutableList<Int>17 바이트 만 차지합니다. 불행히도 유형을 유추 할 수있는 솔루션이 있다고 생각하지 않습니다.