모든 홀수가 모든 짝수 앞에 나타나도록 주어진 목록을 재정렬하십시오. 이 요구 사항 외에, 출력리스트는 임의의 순서로있을 수 있습니다.

입력에는 정수만 포함되지만 음수 일 수도 있고 중복 될 수도 있으며 순서에 상관없이 나타날 수 있습니다.

최단 솔루션이 승리합니다.

테스트 사례

[1,2] → [1,2]

[2,1] → [1,2]

[1,0,0] → [1,0,0]

[0,0,-1] → [-1,0,0]

[3,4,3] → [3,3,4]

[-4,3,3] → [3,3,-4]

[2,2,2,3] → [3,2,2,2]

[3,2,2,2,1,2]→ [1,3,2,2,2,2]또는[3,1,2,2,2,2]

[-2,-2,-2,-1,-2,-3]→ [-1,-3,-2,-2,-2,-2,]또는[-3,-1,-2,-2,-2,-2,]

[] → []

05AB1E , 2 바이트

ΣÉ

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

Pyth , 4 3 바이트

isaacg 덕분에 -1 바이트

iD2

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

_{^{4를 넘어 여전히 여전히 4}}

J , 5 바이트

\:2&|

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

\: 내림차순으로 정렬

2&| 모드 -2

R , 30 24 바이트

(x=scan())[order(!x%%2)]

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

JayCe 덕분에 -6 바이트

C ++, 79 76 64 바이트

[](auto a,auto b){while(a<--b)*a%2?*++a:(*a^=*b,*b^=*a,*a^=*b);}

이 함수는 한 쌍의 반복자 (임의의 액세스 반복자 여야 함)를 허용하고 꾸준히 서로를 향해 이동합니다. a홀수를 가리킬 때 진행됩니다. 그렇지 않으면 a짝수를 가리 킵니다. b가 감소하고로 iter_swap바뀝니다 a. (XOR 스왑을 사용하므로 포함 <algorithm>또는에 <utility>대한 비용을 절약 할 수 있습니다 std::swap).

b짝수를 가리킬 때 불필요한 스왑 이 있지만 우리는 효율성을 압박하지 않고 골프를하고 있습니다!

데모

auto f=[](auto a,auto b){while(a<--b)*a%2?*++a:(*a^=*b,*b^=*a,*a^=*b);};

#include <array>
#include <iostream>
int main()
{
    auto a = std::array{ 3,2,2,5,2,1,2 };

    f(a.begin(),a.end());

    for (auto i: a)
        std::cout << i << " ";
    std::cout << std::endl;
}

비경쟁 답변

자연스러운 C ++ 메소드는입니다 std::partition만 83 바이트로 나옵니다 .

#include<algorithm>
[](auto a,auto b){std::partition(a,b,[](auto x){return x&1;});}

Japt , 2 바이트

ñv

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

펄 6 , 12 바이트

*.sort(*%%2)

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

홀수로 먼저 패리티를 기준으로 입력을 정렬하는 일부 코드입니다. %대신 짝수를 얻기 위해 a 를 제거 할 수 있습니다 . '무엇이든'은 이런 종류의 익명 함수의 이름입니다.

MATL, 6 바이트

tog&)v

MATL Online에서 사용해보십시오

번갈아:

to_2$S

MATL Online에서 사용해보십시오

파이썬 2 , 37 36 바이트

lambda a:sorted(a,key=lambda x:~x%2)

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

Xcoder 씨에게 모자 1 바이트 팁 .

Stax , 5 바이트

{|eom

실행 및 디버깅

설명:

{|eom Full program, implicit input
{  o  Sort by key:
 |e     Is odd?
    m Map over result:
        Implicit output with newline

하스켈 , 23 22 바이트

f odd<>f even
f=filter

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

g x = filter odd x ++ filter even x

Lynn 덕분에 -1 바이트

다른 접근법 :

(<>).($odd)<*>($even)$filter
f x=[i|m<-[0,1],i<-x,odd$m+i]
f x=[i|m<-[1,0],i<-x,mod i 2==m]
f x=id=<<filter<$>[odd,even]<*>[x]

첨부 , 11 바이트

SortBy!Even

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

설명

Even반환 true짝수과 false달리. SortBy로 순위를 매기 므로 false < true(1로 캐스트 됨 0 < 1) 홀수를 짝수 앞에 배치합니다.

자바 스크립트 (Node.js) , 29 바이트

a=>a.sort((a,b)=>(b&1)-(a&1))

온라인으로 사용해보십시오! 를 사용하여 양수 값만 지원하여 4 바이트를 절약하십시오 b%2-a%2. 이것을 다음과 같이 쓰면 :

function(a){return a.sort((a,b)=>(b&1)-(a&1))}

그러면 안정적으로 정렬되지 않은 모든 종류의 오래된 JavaScript 구현에서 작동합니다.

T-SQL, 26 바이트

SELECT*FROM t ORDER BY~i&1

비트 AND 연산자 "&"를 사용하여 마지막 숫자를 1과 비교합니다.

편집 : 비트 1 다음에 1을 추가하는 것보다 짧지 않습니다. 편집 2 : 공간을 제거 할 수 있도록 재정렬.

젤리 , 3 바이트

ḂÞṚ

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

더 원치 않는 원자 중 하나는 (이 2 바이트를 만들 것입니다) 짝수 번째 원자 인 것 같습니다.

ḂÞṚ - Link: list of integers
 Þ  - sort by:
Ḃ   -   bit (least significant bit - i.e. 1 if odd 0 if even)
  Ṛ - reverse

자바 스크립트, 22 20 바이트

a=>a.sort(a=>!(a%2))

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

PHP , 55 바이트

~ 14 개월 후 저는 골프를 조금 더 잘합니다.

for(;''<$n=$argv[++$i];$s=$n%2?"$n $s":"$s $n");echo$s;

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

PHP (> = 5.4), 84 82 바이트

( Ismael Miguel 덕분에 2 바이트 )

<?array_shift($a=&$argv);usort($a,function($i){return$i%2==0;});echo join(' ',$a);

그것을 실행하려면 :

php -n <filename> <number_1> <number_2> ... <number_n>

예:

php -n sort_odds_first.php 2 0 1 -1 3 8 29 -666

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

빨강 , 42 바이트

func[a][sort/compare a func[n][n % 2 = 1]]

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

음수 값을 고려해야하는 경우 :

빨강 , 43 바이트

func[a][sort/compare a func[n][n // 2 = 1]]

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

껍질 , 4 바이트

↔Ö%2

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

설명

 Ö     sort input according to the result of the following function
  %2   modulo 2
↔      reverse result to get odd numbers to the front

스칼라 , 18 바이트

_.sortBy(_.+(1)%2)

C #, 23 바이트

i=>i.OrderBy(u=>u%2==0)

정말 straigt forward : 이것은 기본적으로 숫자를 부울로 변환하지만 숫자 true는 짝수이고 false홀수임을 의미합니다 . 짝수 true보다 높기 때문에 false먼저 나타납니다.

형식이 지정된 버전은 다음과 같습니다.

i => i.OrderBy (u => u % 2 == 0)

그리고 당신은 그것을 다음과 같이 테스트 할 수 있습니다 :

Console.WriteLine (string.Join (",", new Func <IEnumerable <int>, IEnumerable <int>> (
                                    i => i.OrderBy (u => u % 2 == 0)
                                ).Invoke (new [] {3, 2, 2, 2, 1, 2, 5, 5})));

결과는 다음과 같습니다.

3,1,5,5,2,2,2,2

자바 스크립트, 23 바이트

같은 언어를 사용하는 @Neil의 대답 보다 6 바이트 더 짧음 : D

a=>a.sort(n=>-(n&1)||1)

설명:

전달 된 함수 sort는 첫 번째 매개 변수 만 처리합니다. 홀수이면 -1(의 결과 -(n&1))를 반환합니다 . 그렇지 않으면 ( -(n&1)항복 할 때 0) 반환합니다 1.

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

파이썬 , 35 바이트

lambda l:sorted(l,key=(-1).__pow__)

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

홀수 및 짝수 x -> (-1)**x를 제공 하는 함수를 기준으로 정렬합니다 .-11

자바 스크립트 (Chrome v67) -24 19 23 바이트

a=>a.sort(a=>!(a&1)-.5)

@Neil에서 도난 당하지 &1않고 사용했습니다 Math.abs()%2. 감사!

해키 19 바이트 솔루션이 유효하지 않다는 것을 보여 준 @Shaggy에게 감사드립니다. 누구나 원한다면 :

_{브라우저가 해키 리턴 값을 처리하는 방법에 따라 다릅니다 0. Chrome v67은 무작위 배열을 100000 회 반복 한 후에는 잘못 정렬하지 않았습니다. 나는 그것이 작동한다고 확신합니다. 그리고 그것은 Chrome이 사용하는 특정 정렬 알고리즘에 의존합니다. (다른 브라우저에서도 작동 할 수 있습니다.}

a=>a.sort(a=>++a&1)

자바 스크립트, 21 바이트

a=>a.sort(n=>(-1)**n)

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

PowerShell , 22 19 바이트

$args|sort{!($_%2)}

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

예를 들어, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @aTIO에서 각 항목에 대해 별도의 인수로 나타나는 스플래 팅을 통해 입력을 받습니다.

다른 답변과 마찬가지로 Sort-Object표현식을 기준으로 비교할 수 있습니다. 여기에서 표현은 !($_%2)즉, 확률이 정렬 $false되고 심지어 짝수를 정렬하는 것 $true입니다. 부울 값을 비교하는 방법 덕분에 잘못된 값이 먼저 정렬됩니다. 이렇게하면 확률이 출력의 시작 부분으로, 짝수의 끝 부분으로 이동합니다. Sort-ObjectTIO 예제 에서처럼 각 카테고리의 개별 항목 순서는 변경되지 않습니다.

mazzy 덕분에 -3 바이트.

루비 , 23 바이트

->a{a.sort_by{|i|~i%2}}

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

설명:

sort_by값이 블록의 결과 인 것처럼 모든 숫자를 정렬합니다 ( ~i%2)

~x동등 -x-1하고 우선합니다%2

홀수는 평가 0되고 짝수는 평가 1되어 홀수가 먼저 정렬됩니다.

거의 관련이 없음 : homebrew 2.5.1p57의 루비 (작은 버그를 기반으로하기 때문에)에서 작동하지만 음이 아닌 정수, 20 바이트에 대해서만

->a{a.sort{|i|i%-2}}

설명:

이 용도 sort2 개 값 복귀 걸리는 기대 블록 -1, 0또는 1첫 번째는 더 큰인지에 따라, 그들은 동일한 것 또는 두번째 커이다.

여기에 주어진 블록은 두 번째 값을 무시하고 -1첫 번째 숫자가 홀수인지 짝수인지를 0반환합니다.

작동한다고 보장되지는 않지만 (버그가 있다고 생각하는) 구현에서는 작동합니다.

6502 머신 코드 루틴, 47 바이트

A0 00 84 FE B1 FB 4A 90 07 C8 C4 FD F0 20 D0 F4 2A 85 02 84 FE A4 FD 88 C4 FE
F0 12 B1 FB 4A 90 F6 2A AA A5 02 91 FB A4 FE 8A 91 FB 90 D6 60

숫자의 배열에 대한 포인터 예상 $fb/ $fc및이 어레이의 길이 $fd. 앞에 홀수를 갖도록 배열을 제자리에서 조작합니다. 위치 독립적 인 코드이므로로드 주소가 필요하지 않습니다.

6502가 8 비트 칩이므로 명령은 선택적으로 부호있는 8 비트 값만 처리하므로 유효한 숫자 범위는 [-128 .. 127]최대 배열 크기는 256입니다.

주석 처리 된 분해

; function to "partially sort" array, so all odd numbers come before all
; even numbers.
;
; input:
;   $fb/$fc: address of array to sort
;   $fd:     length of array to sort, 0 means 256 (maximum size)
;
; clobbers:
;   $fd/$fe: position from back/front of array
;   $2:      temporary for exchanging two values
;   A, X, Y

 .oddfirst:
A0 00       LDY #$00            ; initialize index from front
84 FE       STY $FE             ; to 0

 .search_front:
B1 FB       LDA ($FB),Y         ; load number from front
4A          LSR A               ; check for even/odd by shifting
90 07       BCC .search_back    ; if odd -> to searching from back
C8          INY                 ; next position from front
C4 FD       CPY $FD             ; same as position searching from back?
F0 20       BEQ .done           ; then we're finished
D0 F4       BNE .search_front   ; else check next from front
 .search_back:
2A          ROL A               ; shift carry back in
85 02       STA $02             ; and save number to temp
84 FE       STY $FE             ; save index from front
A4 FD       LDY $FD             ; load index from back
 .sb_loop:
88          DEY                 ; previous position from back
C4 FE       CPY $FE             ; same as position searching from front?
F0 12       BEQ .done           ; then we're finished
B1 FB       LDA ($FB),Y         ; load number from back
4A          LSR A               ; check for even/odd by shifting
90 F6       BCC .sb_loop        ; if odd -> check previous position
2A          ROL A               ; shift carry back in
AA          TAX                 ; remember in X
A5 02       LDA $02             ; load temporary from front
91 FB       STA ($FB),Y         ; store at current position
A4 FE       LDY $FE             ; load index from front
8A          TXA                 ; load remembered number
91 FB       STA ($FB),Y         ; store at current position
90 D6       BCC .search_front   ; and back to searching from front
 .done:
60          RTS

루틴을 사용하는 예제 C64 어셈블러 프로그램 :

온라인 데모

ca65 구문의 코드 :

.import oddfirst ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
linebuf:        .res    5               ; maximum length of a valid signed
                                        ; 8-bit number input
convbuf:        .res    3               ; 3 BCD digits for signed 8-bit
                                        ; number conversion
numbers:        .res    $100            ; maximum array size that can be
                                        ; directly handled with indexing
                                        ; instructions

.data
prompt:         .byte   "> ", $0
message:        .byte   $d, $d, "Enter one number per line.", $d
                .byte   "just press enter (empty line) when done.", $0
errmsg:         .byte   "Error parsing number, try again.", $d, $0

.code
                lda     #$17            ; set upper/lower mode
                sta     $d018

                lda     #0
                sta     $2a             ; index for number array
                sta     $52             ; flag that at least one number was
                                        ; entered

                lda     #<message       ; display message
                ldy     #>message
                jsr     $ab1e

inputloop:
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<linebuf       ; read string into buffer
                ldy     #>linebuf
                ldx     #5
                jsr     readline

                lda     linebuf         ; empty line?
                beq     process         ; -> start processing

                lda     #<linebuf       ; convert input to int8
                ldy     #>linebuf
                jsr     toint8
                bcc     numok           ; successful -> store number
                lda     #<errmsg        ; else show error message and repeat
                ldy     #>errmsg
                jsr     $ab1e
                bcs     inputloop

numok:          ldx     #$ff            ; set flag that we have a number
                stx     $52
                ldx     $2a
                sta     numbers,x
                inc     $2a             ; next index
                bne     inputloop       ; if array not full, next input

process:        lda     $52             ; check we have some numbers
                beq     exit            ; otherwise exit program

                lda     #<numbers       ; address of array to $fb/fc
                sta     $fb
                lda     #>numbers
                sta     $fc
                lda     $2a             ; length of array to $fd
                sta     $fd
                jsr     oddfirst        ; call "sorting" function

                lda     #$0             ; index variable for output loop
                sta     $52
outloop:        ldy     $52             ; load current index
                lda     numbers,y       ; load current number
                jsr     printnum        ; -> output
                inc     $52             ; next index
                lda     $52             ; compare with ...
                cmp     $2a             ; ... array size
                bne     outloop         ; not reached yet -> repeat

exit:           rts                     ; done, exit program

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

; print an int8 number to the screen
; input:
;   A - the number to print
; clobbers:
;   X, Y
.proc printnum
                bpl     doprint         ; positive? -> direct number output
                eor     #$ff            ; else invert, 
                sta     $2              ; ...
                inc     $2              ; add one,
                lda     #'-'            ; output a minus sign
                jsr     $e716
                lda     $2
doprint:        tax                     ; number to X reg
                lda     #$0             ; set A to 0
                jsr     $bdcd           ; routine for uint16 in X/A output
                lda     #' '            
                jmp     $e716           ; and print a space
.endproc

; parse / convert int8 number using a BCD representation and double-dabble,
; handle negative numbers.
.proc toint8
                sta     $fb
                sty     $fc
                ldy     #$0
                sty     $fd
                sty     $fe
                sty     convbuf
                sty     convbuf+1
                sty     convbuf+2
scanloop:       lda     ($fb),y
                beq     copy
                iny
                cmp     #$20
                beq     scanloop
                cmp     #$2d
                beq     minus
                cmp     #$30
                bcc     error
                cmp     #$3a
                bcs     error
                inc     $fd
                bcc     scanloop
minus:          lda     $fd
                bne     error
                lda     $fe
                bne     error
                inc     $fe
                bne     scanloop
error:          sec
                rts
copy:           dey
                bmi     error
                ldx     #$2
copyloop:       lda     ($fb),y
                cmp     #$30
                bcc     copynext
                cmp     #$3a
                bcs     copynext
                sec
                sbc     #$30
                sta     convbuf,x
                dex
copynext:       dey
                bpl     copyloop
                lda     #$0
                sta     $fb
                ldx     #$8
loop:           lsr     convbuf
                lda     convbuf+1
                bcc     skipbit1
                ora     #$10
skipbit1:       lsr     a
                sta     convbuf+1
                lda     convbuf+2
                bcc     skipbit2
                ora     #$10
skipbit2:       lsr     a
                sta     convbuf+2
                ror     $fb
                dex
                beq     done
                lda     convbuf
                cmp     #$8
                bmi     nosub1
                sbc     #$3
                sta     convbuf
nosub1:         lda     convbuf+1
                cmp     #$8
                bmi     nosub2
                sbc     #$3
                sta     convbuf+1
nosub2:         lda     convbuf+2
                cmp     #$8
                bmi     loop
                sbc     #$3
                sta     convbuf+2
                bcs     loop
done:           lda     $fe
                beq     positive
                lda     #$ff
                eor     $fb
                sta     $fb
                inc     $fb
positive:       lda     $fb
                clc
                rts
.endproc

엘릭서 , 37 35 바이트

암호:

fn x->Enum.sort_by x,&(-rem&1,2)end

확장 버전 :

fn x -> Enum.sort_by(x, fn y -> -rem(y, 2) end) end

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

클로저-35 바이트

(defn o[c](sort(fn[p _](odd? p))c))

언 골프 드 :

(defn oddsort [col]
  (sort (fn [p _] (odd? p)) col))