Sortir angka ganjil terlebih dahulu

20

Atur ulang daftar yang diberikan sedemikian rupa sehingga semua angka ganjil muncul sebelum semua angka genap. Selain untuk persyaratan ini, daftar keluaran mungkin dalam urutan apa pun.

Input hanya akan berisi bilangan bulat, tetapi mungkin negatif dan mungkin ada duplikat, dan mereka dapat muncul dalam urutan apa pun.

Solusi terpendek menang.

Uji kasus

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

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

[] → []

code-golf  number  sorting 
— nama tampilan
sumber
Ty. Pertanyaan bagus. Jawaban: angka ganjil bisa datang dalam urutan apa pun. :)
— display_name
11
Meskipun tantangannya cukup sederhana, menambahkan beberapa test case akan menyenangkan. Misalnya pada pandangan pertama saya pikir blok angka ganjil dan genap juga perlu disortir.
— Laikoni
1
@ AsoneTuhid Ya :), angka dapat diulang.
— display_name
11
@Willmore Anda tidak pernah tahu dengan kode golf, aturan itu penting. Silakan gunakan Sandbox lain kali untuk mengklarifikasi pertanyaan Anda sebelum Anda mempostingnya.
— Asone Tuhid
12
Harap edit pertanyaan Anda untuk memasukkan klarifikasi yang Anda berikan di komentar.
— Laikoni

Jawaban:

9

C ++, 79 76 64 byte

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

Fungsi ini menerima sepasang iterator (yang harus merupakan iterator akses acak), dan terus menggerakkan mereka ke arah satu sama lain. Ketika amenunjuk ke nomor ganjil, itu maju. Jika tidak, aarahkan ke nomor genap; bdidekrementasi, dan iter_swapdiedit dengan a. (Kami menggunakan XOR swap, yang menyelamatkan kami harus menyertakan <algorithm>- atau <utility>untukstd::swap ).

Ada swap yang tidak perlu saat b menunjuk ke angka genap, tapi kami bermain golf, bukan menekan efisiensi!

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

Jawaban tidak kompetitif

Metode C ++ alami std::partition, tetapi keluar pada 83 byte:

#include<algorithm>
[](auto a,auto b){std::partition(a,b,[](auto x){return x&1;});}
— Toby Speight
sumber
Saya percaya itu 80 byte, karena Anda memerlukan baris baru setelah #includearahan. Matematika saya payah ^^. Anda dapat mengganti !=dengan -, menghemat 1 byte. Saya suka pendekatan Anda, itu pintar!
— OOBalance
1
jika tidak iterator dapat saling melewati tanpa pernah menjadi setara. Jika Anda menggunakan RandomAccessIterator , Anda dapat menggunakan while(a<b)jika itu lebih nyaman daripada a!=bmenggunakan versi @ OOBalance a-b.
— Peter Cordes
Anda dapat mempersingkat jawaban 83-byte sedikit dengan menggantinya algorithmdengan regex: codegolf.stackexchange.com/a/150895
— OOBalance
7

Perl 6 , 12 byte

*.sort(*%%2)

Cobalah online!

Beberapa kode apa pun yang mengurutkan input berdasarkan paritas, dengan angka ganjil terlebih dahulu. Anda dapat menghapus a %untuk mendapatkan nomor genap sebagai gantinya. Perhatikan bahwa 'Apapun' adalah nama dari fungsi anonim semacam ini.

— Jo King
sumber
1
Maaf! Saya tidak sengaja mengedit jawaban Anda, bukan jawaban saya!
— Chas Brown
5

Haskell , 23 22 byte

f odd<>f even
f=filter

Cobalah online! Ini setara dengan

g x = filter odd x ++ filter even x

-1 byte terima kasih kepada Lynn

Pendekatan lain:

(<>).($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]
— Laikoni
sumber
Tapi bukankah ini perlu import Data.Semigroup?
— AlexJ136
1
@ AlexJ136 Pada GHC 8.4.1, (<>)adalah bagian dari Prelude . Karena TIO masih menjalankan versi yang lebih lama, impor diperlukan di sana. Tapi Anda benar, saya seharusnya menyebutkan ini secara langsung.
— Laikoni
1
k odd<>k even;k=filtermenghemat satu byte.
— Lynn
5

Attache , 11 byte

SortBy!Even

Cobalah online!

Penjelasan

Evenmengembalikan trueangka genap dan falsesebaliknya. SortByperingkat false < true(oleh pemain numerik ke 0 < 1), sehingga menempatkan angka ganjil sebelum yang genap.

— Conor O'Brien
sumber
5

JavaScript (Node.js) , 29 byte

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

Cobalah online! Simpan 4 byte dengan hanya mendukung nilai positif menggunakan b%2-a%2. Jika Anda menulis ini sebagai:

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

maka itu akan bekerja pada semua jenis implementasi JavaScript lama yang tidak mengurutkan secara stabil.

— Neil
sumber
1
Tidak a=>a.sort((a,b)=>b&1-a&1)bekerja
— Alexis Facques
1
@AlexisFacques Tidak, itu diuraikan sebagai b&(1-a)&1.
— Neil
1
a=>a.sort(a=>++a&1)lebih pendek :)
— Maks
@ Max Ini mungkin bekerja pada kasus uji yang diberikan tetapi saya tidak akan terkejut jika seseorang menemukan contoh di mana itu tidak berhasil.
— Neil
1
@ Max Anda mungkin juga mengirimkannya sebagai jawaban Anda sendiri.
— Neil
5

T-SQL, 26 byte

SELECT*FROM t ORDER BY~i&1

Menggunakan bitwise DAN operator "&" untuk membandingkan digit terakhir dengan 1.

EDIT: Bitwise TIDAK lebih pendek daripada menambahkan 1. EDIT2: Urutkan ulang untuk memungkinkan penghapusan ruang.

— George Dando
sumber
1
Bagus! Kalahkan saya 5! Simpan satu byte lagi dengan menukar pesanan dan menjatuhkan ruang:ORDER BY~i&1
— BradC
4

Jelly , 3 byte

ḂÞṚ

Cobalah online!

Salah satu atom yang lebih sering dicari tampaknya adalah atom-bahkan (yang akan menghasilkan 2 byte), tanpa itu kita harus membalikkan saya percaya ...

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

JavaScript, 22 20 byte

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

Cobalah online!

— andii1997
sumber
Saya pikir Anda bisa meletakkan tanda kurung di sekitar sepertiga Anda a.
— Jonathan Frech
Tidak berfungsi jika 0disertakan dalam array.
— Shaggy
That's wrong. js comparator doiesn't work in such way. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
— Qwertiy
2
Menurut spesifikasi ECMA, "Jika comparefn tidak terdefinisi dan bukan fungsi perbandingan yang konsisten untuk elemen-elemen array ini (lihat di bawah), perilaku sort ditentukan oleh implementasi." Fungsi perbandingan ini tidak konsisten. Jadi ini bukan jawaban JavaScript, tapi itu mungkin jawaban untuk beberapa implementasi JavaScript tertentu, dan Anda harus menyebutkan implementasi yang mana.
— user5090812
1
Saya pikir ini gagal [1,2,3,4,5,6,6,-1,-2,-3,-4]. JavaScript array.sortitu aneh.
— Chas Brown
4

PHP , 55 byte

~ 14 bulan kemudian dan saya sedikit lebih baik dalam bermain golf sekarang:

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

Cobalah online!

PHP (> = 5.4), 84 82 byte

(-2 byte, terima kasih kepada Ismael Miguel )

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

Untuk menjalankannya:

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

Contoh:

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

Atau Coba online!

— Night2
sumber
1
Alih-alih $a=array_slice($argv,1);, gunakan array_shift($a=&$argv);, yang menghemat 1 byte. Juga, menghapus ruang sebelum $adi join(' ', $a), menyimpan byte lain. Juga, PHP 5.3 memberikan hasil yang berbeda. Anda harus menentukan versi PHP untuk solusi ini.
— Ismael Miguel
1
@IsmaelMiguel: Terima kasih atas array_shiftidenya dan menunjukkan kesalahan ruang. Saya tidak yakin bagaimana saya kehilangan ruang: DI telah menambahkan judul PHP> = 5,4 juga.
— Malam 2
Itu adalah kesalahan umum. Saya benar-benar terkejut oleh array_shiftketika saya mencobanya dan berhasil.
— Ismael Miguel
3

Sekam , 4 byte

↔Ö%2

Cobalah online!

Penjelasan

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

C #, 23 byte

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

Benar-benar maju: Ini pada dasarnya mengubah angka menjadi boolean, sementara itu trueberarti angkanya genap dan falseganjil. Karena truelebih tinggi daripada falseangka genap yang muncul lebih dulu.

Versi yang diformat terlihat seperti itu:

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

Dan Anda dapat mengujinya seperti itu:

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

Yang menghasilkan sebagai berikut:

3,1,5,5,2,2,2,2
— MetaColon
sumber
1
— Neil
3

JavaScript, 23 byte

6 byte lebih pendek dari jawaban @ Neil menggunakan bahasa yang sama: D

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

Penjelasan:

Fungsi yang diteruskan ke sorthanya peduli tentang parameter pertama. Jika ganjil mengembalikan -1(hasil -(n&1)). Kalau tidak (saat -(n&1)hasil 0) itu kembali1 .

Cobalah online!

— ibrahim mahrir
sumber
2
Selamat datang di PPCG!
— Jonathan Frech
3

Python , 35 byte

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

Cobalah online!

Urutkan berdasarkan fungsi x -> (-1)**x, yang memberi -1untuk ganjil dan 1genap.

— Tidak
sumber
3

JavaScript (Chrome v67) - 24 19 23 byte

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

Penggunaan &1daripada Math.abs()%2dicuri dari @Neil. Terima kasih!

Terima kasih kepada @Shaggy karena menunjukkan solusi 19 byte saya yang hacky tidak valid. Jika ada yang menginginkannya:

Bergantung pada bagaimana browser menangani nilai pengembalian 0. Chrome v67, setelah 100000 iterasi array acak tidak pernah diurutkan salah. Saya sangat yakin ini berfungsi - dan itu bergantung pada algoritma pengurutan khusus yang digunakan Chrome juga, saya percaya. (Mungkin bekerja di browser lain, bukan itu intinya)

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

— Maks
sumber
Selamat datang di PPCG :) Ini gagal untuk 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]di konsol Chrome 67 saya, mengeluarkan [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! Anda memang benar!
— Maks
3

PowerShell , 22 19 byte

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

Cobalah online!

Mengambil input melalui splatting, misalnya, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @a , yang pada TIO bermanifestasi sebagai argumen terpisah untuk setiap entri.

Seperti beberapa jawaban lain di sini, Sort-Objectdapat membandingkan berdasarkan ekspresi. Di sini ungkapannya !($_%2), yaitu, peluang diurutkan ke $falsedan bahkan diurutkan ke $true. Berkat bagaimana nilai Boolean dibandingkan, nilai falsey diurutkan terlebih dahulu. Ini memindahkan peluang ke awal keluaran, dan titik akhir ke akhir. Sort-Objectstabil, sehingga pemesanan setiap item dalam kategorinya masing-masing tidak berubah (seperti pada contoh TIO).

-3 byte berkat mazzy.

— AdmBorkBork
sumber
Itu bisa menggunakan splatting . Sebagai contoh $a=(3,4,3); .\sort-odd-numbers-first.ps1 @a. Jadi $args|sort{!($_%2)}cukup. Bukan?
— mazzy
mengapa "curang"? itu fitur PowerShell asli. Satu pertanyaan lagi: bisakah kita menggunakan splatting di dalam solusi codeGolf? misalnya, solusi berisi beberapa fungsi. jika kita bisa lalu mengapa panggilan eksternal tidak? jika kita tidak bisa mengapa fitur ini dilarang? dan fitur apa yang dilarang juga?
— mazzy
1
@ Mazzy Terima kasih telah menunjukkan itu. Saya telah memperbarui kiriman saya.
— AdmBorkBork
3

Ruby , 23 byte

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

Cobalah online!

Penjelasan:

sort_bymengurutkan setiap angka seolah-olah nilainya adalah hasil dari blok ( ~i%2)

~xsetara dengan -x-1dan diutamakan%2

Angka ganjil akan mengevaluasi 0dan bahkan angka akan mengevaluasi 1sehingga angka ganjil akan diurutkan terlebih dahulu.

Hampir tidak berhubungan: ini bekerja pada ruby ​​dari homebrew 2.5.1p57 (karena didasarkan pada bug kecil) tetapi hanya untuk bilangan bulat non-negatif, 20 byte

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

Penjelasan:

Ini menggunakan sortyang mengharapkan blok yang mengambil 2 nilai dan pengembalian -1, 0atau 1tergantung pada apakah yang pertama lebih besar, mereka sama atau yang kedua lebih besar.

Blok yang diberikan di sini mengabaikan nilai kedua dan kembali -1jika angka pertama ganjil atau 0bahkan genap.

Itu tidak dijamin untuk bekerja tetapi itu dalam beberapa (saya pikir kereta) implementasi.

— Asone Tuhid
sumber
Kami mendefinisikan bahasa dengan penerapannya di sini sehingga solusi 20 byte Anda valid.
— Shaggy
@Shaggy Sudahlah, saya mengacaukan pengujian saya kemarin.
— Asone Tuhid
3

6502 rutin kode mesin , 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

Mengharapkan pointer ke array angka di $fb/ $fcdan panjang array ini di$fd . Memanipulasi array di tempat untuk memiliki semua angka ganjil di depan. Ini adalah kode posisi independen, jadi tidak perlu memuat alamat.

Karena 6502 adalah chip 8bit (jadi instruksi hanya menangani nilai 8bit, ditandatangani opsional), kisaran angka yang valid adalah [-128 .. 127]dan ukuran array maksimumnya 256.

Dikomentari pembongkaran

; 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

Contoh program assembler C64 menggunakan rutin:

Demo online

tangkapan layar

Kode dalam sintaksis 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
— Felix Palmen
sumber
2

Elixir , 37 35 byte

Kode:

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

Versi yang diperluas:

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

Cobalah online!

— Adnan
sumber
2

Clojure - 35 byte

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

Tidak Disatukan:

(defn oddsort [col]
  (sort (fn [p _] (odd? p)) col))
— Bob Jarvis - Pasang kembali Monica
sumber
Ada banyak ruang untuk perbaikan, misalnya Anda dapat mengirimkan fungsi anonim yang memiliki sintaks pembuatan yang lebih pendek via #(...). Anda juga bisa sort-bymencoba, meskipun pengiriman sudah ada.
— NikoNyrh
@NikoNyrh: mencoba #()fungsi anonim tetapi mendapatkan kesalahan arity karena dua parameter dilewati tetapi hanya pada yang diharapkan / digunakan, dan membawanya %2menambahkan lebih banyak karakter. Akan tertarik untuk melihat bagaimana ini bisa dilakukan.
— Bob Jarvis - Pasang kembali Monica
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.