Переставьте данный список так, чтобы все нечетные числа стояли перед всеми четными числами. Кроме того, для этого требования список вывода может быть в любом порядке.

Входные данные будут содержать только целые числа, но они могут быть отрицательными и могут быть дубликатами, и они могут появляться в любом порядке.

Самое короткое решение побеждает.

Контрольные примеры

[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 байта

-1 байт благодаря isaacg

iD2

Попробуйте онлайн!

_{^{вычеркнуто 4 все еще регулярно 4}}

J , 5 байт

\:2&|

Попробуйте онлайн!

\: сортировать по убыванию

2&| мод-2

R , 30 24 байта

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

Попробуйте онлайн!

-6 байт благодаря JayCe

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

Попробуйте онлайн!

Perl 6 , 12 байт

*.sort(*%%2)

Попробуйте онлайн!

Какой-то код, сортирующий ввод по паритету, с нечетными числами в первую очередь. %Вместо этого вы можете сначала удалить четные числа. Обратите внимание, что «что угодно» - это название анонимной функции.

MATL, 6 байтов

tog&)v

Попробуйте это на MATL Online

С другой стороны:

to_2$S

Попробуйте это на MATL Online

Python 2 , 37 36 байт

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

Попробуйте онлайн!

1 байт подсказка мистеру Xcoder .

Stax , 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]

Атташе , 11 байт

SortBy!Even

Попробуйте онлайн!

объяснение

Evenвозвращает trueчетные числа и в 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. РЕДАКТИРОВАТЬ 2: изменить порядок, чтобы разрешить удаление пространства.

Желе , 3 байта

ḂÞṚ

Попробуйте онлайн!

Похоже, что один из наиболее часто используемых атомов - это даже четный (который сделал бы это 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 байта, спасибо Исмаилу Мигелю )

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

На самом деле довольно прямолинейно: это в основном конвертирует числа в логические значения, а 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 байта

На 6 байт короче, чем ответ @ Neil на одном языке: 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, которая дает -1нечетные и 1четные.

JavaScript (Chrome v67) - 24 19 23 байта

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

Использование, &1а не Math.abs()%2был украден из @Neil. Благодарность!

Спасибо @Shaggy за то, что показал мое хакерское 19-байтовое решение недействительным. Если кто-то хочет это:

_{Зависит от того, как браузер обрабатывает взломанное возвращаемое значение 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)}

Попробуйте онлайн!

Принимает ввод через splatting, например, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @aкоторый в TIO проявляется как отдельные аргументы для каждой записи.

Как и некоторые другие ответы здесь, Sort-Objectможно сравнить на основе выражения. Здесь используется выражение !($_%2), то есть шансы сортируются, $falseа четные сортируются $true. Благодаря тому, как булевы значения сравниваются, значения Falsey сортируются первыми. Это перемещает шансы в начало вывода, а четные - в конец. Sort-Objectявляется стабильным, поэтому порядок отдельных элементов в соответствующих категориях не изменяется (как в примере TIO).

-3 байта благодаря маззи.

Рубин , 23 байта

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

Попробуйте онлайн!

Объяснение:

sort_byсортирует каждое число так, как если бы его значение было результатом блока ( ~i%2)

~xэквивалентно -x-1и имеет приоритет над%2

Нечетные числа будут сравниваться с 0четными числами, 1поэтому нечетные числа будут отсортированы первыми.

Едва ли связано: это работает на ruby ​​из homebrew 2.5.1p57 (потому что он основан на небольшой ошибке), но только для неотрицательных целых чисел, 20 байтов

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

Объяснение:

Это использует, sortкоторый ожидает блок, который принимает 2 значения и возвращает -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

Попробуйте онлайн!

Clojure - 35 байт

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

Ungolfed:

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