Dado un entero no negativo ( n), cree una función que regrese nen orden alfabético, de acuerdo con la ortografía literal de cada dígito en n.

Ejemplos:

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

Nota: las operaciones en el ejemplo son solo ilustrativas y no necesitan ser incluidas en la salida. Solo debe devolverse el número ordenado alfabéticamente.

Este es el código de golf, por lo que gana el código más corto en bytes.

Editar: la entrada se puede tomar en cualquier formato deseado que mejor se adapte a su idioma, y ​​la salida se puede producir de manera similar al regresar de la función o imprimir. La entrada siempre será un número natural (incluido 0) y no contendrá ceros a la izquierda.

Entrada OEIS relevante (A057846) encontrada por @DomHastings

Perl 6 ,  32  28 bytes

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

Explicación:

{
  # 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)
}

Prueba:

#! /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 bytes

•OWÿ¾•vy†J

Explicado

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

Pruébalo en línea

Guardado 1 byte gracias a Adnan

JavaScript (ES6), 54

Edite el mismo recuento de caracteres, pero evite la variable globalz

Entrada / salida como cadenas

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

Prueba

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 bytes

Como sugirió @nimi, usar una comprensión de lista es más corto que componer funciones:

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

Para referencia mi versión:

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

La versión sin puntos es un poco más larga:

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

Directo: filtre los dígitos en el orden correcto y luego concatene el resultado.

Pyth, 12 10 bytes

ox`C" Ȁ\0

No estoy seguro si se puede jugar más al golf. La entrada debe estar entre comillas.

¡2 bytes guardados gracias a @isaacg!

En pseudocódigo pitónico:

                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
                )

Pruébalo aquí .

Perl, 37 bytes

Código de 36 bytes + línea de comando de 1 byte (-F)

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

Ejemplo de uso:

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

MATL , 19 bytes

Vt'8549176320'&m2$S

Pruébalo en línea!

Explicación

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

Jalea, 11 bytes

“U1°ŀ”OṾf@€

Pruébalo aquí

Explicación

“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 bytes

¡31 bytes guardados gracias a una sugerencia de LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitsdivide el número en dígitos que luego se ordenan según sus nombres en inglés. FromDigitsensambla los dígitos en un número base 10.

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

8549176320

C, 142 141 117

Pase el parámetro long long *a f(); la función modifica el parámetro:

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 longes necesario ya que el último caso de prueba se desbordó intcuando se ordenó.

Python 2 - 95 bytes

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

Intentando más golf ... Creo que la línea 2 es innecesaria y esto puede convertirse en 1 lambda.

EDITAR: versión de 49 caracteres en comentarios, gracias a xnor y vaultah por ayuda.

- Oracle 11 (SQL): 164 bytes

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

Forma larga y explicación

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

Obtenga la entrada como parámetro para el script:

  SELECT &1 FROM dual

"crear" filas usando connect by según la longitud de la entrada:

  CONNECT BY LEVEL <= LENGTH(&1)

Extraiga cada dígito de la cadena para cada posición:

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

Convierta el dígito a fecha juliana y vuelva a Char para obtener la ortografía:

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

Verificar cero - caso especial.

  DECODE(s,0,'zero'

Utilice la función LISTAGG para concatenar filas nuevamente en una sola lista de filas, delimitada por comas, ordenada alfabéticamente

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

Siempre es divertido tratar de ajustar SQL para cosas como esta ... :) realmente prueba mi conocimiento del bugger ...

Rubí, 60 bytes.

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

Raqueta, 142 130 bytes

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

De las cuales las conversiones son más de casi la mitad de la longitud ( 76 64 bytes).

TSQL, 260 bytes

Se utilizó la clasificación de burbuja invertida para evitar referirse a la longitud, para guardar algunos bytes

Golfizado:

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 @

Sin 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)

Insistiendo en usar tipos enteros como entrada y salida agregada 37 bytes

ClojureScript, 45 bytes

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

Utiliza un poco de conversión de string-> int de fuga de Javascript, por lo que no es válido Clojure.

Firebird, 317 bytes

Golfizado:

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

Sin 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)))))))))
)

No hay funcionalidad dividida en Firebird. En su lugar, creé una consulta recursiva para obtener el siguiente personaje una y otra vez. Luego, vuelva a seleccionarlos mientras ordena por nuestro orden adecuado. Finalmente concatene esos resultados nuevamente en una lista. Anule el delimitador de coma predeterminado con un espacio en blanco. Podría ahorrar 11 bytes creando una nueva tabla ficticia en lugar de hacerlo, rdb$databasepero pensé que podría estar en contra de las reglas.

ZX Spectum, código de máquina, 53 48 47 45 44 bytes

    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

Factor, 128

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

¡Hurra por las builtins! :RE

PHP, 126 bytes

Hasta donde sé, php no tiene ningún componente integrado que realmente ayude con esto (lo mejor que pude hacer usando un usort (str_split ()) fue 5 bytes más largo), así que lo único que estoy contento con esta respuesta es el juegos jugados con $ i para ahorrar un par de bytes en la iteración.

<?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 bytes

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

Explicación:

• n←⍕⍵: obtener la representación de cadena de ny almacenarla enn
• '8549176320'⍋: encuentra una permutación de nese tipo ndada la orden 8549176320.
• n[... ]: reordenar npor esa permutación
• ⍎: evalúa el resultado (para volverlo a convertir en un número)

Clojure, 53 bytes

Bueno, la idea de comprensión de listas de la solución de Haskell parece ser la más corta:

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

Mi enfoque original es 1 byte más largo:

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

Puede ver ambas funciones en línea aquí: https://ideone.com/afac5n

Lisp común, 104

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

Sin golf

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

Convierta un entero como una cadena, ordene los caracteres usando la string<=comparación mientras usa una :keyfunción personalizada que convierte un carácter dado como la representación en inglés del valor numérico que representa. Por lo general, no usaría una función clave que haga tanto como esta, pero cuesta menos en bytes que decorar / ordenar / decorar.

Python 3, 234 bytes

Esta es una traducción directa de mi respuesta Factor , solo por diversión.

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 semántica de la evaluación del mapa "perezoso" y los objetos zip es la pieza más sutil de excremento de caballo genuino difícil de encontrar que induce a los insectos en el universo. A veces, s = map(f, x)no permitirá sque se use correctamente o en absoluto.

Pyke, 14 bytes

.#uЀB`@

Pruébalo aquí!

C, 80 bytes

Toma una cadena que contiene un número en la base 10 e imprime en 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 bytes

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

Toma una cadena como entrada y genera una cadena.

Python 3, 74 bytes

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

PHP , 107 bytes

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

Pruébalo en línea!

Utiliza una función de comparación definida por el usuario para ajustar el orden de clasificación.

Salida

101         110
31948       84913
5544        5544
1234567890  8549176320