Trier d'abord les nombres impairs

20

Réorganisez une liste donnée de sorte que tous les nombres impairs apparaissent avant tous les nombres pairs. Outre cette exigence, la liste de sortie peut être dans n'importe quel ordre.

L'entrée ne contiendra que des entiers, mais ils peuvent être négatifs et il peut y avoir des doublons, et ils peuvent apparaître dans n'importe quel ordre.

La solution la plus courte l'emporte.

Cas de 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]ou[3,1,2,2,2,2]

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

[] → []

code-golf  number  sorting 
— Afficher un nom
source
Ty. Bonne question. Réponse: les nombres impairs peuvent venir dans n'importe quel ordre. :)
— display_name
11
Même si le défi est assez simple, ajouter des cas de test serait bien. Par exemple, à première vue, je pensais que le bloc de nombres pairs et impairs devait également être trié.
— Laikoni
1
@AsoneTuhid Oui :), les chiffres peuvent se répéter.
— display_name
11
@Willmore Vous ne savez jamais avec le golf de code, les règles sont importantes. Veuillez utiliser le bac à sable la prochaine fois pour clarifier votre question avant de la poster.
— Asone Tuhid
12
Veuillez modifier votre question pour inclure les clarifications que vous avez fournies dans les commentaires.
— Laikoni

Réponses:

9

C ++, 79 76 64 octets

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

Cette fonction accepte une paire d'itérateurs (qui doivent être des itérateurs à accès aléatoire) et les déplace progressivement l'un vers l'autre. Lorsqu'il apointe vers un nombre impair, il est avancé. Sinon, apointe vers un nombre pair; best décrémenté et iter_swapédité avec a. (Nous utilisons le swap XOR, ce qui nous évite d'avoir à inclure <algorithm>- ou <utility>pour std::swap).

Il y a des échanges inutiles quand on bpointe vers un nombre pair, mais nous jouons au golf, pas en réduisant l'efficacité!

Démo

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

Réponse non compétitive

La méthode C ++ naturelle est std::partition, mais cela fait 83 octets:

#include<algorithm>
[](auto a,auto b){std::partition(a,b,[](auto x){return x&1;});}
— Toby Speight
source
Je pense que c'est 80 octets, car vous avez besoin d'une nouvelle ligne après la #includedirective. Mais mes calculs sont nulles ^^. Vous pouvez remplacer !=par -, en économisant 1 octet. J'aime ton approche, c'est intelligent!
— OOBalance
1
sinon les itérateurs pourraient se croiser sans jamais devenir égaux. Si vous utilisez RandomAccessIterator , vous pouvez l'utiliser while(a<b)si c'est plus pratique que d' a!=butiliser une a-bversion @ OOBalance .
— Peter Cordes
Vous pouvez raccourcir un peu la réponse de 83 octets en la remplaçant algorithmpar regex: codegolf.stackexchange.com/a/150895
— OOBalance
7

Perl 6 , 12 octets

*.sort(*%%2)

Essayez-le en ligne!

Quel que soit le code qui trie l'entrée par parité, avec des nombres impairs en premier. Vous pouvez supprimer un %pour obtenir d'abord des nombres pairs. Notez que «peu importe» est le nom de ce type de fonction anonyme.

— Jo King
source
1
Pardon! J'ai accidentellement modifié votre réponse au lieu de la mienne!
— Chas Brown
5

Haskell , 23 22 octets

f odd<>f even
f=filter

Essayez-le en ligne! Cela équivaut à

g x = filter odd x ++ filter even x

-1 octet grâce à Lynn

Autres approches:

(<>).($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
source
Mais n'est-ce pas nécessaire import Data.Semigroup?
— AlexJ136
1
@ AlexJ136 Depuis GHC 8.4.1, (<>)fait partie de Prelude . Comme TIO exécute toujours une version plus ancienne, l'importation y est nécessaire. Mais vous avez raison, j'aurais dû le mentionner directement.
— Laikoni
1
k odd<>k even;k=filterenregistre un octet.
— Lynn
5

Attaché , 11 octets

SortBy!Even

Essayez-le en ligne!

Explication

Evenrenvoie truepour les nombres pairs et falseautrement. SortByrangs false < true(par une conversion numérique en 0 < 1), plaçant ainsi les nombres impairs avant les pairs.

— Conor O'Brien
source
5

JavaScript (Node.js) , 29 octets

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

Essayez-le en ligne! Économisez 4 octets en prenant uniquement en charge les valeurs positives à l'aide de b%2-a%2. Si vous écrivez ceci comme:

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

il fonctionnera ensuite sur toutes sortes d'anciennes implémentations JavaScript qui ne sont pas triées de manière stable.

— Neil
source
1
Ça ne a=>a.sort((a,b)=>b&1-a&1)marche pas ?
— Alexis Facques
1
@AlexisFacques Non, cela analyse comme b&(1-a)&1.
— Neil
1
a=>a.sort(a=>++a&1)est plus court :)
— Max
@Max Cela pourrait fonctionner sur les cas de test donnés, mais je ne serais pas surpris si quelqu'un trouvait un exemple où cela ne fonctionne pas.
— Neil
1
@Max Vous pourriez aussi bien soumettre cela comme votre propre réponse.
— Neil
5

T-SQL, 26 octets

SELECT*FROM t ORDER BY~i&1

Utilise l'opérateur AND au niveau du bit "&" pour comparer le dernier chiffre avec 1.

EDIT: au niveau du bit PAS puis plus court que l'ajout de 1. EDIT2: réorganiser pour permettre la suppression de l'espace.

— George Dando
source
1
Agréable! Battez-moi par 5! Économisez un octet de plus en échangeant la commande et en ORDER BY~i&1
— supprimant
4

Gelée , 3 octets

ḂÞṚ

Essayez-le en ligne!

L'un des atomes les plus recherchés semble être un is-even one (ce qui ferait ces 2 octets), sans cela nous devons inverser je crois ...

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

JavaScript, 22 20 octets

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

Essayez-le en ligne!

— andii1997
source
Je pense que vous pouvez laisser tomber les parenthèses autour de votre troisième a.
— Jonathan Frech
Ne fonctionne pas si 0est inclus dans le tableau.
— Shaggy
C'est faux. Le comparateur js ne fonctionne pas de cette manière. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
— Qwertiy
2
Selon la spécification ECMA, "Si comparefn n'est pas indéfini et n'est pas une fonction de comparaison cohérente pour les éléments de ce tableau (voir ci-dessous), le comportement de tri est défini par l'implémentation." Cette fonction de comparaison n'est pas cohérente. Ce n'est donc pas une réponse JavaScript, mais il peut s'agir d'une réponse pour une implémentation JavaScript particulière, et vous devrez nommer quelle implémentation.
— user5090812
1
Je pense que cela échoue [1,2,3,4,5,6,6,-1,-2,-3,-4]. JavaScript array.sortest bizarre.
— Chas Brown
4

PHP , 55 octets

~ 14 mois plus tard et je suis un peu mieux au golf maintenant:

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

Essayez-le en ligne!

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

(-2 octets, merci à Ismael Miguel )

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

Pour l'exécuter:

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

Exemple:

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

Ou essayez-le en ligne!

— Nuit2
source
1
Au lieu de $a=array_slice($argv,1);, utilisez array_shift($a=&$argv);, qui économise 1 octet. Supprimez également l'espace avant $adans join(' ', $a), économisant un autre octet. De plus, PHP 5.3 donne des résultats différents. Vous devez spécifier pour quelle version de PHP cette solution est destinée.
— Ismael Miguel
1
@IsmaelMiguel: Merci pour l' array_shiftidée et en signalant l'erreur spatiale. Je ne sais pas comment j'ai raté l'espace: DI a également ajouté PHP> = 5.4 dans le titre.
— Night2
C'est une erreur courante. En fait, j'ai été surpris par le array_shiftmoment où j'ai essayé et travaillé.
— Ismael Miguel
3

Husk , 4 octets

↔Ö%2

Essayez-le en ligne!

Explication

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

C #, 23 octets

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

Assez straigt vraiment: cela convertit essentiellement les nombres en booléens, tout en truesignifiant que le nombre est pair et falsequ'il est impair. Parce que trueest plus élevé que falseles nombres pairs apparaissent en premier.

La version formatée ressemble à ça:

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

Et vous pouvez le tester comme ça:

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

Ce qui se traduit par ce qui suit:

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

JavaScript, 23 octets

6 octets plus court que la réponse de @ Neil en utilisant la même langue: D

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

Explication:

La fonction passée à sortne se soucie que du premier paramètre. S'il est impair, il revient -1(le résultat de -(n&1)). Sinon (quand il -(n&1)cède 0) il revient 1.

Essayez-le en ligne!

— ibrahim mahrir
source
2
Bienvenue chez PPCG!
— Jonathan Frech
3

JavaScript (Chrome v67) - 24 19 23 octets

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

L'utilisation &1plutôt queMath.abs()%2 été volée à @Neil. Merci!

Merci à @Shaggy d'avoir montré que ma solution hacky de 19 octets n'était pas valide. Si quelqu'un le veut:

Dépend de la façon dont le navigateur gère une valeur de retour hacky de 0. Chrome v67, après 100 000 itérations de tableaux aléatoires, ne l'a jamais mal réglé. Je suis très sûr que cela fonctionne - et cela dépend également de l'algorithme de tri spécifique que Chrome utilise. (Cela pourrait fonctionner dans d'autres navigateurs, ce n'est pas le but)

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

— Max
source
Bienvenue dans PPCG :) Cela échoue pour l'entrée [-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]dans ma console Chrome 67, la sortie [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 - oups! vous avez absolument raison!
— Max
3

PowerShell , 22 19 octets

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

Essayez-le en ligne!

Prend l'entrée par splatting, par exemple, $a=(3,4,3); .\sort-odd-numbers-first.ps1 @aqui sur TIO se manifeste comme des arguments séparés pour chaque entrée.

Comme certaines autres réponses ici, Sort-Objectpeut comparer en fonction d'une expression. Ici, l'expression est !($_%2), c'est-à-dire que les cotes sont triées $falseet les égales sont triées $true. Grâce à la comparaison des valeurs booléennes, les valeurs de falsey sont d'abord triées. Cela déplace les probabilités au début de la sortie et les égalités à la fin.Sort-Objectest stable, donc l'ordre des éléments individuels dans leurs catégories respectives ne change pas (comme dans l'exemple TIO).

-3 octets grâce à mazzy.

— AdmBorkBork
source
Il peut utiliser une éclaboussure . Par exemple $a=(3,4,3); .\sort-odd-numbers-first.ps1 @a. C'est $args|sort{!($_%2)}assez. N'est-ce pas?
— mazzy
pourquoi "tricher"? c'est une fonction native de PowerShell. Une dernière question: pouvons-nous utiliser les éclaboussures dans la solution codeGolf? par exemple, une solution contient plusieurs fonctions. si nous pouvons alors pourquoi l'appel externe ne devrait pas? si nous ne pouvons pas alors pourquoi cette fonctionnalité a été interdite? et quelles fonctionnalités sont également interdites?
— mazzy
1
@mazzy Merci de l'avoir signalé. J'ai mis à jour ma soumission.
— AdmBorkBork
3

Rubis , 23 octets

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

Essayez-le en ligne!

Explication:

sort_by trie chaque nombre comme si sa valeur était le résultat du bloc (~i%2 )

~xest équivalent à -x-1et a priorité sur%2

Les nombres impairs évalueront 0et les nombres pairs évalueront1 donc les nombres impairs seront triés en premier.

À peine lié: cela fonctionne sur ruby ​​de homebrew 2.5.1p57 (car il est basé sur un petit bug) mais uniquement pour les entiers non négatifs, 20 octets

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

Explication:

Cela utilise sortqui attend un bloc qui prend 2 valeurs et renvoie -1, 0ou1 selon que le premier est plus grand, ils sont égaux ou le second est plus grand.

Le bloc donné ici ignore la deuxième valeur et retourne -1si le premier nombre est impair ou0 s'il est pair.

Il n'est pas garanti de fonctionner, mais il le fait dans certaines implémentations (je pense buggy).

— Asone Tuhid
source
Nous définissons ici les langues par leur implémentation afin que votre solution de 20 octets soit valide.
— Shaggy
@Shaggy Tant pis, j'avais foiré mes tests hier.
— Asone Tuhid
3

6502 routine de code machine , 47 octets

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

Attend un pointeur sur un tableau de nombres dans $fb/ $fcet la longueur de ce tableau dans$fd . Manipule le tableau en place pour avoir tous les nombres impairs devant. Il s'agit d'un code indépendant de la position, donc aucune adresse de chargement n'est nécessaire.

Comme le 6502 est une puce 8 bits (les instructions ne concernent donc que les valeurs 8 bits, éventuellement signées), la plage de numéros valide est [-128 .. 127]la taille maximale du tableau 256.

Démontage commenté

; 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

Exemple de programme assembleur C64 utilisant la routine:

Démo en ligne

screenshot

Code dans la syntaxe 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
source
2

Clojure - 35 octets

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

Non golfé:

(defn oddsort [col]
  (sort (fn [p _] (odd? p)) col))
— Bob Jarvis - Réintégrer Monica
source
Il y a beaucoup de place pour l'amélioration, par exemple vous pouvez soumettre une fonction anonyme qui a une syntaxe de création plus courte via #(...). Vous pouvez également sort-byessayer, bien que la soumission existe déjà.
— NikoNyrh
@NikoNyrh: a essayé une #()fonction anonyme mais a obtenu une erreur d'arité car deux paramètres ont été passés, mais uniquement sur attendu / utilisé, et %2en y ajoutant plus de caractères. Serait intéressé de voir comment cela pourrait être fait.
— Bob Jarvis - Réintègre Monica le
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.