Étant donné un entier non négatif ( n), créez une fonction qui retourne ndans l'ordre alphabétique, selon l'orthographe littérale de chaque chiffre dans n.

Exemples:

Input: 101
>> one, zero, one
>> one, one, zero
Output: 110

Input: 31948
>> three, one, nine, four, eight
>> eight, four, nine, one, three
Output: 84913

Input: 5544
>> five, five, four, four
>> five, five, four, four
Output: 5544

Input: 1234567890
Output: 8549176320

Remarque: les opérations dans l'exemple ne sont qu'illustratives et n'ont pas besoin d'être incluses dans la sortie. Seul le numéro trié par ordre alphabétique doit être renvoyé.

Il s'agit de code-golf, donc le code le plus court en octets l'emporte.

Modifier: l'entrée peut être prise dans le format souhaité qui convient le mieux à votre langue, et la sortie peut être produite de la même manière en revenant de la fonction ou de l'impression. L'entrée sera toujours un nombre naturel (y compris 0) et ne contiendra pas de 0 en tête.

Entrée OEIS pertinente (A057846) trouvée par @DomHastings

Perl 6 ,  32  28 octets

{+[~] .comb.sort: *.Str.uniname}
{+[~] .comb.sort: *.uniname}

Explication:

{
  # turn the following into a Numeric
  +

  # fold the following list using string concatenation operator
  [~]

    # split $_ into individual characters
    # (implicit method call on implicit parameter)
    .comb

    .sort:
    *.uniname # sort by the Unicode name of the character (digit)
}

Tester:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  101 => 110,
  31948 => 84913,
  5544 => 5544,
  1234567890 => 8549176320,
);

# give the lambda a lexical name for clarity
my &int-sort = {+[~] .comb.sort: *.uniname}

plan 3 * @tests;

for @tests -> $_ ( :key($input), :value($expected) ) {
  put '';
  isa-ok $input, Int, "input ($input) is an Int";

  my $output = int-sort $input;

  is $output, $expected, .gist;
  isa-ok $output, Int, "output ($output) is an Int"
}

1..12

ok 1 - input (101) is an Int
ok 2 - 101 => 110
ok 3 - output (110) is an Int

ok 4 - input (31948) is an Int
ok 5 - 31948 => 84913
ok 6 - output (84913) is an Int

ok 7 - input (5544) is an Int
ok 8 - 5544 => 5544
ok 9 - output (5544) is an Int

ok 10 - input (1234567890) is an Int
ok 11 - 1234567890 => 8549176320
ok 12 - output (8549176320) is an Int

05AB1E, 12 11 10 octets

•OWÿ¾•vy†J

Expliqué

•OWÿ¾•        # push sortorder (236719458)
      v       # for each number in sortorder
       y†     # filter to the front
         J    # join
              # implicitly print

Essayez-le en ligne

1 octet enregistré grâce à Adnan

JavaScript (ES6), 54

Modifier le même nombre de caractères, mais en évitant la variable globalez

Entrée / sortie sous forme de chaînes

n=>[...n].sort((a,b)=>n[a]-n[b],n='9487216503').join``

Tester

f=n=>[...n].sort((a,b)=>n[a]-n[b],n='9487216503').join``

function test() {
  O.textContent=f(I.value)
}

test()

<input id=I type=number value=31948 oninput='test()'>
<pre id=O></pre>

Haskell, 62 51 44 octets

Comme l'a suggéré @nimi, l'utilisation d'une liste de compréhension est plus courte que la composition de fonctions:

f x=0+read[a|a<-"8549176320",b<-show x,a==b]

Pour référence ma version:

f n=read.(=<<)(\x->filter(==x)$show n)$"8549176320"

La version sans point est un peu plus longue:

f=flip(read.)"8549176320".(=<<).flip(filter.(==)).show

Simple: filtrez les chiffres dans le bon ordre, puis concaténez le résultat.

Pyth, 12 10 octets

ox`C" Ȁ\0

Je ne sais pas s'il peut être joué plus loin. L'entrée doit être placée entre guillemets.

2 octets économisés grâce à @isaacg!

En pseudocode pythonique:

                Q = input()
o          Q    sort(Q, key = lambda N:
  `C" Ȁ\0        repr(base256toDec(" Ȁ\0"))
 x        N         .index(N)     # 8 being absent from the number yields -1
                )

Testez-le ici .

Perl, 37 octets

Code de 36 octets + ligne de commande de 1 octet (-F)

say sort{8549176320=~/$b.*$a/||-1}@F

Exemple d'utilisation:

echo -n "04823" | perl -F -M5.010 entry.pl

MATL , 19 octets

Vt'8549176320'&m2$S

Essayez-le en ligne!

Explication

V              % Implicitly input number. Convert to string (¹)
t              % Push copy of (¹)
'8549176320'   % Push this string (²), which defines order
&m             % Indices (³) of each element of (¹) in (²)
2$S            % Sort copy of (¹) according to (³). Implicitly display

Gelée, 11 octets

“U1°ŀ”OṾf@€

Essayez-le ici.

Explication

“U1°ŀ”O       Get the Unicode ordinals of “U1°ŀ”
                (all of which are coincidentally single bytes
                in the Jelly code page!)
              The result is [85, 49, 176, 320].
       Ṿ      Uneval. This gets us the string “85,49,176,320”.
        f@€   For each char in this string, extract all chars
                from the first command line argument that
                equal it.

Mathematica 35 78 47 octets

31 octets économisés grâce à une suggestion de LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitsdécompose le nombre en chiffres qui sont ensuite triés en fonction de leurs noms en anglais. FromDigitsassemble les chiffres en un nombre de base 10.

FromDigits@SortBy[IntegerDigits@#,IntegerName]&[1234567890]

8549176320

C, 142 141 117

Passez le paramètre long long *à f(); la fonction modifie le paramètre:

f(long long*n){char*c="8549176320",g[10]={0};for(;*n;*n/=10)++g[*n%10];for(;*c;++c)for(;g[*c-48]--;*n=*n*10+*c-48);}

long longest nécessaire car le dernier cas de test a débordé intlors du tri.

Python 2 - 95 octets

def s(n):
    l=list("8549176320")
    return "".join(sorted(list(n),key=lambda x: l.index(x)))

Essayer de continuer à jouer au golf ... Je pense que la ligne 2 est inutile et cela peut devenir 1 lambda.

EDIT: version 49 caractères dans les commentaires, thx à xnor et vaultah pour de l'aide.

- Oracle 11 (SQL): 164 octets

  SELECT LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',')WITHIN GROUP(ORDER BY 1)FROM(SELECT SUBSTR(&1,level,1)s FROM dual CONNECT BY LEVEL<=LENGTH(&1));

Forme longue et explication

  SELECT LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',') WITHIN GROUP (ORDER BY 1)
  FROM ( SELECT SUBSTR(&1,level,1)s FROM dual
           CONNECT BY LEVEL <= LENGTH(&1)
        );

Obtenez l'entrée en tant que paramètre du script:

  SELECT &1 FROM dual

"créer" des lignes en utilisant la connexion en fonction de la longueur de l'entrée:

  CONNECT BY LEVEL <= LENGTH(&1)

Extrayez chaque chiffre de la chaîne pour chaque position:

  SELECT SUBSTR(&1,level,1)s FROM dual

Convertissez le chiffre en date julienne, puis revenez à Char pour obtenir l'orthographe:

  TO_CHAR(TO_DATE(s,'j'),'jsp')

Vérifiez zéro - cas spécial.

  DECODE(s,0,'zero'

Utilisez la fonction LISTAGG pour concaténer des lignes en une seule liste de lignes, délimitées par des virgules, classées par ordre alphabétique

  LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',') WITHIN GROUP (ORDER BY 1)

Toujours amusant d'essayer de modifier SQL pour des choses comme ça ... :) teste vraiment ma connaissance du bugger ...

Rubis, 60 octets

->n{n.to_s.chars.sort_by{|c|'8549176320'.index c}.join.to_i}

Raquette, 142 130 octets

(λ(n)(string->number(list->string(sort(string->list(~a n))char<? #:key(λ(m)(string-ref "9487216503"(-(char->integer m)48)))))))

Dont les conversions sont plus près de la moitié de la longueur ( 76 64 octets).

TSQL, 260 octets

Tri des bulles inversé utilisé pour éviter de se référer à la longueur, pour économiser quelques octets

Golfé:

DECLARE @ varchar(99)=101

,@i INT=99,@j INT=98WHILE @i>1SELECT
@=IIF(CHARINDEX(x,'598327614')>CHARINDEX(y,'598327614'),STUFF(STUFF(@,@j,1,x),@i,1,y),@),@i-=IIF(@j=1,1,0),@j=IIF(@j=1,@i,@j-1)FROM(SELECT
SUBSTRING(@,@i,1)x,SUBSTRING(@,@j,1)y)z
PRINT @

Non golfé:

DECLARE @s BIGINT=1234567890

DECLARE @ char(99)=@s,@i INT=99,@j INT=98
WHILE @i>1
  SELECT 
    @=IIF(CHARINDEX(x,'236719458')>CHARINDEX(y,'236719458'),
        STUFF(STUFF(@,@j,1,x),@i,1,y),@), 
    @i-=IIF(@j=1,1,0),
    @j=IIF(@j=1,@i,@j-1)
  FROM(SELECT SUBSTRING(@,@i,1)x,SUBSTRING(@,@j,1)y)z
PRINT CAST(@ as bigint)

Insister sur l'utilisation de types entiers comme entrée et sortie a ajouté 37 octets

ClojureScript, 45 octets

#(apply str(sort-by(vec"9487216503")(str %)))

Utilise une conversion stringy>> int vissée à partir de la fuite de Javascript, donc ce n'est pas valide Clojure.

Firebird, 317 octets

Golfé:

select list(s,'')from(with recursive q as(select 1 p,substring(:a from 1 for 1)s from rdb$database q union all select q.p+1 p,substring(:a from q.p+1 for 1)s from q where q.p<char_length(:a))select s from q order by iif(s=8,0,iif(s=5,1,iif(s=4,2,iif(s=9,3,iif(s=1,4,iif(s=7,5,iif(s=3,7,iif(s=2,8,iif(s=0,9,6))))))))))

Non golfé:

select list(s, '')
from (
   with recursive q as (
      select 1 as p, substring(:a from 1 for 1) s
      from rdb$database q
      union all
      select q.p + 1 as p, substring(:a from q.p + 1 for 1) as s
      from q
      where q.p < char_length(:a)
   )
   select s
   from q
   order by iif(s = 8, 0,
               iif(s = 5, 1,
                  iif(s = 4, 2,
                     iif(s = 9, 3,
                        iif(s = 1, 4,
                           iif(s = 7, 5,
                              iif(s = 3, 7,
                                 iif(s = 2, 8,
                                    iif(s = 0, 9, 6)))))))))
)

Il n'y a pas de fonctionnalité partagée dans Firebird. Au lieu de cela, j'ai créé une requête récursive pour obtenir le caractère suivant encore et encore. Puis resélectionnez-les en les triant par notre bon ordre. Enfin concaténer ces résultats ensemble dans une liste. Remplacez le délimiteur de virgule par défaut par un blanc. Je pourrais économiser 11 octets en créant une nouvelle table factice au lieu de rdb$databasemais j'ai pensé que cela pouvait être contraire aux règles.

ZX Spectum, code machine, 53 48 47 45 44 octets

    org 49200 ; #c030

; table converts ascii to alfabetical order
; start from BASIC with any number as : PRINT "1234567890" AND USR 49208

convtab defb 249 ; zero defb 244 ; one defb 248 ; two defb 247 ; three defb 2+205 ; four defb 1+205 ; five defb 246 ; six defb 245 ; seven ; defb 0 ; eight ; defb 3 ; nine ; last 2 conversions hidden in call-command

start Call #2bf1    ; fetch stackindex
    call #2ab2 ; store back
    ld h,#c0    ; set highbyte of table


Sort Push de
loop ld b,d
    ld c,e
    inc de
    ld a,(bc)   ; fetch number
    Ld l,a
    ld a,(de)
    cp 34       ; endmarker "
    Jr z,exit   ; end reached?
    push hl     ; save number
    ld l,a
    Ld a,(hl)   ; convert second number
    pop hl
    cp (hl)     ; compare numbers
    jr nc,loop  ; in order, no swap
swap ld a,(bc)  ; swap original numbers
    ld l,a
    ld a,(de)
    ld (bc),a
    ld a,l
    ld (de),a
Exit pop de
    Ret z
    jr sort     ; check number for order

Facteur, 128

[ 10 base> [ 48 - ] { } map-as dup [ number>text ] map zip [ second first ] sort-with [ first ] map [ 48 + ] ""map-as 10 >base ]

Hourra pour les intégrés! :RÉ

PHP, 126 octets

Pour autant que je sache, php n'a pas de code intégré qui pourrait vraiment aider à cela (le mieux que je puisse faire en utilisant un usort (str_split ()) était de 5 octets de plus), donc la seule chose que je suis satisfait de cette réponse est la jeux joués avec $ i pour économiser quelques octets sur l'itération.

<?php for($i=-1;$i<9;)$a[++$i]=preg_replace("/[^$i]/","",$argv[1]);array_multisort([9,4,8,7,2,1,6,5,0,3],$a);echo implode($a);

APL, 23 octets

{⍎n['8549176320'⍋n←⍕⍵]}

Explication:

• n←⍕⍵: obtenir la représentation sous forme de chaîne net la stocker dansn
• '8549176320'⍋: trouver une permutation de nce genre nétant donné l'ordre 8549176320.
• n[... ]: réorganiser npar cette permutation
• ⍎: évaluer le résultat (pour le reconvertir en nombre)

Clojure, 53 octets

Eh bien, l'idée de compréhension de liste de la solution Haskell semble être la plus courte:

#(apply str(for[p"8549176320"b(str %):when(= p b)]p))

Mon approche originale est d'un octet de plus:

#(apply str(sort-by(zipmap"549176320"(range))(str %)))

Vous pouvez voir les deux fonctions en ligne ici: https://ideone.com/afac5n

Lisp commun, 104

(lambda(n)(#1=parse-integer(sort(format()"~A"n)'string<= :key(lambda(u)(format()"~R"(#1#(string u)))))))

Non golfé

(lambda (n)
  (parse-integer
   (sort (format nil "~A" n)
         #'string<=
         :key (lambda (u) (format nil "~R" (parse-integer (string u)))))))

Convertissez un entier sous forme de chaîne, triez les caractères à l'aide de la string<=comparaison tout en utilisant une :keyfonction personnalisée qui convertit un caractère donné en représentation anglaise de la valeur numérique qu'il représente. Habituellement, je n'utiliserais pas une fonction clé qui fait autant que celle-ci, mais elle coûte moins en octets que décorer / trier / décorer.

Python 3, 234 octets

Ceci est une traduction directe de ma réponse Factor , juste pour le plaisir.

def f(n):
 s=list(map(int,str(n)))
 return int("".join(list(map(str,list(map(lambda x:x[1],sorted(list(zip(list(map(lambda t:{0:"zero",1:"one",2:"two",3:"three",4:"four",5:"five",6:"six",7:"seven",8:"eight",9:"nine"}[t],s)),s)))))))))

La sémantique de l'évaluation des objets "paresseux" de la carte et du zip est la pièce la plus subtile des excréments de chevaux induisant les insectes les plus difficiles à trouver dans l'univers. Parfois, s = map(f, x)ne permet pas sd'être utilisé correctement ou pas du tout.

Pyke, 14 octets

.#uЀB`@

Essayez-le ici!

C, 80 octets

Prend une chaîne contenant un nombre en base 10 et imprime dans stdio:

F(char*i){for(char*p,d,*o="8549176320";*o;++o)for(p=i;d=*p++;d-*o||putchar(d));}

Python 2.7.11, 67 octets

lambda n:''.join(sorted(list(n),key=lambda s:"9487216503"[int(s)]))

Prend une chaîne en entrée et sort une chaîne.

Python 3, 74 octets

lambda x:''.join(i[1]for i in sorted(['9487216503'[int(j)],j]for j in x))

PHP , 107 octets

function($a){usort($a,function($a,$b){return($z=array_flip([8,5,4,9,1,7,6,3,2,0]))[$a]-$z[$b];});return$a;}

Essayez-le en ligne!

Utilise une fonction de comparaison définie par l'utilisateur pour ajuster l'ordre de tri.

Sortie

101         110
31948       84913
5544        5544
1234567890  8549176320