Ordina prima i numeri dispari


20

Riorganizza un determinato elenco in modo tale che tutti i numeri dispari vengano visualizzati prima di tutti i numeri pari. Inoltre per questo requisito, l'elenco di output può essere in qualsiasi ordine.

L'input conterrà solo numeri interi, ma potrebbero essere negativi e potrebbero esserci duplicati e potrebbero apparire in qualsiasi ordine.

Vince la soluzione più breve.

Casi test

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

[-2,-2,-2,-1,-2,-3][-1,-3,-2,-2,-2,-2,]o[-3,-1,-2,-2,-2,-2,]

[][]


Ty. Buona domanda. Risposta: i numeri dispari possono arrivare in qualsiasi ordine. :)
display_name

11
Anche se la sfida è piuttosto semplice, aggiungere alcuni casi di test sarebbe bello. Ad esempio, a prima vista, ho pensato che anche il blocco di numeri pari e dispari dovesse essere ordinato.
Laikoni,

1
@AsoneTuhid Sì :), i numeri possono ripetere.
display_name

11
@Willmore Non sai mai con il golf del codice, le regole sono importanti. Utilizza Sandbox la prossima volta per chiarire la tua domanda prima di pubblicarla.
Asone Tuhid,

12
Modifica la tua domanda per includere i chiarimenti che hai fornito nei commenti.
Laikoni,

Risposte:






9

C ++, 79 76 64 byte

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

Questa funzione accetta una coppia di iteratori (che devono essere iteratori ad accesso casuale) e li sposta costantemente l'uno verso l'altro. Quando apunta a un numero dispari, è avanzato. Altrimenti,a punta a un numero pari; bè decrementato, ed è iter_swapedito con a. (Usiamo lo scambio XOR, che ci evita di dover includere <algorithm>- o <utility>per std::swap).

Ci sono scambi non necessari quando si bpunta a un numero pari, ma stiamo giocando a golf, non schiacciando l'efficienza!

dimostrazione

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

Risposta non competitiva

Il metodo C ++ naturale è std::partition, ma questo risulta a 83 byte:

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

Credo che siano 80 byte, dal momento che è necessaria una nuova riga dopo la #includedirettiva. La mia matematica fa schifo però ^^. È possibile sostituire !=con -, salvando 1 byte. Mi piace il tuo approccio, è intelligente!
OOBalance,

1
altrimenti gli iteratori potrebbero passare l'un l'altro senza mai diventare uguali. Se stai usando RandomAccessIterator , puoi usarlo while(a<b)se è più conveniente che a!=busare una a-bversione di @ OOBalance .
Peter Cordes,

Puoi abbreviare un po 'la risposta a 83 byte sostituendo algorithmcon regex: codegolf.stackexchange.com/a/150895
OOBalance,


7

Perl 6 , 12 byte

*.sort(*%%2)

Provalo online!

Qualche codice qualunque che ordina l'input per parità, con numeri dispari per primi. Puoi invece rimuovere a %per ottenere prima i numeri pari. Si noti che "Qualunque" è il nome di questo tipo di funzione anonima.


1
Scusate! Ho modificato accidentalmente la tua risposta anziché la mia!
Chas Brown,




5

Haskell , 23 22 byte

f odd<>f even
f=filter

Provalo online! Questo equivale a

g x = filter odd x ++ filter even x

-1 byte grazie a Lynn


Altri approcci:

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

Ma questo non è necessario import Data.Semigroup?
AlexJ136,

1
@ AlexJ136 A partire da GHC 8.4.1, (<>)fa parte di Prelude . Poiché TIO esegue ancora una versione precedente, è necessaria l'importazione lì. Ma hai ragione, avrei dovuto dirlo direttamente.
Laikoni,

1
k odd<>k even;k=filtersalva un byte.
Lynn,

5

Attache , 11 byte

SortBy!Even

Provalo online!

Spiegazione

Evenritorna trueper numeri pari e falsenon. SortBygradi false < true(per un cast numerico a 0 < 1), posizionando così numeri dispari prima di quelli pari.


5

JavaScript (Node.js) , 29 byte

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

Provalo online! Salva 4 byte supportando solo valori positivi utilizzando b%2-a%2. Se lo scrivi come:

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

quindi funzionerà su tutti i tipi di vecchie implementazioni JavaScript che non sono state ordinate stabilmente.


1
Non a=>a.sort((a,b)=>b&1-a&1)funziona?
Alexis Facques,

1
@AlexisFacques No, che analizza come b&(1-a)&1.
Neil,

1
a=>a.sort(a=>++a&1)è più corto :)
Max

@Max Potrebbe funzionare sui casi di test indicati ma non sarei sorpreso se qualcuno trovasse un esempio in cui non funziona.
Neil,

1
@Max Potresti anche inviarlo come risposta personale.
Neil,

5

T-SQL, 26 byte

SELECT*FROM t ORDER BY~i&1

Utilizza l'operatore AND bit per bit "&" per confrontare l'ultima cifra con 1.

EDIT: bit a bit NON più breve dell'aggiunta 1. EDIT2: riordina per consentire la rimozione dello spazio.


1
Bello! Battimi di 5! Salvare un altro byte scambiando l'ordine e rilasciando lo spazio:ORDER BY~i&1
BradC

4

Gelatina , 3 byte

ḂÞṚ

Provalo online!

Uno degli atomi più richiesti sembra essere uno è pari (che renderebbe questi 2 byte), senza di esso dobbiamo invertire credo ...

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

4

JavaScript, 22 20 byte

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

Provalo online!


Penso che puoi lasciare le parentesi intorno al tuo terzo a.
Jonathan Frech,

Non funziona se 0è incluso nell'array.
Shaggy,

È sbagliato. js comparator non funziona in questo modo. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Qwertiy,

2
Secondo la specifica ECMA, "Se comparefn non è indefinito e non è una funzione di confronto coerente per gli elementi di questo array (vedi sotto), il comportamento dell'ordinamento è definito dall'implementazione". Questa funzione di confronto non è coerente. Quindi questa non è una risposta JavaScript, ma potrebbe essere una risposta per una particolare implementazione JavaScript e dovresti nominare quale implementazione.
user5090812

1
Penso che questo fallisca [1,2,3,4,5,6,6,-1,-2,-3,-4]. JavaScript array.sortè strano.
Chas Brown,

4

PHP , 55 byte

~ 14 mesi dopo e ora sono un po 'più bravo a giocare a golf:

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

Provalo online!


PHP (> = 5.4), 84 82 byte

(-2 byte, grazie a Ismael Miguel )

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

Per eseguirlo:

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

Esempio:

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

Oppure provalo online!


1
Invece di $a=array_slice($argv,1);, usa array_shift($a=&$argv);, che salva 1 byte. Inoltre, rimuovere lo spazio prima di $ain join(' ', $a), salvando un altro byte. Inoltre, PHP 5.3 offre risultati diversi. Dovresti specificare per quale versione di PHP è questa soluzione.
Ismael Miguel,

1
@IsmaelMiguel: Grazie per l' array_shiftidea e per aver sottolineato l'errore nello spazio. Non sono sicuro di come mi sia perso lo spazio: DI ha aggiunto anche PHP> = 5.4 nel titolo.
Night2

È un errore comune. In realtà sono rimasto sorpreso da array_shiftquando l'ho provato e ha funzionato.
Ismael Miguel,


3

Buccia , 4 byte

↔Ö%2

Provalo online!

Spiegazione

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


3

C #, 23 byte

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

Abbastanza avanti davvero: questo fondamentalmente converte i numeri in booleani, mentre truesignifica che il numero è pari e falseche è dispari. Perché trueè più alto di quanto falsei numeri pari compaiano per primi.

La versione formattata si presenta così:

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

E puoi provarlo così:

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

Il risultato è il seguente:

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


3

JavaScript, 23 byte

6 byte più brevi della risposta di @ Neil usando la stessa lingua: D

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

Spiegazione:

La funzione passata sortsi preoccupa solo del primo parametro. Se è dispari restituisce -1(il risultato di -(n&1)). Altrimenti (quando -(n&1)cede 0) ritorna 1.

Provalo online!


2
Benvenuti in PPCG!
Jonathan Frech,


3

JavaScript (Chrome v67) - 24 19 23 byte

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

L'uso di &1piuttosto che è Math.abs()%2stato rubato da @Neil. Grazie!

Grazie a @Shaggy per aver mostrato che la mia soluzione hacky 19 byte non era valida. Se qualcuno lo vuole:

Dipende da come il browser gestisce un valore di ritorno hacky di 0. Chrome v67, dopo 100000 iterazioni di array casuali non l'hanno mai risolto. Sono molto sicuro che funzioni e si basa anche sull'algoritmo di ordinamento specifico che Chrome utilizza. (Potrebbe funzionare in altri browser, non è questo il punto)

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


Benvenuto in PPCG :) Questo non riesce per l'input [-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]nella mia console Chrome 67, in uscita [7,-5,-3,17,-1,15,1,13,3,11,5,9,2,19,14,-4,6,18,-2,16,0,10,8,12,4].
Shaggy,

@Shaggy - oops! hai assolutamente ragione!
Max


3

PowerShell , 22 19 byte

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

Provalo online!

Accetta input tramite splatting, ad esempio, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @ache su TIO si manifesta come argomenti separati per ogni voce.

Come alcune altre risposte qui, Sort-Objectpuoi confrontare in base a un'espressione. Qui l'espressione è !($_%2), cioè, le probabilità vengono ordinate $falsee anche le categorie vengono ordinate $true. Grazie al confronto dei valori booleani, i valori di falso vengono ordinati per primi. Questo sposta le probabilità all'inizio dell'output e i pari alla fine. Sort-Objectè stabile, quindi l'ordine dei singoli articoli nelle rispettive categorie non cambia (come nell'esempio TIO).

-3 byte grazie a mazzy.


Può usare uno splatting . Per esempio $a=(3,4,3); .\sort-odd-numbers-first.ps1 @a. Quindi $args|sort{!($_%2)}è abbastanza. No?
mazzy,

perché "barare"? è la funzionalità PowerShell nativa. Un'altra domanda: possiamo usare lo splatting all'interno della soluzione codeGolf? ad esempio, una soluzione contiene diverse funzioni. se possiamo allora perché la chiamata esterna non dovrebbe? se non possiamo quindi perché questa funzione è stata vietata? e quali funzionalità sono vietate?
mazzy,

1
@mazzy Grazie per averlo sottolineato. Ho aggiornato la mia richiesta.
AdmBorkBork,

3

Rubino , 23 byte

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

Provalo online!

Spiegazione:

sort_byordina ogni numero come se il suo valore fosse il risultato del blocco ( ~i%2)

~x è equivalente a -x-1 e ha la precedenza su%2

I numeri dispari verranno valutati 0e i numeri pari verranno valutati in 1modo che i numeri dispari vengano ordinati per primi.

A malapena correlato: funziona su ruby ​​dall'homebrew 2.5.1p57 (perché si basa su un piccolo bug) ma solo per numeri interi non negativi, 20 byte

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

Spiegazione:

Questo utilizza ciò sortche prevede un blocco che accetta 2 valori e restituisce -1, 0oppure a 1seconda che il primo sia più grande, siano uguali o il secondo più grande.

Il blocco qui indicato ignora il secondo valore e restituisce -1se il primo numero è dispari o 0se è pari.

Non è garantito che funzioni, ma lo fa in alcune implementazioni (penso buggy).


Definiamo le lingue in base alla loro implementazione qui, quindi la tua soluzione a 20 byte è valida.
Shaggy,

@Shaggy Non importa, avevo incasinato i miei test ieri.
Solo Tuhid,

3

6502 routine codice macchina , 47 byte

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

Si aspetta un puntatore a una matrice di numeri in $fb/ $fce la lunghezza di questa matrice in$fd . Manipola l'array in posizione per avere tutti i numeri dispari in primo piano. Questo è un codice indipendente dalla posizione, quindi non è necessario alcun indirizzo di caricamento.

Poiché il 6502 è un chip a 8 bit (quindi le istruzioni riguardano solo i valori a 8 bit, facoltativamente firmati), l'intervallo di numeri valido è [-128 .. 127]e la dimensione massima dell'array è 256.

Smontaggio commentato

; 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

Esempio di programma assemblatore C64 che utilizza la routine:

Demo online

screenshot

Codice nella sintassi 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

2

Elisir , 37 35 byte

Codice:

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

Versione estesa:

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

Provalo online!


2

Clojure - 35 byte

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

Ungolfed:

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

C'è molto margine di miglioramento, ad esempio è possibile inviare una funzione anonima che ha una sintassi di creazione più breve tramite #(...). Inoltre potresti sort-byprovare, anche se l'invio esiste già.
NikoNyrh,

@NikoNyrh: ha provato una #()funzione anonima ma ha ricevuto un errore arity quando sono stati passati due parametri ma solo su previsto / utilizzato, e portando %2in esso ha aggiunto più caratteri. Sarebbe interessato a vedere come questo potrebbe essere fatto.
Bob Jarvis - Ripristina Monica il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.