Biorąc pod uwagę nieujemną liczbę całkowitą ( n), utwórz funkcję zwracającą się nw kolejności alfabetycznej, zgodnie z literalną pisownią każdej cyfry w n.

Przykłady:

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

Uwaga: operacje w tym przykładzie mają jedynie charakter ilustracyjny i nie muszą być uwzględniane w danych wyjściowych. Należy zwrócić tylko posortowaną alfabetycznie liczbę.

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach.

Edycja: dane wejściowe można zapisać w dowolnym formacie, który najlepiej odpowiada Twojemu językowi, a dane wyjściowe można wygenerować podobnie, wracając z funkcji lub drukowania. Dane wejściowe zawsze będą liczbami naturalnymi (w tym 0) i nie będą zawierać wiodących zer.

Odpowiedni wpis OEIS (A057846) znaleziony przez @DomHastings

Perl 6 ,  32  28 bajtów

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

Wyjaśnienie:

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

Test:

#! /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 bajtów

•OWÿ¾•vy†J

Wyjaśnił

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

Wypróbuj online

Zaoszczędzono 1 bajt dzięki Adnanowi

JavaScript (ES6), 54

Edytuj tę samą liczbę znaków, ale unikaj zmiennej globalnejz

Wejście / wyjście jako ciągi

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

Test

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 bajtów

Jak sugeruje @nimi, użycie rozumienia listy jest krótsze niż komponowanie funkcji:

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

Dla odniesienia moja wersja:

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

Wersja pointfree jest nieco dłuższa:

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

Prosto: Filtruj cyfry we właściwej kolejności, a następnie połącz wynik.

Pyth, 12 10 bajtów

ox`C" Ȁ\0

Nie jestem pewien, czy można dalej grać w golfa. Dane wejściowe należy ująć w cudzysłów.

2 bajty zapisane dzięki @isaacg!

W pythonowym pseudokodzie:

                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
                )

Sprawdź to tutaj .

Perl, 37 bajtów

Kod 36 bajtów + 1 bajt wiersz poleceń (-F)

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

Przykład użycia:

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

MATL , 19 bajtów

Vt'8549176320'&m2$S

Wypróbuj online!

Wyjaśnienie

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

Galaretka, 11 bajtów

“U1°ŀ”OṾf@€

Wypróbuj tutaj.

Wyjaśnienie

“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 bajtów

31 bajtów zapisanych dzięki sugestii LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitsdzieli liczbę na cyfry, które są następnie sortowane według ich nazw w języku angielskim. FromDigitsłączy cyfry w liczbę podstawową 10.

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

8549176320

C, 142 141 117

Przejść parametr w long long *celu f(); funkcja modyfikuje parametr:

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 longjest konieczne, ponieważ ostatni przypadek testowy przepełnił się intpodczas sortowania.

Python 2 - 95 bajtów

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

Próba dalszego gry w golfa ... Myślę, że linia 2 jest niepotrzebna i może to być 1 lambda.

EDYCJA: 49 znaków w komentarzach, dzięki xnor i vaultah za pomoc.

- Oracle 11 (SQL): 164 bajty

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

Długa forma i wyjaśnienie

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

Uzyskaj dane wejściowe jako parametr do skryptu:

  SELECT &1 FROM dual

„twórz” wiersze za pomocą Connect przez na podstawie długości danych wejściowych:

  CONNECT BY LEVEL <= LENGTH(&1)

Oderwij każdą cyfrę z łańcucha dla każdej pozycji:

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

Konwertuj cyfrę na datę Juliana i wróć do Char, aby uzyskać pisownię:

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

Sprawdź zero - przypadek specjalny.

  DECODE(s,0,'zero'

Użyj funkcji LISTAGG, aby połączyć wiersze z powrotem w listę pojedynczych wierszy, rozdzielaną przecinkami, uporządkowaną alfabetycznie

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

Zawsze fajnie jest poprawiać SQL dla takich rzeczy ... :) naprawdę testuje moją wiedzę na temat buggera ...

Rubinowy, 60 bajtów

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

Rakieta, 142 130 bajtów

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

Od konwersji, które są bardziej niż prawie połowę długości ( 76 64 bajtów).

TSQL, 260 bajtów

Użyto odwróconego sortowania bąbelkowego, aby uniknąć odniesienia do długości, aby zaoszczędzić niektóre bajty

Gra w golfa:

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 @

Nie golfowany:

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)

Nalegając na użycie typów całkowitych jako danych wejściowych i wyjściowych dodano 37 bajtów

ClojureScript, 45 bajtów

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

Wykorzystuje konwersję screwy string-> int z wycieku JavaScript, więc nie jest to poprawne Clojure.

Firebird, 317 bajtów

Gra w golfa:

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

Nie golfowany:

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

W Firebird nie ma podzielonej funkcjonalności. Zamiast tego utworzyłem zapytanie rekurencyjne, aby uzyskać kolejny znak w kółko. Następnie wybierz je ponownie, sortując według naszej właściwej kolejności. Na koniec połącz wyniki z powrotem na liście. Zastąp domyślny separator przecinkiem spacją. Mógłbym zaoszczędzić 11 bajtów, tworząc nowy fikcyjny stół zamiast, rdb$databaseale pomyślałem, że może to być niezgodne z regułami.

ZX Spectum, kod maszynowy, 53 48 47 45 44 bajtów

    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

Współczynnik, 128

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

Brawo dla wbudowanych! :RE

PHP, 126 bajtów

O ile wiem, php nie ma żadnych wbudowań, które naprawdę by w tym pomogły (najlepsze, co mogłem zrobić przy użyciu usortu (str_split ()) było o 5 bajtów dłużej), więc jedyną rzeczą, którą cieszę się w tej odpowiedzi, jest gry rozgrywane za pomocą $ i, aby zaoszczędzić kilka bajtów na iteracji.

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

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

Wyjaśnienie:

• n←⍕⍵: pobierz reprezentację ciągu n i zapisz jąn
• '8549176320'⍋: znajdź permutację ntego rodzaju, nbiorąc pod uwagę kolejność8549176320 .
• n[... ]: zmiana kolejności nwedług tej permutacji
• ⍎: oceń wynik (aby zamienić go z powrotem w liczbę)

Clojure, 53 bajty

Cóż, pomysł na zrozumienie listy z rozwiązania Haskell wydaje się być najkrótszy:

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

Moje oryginalne podejście jest dłuższe o 1 bajt:

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

Możesz zobaczyć obie funkcje online tutaj: https://ideone.com/afac5n

Common Lisp, 104

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

Bez golfa

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

Konwertuj liczbę całkowitą na ciąg, sortuj znaki przy użyciu string<=porównania, używając :keyfunkcji niestandardowej, która konwertuje dany znak jako angielską reprezentację reprezentowanej przez niego wartości liczbowej. Zwykle nie używałbym funkcji kluczowej, która działa tak samo jak ta, ale kosztuje mniej bajtów niż dekorowanie / sortowanie / undecorate.

Python 3, 234 bajty

To jest bezpośrednie tłumaczenie mojej odpowiedzi Factor , dla zabawy.

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

Semantyka oceny „leniwych” map i obiektów zip jest najbardziej subtelnym, trudnym do znalezienia, powodującym błędy, fragmentem prawdziwych odchodów koni we wszechświecie. Czasami s = map(f, x)nie pozwala sna prawidłowe użycie lub wcale.

Pyke, 14 bajtów

.#uЀB`@

Wypróbuj tutaj!

C, 80 bajtów

Pobiera ciąg zawierający liczbę w podstawie 10 i drukuje 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 bajtów

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

Pobiera ciąg jako dane wejściowe i wyprowadza ciąg.

Python 3, 74 bajty

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

PHP , 107 bajtów

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

Wypróbuj online!

Korzysta ze zdefiniowanej przez użytkownika funkcji porównania, aby dostosować porządek sortowania.

Wydajność

101         110
31948       84913
5544        5544
1234567890  8549176320