Stack Overflow 에 대한 질문 에서 영감을 얻었습니다 . 여기서 제목은 전적으로 내 잘못입니다.

도전

두 개 이상의 항목을 포함하는 양의 정수 목록이 제공되면 각 숫자를 자신을 제외한 모든 항목의 최소값으로 바꾸십시오.

테스트 사례

[4 3 2 5]    ->  [2 2 3 2]
[4 2 2 5]    ->  [2 2 2 2]
[6 3 5 5 8]  ->  [3 5 3 3 3]
[7 1]        ->  [1 7]
[9 9]        ->  [9 9]
[9 8 9]      ->  [8 9 8]

규칙

알고리즘은 이론적으로 모든 입력 크기 (1 이상) 및 값 (양의 정수)에 대해 작동해야합니다. 프로그램이 시간, 메모리 또는 데이터 유형에 의해 제한되어 허용되므로 주어진 값까지의 숫자 또는 주어진 값까지의 입력 크기에 대해서만 작동합니다.

모든 프로그래밍 언어의 프로그램 또는 기능 이 허용 됩니다 . 표준 허점 은 금지되어 있습니다.

합리적인 수단으로 입력 할 수 있습니다 . 그리고 어떤 형식으로. 출력과 동일합니다. 입력 및 출력 형식이 다를 수 있습니다.

바이트 단위의 최단 코드가 이깁니다.

젤리 , 9 6 5 바이트

JḟÐ €`ị⁸Ṃ € 
ṙJṖ € Ṃ €
ṙJṖ«/ argument : 1D 배열 (z)

 J [1,2,3, ..., len (z)]
amount 위의 양만큼 z를 회전시킵니다 (현재 배열은 2D입니다)
  array 마지막 배열을 제거
   «/ 최소한의 벡터로 축소

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

한 번에 모두 확인하십시오! (약간 수정 됨)

나는 Dennis가 이것을 밖으로 골라 낼 수 있다고 확신한다.

작동 원리

알고리즘은 다소 복잡합니다. 이것이 무엇을하는지 관찰하자 [4,2,2,5].

먼저 우리는를 J얻는 데 사용 합니다 [1,2,3,4]. Jelly는 1- 인덱싱을 사용합니다.

그런 다음을 참조하십시오 ṙ. 배열과 정수라는 두 가지 인수가 필요합니다. 정수로 지정된 양만큼 배열을 왼쪽으로 회전합니다. 여기에, ṙ볼 것이다 [4,2,2,5]그것의 왼쪽과 [1,2,3,4](이 작품은에서 찾을 수 있습니다 방법에 대한 자세한 오른쪽에 튜토리얼 ). Jelly에서는 명령이 암시 적으로 벡터화됩니다. 따라서이 명령은 오른쪽의 각 개별 요소에 대해 수행되므로 2D 배열을 만드는 것입니다.

따라서, [4,2,2,5]ṙ[1,2,3,4]이된다 [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4]해지는 :

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2],
 [4,2,2,5]]

원래 요소는 마지막 행에 있습니다.이 행에서 배열의 길이와 같은 양만큼 왼쪽으로 회전했기 때문에 Ṗ다음 행을 제거 하여 다음 행을 사용하여 열이 현재 색인에없는 배열 요소 :

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2]]

다음 작업 «/도 상당히 복잡합니다. 먼저 «왼쪽과 오른쪽에 보이는 두 숫자의 최소값을 반환합니다. 예를 5«3들어을 반환합니다 3. 이제 두 인수가 배열이면 위에서 말한 것처럼 벡터화됩니다. 이것이 의미하는 바 [1,5,2,3]«[4,1,5,2]는 [1«4,5«1,2«5,3«2]어느 것입니다 [1,1,2,2]. 이제 /is reduce입니다. 즉, 각 행에서 끝까지 작업을 수행합니다. 예를 들어, [1,2,3,4]+/는 ((1+2)+3)+4배열의 합이됩니다 [1,2,3,4].

«/방금 얻은 2D 배열에 적용 하면 다음과 같은 결과를 얻습니다.

([2,2,5,4]«[2,5,4,2])«[5,4,2,2]

벡터화로 인해 다음과 같습니다.

[2«2«5,2«5«4,5«4«2,4«2«2]

인덱스에 요소가없는 모든 배열의 최소값을 계산합니다.

파이썬 2 , 41 바이트

lambda l:[sorted(l)[x==min(l)]for x in l]

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

각 요소에 x대해 우리는 여부를 확인합니다 x==min(l). 그렇지 않은 경우이 요소 는 목록 인덱스로 사용될 때로 False처리되어 가장 작은 요소를 제공합니다. 그렇지 않으면, 요소 자체가 가장 작고 무시해야하기 때문에 두 번째로 작은 요소를 제공하는 일명 입니다.0sorted(l)True1

젤리 , 5 바이트

=Ṃ‘ịṢ

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

어떻게?

=Ṃ‘ịṢ - Main link: list a     e.g.  [4,3,2,5]
 Ṃ    - minimum of a                2
=     - equals? (vectorises)        [0,0,1,0]
  ‘   - increment                   [1,1,2,1]
    Ṣ - sort a                      [2,3,4,5]
   ị  - index into                  [2,2,3,2]

하스켈 , 42 41 39 바이트

편집하다:

• nimi 덕분에 -1 바이트!
• -2 바이트 xnor에게 감사드립니다! 그리고 혼자서.

f정수 (또는 모든 Ord유형) 목록을 가져 와서 목록을 반환합니다.

f(x:y)=minimum y:(fst<$>zip(f$y++[x])y)

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

f목록을 회전하는 동안 되풀이됩니다. x첫 번째 목록 요소와 y나머지입니다. 재귀는 무한하기 때문에, 결과 목록의 요구가 차단되는 : fst<$>zip...y말하는 짧은 방법입니다 take(length y)....

옥타브, 26 바이트

@(x)sort(x)((x==min(x))+1)

이 답변에 사용 된 것과 유사한 접근 방식 이 이와 동일 합니다 .

나는 실제로 다른 답변을 포팅하는 팬이 아니므로 다른 답변을보기 전에 비슷한 아이디어가 있다는 것을 알고 싶습니다.

설명:

Jonathan Allan은 이미 Jelly 코드에 대한 좋은 설명을 제공 했으므로 옥타브 비트와 그 이유와 MATLAB에서 작동하지 않는 이유에 대해 설명합니다.

@(x)                       % An unnamed anonymous function taking a vector x as input
    sort(x)                % Gives a sorted version of x
            (x==min(x))    % Checks if each element is equal to the minimum value
           ((x==min(x))+1) % Adds 1 to the boolean vector, to use as indices
@(x)sort(x)((x==min(x))+1) % Complete function

인라인 할당 및 직접 인덱싱이 작동하지 않으므로 MATLAB에서는 작동하지 않습니다. sort(x)(1)정렬 된 벡터의 첫 번째 요소가 아니라 MATLAB에 오류가 발생합니다.

하스켈, 41 바이트

a#(b:c)=minimum(a++c):(b:a)#c
a#b=b 
([]#)

사용 예 : ([]#) [4,3,2,5]-> [2,2,3,2]. 온라인으로 사용해보십시오!

빈 누산기로 시작 a하여 입력 목록을 아래로 내리십시오. 출력 목록의 다음 요소는 누산기의 최소값 a과 입력 목록의 첫 번째 요소 (-> c)를 제외한 모든 요소에 이어 첫 번째 요소 b가 누산기에 추가 된 재귀 호출 및 c입니다. 입력 목록 끝에 도달하면 중지하십시오.

자바 스크립트 (ES6), 50 46 바이트

a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))

편집 : @Arnauld 덕분에 4 바이트가 절약되었습니다.

Brachylog , 13 12 바이트

l+₁:?⊇ᶠ⁽⌋ᵐb↔

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

@ ais523 덕분에 1 바이트를 절약했습니다.

설명

l+₁:?            The list [length(Input) + 1, Input]
     ⊇ᶠ⁽         Find the length(Input) + 1 first subsets of the Input
        ⌋ᵐ       Get the min of each subset 
           b↔    Remove the first element and reverse

우리는 ⊇서브셋을 가장 큰 것에서 가장 작은 것으로 통합 한다는 사실을 이용합니다 . 예를 들어 [1,2,3], 우리가 얻는 서브셋은 다음 순서로되어 [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], []있습니다.

우리는 하위 집합 [1,2], [1,3], [2,3]이 원하는 최소 항목이지만 입력 목록과 비교하여 역순 임을 알 수 있습니다 (따라서 ↔). 첫 번째 length(Input) + 1하위 집합 을 찾아야 만 하위 집합을 선택할 수 있습니다. 첫 번째 하위 집합은 모두 + 전체 목록을 먼저 포함합니다. 로 전체 목록을 버립니다 b.

실제로 13 바이트

;;S╝m╗⌠╜=╛E⌡M

xnor도 발견 한 것과 동일한 기술을 사용합니다 .

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

설명:

;;S╝m╗⌠╜=╛E⌡M
;;             make two extra copies of input list
  S╝           sort one and save it in register 1
    m╗         save the minimum of the other in register 0
      ⌠╜=╛E⌡M  for each value in list:
       ╜=╛E      return the minimum element of the input list if the value is not equal to the minimum, else return the second-smallest element

R, 46 31 바이트

l=scan();sort(l)[(min(l)==l)+1]

R에 Stewie Griffin의 솔루션 을 구현합니다 . 아아, 내 원래 아이디어는 50 % 더 길었습니다! 여전히 stdin에서 목록을 읽지 만 훨씬 더 읽기 쉬운 숫자 형 벡터를 반환합니다.

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

오래된 구현 :

l=scan();Map(function(x)min(l[-x]),match(l,l))

stdin에서 목록을 읽습니다. 음수 인덱스 l[-x]는 목록에서 요소를 제외하고 목록 match(l,l)의 각 요소가 처음 나타나는 인덱스를 반환합니다. 리스트를 돌려줍니다.

파이썬 2, 51 바이트

이미 더 나은 Python 솔루션이 있다는 것을 알고 있지만 여전히 게시하고 싶습니다.

lambda L:[min(L[:i]+L[i+1:])for i in range(len(L))]

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

매스 매 티카 34 바이트

Min[#~Drop~{i}]~Table~{i,Tr[1^#]}&

PowerShell , 68 59 바이트

($a=$args)|%{$b+=@((($c=$a|sort)[0],$c[1])[$_-eq$c[0]])};$b

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

나는 그것이 단축 될 수 있다고 확신합니다, 나는 그것을 계속 볼 것입니다

C, 85 바이트

i,j,m;f(d,o,n)int*d,*o;{for(i=n;i--;)for(m=d[!i],j=n;j;o[i]=m=--j^i&&d[j]<m?d[j]:m);}

첫 번째 인수는 입력 정수 배열입니다. 두 번째 인수는 출력 정수 배열입니다. 세 번째 인수는 두 배열의 요소 개수입니다.

온라인에서 작동 하는지 확인하십시오 .

펄 6 ,  26 24  19 바이트

26

{.map: (.Bag∖*).min.key}

참고 ∖U + 2,216되지 \U + 5C

시도 해봐

{.map: (.Bag⊖*).min.key}

시도 해봐

24

{(.min X%$_)X||.sort[1]}

시도 해봐

19

{.sort[.min X==$_]}

시도 해봐

26

{           # bare block lambda with implicit parameter ｢$_｣

  .map:     # for each of the values in the input (implicit method call on ｢$_｣)
  (
    .Bag    # turn the block's input into a Bag
    ∖       # set-difference           ｢∖｣ U+2216 aka ｢(-)｣
    # ⊖     # symmetric-set-difference ｢⊖｣ U+2296 aka ｢(^)｣
    *       # turn expression into a WhateverCode lambda (this is the parameter)
  ).min.key # get the minimum pair from the Bag, and return its key
}

나는 메소드 호출의 일부로 파싱되지 않도록하기 전에 공백이 필요했기 때문에 ASCII 동등 물 대신 "팬시"유니 코드 연산자를 사용했다 .Bag.

24

{
  (.min X% $_) # the minimum cross modulus-ed with the input
  X||          # cross or-ed 
  .sort[1]     # with the second minimum
}

19

{
  .sort\        # sort the values
  [             # index into that
    .min X== $_ # the minimum cross compared with the input
  ]
}

(24 및 19 바이트 골프는 젤리 구현에서 영감을 얻었습니다 )

클로저, 36 81 62 71 바이트

최신 (실제로 서둘러 제출하지 않아야 함) :

#(for[c[(zipmap(range)%)]i(sort(keys c))](apply min(vals(dissoc c i))))

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

Aaaand 이것은 버그 (62 바이트)를 가지고 있으며 zipmap은 정렬되지 않은 맵을 생성하므로 더 큰 입력에서 올바른 시퀀스를 생성하지 않습니다.

#(for[c[(zipmap(range)%)][i v]c](apply min(vals(dissoc c i))))

v실제로는 아무것도 사용되지 않지만 이보다 짧습니다 i (keys c).

81 바이트 이전

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

#(let[r(range(count %))](for[i r](apply min(for[j r :when(not= i j)](nth % j)))))

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

아 젠장 원래는 (36 바이트)의 최소 번호가 반복 될 때 작동하지 않습니다 [4 2 2 5]에 결과를 [2 4 4 2]모두로 2의이 제거 :(

#(for[i %](apply min(remove #{i}%)))

#{i}은을 포함하는 집합이며 i, i다른 사람들에게는 진실하고 거짓을 반환 합니다. 즉, 입력 목록 내의 다른 모든 숫자에서 최소값이 계산됩니다.

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

Pyth, 8 7 바이트

mh.-SQ]

@isaacg 덕분에 -1 바이트

시도 해봐!

PHP, 72 바이트

<?$k=$g=$_GET;sort($k);foreach($g as&$v)$v=$k[$v==$k[0]?:0];print_r($g);

온라인 버전

PHP, 47 바이트

while(++$i<$argc)echo@min([z,$i=>z]+$argv),' ';

스칼라, 37 바이트

l.indices map(i=>l diff Seq(l(i))min)

l Int의 모든 모음입니다.

테스트 사례 :

scala> val l = List(4,3,2,5)
l: List[Int] = List(4, 3, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 3, 2)

scala> val l = List(4,2,2,5)
l: List[Int] = List(4, 2, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 2, 2)

scala> val l = List(6,3,5,5,8)
l: List[Int] = List(6, 3, 5, 5, 8)

scala> l.indices map(i=>l diff Seq(l(i))min)
res2: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 5, 3, 3, 3)

scala> val l = List(7,1)
l: List[Int] = List(7, 1)

scala> l.indices map(i=>l diff Seq(l(i))min)
res3: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 7)

scala> val l = List(9,9)
l: List[Int] = List(9, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res4: scala.collection.immutable.IndexedSeq[Int] = Vector(9, 9)

scala> val l = List(9,8,9)
l: List[Int] = List(9, 8, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res5: scala.collection.immutable.IndexedSeq[Int] = Vector(8, 9, 8)

이것은 여전히 ​​골프 일 수 있습니다. 목록에서 요소를 제거하는 더 짧은 방법을 찾을 수 없었습니다. l diff Seq(l(i))

C #, 36 바이트

i.Select((x,a)=>i.Where((y,b)=>b!=a).Min())

요소 (i)를 가져 와서 현재 항목이없는 요소를 최소값으로 찾습니다.

우리가 원시 유형으로 작업 할 때 다른 시도가 작동하지 않아서 항목을 비교할 참조가없는 목록이 없다는 것은 슬픈 일입니다.

PowerShell , 49 38 바이트

^{mazzy 덕분에 -11 바이트}

($a=$args)|%{($c=$a|sort)[$_-eq$c[0]]}

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

정현파의 사랑스러운 답변 개선 . 배열을 작성하는 대신 명시 적 출력을 사용하여 10 바이트를 절약합니다. 조건이 참이면 스폿 0 (즉, 가장 작은 값) 또는 스폿 1로 정렬 된 배열에 인덱스합니다.

펄 5, 43 바이트

sub{@x=sort{$a<=>$b}@_;map$x[$_==$x[0]],@_}

파이썬 솔루션과 동일합니다. 펄입니다 sort불행하게도 숫자에 대한 잘못된 기본 (명시 적 비교를 요구하는)을 가지고 있으며, min내장 된 것이 아니라, 거의하여 보상 해 sub보다 짧은되는 lambda, map$_,보다 짧은되는 x for x in, 그리고 반환 및 인수 목록의 implicitness.

루비, 30 바이트

각 요소에 대해 배열을 정렬하고 현재 요소를 제거하고 나머지 배열의 첫 번째 요소를 가져옵니다.

->a{a.map{|e|(a.sort-[e])[0]}}

다음과 같이 사용할 수있는 익명 함수입니다.

f = ->a{a.map{|e|(a.sort-[e])[0]}}
p f[[6, 3, 5, 5, 8]] # => [3, 5, 3, 3, 3]

CJam, 15 바이트

{:S{S:e<=S$=}%}

본질적으로 xnor의 알고리즘을 CJam으로 변환합니다.

스택에서 배열을 가져와 스택에 결과를 남기는 명명되지 않은 블록입니다.

설명:

{
  :S     e# Save in S
  {      e# For X in S:
    S:e< e#   Push Min(S)
    =    e#   X == Min(S)
    S$=  e#   Sorted(S)[top of stack]
  }%     e# End
}

05AB1E , 5 바이트

{sWQè

@xnor 의 Python 2 답변 포트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

{        # Sort the (implicit) input-list
         #  i.e. [4,1,3,6] → [1,3,4,6]
 s       # Swap, so the (implicit) input-list is at the top of the stack again
  W      # Get the minimum without popping from the list
         #  i.e. [4,1,3,6] → 1
   Q     # Check for each element if they are equal to this value (1/0 as truthy/falsey)
         #  i.e. [4,1,3,6] and 1 → [0,1,0,0]
    è    # Use these 0s and 1s to index in the sorted list
         #  i.e. [1,3,4,6] and [0,1,0,0] → [1,3,1,1]

자바 8, 119 바이트

a->{int t[]=a.clone(),m=a[0],i=a.length;for(int x:a)m=x<m?x:m;for(java.util.Arrays.sort(t);i-->0;)a[i]=t[a[i]==m?1:0];}

@xnor 의 Python 2 답변 포트 .

바이트를 절약하기 위해 새로운 것을 반환하는 대신 입력 배열을 수정합니다.

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

설명:

a->{                  // Method with integer-array parameter and no return-type
  int t[]=a.clone(),  //  Make a copy of the input-array
      m=a[0],         //  Minimum `m`, starting at the first value of the input-array
      i=a.length;     //  Index-integer, starting at the length of the input-array
  for(int x:a)        //  Loop over the input-array
    m=x<m?            //   If the current item is smaller than the current `m`
       x              //    Replace `m` with this value
      :               //   Else:
       m;             //    Leave `m` the same
  for(java.util.Arrays.sort(t);
                      //  Sort the copy we've made of the input-array
      i-->0;)         //  Loop `i` in the range (length, 0]
    a[i]=             //   Modify the item at index `i` of the input-array to:
      t[              //    The item in the sorted array at index:
        a[i]==m?      //     If the current item and the minimum are equal:
         1            //      Use index 1 in the sorted array
        :             //     Else:
         0];}         //      Use index 0 in the sorted array

APL (Dyalog Extended) , 7 바이트

xnor의 Python 2 답변 포트. 요구 ⎕IO←0사항 :

∧⊇⍨⊢=⌊/

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

설명:

∧⊇⍨⊢=⌊/  ⍝ Monadic function train
      ⌊/  ⍝ The minimum element of the input
    ⊢=    ⍝ Element-wise compare the input to the above
          ⍝ Results in a boolean vector, let's call it "X"
∧         ⍝ Sort the input
 ⊇⍨      ⍝ Index into sorted input by X

하스켈 , 76 바이트

이것은 이전 Haskell 항목보다 상당히 길지만 선형 수의 비교와 선형적인 추가 작업 만 수행하는 첫 번째 항목입니다.

f(x:y)|(z,w)<-x!y=z:w
a![x]=(x,[a])
a!(x:y)|(p,q)<-a#x!y=(x#p,a#p:q)
(#)=min

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

설명

!최소 및 비 공백 목록이라는 두 가지 인수를 사용합니다. 목록의 최소값과 실행중인 최소값을 사용하여 주어진 목록을 처리 한 결과를 리턴합니다.

MathGolf , 9 7 바이트

s_╓?m=§

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

설명

기본적으로 Kevin Cruijssen의 05AB1E 답변 포트이지만 명시 적으로 수행해야하므로 2 바이트가 손실됩니다.

s         sort(array)
 _        duplicate TOS
  ╓       minimum of two elements, min of list, minimum by filter
   ?      rot3 pops input on top of stack again
    m=    explicit map to check equality
      §   get from sorted array for each