Diberikan integer non-negatif ( n), buat fungsi yang mengembalikan ndalam urutan abjad, sesuai dengan ejaan literal dari setiap digit n.

Contoh:

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

Catatan: operasi dalam contoh hanya ilustratif dan tidak perlu dimasukkan dalam output. Hanya nomor yang diurutkan berdasarkan abjad yang perlu dikembalikan.

Ini adalah kode-golf, jadi kode terpendek dalam byte menang.

Sunting: input dapat diambil dalam format yang diinginkan yang paling sesuai dengan bahasa Anda, dan output dapat diproduksi dengan cara yang sama dengan kembali dari fungsi atau pencetakan. Masukan akan selalu berupa bilangan asli (termasuk 0) dan tidak akan berisi awalan 0.

Entri OEIS yang relevan (A057846) ditemukan oleh @DomHastings

Perl 6 ,  32  28 byte

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

Penjelasan:

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

Uji:

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

•OWÿ¾•vy†J

Dijelaskan

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

Cobalah online

Disimpan 1 byte berkat Adnan

JavaScript (ES6), 54

Edit jumlah char yang sama, tetapi hindari variabel globalz

Input / output sebagai string

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

Uji

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 byte

Seperti yang disarankan @nimi, menggunakan pemahaman daftar lebih pendek daripada menyusun fungsi:

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

Untuk referensi versi saya:

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

Versi pointfree sedikit lebih lama:

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

Mudah: Saring angka dalam urutan yang benar dan kemudian gabungkan hasilnya.

Pyth, 12 10 byte

ox`C" Ȁ\0

Tidak yakin apakah bisa bermain golf lebih lanjut. Input harus dilampirkan dalam tanda kutip.

2 byte disimpan berkat @isaacg!

Dalam pseudocode pythonic:

                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
                )

Uji di sini .

Perl, 37 byte

36 byte kode + 1 byte command line (-F)

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

Contoh penggunaan:

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

MATL , 19 byte

Vt'8549176320'&m2$S

Cobalah online!

Penjelasan

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

Jelly, 11 byte

“U1°ŀ”OṾf@€

Coba di sini.

Penjelasan

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

31 byte disimpan berkat saran oleh LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitsmemecah nomor menjadi digit yang kemudian diurutkan sesuai dengan namanya dalam bahasa Inggris. FromDigitsmerakit digit menjadi nomor basis-10.

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

8549176320

C, 142 141 117

Lewati parameter long long *ke f(); fungsi memodifikasi parameter:

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 longdiperlukan karena test case terakhir meluap intketika diurutkan.

Python 2 - 95 byte

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

Mencoba bermain golf lebih lanjut ... Saya pikir jalur 2 tidak perlu dan ini bisa menjadi 1 lambda.

EDIT: 49 versi char dalam komentar, thx to xnor dan vaultah untuk bantuan.

- Oracle 11 (SQL): 164 byte

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

Bentuk dan penjelasan panjang

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

Dapatkan input sebagai parameter ke skrip:

  SELECT &1 FROM dual

"buat" baris dengan menggunakan koneksi dengan berdasarkan pada panjang input:

  CONNECT BY LEVEL <= LENGTH(&1)

Lepaskan setiap digit dari string untuk setiap posisi:

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

Ubah digit menjadi tanggal Julian, dan kembali ke Char untuk mendapatkan ejaan:

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

Periksa nol - kasing khusus.

  DECODE(s,0,'zero'

Gunakan fungsi LISTAGG untuk menggabungkan baris kembali ke daftar baris tunggal, dibatasi koma, diurutkan berdasarkan abjad

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

Selalu menyenangkan mencoba untuk men-tweak SQL untuk hal-hal seperti ini ... :) benar-benar menguji pengetahuan saya tentang bugger ...

Ruby, 60 byte

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

Racket, 142 130 byte

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

Dari konversi yang lebih dari hampir setengah dari panjang ( 76 64 byte).

TSQL, 260 byte

Digunakan semacam gelembung terbalik untuk menghindari merujuk pada panjang, untuk menyimpan beberapa byte

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 @

Tidak Disatukan:

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)

Bersikeras menggunakan jenis integer sebagai input dan output ditambahkan 37 byte

ClojureScript, 45 byte

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

Menggunakan beberapa konversi string-> int yang rumit dari Javascript, jadi itu bukan Clojure yang valid.

Firebird, 317 byte

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

Tidak Disatukan:

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

Tidak ada fungsi pemisahan di Firebird. Alih-alih, saya membuat kueri rekursif untuk mendapatkan karakter berikutnya berulang-ulang. Kemudian pilih kembali mereka sambil menyortir dengan urutan yang tepat. Akhirnya gabungkan hasil-hasil itu kembali bersama dalam daftar. Timpa pembatas koma default dengan kosong. Saya bisa menghemat 11 byte dengan membuat tabel boneka baru alih-alih rdb$databasetetapi saya pikir itu mungkin melanggar aturan.

ZX Spectum, kode mesin, 53 48 47 45 44 byte

    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

Faktor, 128

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

Hore untuk builtin! : D

PHP, 126 byte

Sejauh yang saya tahu php tidak memiliki builtin yang akan sangat membantu dengan ini (yang terbaik yang bisa saya lakukan dengan menggunakan usort (str_split ()) adalah 5 byte lebih lama) jadi satu-satunya hal yang saya senang dalam jawaban ini adalah game yang dimainkan dengan $ i untuk menyimpan beberapa byte pada itteration.

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

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

Penjelasan:

• n←⍕⍵: dapatkan representasi string ndan simpan din
• '8549176320'⍋: menemukan permutasi nsemacam itu ndiberi perintah 8549176320.
• n[... ]: memesan ulang ndengan permutasi itu
• ⍎: mengevaluasi hasilnya (untuk mengubahnya kembali menjadi angka)

Clojure, 53 byte

Nah, daftar gagasan pemahaman dari solusi Haskell tampaknya menjadi yang terpendek:

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

Pendekatan asli saya adalah 1 byte lebih lama:

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

Anda dapat melihat keduanya berfungsi online di sini: 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)))))))

Tidak disatukan

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

Konversi integer sebagai string, urutkan karakter menggunakan string<=perbandingan sambil menggunakan :keyfungsi kustom yang mengubah karakter yang diberikan sebagai representasi bahasa Inggris dari nilai numerik yang diwakilinya. Biasanya saya tidak akan menggunakan fungsi kunci yang melakukan sebanyak ini, tetapi harganya lebih murah dalam byte daripada menghias / mengurutkan / undecorate.

Python 3, 234 byte

Ini adalah terjemahan langsung dari jawaban Factor saya , hanya untuk bersenang-senang.

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

Semantik dari evaluasi "malas" peta dan objek zip adalah yang paling sulit-menemukan-bug-inducing kotoran kuda asli di alam semesta. Terkadang, s = map(f, x)tidak memungkinkan suntuk digunakan dengan benar atau tidak sama sekali.

Pyke, 14 byte

.#uЀB`@

Coba di sini!

C, 80 byte

Mengambil string yang berisi angka dalam basis 10 dan mencetak ke 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 byte

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

Mengambil string sebagai input dan menghasilkan string.

Python 3, 74 byte

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

PHP , 107 byte

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

Cobalah online!

Menggunakan fungsi perbandingan yang ditentukan pengguna untuk menyesuaikan urutan penyortiran.

Keluaran

101         110
31948       84913
5544        5544
1234567890  8549176320