Ordnen Sie eine gegebene Liste neu an, so dass alle ungeraden Zahlen vor allen geraden Zahlen erscheinen. Außerdem kann die Ausgabeliste für diese Anforderung in beliebiger Reihenfolge sein.

Die Eingabe enthält nur Ganzzahlen, aber sie können negativ sein und es können Duplikate vorhanden sein, und sie können in beliebiger Reihenfolge angezeigt werden.

Kürzeste Lösung gewinnt.

Testfälle

[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]oder[3,1,2,2,2,2]

[-2,-2,-2,-1,-2,-3]→ [-1,-3,-2,-2,-2,-2,]oder[-3,-1,-2,-2,-2,-2,]

[] → []

05AB1E , 2 Bytes

ΣÉ

Probieren Sie es online!

Pyth , 4 3 Bytes

-1 Byte dank isaacg

iD2

Probieren Sie es online!

_{^{durchgestrichen 4 ist immer noch regulär 4}}

J , 5 Bytes

\:2&|

Probieren Sie es online!

\: absteigend sortieren nach

2&| mod-2

R , 30 24 Bytes

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

Probieren Sie es online!

-6 Bytes dank JayCe

C ++, 79 76 64 Bytes

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

Diese Funktion akzeptiert ein Paar Iteratoren (die Iteratoren mit wahlfreiem Zugriff sein müssen) und bewegt sie stetig aufeinander zu. Wenn aauf eine ungerade Zahl gezeigt wird, wird sie vorgerückt. Andernfalls wird aauf eine gerade Zahl verwiesen. bwird dekrementiert und iter_swapmit a. (Wir verwenden XOR-Swap, was uns das Einbeziehen von <algorithm>- oder <utility>für - erspart std::swap.)

Es gibt unnötige Swaps, wenn bPunkte auf eine gerade Zahl gesetzt werden, aber wir spielen Golf, ohne die Effizienz zu beeinträchtigen!

Demo

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;
}

Nicht wettbewerbsfähige Antwort

Die natürliche C ++ - Methode ist std::partition, aber das kommt bei 83 Bytes heraus:

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

Japt , 2 Bytes

ñv

Probieren Sie es online!

Perl 6 , 12 Bytes

*.sort(*%%2)

Probieren Sie es online!

Ein beliebiger Code, der die Eingabe nach Parität sortiert, wobei ungerade Zahlen an erster Stelle stehen. Sie können %stattdessen a entfernen , um zuerst gerade Zahlen zu erhalten. Beachten Sie, dass "Was auch immer" der Name dieser Art anonymer Funktion ist.

MATL, 6 Bytes

tog&)v

Probieren Sie es auf MATL Online aus

Abwechselnd:

to_2$S

Probieren Sie es auf MATL Online aus

Python 2 , 37 36 Bytes

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

Probieren Sie es online!

1 Byte Trinkgeld für Mr. Xcoder .

Stax , 5 Bytes

{|eom

Führen Sie es aus und debuggen Sie es

Erläuterung:

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

Haskell , 23 22 Bytes

f odd<>f even
f=filter

Probieren Sie es online! Dies ist äquivalent zu

g x = filter odd x ++ filter even x

-1 Byte danke an Lynn

Andere Ansätze:

(<>).($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 Bytes

SortBy!Even

Probieren Sie es online!

Erläuterung

EvenGibt truefür gerade und falseandere Zahlen zurück . SortByRänge false < true(durch einen numerischen Wurf auf 0 < 1), wodurch ungerade Zahlen vor gerade gestellt werden.

JavaScript (Node.js) , 29 Byte

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

Probieren Sie es online! Sparen Sie 4 Bytes, indem Sie nur positive Werte mit unterstützen b%2-a%2. Wenn Sie dies schreiben als:

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

dann wird es auf allen Arten von alten JavaScript-Implementierungen funktionieren, die nicht stabil sortiert wurden.

T-SQL, 26 Bytes

SELECT*FROM t ORDER BY~i&1

Verwendet den bitweisen AND-Operator "&", um die letzte Ziffer mit 1 zu vergleichen.

BEARBEITEN: Bitweise NICHT kürzer als Hinzufügen von 1. BEARBEITEN2: Neu anordnen, um das Entfernen des Leerzeichens zu ermöglichen.

Gelee , 3 Bytes

ḂÞṚ

Probieren Sie es online!

Eines der am häufigsten gesuchten Atome scheint ein gleichmäßiges zu sein (was diese 2 Bytes ergeben würde), ohne das wir umkehren müssen, glaube ich ...

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

JavaScript, 22 bis 20 Byte

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

Probieren Sie es online!

PHP , 55 Bytes

~ 14 Monate später und ich bin jetzt ein bisschen besser im Golfen:

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

Probieren Sie es online!

PHP (> = 5,4), 84 82 Bytes

(-2 Bytes, danke an Ismael Miguel )

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

Um es auszuführen:

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

Beispiel:

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

Oder versuchen Sie es online!

Rot , 42 Bytes

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

Probieren Sie es online!

Wenn wir negative Werte berücksichtigen müssen:

Rot , 43 Bytes

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

Probieren Sie es online!

Schale , 4 Bytes

↔Ö%2

Probieren Sie es online!

Erläuterung

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

Scala , 18 Bytes

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

C #, 23 Bytes

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

Richtig geradeaus: Das konvertiert im Grunde genommen die Zahlen in Boolesche Werte, während truedie Zahl gerade und falsedie ungerade ist. Denn trueist höher als falsedie geraden Zahlen erscheinen zuerst.

Die formatierte Version sieht so aus:

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

Und so kannst du es testen:

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})));

Was zu Folgendem führt:

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

JavaScript, 23 Byte

6 Bytes kürzer als die Antwort von @ Neil in derselben Sprache: D

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

Erläuterung:

Die an übergebene Funktion sortkümmert sich nur um den ersten Parameter. Wenn es ungerade ist, gibt es zurück -1(das Ergebnis von -(n&1)). Andernfalls (wenn sich -(n&1)ergibt 0) kehrt es zurück 1.

Probieren Sie es online!

Python , 35 Bytes

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

Probieren Sie es online!

Sortiert nach der Funktion x -> (-1)**x, die -1für ungerade und 1für gerade gibt.

JavaScript (Chrome v67) - 24 19 23 Bytes

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

Die Verwendung von &1anstatt Math.abs()%2wurde von @Neil gestohlen. Vielen Dank!

Vielen Dank an @Shaggy für die Anzeige, dass meine 19-Byte-Hacky-Lösung nicht gültig war. Wenn jemand es will:

_{Hängt davon ab, wie der Browser mit einem Hacky Return-Wert von umgeht 0. Chrome v67 hat es nach 100000 Iterationen von zufälligen Arrays nie falsch sortiert. Ich bin mir sehr sicher, dass es funktioniert - und es hängt auch von dem speziellen Sortieralgorithmus ab, den Chrome verwendet, glaube ich. (Es könnte in anderen Browsern funktionieren, das ist nicht der Punkt)}

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

JavaScript, 21 Bytes

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

Probieren Sie es online aus

PowerShell , 22 bis 19 Byte

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

Probieren Sie es online!

Nimmt Eingaben über Splatting entgegen, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @adie sich bei TIO als separate Argumente für jeden Eintrag manifestieren.

Wie einige andere Antworten hier, Sort-Object kann auch ein Vergleich anhand eines Ausdrucks erfolgen. Hier ist der Ausdruck !($_%2), dh die Gewinnchancen werden sortiert $falseund die Gewinnchancen werden sortiert $true. Durch den Vergleich von Booleschen Werten werden falsche Werte zuerst sortiert. Dadurch werden die Gewinnchancen an den Anfang der Ausgabe und die Gewinnchancen an das Ende verschoben. Sort-Objectist stabil, daher ändert sich die Reihenfolge der einzelnen Artikel in ihren jeweiligen Kategorien nicht (wie im TIO-Beispiel).

-3 Bytes dank mazzy.

Ruby , 23 Bytes

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

Probieren Sie es online!

Erläuterung:

sort_by sortiert jede Zahl so, als wäre ihr Wert das Ergebnis des Blocks (~i%2 )

~xist gleichbedeutend mit -x-1und hat Vorrang vor%2

Ungerade Zahlen werden zu 0und gerade Zahlen werden zu ausgewertet, 1sodass ungerade Zahlen zuerst sortiert werden.

Kaum verwandt: Dies funktioniert auf Ruby aus Homebrew 2.5.1p57 (da es auf einem kleinen Fehler basiert), aber nur für nicht negative ganze Zahlen, 20 Bytes

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

Erläuterung:

Dies verwendet, sortwas einen Block erwartet, der 2 Werte annimmt und zurückgibt -1, 0oder 1je nachdem, ob der erste größer ist, sie gleich sind oder der zweite größer ist.

Der hier angegebene Block ignoriert den zweiten Wert und gibt zurück, -1ob die erste Zahl ungerade oder 0gerade ist.

Es ist nicht garantiert, dass es funktioniert, aber es funktioniert in einigen (ich denke fehlerhaften) Implementierungen.

6502 Maschinencode- Routine, 47 Bytes

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

Erwartet einen Zeiger auf ein Array von Zahlen in $fb/ $fcund die Länge dieses Arrays in$fd . Manipuliert das Array so, dass alle ungeraden Zahlen im Vordergrund stehen. Dies ist ein positionsunabhängiger Code, daher wird keine Ladeadresse benötigt.

Da es sich beim 6502 um einen 8-Bit-Chip handelt (in den Anweisungen werden nur 8-Bit-Werte behandelt, die optional signiert sind), gilt der gültige Nummernbereich [-128 .. 127]und die maximale Array-Größe 256.

Kommentierte Demontage

; 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

Beispiel C64 Assembler Programm mit der Routine:

Online-Demo

Code in ca65- Syntax:

.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

Elixier , 37-35 Bytes

Code:

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

Erweiterte Version:

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

Probieren Sie es online!

Clojure - 35 Bytes

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

Ungolfed:

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