이 질문에서 영감을 얻었습니다 .

숫자 목록을 수신하고 재정렬 된 목록을 출력하는 함수 (또는 전체 프로그램)를 만들어 짝수 색인이 먼저 나타나고 홀수 색인이 뒤 따릅니다. 숫자 자체의 값은 순서에 영향을 미치지 않으며 지수 만 영향을 미칩니다. 모든 지수는 0부터 시작합니다.

예를 들면 다음과 같습니다.

입력: [0, 1, 2, 3, 4]

산출: [0, 2, 4, 1, 3]

또 다른 예:

입력: [110, 22, 3330, 4444, 55555, 6]

산출: [110, 3330, 55555, 22, 4444, 6]

귀하의 언어가 가지고있는 목록에 가장 자연스러운 표현을 사용하십시오. 복잡성에 대한 제한은 없습니다 (예 : 임시 목록을 할당해도 괜찮습니다. 제자리에서 할 필요가 없습니다).

추신 빈 목록 (빈 입력 => 빈 출력)에 대해 작동합니다.

Japt , 1 바이트

ó

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

파이썬, 23 바이트

lambda x:x[::2]+x[1::2]

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

피스, 5

o~!ZQ

온라인으로 사용해 보거나 Test Suite를 실행하십시오.

설명

o~!ZQ    ## implicit: Z = 0; Q = eval(input)
o   Q    ## sort Q using a supplied function
 ~!Z     ## Use the old value of Z, then set Z to be not Z
         ## This assigns a weight to each number in the list, for example given [0,1,2,3,4]
         ## This will give (value, weight) = [(0,0), (1,1), (2,0), (3,1), (4,0)]
         ## The values are sorted by weight and then by index
         ## This happens because Pyth is written in Python, which performs stable sorts

CJam, 7 바이트

{2/ze_}

필요에 따라 최상위 스택 요소를 변환하는 블록 (이름이없는 함수에 가장 가까운 것)을 푸시합니다.

여기에서 테스트하십시오.

설명

설명에서는 스택의 상단이 배열이라고 가정합니다 [0 1 2 3 4]. 실제 값은 계산에 영향을 미치지 않습니다.

2/  e# Split the array into chunks of two: [[0 1] [2 3] [4]]
z   e# Zip/transpose, which works on ragged arrays: [[0 2 4] [1 3]]
e_  e# Flatten the result: [0 2 4 1 3]

미로 , 28 25 24 23 22 바이트

" >
?!?:|}\{@
@\?"":)!

이것은 미친 재미이었다! :) 그것은 지금까지 내가 작성한 가장 조밀하게 압축 된 미로 프로그램입니다. 나는 20과 21 바이트에 너무 많은 버전을 가지고있어 거의 효과가 있었지만 여전히 이것이 최적인지 의심하고 있습니다 ...

입력은 양의 정수 목록 (임의의 구분 기호 포함) 으로 가져 와서 결과를 줄 바꿈으로 구분 된 정수로 STDOUT에 인쇄합니다.

20/21 바이트 사냥 : 나는 양식의 모든 프로그램을 확인했습니다.

" XX
?!?X}\{@
@\?XX)!

여기서 X짐승 힘에 의한 합리적인 성격이지만, 유효한 해결책을 찾지 못했습니다. 물론 이것이 더 짧은 솔루션이 존재하지 않는다는 것을 의미하지는 않지만 20 바이트 프로그램을 구조에 대한 적절한 가정없이 강제로 할 수는 없습니다.

설명

(설명은 약간 구식이지만 솔루션이 최적이라고 확신하지 못하므로 업데이트를 기다릴 것입니다.)

따라서 일반적으로 미로 프로그램은 미로처럼 보일 것입니다. 명령 포인터가 복도에있는 동안 해당 복도를 따릅니다. IP가 모든 종류의 정션에 도달하면 방향은 Labyrinth의 기본 스택의 최상위 값을 기준으로 결정됩니다 (미로에는 두 개의 스택이 있으며 맨 아래에는 무한한 양의 0이 있음). 즉, 벽이 아닌 셀이 모든 곳에 연결되어 있으면 모든 것이 접합이며 대부분의 경우 스택의 상단에 IP에 대한 올바른 값이 없기 때문에 사소하지 않은 루프는 상당히 비쌉니다. 원하는 길을 가고 그래서 당신이하는 일은 루프를 확대하여 중앙에 하나의 잘 정의 된 진입 점과 출구 점이 각각 하나씩 있도록합니다.

그러나 이번에는 정말 운이 좋았고 모든 것이 잘 어울려서 하나의 큰 덩어리로 스쿼시 할 수있었습니다. :)

_남쪽으로 가면서 제어 흐름이 시작됩니다 . 는 _메인 스택에 0을 민다. 이는 작동하지 않는 것처럼 보이지만 1나중에 필요 로 하는 ( 암시 적이 지 않은) 스택 깊이를 증가시킵니다 .

?STDIN에서 정수를 읽습니다. 읽을 정수가 더 이상 없으면 0을 푸시합니다. 이 경우 IP는 계속 남쪽으로 이동 @하고 입력 목록이 비어 있기 때문에 프로그램을 즉시 종료합니다. 그렇지 않으면 IP가 동쪽으로 바뀝니다.

우리는 이제 두 개의 출구 지점으로 매우 단단한 루프를 시작합니다.

 !?;
 \?
  ;

!스택에 0 만 남기고 정수를 다시 STDOUT으로 인쇄합니다. IP는 계속 동쪽으로 이동 ?하고 다음 정수를 읽습니다. 그것이 0이 아닌 경우 우회전하여 남쪽으로 이동합니다. ?다른 것을 읽습니다 (다음 짝수 색인). 다시, 그것이 0이 아닌 경우, 우리는 오른쪽을 잡고 서쪽으로 움직입니다.

그런 다음 \스택을 변경하지 않고 줄 바꿈을 인쇄하므로 오른쪽으로 이동하여 북쪽으로 이동합니다. !그 다음 짝수 색인 정수를 인쇄합니다. 이제 스택에 하나 이상의 (양의) 홀수 인덱스 정수가 있으므로 계속 우회전하여 루프가 반복됩니다.

둘 중 하나가 ?목록의 끝에 도달하면 0을 밀어 해당 해당 항목으로 바로 이동하여 해당 ;0을 버립니다.

목록에 하나의 요소 만있는 경우 (우리가 즉시 인쇄했기 때문에) IP가 완료되었으므로 IP는 계속 동쪽으로 계속 이동 @하여 프로그램을 종료합니다 (후행 인쇄) 길에 줄 바꿈).

그렇지 않으면 홀수 인덱스 정수도 인쇄해야합니다. 이 경우 두 경로 (첫 번째 루프의 두 출구 지점에서)가 가운데 "에서 병합 되어 어느 쪽이든 동쪽으로 전환됩니다.

_에 왼쪽을 복용하지 않도록 0을 밀어 @및 ;폐기 제로 그. 이제 우리는 새로운 루프를 입력합니다 :

     "}
     ""

IP는 왼쪽 아래 셀에 이것을 입력하고 북쪽으로 이동하여 시계 방향으로 루프를 돌립니다. 는 }보조 스택을 통해 주요 스택의 상단을 이동합니다. 스택에 여전히 요소가 있지만 IP는 계속 작동합니다. 모든 것이 보조 스택으로 이동되고 프로세스에서 반대로 바뀌면 IP는 계속 동쪽으로 이동하여 마지막 루프에 들어갑니다.

       \{@
       #!

\줄 바꿈을 다시 인쇄 {하고 보조 스택에서 주 항목으로 항목을 다시 이동합니다. 이 항목이 여전히 목록의 항목이면 양수이고 IP가 남쪽으로 바뀌고 항목이로 인쇄됩니다 !. 그런 다음 #스택 깊이를 밀어 (초기 어디 지금은 _중요하다이 때문에, #긍정적 인 스택 깊이를 보장)에 IP가 여전히 통해, 우회전 그래서, \그리고 {다시.

모든 것을 인쇄 한 후 {보조 스택의 맨 아래에서 0을 가져 오면 IP는 동쪽을 계속 @하고 프로그램을 종료합니다.

MATLAB, 24

@(x)x([1:2:end 2:2:end])

파이썬과 비슷합니다.

2 바이트를 절약 해 주셔서 감사합니다 @LuisMendo!

하스켈 , 37 바이트

concat.foldr(\x[l,r]->[x:r,l])[[],[]]

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

는 foldr재귀 적으로도 목록 및 홀수 목록을 작성합니다. 요소를 목록에 추가하면 홀수 목록 앞에 추가하고 새 짝수 목록을 호출하고 이전 짝수 목록을 호출하여 새 홀수 목록을 업데이트합니다. 그런 다음 쌍이 [l,r]에 연결됩니다 l++r.

튜플 대신 2 요소 목록을 사용하여 5 바이트를 저장 한 Ørjan Johansen에게 감사합니다.

42 바이트 :

f l=[x|p<-[even,odd],(i,x)<-zip[0..]l,p i]

목록에 색인을 추가 l하고 짝수 또는 홀수를 필터링합니다.

g(a:_:l)=a:(g l)
g l=l
f l=g l++(g$drop 1 l)

44의 또 다른 형식입니다.이 함수 g는 모든 짝수 색인 요소를 사용합니다. 홀수 지수는 먼저 요소를 삭제 한 다음을 적용하여 얻습니다 g. l비어 있지 않다고 보장 되면 tail41

g(a:_:l)=a:(g l)
g l=l
f l=g l++g(tail l)

PowerShell v3 +, 75 67 49 47 바이트

$l=,@()*2
$args|%{$l[($f=!$f)]+=$_}
$l[0]
$l[1]

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

TIO 링크에 표시된대로 스플래 팅을 통한 입력을 예상합니다.

행렬 $l을 배열의 배열로 만든 다음 입력 $args을 loop로 파이프합니다 |%{}. 루프를 통과 할 때마다 부울 논리를 사용 $l하여 $f변수를 플립 플롭 하여 두 자식 배열 중 하나에 요소를 추가합니다 . 통해 처음 $f인 $null1, !로되어있는 $true, 또는 1배열로 색인화 할 때. 이것은 첫 번째 요소가의 두 번째 배열에 들어가 $l므로 $l[1]먼저 출력을 얻는 것입니다.

에 소품 TessellatingHeckler 골프를 치는 도움이 변화합니다.
mazzy 덕분에 -2 바이트.

경고

질문이 쓰여질 때 엄격하게 진행하면 PowerShell에는 의사 불변 객체로서 배열 또는 해시 테이블 (일명 사전)이라는 "목록"개념이 없으므로 기술적으로 유효하지 않습니다. 따라서 저는 PowerShell에서 가장 가까운 배열이므로 " 언어가 가지고있는 목록에 가장 자연스러운 표현을 사용하십시오 "라는 질문을 처리하고 있습니다. 또한 출력은 한 줄에 하나의 요소입니다. 이는 배열을 작성하는 기본 PowerShell 방법이기 때문입니다. 이것은 (0,1,2,3,4)will 의 입력 이 출력 됨을 의미합니다 0\r\n2\r\n4\r\n1\r\n3\r\n.

F #, 79 77 56

fun x->List.foldBack(fun x (l,r)->x::r,l)x ([],[])||>(@)

하스켈 답변 중 하나를 기반으로

fun x->x|>List.indexed|>List.partition(fst>>(&&&)1>>(=)0)||>(@)|>List.map snd

먼저 목록을 색인화 한 다음 기준으로 분할합니다. 첫 번째 항목 (색인) 및 1과 0
이 같음 . 쌍 쌍 목록을 제공합니다. 첫 번째 목록에는 모든 인덱스 짝수와 다른 인덱스 확률이 포함됩니다.
여기에서 append 연산자로 두 목록을 다시 어셈블하고 마지막으로 인덱스를 버립니다.

편집 : arg "xs"(habits)의 이름을 지정할 필요가 없으므로 1 글자 이름으로 줄일 수 있습니다.

또한 잠재적으로 76 바이트가 기본적으로 동일하지만 함수 구성으로 정의됩니다. 문제는 값으로 컴파일되지 않지만 주어진 목록 인수와 효과적으로 작동하므로 그것이 괜찮는지 확실하지 않습니다.

List.indexed>>List.partition(fst>>(&&&)1>>(=)0)>>fun(e,o)->e@o|>List.map snd

참고 : List.indexed는 아직 MSDN에 문서화되어 있지는 않지만 F # 4.0에서만 사용할 수 있습니다.

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

또한 한 번에 그것을 수행

x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])

F=x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])

input.oninput = setValue;

function setValue() {
  var arr = input.value.match(/\d+/g) || [];
  unsorted.innerHTML = arr.join(', ');
  sorted.innerHTML = F(arr).join(', ');
}

setValue();

* {
  font-family: monospace
}

th {
  text-align: right;
  padding-right: 0.5em;
}

<input id="input" type="text" value="0 1 2 3 4 5 6"/>
<hr/>
<table>
  <tr>
    <th>Unsorted:</th>
    <td id="unsorted"></td>
  </tr>
  <tr>
    <th>Sorted:</th>
    <td id="sorted"></td>
  </tr>
</table>

줄리아, 23 바이트

i->i[[1:2:end;2:2:end]]

J, 8 바이트

/:0 1$~#

이것은 다음과 같이 사용되는 모나 딕 (1 인수) 동사입니다.

  (/:0 1$~#) 110 22 3330 4444 55555 6
110 3330 55555 22 4444 6

설명

/:        Sort the input array according to
  0 1     the array 0 1
     $~   repeated enough times to be of length
       #  length of input

젤리 , 4 바이트

s2ZF

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

Martin의 CJam 답변을 바탕으로

s2ZF - Main link. Argument: L (a list) e.g.  [110, 22, 3330, 4444, 55555, 6]
s2   - Split into chunks of length 2         [[110, 22], [3330, 4444], [55555, 6]]
  Z  - Columns                               [[110, 3330, 55555], [22, 4444, 6]]
   F - Flatten                               [110, 3330, 55555, 22, 4444, 6]

Mathematica, 40 바이트

#[[;;;;2]]~Join~If[#=={},#,#[[2;;;;2]]]&

{}[[2;;;;2]] 오류가 발생합니다.

해 학적 인, 12 바이트

J2ENj[-2EN_+

다음과 같이 사용법 :

blsq ) {0 1 2 3 4}J2ENj[-2EN_+
{0 2 4 1 3}
blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN_+
{110 3330 55555 22 4444 6}

설명:

J     -- duplicate
2EN   -- every 2nd element
j     -- swap
[-    -- tail
2EN   -- every 2nd element
_+    -- concatenate parts

새 업데이트가 릴리스되면 새로운 병합 해제 기본 제공 ( 병합 기본 제공의 반대 기능)으로이를 수행 할 수 있습니다 **.

blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN**
{110 22 3330 4444 55555 6}

펄, 35 33 바이트

perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'

31 바이트 + 2 바이트 -ap. STDIN에서 공백으로 구분 된 문자열을 읽습니다.

$ echo 0 1 2 3 4 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
0 2 4 1 3

$ echo 110 22 3330 4444 55555 6 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
110 3330 55555 22 4444 6

입력이 비어있을 때 하나의 공백을 인쇄합니다. 이는 빈 목록과 같습니다. 그렇지 않은 경우 다음을 사용하여 4 바이트의 비용으로 수정할 수 있습니다.

perl -anE 'push@{$|--},$_ for@F;$,=$";say@0,@1'

(Perl 5.10+ 필요, 후행 줄 바꿈 인쇄)

또는 5 바이트의 비용으로 :

perl -ape 'push@{$|--},$_ for@F;$_=join$",@0,@1'

(후행 공백 없음)

작동 원리

이 솔루션은 -a입력을 공백으로 분할하고 결과를 @F배열 에 넣는 플래그를 사용합니다 .

실제 마술은 push:

push@{$|--},$_

이 $|변수 는 일반적으로 출력 플러싱을 강제하는 데 사용되지만 또 다른 흥미로운 속성이 있습니다. 반복적으로 감소하면 값이 0과 1 사이에서 전환됩니다.

perl -E 'say $|-- for 0..4'
0
1
0
1
0

심볼릭 역 참조를 통해 지정된 식별자에 제한이 없다는 사실을 이용하여 배열 요소를 @0and @1배열 로 번갈아 가며 @0모든 짝수 색인 요소와 @1확률로 끝납니다 . 그런 다음 단순히 문자열 배열을 연결하여 출력을 얻습니다.

C, 70

특별한 것은없고, 인덱스 매핑 기능 일뿐입니다.

a=0;main(int c,int** v){for(c--;a<c;)puts(v[1+a*2%c+!(a++<c/2|c%2)]);}

덜 골프

a=0;
main(int c, int** v) {
  for(c--; a<c;)
    puts(v[1 + a*2%c + !(a++ < c/2 | c%2) ]);
}

Pyth, 8 바이트

+%2Q%2tQ

비교적 간단

비시, 22 바이트

Vitsy은 정말 이 일을하게되지 ...

r ''Vl2 / \ [N {VO] l \ [NVO]
r 암시 적 숫자 입력 스택을 뒤집습니다.
 ''V "공백"문자를 전역 최종 변수로 저장하십시오.
     l2 / \ [....] 입력 길이만큼 괄호 안의 내용을 반복하십시오.
                        스택을 2로 나눈 값입니다.
          N {VO 스택의 최상위 항목을 숫자로 출력 한 다음 Shift
                        스택을 왼쪽으로 한 번 넘겨 공백을 밀고 출력하십시오.
               l \ [...] 스택의 나머지 부분에 대해 여러 번 반복하십시오 ...
                  NVO 스택의 최상위 항목을 숫자로 분리하여 출력 
                        공간으로.

펄 6 , 25 바이트

이것은 내가 생각해 낼 수있는 가장 짧은 람다입니다.

{|.[0,2...*],|.[1,3...*]} # 25 byte "Texas" version
{|.[0,2…*],|.[1,3…*]}     # 25 byte "French" version

say {|.[0,2…*],|.[1,3…*]}( ^5 ); # (0 2 4 1 3)␤

say ((0..4),('m'..'q'),(5..9)).map: {|.[0,2…*],|.[1,3…*]}
# ((0 2 4 1 3) (m o q n p) (5 7 9 6 8))␤


# bind it as a lexical sub
my &foo = {|.[0,2…*],|.[1,3…*]}

say foo [110, 22, 3330, 4444, 55555, 6]; # (110 3330 55555 22 4444 6)␤

say [~] foo 'a'..'z' # acegikmoqsuwybdfhjlnprtvxz␤

Minkolang 0.12 , 15 바이트

$nI2:[i1+g]r$N.

여기에서 시도하십시오.

설명

$n                 Read in all of input as numbers
  I2:              The length of the stack divided by 2 (n)
     [             Open for loop that repeats n times
      i1+          Loop counter + 1
         g         Gets the (i+1)th item from the stack and puts it on top
          ]        Close for loop
           r       Reverse the stack (for outputting)
            $N.    Output the whole stack as numbers and stop.

R, 49 바이트

q<-function(x)c(x[seq(x)%%2==1],x[seq(x)%%2==0])

이것을 q (blah)라고 부릅니다. 또는 x에 재 배열 할 목록이 이미 포함되어 있다면

c(x[seq(x)%%2==1],x[seq(x)%%2==0])

단지 35 바이트입니다.

F #, 64

fun x->List.mapi(fun i l->l,i%2)x|>List.sortBy snd|>List.map fst

Sehnsucht의 답변에서 영감을 얻었습니다 (그러나 충분한 담당자는 아닙니다).

두 번째 항목이 목록 인덱스의 모듈로 인 튜플에 각 값을 매핑하고 모듈로를 기준으로 정렬 한 다음 원래 값으로 다시 매핑합니다.

프롤로그, 103 바이트

r([E,O|T],[E|A],[O|B]):-r(T,A,B).
r([],[],[]).
r([E],[E],[]).
p(L):-r(L,A,B),append(A,B,X),write(X).

예

>p([1,2,3,4,5]).
[1,3,5,2,4]

bash 및 GNU coreutils, 68 바이트

리스트는 개행 문자로 분리되어 표준 입력으로 전달되었다고 가정합니다.

(paste - <(seq 0 5 9999)|tee x|grep 0$;grep 5$<x)|cut -f1|grep -v ^$

불행히도 이것은 인덱스 1999 이상의 입력을 무시하므로 사양을 충족시키지 못합니다.

또한 하드 코딩 된 임시 파일 ( 'x')을 복제하여 병렬로 실행할 경우 문제가 될 수 있으며 이후에 제거되지 않습니다. 미안합니다!

PHP, 78 69 바이트

PHP는 배열을 청크 및 슬라이스 할 수 있지만 인터리브는 할 수 없습니다. 이것은 이것을 약간 부피가 커지게 만듭니다.

function(&$a){while($i++<count($a)>>1)$a[]=array_splice($a,$i,1)[0];}

참조로 전화하거나 온라인으로 시도하십시오 .

첫 번째 접근 방식 (78 바이트 프로그램) :

for(;++$i<$argc;)echo",",$argv[$i++];for($i=1;++$i<$argc;)echo",",$argv[$i++];

선행 쉼표를 인쇄합니다. [!$i]첫 번째 전에 삽입$argv 제거 하십시오.

다른 두 가지 78 바이트 솔루션 (앞과 뒤에 쉼표 인쇄) :

for($n=$argc-2|1;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[$n+=2]=$argv[$i];
for($n=$argc-2;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[1|$n+=2]=$argv[$i];

온라인으로 실행 php -nr '<code>' <arguments>하거나 사용해보십시오

Japt , 3 바이트

ñÏu

시도 해봐

ñÏu     :Implicit input of array
ñ       :Sort by
 Ï      :Passing the 0-based index of each through a function
  u     :  Modulo 2 of index

ó c

시도 해봐

ó c     :Implicit input of array
ó       :Split into 2 arrays of every 2nd item
  c     :Flatten
        :Implicit output

Clojure / ClojureScript, 52 바이트

(defn f[l](flatten(map #(take-nth 2 %)[l(rest l)])))

ClojureScript REPL로 작성되었으며 유효한 Clojure 여야합니다.

K, 10 바이트

{x@<2!!#x}

5 바이트 Pyth 답변을 기반으로합니다.

Hassium , 191 바이트

이것은 꽤 길었
습니다 :( args에서 배열을 읽습니다.hassium file.has 0 1 2 3 4

func main(){a=args;e,o=[]for(c=0;c<a.length;c++)if(c%2==0)e.add(a[c])else o.add(a[c])print("["+(e+o).toString().replace("{", "").replace("}", "").replace("Array", "").replace("  ", "")+"]");}

여기 에서 테스트 사례로 확장하여 실행 하십시오.