Ordenar los números impares primero

20

Reorganice una lista dada de modo que todos los números impares aparezcan antes de todos los números pares. Además de este requisito, la lista de salida puede estar en cualquier orden.

La entrada solo contendrá enteros, pero pueden ser negativos y puede haber duplicados, y pueden aparecer en cualquier orden.

La solución más corta gana.

Casos de prueba

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

[] → []

code-golf  number  sorting 
— nombre para mostrar
fuente
Ty Buena pregunta. Respuesta: los números impares pueden venir en cualquier orden. :)
— display_name
11
Aunque el desafío es bastante simple, sería bueno agregar algunos casos de prueba. Por ejemplo, a primera vista, pensé que el bloque de números pares e impares también necesita ser ordenado.
— Laikoni
1
@AsoneTuhid Sí :), los números pueden repetirse.
— display_name
11
@Willmore Nunca se sabe con el código de golf, las reglas son importantes. Utilice el Sandbox la próxima vez para aclarar su pregunta antes de publicarla.
— Asone Tuhid
12
Edite su pregunta para incluir las aclaraciones que dio en los comentarios.
— Laikoni

Respuestas:

9

C ++, 79 76 64 bytes

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

Esta función acepta un par de iteradores (que deben ser iteradores de acceso aleatorio) y los mueve constantemente uno hacia el otro. Cuando aapunta a un número impar, se avanza. De lo contrario, aapunta a un número par; bes decrementado y iter_swapeditado con a. (Utilizamos XOR swap, lo que nos ahorra tener que incluir <algorithm>- o <utility>para std::swap).

Hay intercambios innecesarios cuando bapunta a un número par, ¡pero estamos jugando al golf, no exprimiendo la eficiencia!

Manifestación

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

Respuesta no competitiva

El método natural de C ++ es std::partition, pero eso sale a 83 bytes:

#include<algorithm>
[](auto a,auto b){std::partition(a,b,[](auto x){return x&1;});}
— Toby Speight
fuente
Creo que son 80 bytes, ya que necesita una nueva línea después de la #includedirectiva. Mis matemáticas apestan aunque ^^. Puede reemplazar !=con -, ahorrando 1 byte. Me gusta tu enfoque, ¡es inteligente!
— OOBalance
1
de lo contrario, los iteradores podrían cruzarse sin llegar a ser iguales. Si usa RandomAccessIterator , puede usarlo while(a<b)si es más conveniente que a!=busar una a-bversión de @ OOBalance .
— Peter Cordes
Puede acortar un poco la respuesta de 83 bytes reemplazándola algorithmpor regex: codegolf.stackexchange.com/a/150895
— OOBalance del
7

Perl 6 , 12 bytes

*.sort(*%%2)

Pruébalo en línea!

Algunos Cualquier código que ordene la entrada por paridad, con números impares primero. Puede eliminar a %para obtener números pares primero. Tenga en cuenta que 'Cualquiera' es el nombre de este tipo de función anónima.

— Jo King
fuente
1
¡Lo siento! ¡Accidentalmente edité tu respuesta en lugar de la mía!
— Chas Brown
5

Stax , 5 bytes

{|eom

Ejecutar y depurarlo

Explicación:

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

Haskell , 23 22 bytes

f odd<>f even
f=filter

Pruébalo en línea! Esto es equivalente a

g x = filter odd x ++ filter even x

-1 byte gracias a Lynn

Otros enfoques:

(<>).($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
fuente
¿Pero no necesita esto import Data.Semigroup?
— AlexJ136
1
@ AlexJ136 A partir de GHC 8.4.1, (<>)es parte de Prelude . Como TIO todavía ejecuta una versión anterior, la importación es necesaria allí. Pero tienes razón, debería haber mencionado esto directamente.
— Laikoni
1
k odd<>k even;k=filterGuarda un byte.
— Lynn
5

Adjunto , 11 bytes

SortBy!Even

Pruébalo en línea!

Explicación

Evendevuelve truepara números pares y de falseotra manera. SortByrangos false < true(por un reparto numérico a 0 < 1), colocando números impares antes de los pares

— Conor O'Brien
fuente
5

JavaScript (Node.js) , 29 bytes

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

Pruébalo en línea! Ahorre 4 bytes al admitir solo valores positivos con b%2-a%2. Si escribe esto como:

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

entonces funcionará en todo tipo de implementaciones de JavaScript antiguas que no se ordenaron de manera estable.

— Neil
fuente
1
No a=>a.sort((a,b)=>b&1-a&1)funciona
— Alexis Facques
1
@AlexisFacques No, que se analiza como b&(1-a)&1.
— Neil
1
a=>a.sort(a=>++a&1)es más corto :)
— Max
@Max Podría funcionar en los casos de prueba dados, pero no me sorprendería si alguien encontrara un ejemplo en el que no funciona.
— Neil
1
@Max También podría enviar eso como su propia respuesta.
— Neil
5

T-SQL, 26 bytes

SELECT*FROM t ORDER BY~i&1

Utiliza el operador AND "bit a bit" para comparar el último dígito con 1.

EDITAR: A nivel de bits NO, entonces más corto que agregar 1. EDITAR2: Reordenar para permitir la eliminación del espacio.

— George Dando
fuente
1
¡Agradable! ¡Derrótame por 5! Ahorre un byte más cambiando el orden y soltando el espacio:ORDER BY~i&1
— BradC
4

Jalea , 3 bytes

ḂÞṚ

Pruébalo en línea!

Uno de los átomos más buscados parece ser uno par (lo que haría que estos 2 bytes), sin él debemos revertir, creo ...

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

JavaScript, 22 20 bytes

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

Pruébalo en línea!

— andii1997
fuente
Creo que puedes dejar los paréntesis alrededor de tu tercero a.
— Jonathan Frech
No funciona si 0está incluido en la matriz.
— Shaggy
Eso está mal. js comparator no funciona de esa manera. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
— Qwertiy
2
De acuerdo con la especificación ECMA, "si comparefn no está indefinido y no es una función de comparación consistente para los elementos de esta matriz (ver más abajo), el comportamiento de ordenación está definido por la implementación". Esta función de comparación no es consistente. Entonces, esta no es una respuesta de JavaScript, pero podría ser una respuesta para alguna implementación particular de JavaScript, y tendría que nombrar qué implementación.
— user5090812
1
Creo que esto falla [1,2,3,4,5,6,6,-1,-2,-3,-4]. JavaScript array.sortes raro.
— Chas Brown
4

PHP , 55 bytes

~ 14 meses después y ahora estoy un poco mejor jugando al golf:

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

Pruébalo en línea!

PHP (> = 5.4), 84 82 bytes

(-2 bytes, gracias a Ismael Miguel )

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

Para ejecutarlo:

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

Ejemplo:

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

O Pruébelo en línea!

— Noche2
fuente
1
En lugar de $a=array_slice($argv,1);, use array_shift($a=&$argv);, que ahorra 1 byte. Además, elimine el espacio antes $aen join(' ', $a), guardando otro byte. Además, PHP 5.3 da resultados diferentes. Debe especificar para qué versión de PHP es esta solución.
— Ismael Miguel
1
@IsmaelMiguel: Gracias por la array_shiftidea y por señalar el error espacial. No estoy seguro de cómo perdí el espacio: DI también he agregado PHP> = 5.4 en el título.
— Noche2
Es un error común. De hecho, me sorprendió array_shiftcuando lo probé y funcioné.
— Ismael Miguel
3

Casco , 4 bytes

↔Ö%2

Pruébalo en línea!

Explicación

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

C #, 23 bytes

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

Realmente bastante directo: esto básicamente convierte los números en booleanos, mientras trueque significa que el número es par y falseque es impar. Porque truees más alto que falselos números pares aparecen primero.

La versión formateada se ve así:

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

Y puedes probarlo así:

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

Lo que resulta en lo siguiente:

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

JavaScript, 23 bytes

6 bytes más cortos que la respuesta de @ Neil usando el mismo idioma: D

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

Explicación:

La función pasada a sortsolo se preocupa por el primer parámetro. Si es impar, devuelve -1(el resultado de -(n&1)). De lo contrario (cuando -(n&1)rinde 0) vuelve 1.

Pruébalo en línea!

— ibrahim mahrir
fuente
2
Bienvenido a PPCG!
— Jonathan Frech
3

JavaScript (Chrome v67) - 24 19 23 bytes

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

El uso de en &1lugar de Math.abs()%2fue robado de @Neil. ¡Gracias!

Gracias a @Shaggy por mostrar que mi solución hacky de 19 bytes no era válida. Si alguien lo quiere:

Depende de cómo maneje el navegador un valor de retorno hacky de 0. Chrome v67, después de 100000 iteraciones de matrices aleatorias nunca lo ordenó mal. Estoy muy seguro de que funciona, y creo que también depende del algoritmo de clasificación específico que Chrome usa. (Puede funcionar en otros navegadores, ese no es el punto)

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

— Max
fuente
Bienvenido a PPCG :) Esto falla para la entrada [-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]en mi consola Chrome 67, la salida [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 - ¡Uy! ¡Estás absolutamente en lo correcto!
— Max
3

PowerShell , 22 19 bytes

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

Pruébalo en línea!

Toma información a través de salpicaduras, por ejemplo, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @aque en TIO se manifiesta como argumentos separados para cada entrada.

Al igual que algunas otras respuestas aquí, Sort-Objectpuede comparar en función de una expresión. Aquí la expresión es !($_%2), es decir, las probabilidades se ordenan $falsey los pares se ordenan $true. Gracias a cómo se comparan los valores booleanos, los valores de falsey se ordenan primero. Esto mueve las probabilidades al comienzo de la salida, y las iguala al final.Sort-Objectes estable, por lo que el orden de los elementos individuales en sus respectivas categorías no cambia (como en el ejemplo de TIO).

-3 bytes gracias a mazzy.

— AdmBorkBork
fuente
Se puede usar un splatting . Por ejemplo $a=(3,4,3); .\sort-odd-numbers-first.ps1 @a. Entonces $args|sort{!($_%2)}es suficiente. ¿No es así?
— mazzy
¿Por qué "hacer trampa"? Es una característica nativa de PowerShell. Una pregunta más: ¿podemos usar salpicaduras dentro de la solución codeGolf? Por ejemplo, una solución contiene varias funciones. si podemos entonces, ¿por qué las llamadas externas no deberían? si no podemos, ¿por qué esta característica prohibida? ¿Y qué características están prohibidas también?
— mazzy
1
@mazzy Gracias por señalar eso. He actualizado mi envío.
— AdmBorkBork
3

Ruby , 23 bytes

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

Pruébalo en línea!

Explicación:

sort_byordena cada número como si su valor fuera el resultado del bloque ( ~i%2)

~xes equivalente -x-1y tiene prioridad sobre%2

Los números impares se evaluarán 0y los pares se evaluarán de 1manera que los números impares se ordenarán primero.

Apenas relacionado: esto funciona en ruby ​​de homebrew 2.5.1p57 (porque se basa en un pequeño error) pero solo para enteros no negativos, 20 bytes

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

Explicación:

Esto usa sortque espera un bloque que toma 2 valores y devuelve -1, 0o1 dependiendo de si el primero es más grande, son iguales o el segundo es más grande.

El bloque dado aquí ignora el segundo valor y devuelve -1si el primer número es impar o0 par.

No se garantiza que funcione, pero lo hace en algunas implementaciones (creo que tiene errores).

— Asone Tuhid
fuente
Aquí definimos los idiomas por su implementación para que su solución de 20 bytes sea válida.
— Shaggy
@ Shaggy No importa, ayer había estropeado mis pruebas.
— Asone Tuhid
3

6502 rutina de código de máquina , 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

Espera un puntero a una matriz de números en $fb/ $fcy la longitud de esta matriz en$fd . Manipula la matriz en su lugar para tener todos los números impares al frente. Este es un código independiente de la posición, por lo que no se necesita una dirección de carga.

Como el 6502 es un chip de 8 bits (por lo que las instrucciones solo tratan con valores de 8 bits, opcionalmente firmados), el rango de número válido es [-128 .. 127]y el tamaño máximo de la matriz es 256.

Desmontaje comentado

; 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

Ejemplo de programa ensamblador C64 usando la rutina:

Demostración en línea

captura de pantalla

Código en sintaxis 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
fuente
2

Clojure - 35 bytes

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

Sin golf:

(defn oddsort [col]
  (sort (fn [p _] (odd? p)) col))
— Bob Jarvis - Restablece a Monica
fuente
Hay mucho margen de mejora, por ejemplo, puede enviar una función anónima que tenga una sintaxis de creación más corta a través de #(...). También podría sort-byintentarlo, aunque la presentación ya existe.
— NikoNyrh
@NikoNyrh: probé una #()función anónima pero obtuve un error de arity ya que se pasaron dos parámetros pero solo en el esperado / usado, y %2al agregarle más caracteres. Estaría interesado en ver cómo se puede hacer esto.
— Bob Jarvis - Restablece a Monica el
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.