すべての奇数がすべての偶数の前に表示されるように、指定されたリストを再配置します。この要件に加えて、出力リストの順序は任意です。

入力には整数のみが含まれますが、それらは負であり、重複がある場合があり、任意の順序で表示される場合があります。

最短のソリューションが勝ちます。

テストケース

[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&| mod-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);}

この関数は、1組のイテレーター（ランダムアクセスイテレーターでなければなりません）を受け入れ、それらを相互に着実に移動します。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

オンラインでお試しください！

Perl 6、12バイト

*.sort(*%%2)

オンラインでお試しください！

入力をパリティでソートし、奇数を最初に使用するコード。%代わりにa を削除して、最初に偶数を取得できます。「Whatever」は、この種の匿名関数の名前です。

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バイトのヒント。

スタックス、5バイト

{|eom

実行してデバッグする

説明：

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

Haskell、23 22バイト

f odd<>f even
f=filter

オンラインでお試しください！これは同等です

g x = filter odd x ++ filter even x

リンのおかげで-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]

Attache、11バイト

SortBy!Even

オンラインでお試しください！

説明

Eventrue偶数などのfalse場合に戻ります。SortByランクfalse < true（への数値キャストによる0 < 1）、したがって、偶数の前に奇数を配置します。

JavaScript（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を追加するよりも短くなります。

ゼリー、3 バイト

ḂÞṚ

オンラインでお試しください！

より頻繁に望まれる原子の1つは偶数であるようであり（これは2バイトになります）、それなしでは逆転しなければなりません...

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

JavaScript、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バイト

（-2バイト、Ismael Miguelのおかげで）

<?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

Scala、18バイト

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

C＃、23バイト

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

かなり前向きです：これは基本的に数値をブール値に変換します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

JavaScript、23バイト

同じ言語を使用した@Neilの回答より6バイト短い：D

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

説明：

渡される関数はsort、最初のパラメーターのみを考慮します。奇数の場合、-1（の結果-(n&1)）を返します。そうでない場合（とき-(n&1)利回り0）が戻ります1。

オンラインでお試しください！

Python、35バイト

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

オンラインでお試しください！

奇数と偶数x -> (-1)**xを与える関数でソートします。-11

JavaScript（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)

JavaScript、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-Object安定しているため、それぞれのカテゴリの個々のアイテムの順序は変わりません（TIOの例のように）。

mazzyのおかげで-3バイト。

ルビー、23バイト

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

オンラインでお試しください！

説明：

sort_by値がブロックの結果であるかのようにすべての数値をソートします（~i%2）

~xと同等で-x-1あり、優先されます%2

奇数が評価され0、偶数が評価される1ため、奇数が最初にソートされます。

辛うじて関連：これはhomebrew 2.5.1p57のrubyで機能します（小さなバグに基づいているため）が、20バイトの負でない整数に対してのみ

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

説明：

この用途は、sortその2つの値を返すをとるブロックを期待する-1、0または1最初のものが大きいかどうかに応じて、それらが等しいだ又は第二の一方が大きいです。

ここで指定されたブロックは、2番目の値を無視し、-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

オンラインでお試しください！

Clojure-35バイト

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

ゴルフをしていない：

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