일반화 된 어레이 리플

22

주를 시작하는 간단한 골프! 기본 배열 B , 값 배열 V 및 인덱스 배열의 세 가지 배열이 제공 됩니다I . 값이 다른 배열을 생성해야합니다.VB에서 지정한 색인에 이 삽입되는 합니다 I. 예를 들면 다음과 같습니다.

Base:    [5, 1, 4, 1, 3]
Values:  [0, 0, 7]
Indices: [5, 0, 3]

인덱스는 기본 배열에서 다음 위치를 가리 킵니다.

[ 5, 1, 4, 1, 3 ]
 ^        ^    ^
 0        3    5

따라서 값 배열에서 해당 요소를 삽입하면 결과는 다음과 같아야합니다.

[0, 5, 1, 4, 7, 1, 3, 0]

규칙

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받아 프로그램 또는 함수를 작성하고 STDOUT (또는 가장 가까운 대안), 함수 리턴 값을 통해 또는 B매개 변수 로 지정된 배열을 수정하여 결과를 출력 할 수 있습니다. .

제출이 기능인 경우 I 와 V어떤 방식으로 수정 될 수있다,뿐만 아니라 B경우는 출력을 위해 사용되지 않습니다.

입력에 대해 다음과 같은 가정을 할 수 있습니다.

  • 기본 및 값 배열의 모든 요소는 음이 아닌 정수입니다.
  • 값 배열은 기본 배열보다 최대 하나 이상의 요소를 갖습니다.
  • 값 배열과 인덱스 배열은 같은 수의 요소를 갖습니다.
  • 인덱스 배열에는 반복 인덱스가 포함되지 않으며 모든 인덱스의 범위가됩니다.
  • 기본 및 값 배열 은 에는 반복되는 요소 포함될 있습니다.
  • 일부 또는 모든 어레이가 비어있을 수 있습니다.
  • 지수가 특정 순서로 주어진다고 가정해서는 안됩니다.
  • 편리하고 명확한 문자열 또는 목록 형식으로 입력을 받고 출력을 생성 할 수 있습니다. 3 개의 배열을 다른 순서로 받도록 선택할 수도 있습니다.
  • 0 기반 및 1 기반 색인 중에서 선택할 수 있습니다.

이것은 코드 골프이므로 가장 짧은 대답 (바이트)이 이깁니다.

테스트 사례

B V I => Result0 기반 색인 형식으로 제공됩니다. 1 기반 인덱싱을 사용하는 경우 세 번째 배열의 요소를 1 씩 증가시킵니다.

[] [] [] => []
[] [1] [0] => [1]
[1,2] [] [] => [1,2]
[1,2] [3] [0] => [3,1,2]
[1,2] [3] [1] => [1,3,2]
[1,2] [3] [2] => [1,2,3]
[0,0,0] [1,1,1,1] [0,1,2,3] => [1,0,1,0,1,0,1]
[5,1,4,1,3] [0,0,7] [5,0,3] => [0,5,1,4,7,1,3,0]
[1,2,3,4] [4,3,2,1] [4,0,3,1] => [3,1,1,2,3,2,4,4]

다른 흥미로운 사례를 발견하면 알려 주시면 추가하겠습니다.

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

코드 스 니펫 표시

code-golf  array-manipulation 
— 마틴 엔더
소스
4
NULL빈 배열이있는 언어의 빈 배열에 대해 어떻게 생각 NULL하십니까?
— Alex A.
@AlexA. 해당 언어로 된 빈 배열의 공통적 / 표현 이라면 괜찮습니다.
— 마틴 엔더
3
간단한 골프 ? 내가 일주일 내내 CJam에서 한 가장 어려운 일입니다. : P
— Dennis

답변:

13

Pyth, 14 바이트

s.icFPQmedSCtQ

데모.

이 프로그램은 입력을 Base, Index, Values ​​순서로 3 개의 튜플 목록으로 가져옵니다.

예에 대한 설명 [5, 1, 4, 1, 3], [5, 0, 3], [0, 0, 7]:

  1. 입력 : 암시 적, Q는 입력입니다.

  2. 인덱스, 값 쌍을 만듭니다. CtQ=[(5, 0), (0, 0), (3, 7)]

  3. 쌍을 증가하는 색인 ​​순서로 정렬하십시오. SCtQ=[(0, 0), (3, 7), (5, 0)]

  4. 각 쌍에서 값을 가져옵니다. medSCtQ=[0, 7, 0]

  5. 지수의 위치에서 기준리스트를 분할합니다. cFPQ=[[], [5, 1, 4], [1, 3], []]

  6. 인터리브 3과 4 .icFPQmedSCtQ=[[], 0, [5, 1, 4], 7, [1, 3], 0, []]

  7. 하나의 목록으로 결합 : s.icFPQmedSCtQ=[0, 5, 1, 4, 7, 1, 3, 0]

— 아이작
소스
조금도. 언제부터 인터리브 방식을 사용합니까? 그냥 게시하고 싶었습니다 ssC,cFPQamedSCtQ].
— Jakube
5
@Jakube isaac sneakily이 (가) 6 일 전에 커밋했습니다.
— orlp
— isaacg
3
Pyth 이후 @Jakube는 어떤 문제를 해결하기 위해 성장할 수 있습니다. 이것이 골프 언어의 문제입니다. 비의 언어를 위해 비의 언어가 존재한다. 그것들은 나중에 디자인 되었기 때문에.
— sentiao 7:19에
@sentiao 공정하게 말하면, 호스트 언어 (Python)는 한동안 다른 이름으로 인터리빙 했습니다.
— Mego 2016 년
16

파이썬 2, 54

lambda B,*X:map(B.insert,*zip(*sorted(zip(*X))[::-1]))

로 입력을 B,I,V받습니다. B호출 될 때 입력을 수정합니다 (마틴 부트 너에게 이것이 가능하다는 것을 알려 주셔서 감사합니다).

각 인덱스 / 요소 쌍 map을 호출 B.insert하는 데 사용 합니다 . 요소가 삽입 될 때 목록 색인이 이동되는 문제를 피하기 위해 쌍을 못생긴 zip / sort / unzip으로 색인의 내림차순으로 정렬합니다. 변화하는 문제가 아니라면 할 수 있습니다 map(B.insert,*X).

기존 방법 (65) :

B,V,I=input()
for i,v in sorted(zip(I,V))[::-1]:B[i:i]=v,
print B
— xnor
소스
5

하스켈, 62 바이트

import Data.List
f b v i=map snd$sort$zip[0.5,1.5..]b++zip i v

사용 예 : f [5,1,4,1,3] [0,0,7] [5,0,3]-> [0,5,1,4,7,1,3,0].

작동 방식 : "및 반"지수로 시작하는 기본 목록을 확대합니다 0.5(예 :[(0.5,5),(1.5,1),(2.5,4),(3.5,1),(4.5,3)] 하고 인덱스-값 쌍으로 연결합니다. 색인을 정렬하고 버립니다.

비고 : 내가 속이는 것인지 모르겠다. 보기의 수학적 관점에서 그것은 괜찮지 만 프로그래머가 인덱스의 목록을 주장 할 수 [5,0,3]의 목록이 아닙니다 Integers요청에 따라,하지만의 목록 Fractionals(정확하게는, 타입이 다형성이지만,에 속해야합니다 Fractional예를 들어, 클래스, Float또는 Double).

— 니미
소스
5

루비, 60 59 53 바이트

->a,b,c{c.zip(b).sort.reverse.map{|i,v|a.insert i,v}}

그리고 ungolfed 버전

def riffle(array, values, indices)
    indices.zip(values).sort.reverse.each do |index, value|
        array.insert(index, value)
    end
end
— 딜런 프레이스
소스
2
대신 이름없는 함수로 만들어서 단축시킬 수 있습니다 ->a,b,c{...}. 또한 기회는 insert괄호가 필요하지 않습니다.
— 마틴 엔더
@ MartinBüttner 나는 람다와 함께 명명되지 않은 기능에 대해 알았지 만 도전의 정신에 있다고 느끼지 못했습니다 (일반적으로 명명 된 기능을 요구합니다). 그래도 파 렌스를 찾아 주셔서 감사합니다.
— Dylan Frese 16:19에
도전이 특별히 명명 된 기능을 요구하지 않는 한, 명명되지 않은 함수는 항상 허용 됩니다. 그리고 나는 명명 된 함수를 요구하지 않았다 (나는 결코하지 않는다).
— 마틴 엔더
5

CJam, 34 23 18 바이트

{.\2/\ee+{0=}$1f=}

내 첫 CJam 제출. 조언을 환영합니다. 골프를 많이 할 것이라 확신합니다.

@ MartinBüttner 및 @Dennis의 도움으로 16 바이트가 저장되었습니다.

스택에서 입력을 순서대로 기대하는 기능 B V I (필자는 맨 위)입니다.

사용법 예 :

[5 1 4 1 3] [0 0 7] [5 0 3] {.\2/\ee+{0=}$1f=}~

방법:

  • 배열의 ith 요소를i+0.5
  • 인서트 값과 인서트 위치 쌍
  • 결과 두 배열을 병합
  • 위치 요소를 기준으로 배열 정렬
  • 가치 요소를 유지
— 랜덤
소스
이 부동 소수점 접근 방식은 매우 영리하고 슬프게도 나보다 낫습니다. q~.5fm.\2/\ee+$1f=p익명 함수를 사용하여 19 바이트 까지, 18 바이트까지 줄일 수 있습니다 .{.5fm.\2/\ee+$1f=}
— Dennis
부동 소수점 트릭이없는 동일한 아이디어 : {.\2/\ee+{0=}$1f=}(여전히 18 바이트)
— Dennis
@Dennis 감사 get array element합니다 1f=.에 대한 연산자를 찾을 수 없습니다 . 그래도 전체 프로그램으로 남겨 두겠습니다.
— randomra
당신의 전화. 함수 게시에 반대하는 이유를 물어 보겠습니까?
— 데니스
@Dennis 방금 CJam을 시작했으며 기능을 사용하는 방법을 모르겠습니다. 이제 나는 그것을 알아 냈으므로 대답을 바꿨습니다.
— randomra
5

K, 22 21 바이트

{,//+(y@<z;(z@<z)_ x)}

{…}암시 적 변수 x를 사용 y하고 z각각 시작 목록, 값 목록 및 색인 목록을 나타내는 3 개의 인수 함수 를 정의합니다 . "잘라 내기"연산자 ( _)는 시작 목록을 주어진 색인 ( (z@<z)) 의 정렬 된 목록으로 분리하는 데 사용됩니다 . 리스트를 만들어서 원래 배열의 분할 된 청크와 값을 인터리브합니다 (해당 값을 정렬 한 후).(a;b) ) , 그 조옮김 ( +)을 취하고 결과 ( ,//)를 평탄화 함으로써 값을 ).

사용 예 :

  f:{,//+(y@<z;(z@<z)_ x)}
{,//+(y@<z;(z@<z)_ x)}

  f[1 2 3 4;4 3 2 1;4 0 3 1]
3 1 1 2 3 2 4 4

  f[5 1 4 1 3;0 0 7;5 0 3]
0 5 1 4 7 1 3 0

K는 식별자에 밑줄을 허용하므로 밑줄 주위에 공백이 필요합니다. K5는 이러한 잠재적 모호성을 제거합니다. 우리가 오름차순으로 오는 인덱스를 믿을 수 있고 밑줄이 유효한 식별자가 아니라면 훨씬 더 좋은 13 바이트 프로그램을 사용할 수 있습니다

{,//+(y;z_x)}

(한숨.)

편집하다:

{,//+(y@<z;(z@<z)_ x)} / before
{,//+(y@<z;z[<z]_ x)}  / after

대칭을 […]깨뜨리지 만, @인덱싱 연산자 대신 브라켓 인덱싱 ( ) 을 사용하여 바이트를 절약 할 수 있습니다 . 일반적으로 프로그램이 더 길어 지지만이 경우 z잘라내 기를 수행하기 전에 정렬 할 parens가 필요했습니다 .

— 존
소스
4

Pyth, 17 바이트

ssC,cFPQamedSCtQ]

@isaacg는 이미 내 솔루션을 이겼습니다. 그러나 문서를 완성 했으므로 어쨌든 게시 할 것입니다.

이것은 형식으로 입력을받습니다 B, I, V. 여기에서 시도해 볼 수 있습니다 : 데모 또는 테스트 스위트

설명:

B = [5,1,4,1,3], I = [5,0,3], V = [0,0,7]OP 의 예제 를 사용하고 있습니다.

                    implicit: Q = input()
      PQ            all elements but last of Q   => [[5,1,4,1,3], [5,0,3]]
    cF              split B it the indices in I  => [[], [5,1,4], [1,3], []]

              tQ    all elements but first of Q  => [[5,0,3], [0,0,7]]
             C      zip                          => [(5,0), (0,0), (3,7)]
            S       sort                         => [(0,0), (3,7), (5,0)]
         med        extract the end of each pair => [0,7,0]
        a       ]   append an empty list         => [0,7,0,[]]

   ,                create a pair => ([[], [5,1,4], [1,3], []], [0,7,0,[]])
  C                 zip           => [([],0), ([5,1,4],7), ([1,3],0), ([],[])]
 s                  sum           => ([],0,[5,1,4],7,[1,3],0,[],[])
s                   sum           => [0,5,1,4,7,1,3,0]
— 자쿠 베
소스
4

자바 스크립트 (ES6), 75

배열을 반환하는 3 개의 배열 매개 변수가있는 함수입니다. 이상하게도,이 함수는 i매개 변수를 수정합니다 (OP에 의해 친절하게 허용됨).

스 니펫, Firefox 만 평소와 같이 실행 테스트합니다. 

f=(b,v,i,j=0)=>b.concat(v).map(p=>(p=i.indexOf(j))<0?b[j++]:(i[p]=-1,v[p]))

// TEST
out=x=>O.innerHTML+=x+'\n'

test=[
{ b:[], v:[], i:[], k:[] },
{ b:[], v:[1], i:[0], k:[1] },
{ b:[1,2], v:[], i:[], k:[1,2] },
{ b:[1,2], v:[3], i:[0], k:[3,1,2] },
{ b:[1,2], v:[3], i:[1], k:[1,3,2] },
{ b:[1,2], v:[3], i:[2], k:[1,2,3] },
{ b:[0,0,0], v:[1,1,1,1], i:[0,1,2,3], k:[1,0,1,0,1,0,1] },
{ b:[5,1,4,1,3], v:[0,0,7], i:[5,0,3], k:[0,5,1,4,7,1,3,0] },
{ b:[1,2,3,4], v:[4,3,2,1], i:[4,0,3,1], k:[3,1,1,2,3,2,4,4] }
];

test.forEach(x=>{
  r = f(x.b,x.v,x.i.slice(0)) // pass a copy of i, as the function will alter it
  ok = ''+r==''+x.k
  s='Test ' + (ok?'OK':'FAIL')
  +'\n B ['+x.b
  +']\n V ['+x.v
  +']\n I ['+x.i
  +']\n Result ['+r
  +']\n Check  ['+x.k
  +']\n'
  out(s)
  
})
<pre id=O></pre>
스 니펫 확장

— edc65
소스
호기심으로 코드가 Firefox에만 적용되는 것은 무엇입니까? ES6이기 때문입니까?
— Alex A.
@AlexA. 그것은 ES6이기 때문입니다. 특히이 fat arrow function경우에도 크롬 (AFAIK)의 개발자 버전에서 구현되지 않습니다
— edc65
실제로 Chrome의 Canary 빌드조차도 지원하지 않습니다.
— DocMax
4

매스 매 티카, 52 51 바이트

Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&

예:

In[1]:= f = Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&;

In[2]:= f[{5, 1, 4, 1, 3}, {0, 0, 7}, {5, 0, 3}]

Out[2]= {0, 5, 1, 4, 7, 1, 3, 0}

설명:

위의 예를 사용하십시오.

  • Tr@#2->#&~MapIndexed~# => {1 -> 5, 2 -> 1, 3 -> 4, 4 -> 1, 5 -> 3}
  • Thread[#3+.5->#2] => {5.5 -> 0, 0.5 -> 0, 3.5 -> 7}
  • 그런 다음이 두 목록의 (정렬 된) 조합을 가져옵니다. (=> {0.5 -> 0, 1 -> 5, 2 -> 1, 3 -> 4, 3.5 -> 7, 4 -> 1, 5 -> 3, 5.5 -> 0})
  • 그런 다음 각 쌍의 마지막 요소를 가져옵니다. (=> {0, 5, 1, 4, 7, 1, 3, 0})
— 알레프 알파
소스
3

R, 75 바이트

function(b,v,i){n=b;j=0;for(g in v)n=append(n,g,i[j<-j+1]+sum(i<i[j])-1);n}

이것은 명명되지 않은 함수를 만듭니다. 호출하려면 이름을 입력하십시오 (예 :f=function... . R은 롤 방식이기 때문에 배열은 1 인덱싱되어야합니다.

언 골프 + 설명 :

f <- function(b, v, i) {
    # Initialize the output vector to b
    n <- b

    # Initialize an index over the indices
    j <- 0

    # Loop over the values to insert
    for(g in v) {
        # Get the index of the next given insertion index
        j <- j + 1

        # Insert g into n.
        # The position at which to insert the value is determined by
        # adding the number of indices less than the current one and
        # subtracting 1. The subtraction is because we're using the
        # `after` argument in the `append` function.

        n <- append(n, g, i[j] + sum(i < i[j]) - 1)
    }

    # Return n
    n
}

예 :

> f(c(), c(), c())
[1] NULL

> f(c(0, 0, 0), c(1, 1, 1, 1), c(1, 2, 3, 4))
[1] 1 0 1 0 1 0 1

> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(6, 1, 4))
[1] 0 5 1 4 7 1 3 0

제안은 언제나처럼 환영합니다!

— 알렉스 에이
소스
2

CJam, 19 바이트

l~_,)N*q~.{t}~.\N-p

이것은 배열 B , I 및 V를 읽는 전체 프로그램입니다 STDIN에서 (한 줄에 하나씩)를 .

CJam 통역사 에서 온라인으로 사용해보십시오.

작동 원리

l~    e# Evaluate the first line of input.
_,)   e# Compute the array length and add 1.
N*    e# Push a string of that many linefeeds.
q~    e# Evaluate the remaining input.
.{t}~ e# Vectorized array set: for each index in the array from line 2, replace the
      e# LF at that index by the corresponding element of the array from line 3.
.\    e# Interleave the two arrays on the stack.
N-    e# Remove the linefeeds.
p     e# Print.

CJam, 20 바이트

{Qa+@@.{a2$2$=+t}e_}

이것은 B , V 및 I 를 팝업하는 익명 함수입니다. 스택에서 (위에서 아래로)를 띄우고 스택에 단일 배열을 반환 .

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

Qa+      e# Append [[]] to B.
@@       e# Rotate V and I on top of B.
.{       e# For each v in V and the corresponding i in I:
   a     e#     Push [v].
   2$2$= e#     Retrieve b := B[i].
   +     e#     Append to push [v b].
         e#     The stack now consists of: B i [v b]
   t     e#     Set B[i] := [v b].
}        e#
e_       e# Flatten B.
— 데니스
소스
1

루비, 48 바이트

나는 이것이 규칙을 준수한다고 생각하지만 확인하십시오.

->b,v,i{l=-1;i.map{|j|b[j]=[v[l+=1],b[j]]};b*?:}

이름없는 함수는 3 개의 배열을 입력으로 사용합니다. 루비 식을 사용하여 숫자 배열로 명확하게 구문 분석 할 수있는 문자열을 출력합니다 x.split(/:+/).map(&:to_i).

이데온의 테스트 사례 .

3 바이트를 더 절약 할 수 있지만 출력 형식 [1,2,[nil,5]]은 규칙을 약간 mych imo로 확장하고 있지만 명확하지는 않습니다.

— blutorange
소스
나는 현재 형식이 괜찮다고 생각합니다. 인터리빙 nil값을 갖는 중첩 배열 은 약간 늘어납니다. 그러나 두 경우 모두 대회에서 이기지 못하므로 어느 쪽이든 걱정하지 않습니다.
— 마틴 엔더
1

R, 60

b, v 및 i를 사용하는 명명되지 않은 함수로

function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}

NA를 사용하여 b를 확장합니다. v로 필요한 곳에 간격을 채 웁니다.

> f=function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}
> f(c(), c(), c())
logical(0)
> f(c(0, 0, 0), c(1, 1, 1, 1), c(0, 1, 2, 3))
[1] 1 0 1 0 1 0 1
> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(5, 0, 3))
[1] 0 5 1 4 7 1 3 0
— 미 키티
소스
1

자바, 253, 226, 219, 209

정확히 승자는 아니지만 아.

B, V 및 I가 널이 아니라고 가정합니다. v (소문자 v)는 Values ​​/ Indicies 배열의 길이입니다. R은 반환 된 배열입니다. r은 반환 된 배열의 길이입니다. x, y 및 i는 모두 임시 정수입니다.

int[]f(int[]B,int[]V,int[]I){int v=V.length,r=B.length+v,x,y,i;int[]R=java.utils.Arrays.copyOf(B,r);for(x=0;x<v;x++){i=I[x];for(y=0;y<x;y++)if(I[x]>I[y])i++;for(y=r-2;y>=i;y--)R[y+1]=R[y];R[i]=V[x];}return R;}

넓히는:

int[]f( int[] B, int[] V, int[] I ) {
    int v = V.length, //length of Values
        r = B.length + v, //length of the result
        x, y, i; //temps
        int[] R = java.utils.Arrays.copyOf( B, r );       
        for( x = 0; x < v; x++ ) {
        i = I[x];
        for( y = 0; y < x; y++ )
            if( I[x] > I[y] )
                i++;
        for( y = r - 2; y >= i; y-- )
            R[y+1] = R[y];
        R[i] = V[x];
    }
    return R;
}
— 잭 암모
소스
1

APL, 22 바이트

{(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}

casesIO ← 0에서 테스트 케이스와 일치합니다.

표준 알고리즘입니다. 첫 번째 인수의 인덱스 벡터가 주어진 인덱스 (3 번째 인수)에 추가됩니다. ⍋인덱스를 오름차순으로 정렬하는 순열을 계산합니다. APL의 정렬 알고리즘은 정의에 따라 안정적이므로 계산 된 순열은 두 번째 및 첫 번째 인수의 범주 요소를 올바른 위치에 배치합니다.

예를 들면 :

    {(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}(5 1 4 1 3)(0 0 7)(5 0 3)
0 5 1 4 7 1 3 0
— lstefano
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.