Cho một số nguyên không âm ( n), tạo một hàm trả về ntheo thứ tự bảng chữ cái, theo cách đánh vần theo nghĩa đen của mỗi chữ số trong n.

Ví dụ:

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

Lưu ý: các hoạt động trong ví dụ chỉ mang tính minh họa và không cần đưa vào đầu ra. Chỉ có số được sắp xếp theo thứ tự abc cần được trả về.

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

Chỉnh sửa: đầu vào có thể được thực hiện ở bất kỳ định dạng mong muốn phù hợp nhất với ngôn ngữ của bạn và đầu ra có thể được sản xuất tương tự bằng cách quay lại từ chức năng hoặc in. Đầu vào sẽ luôn là số tự nhiên (bao gồm 0) và sẽ không chứa số 0 đứng đầu.

Mục nhập OEIS có liên quan (A057846) được tìm thấy bởi @DomHastings

Perl 6 ,  32  28 byte

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

Giải trình:

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

Kiểm tra:

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

Giải thích

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

Dùng thử trực tuyến

Đã lưu 1 byte nhờ Adnan

JavaScript (ES6), 54

Chỉnh sửa cùng số char, nhưng tránh biến toàn cụcz

Đầu vào / đầu ra dưới dạng chuỗi

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

Kiểm tra

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

Như @nimi đã đề xuất, sử dụng cách hiểu danh sách ngắn hơn so với việc soạn thảo các hàm:

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

Để tham khảo phiên bản của tôi:

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

Phiên bản pointfree dài hơn một chút:

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

Nói thẳng: Lọc các chữ số theo đúng thứ tự và sau đó nối kết quả.

Bình thường, 12 10 byte

ox`C" Ȁ\0

Không chắc chắn nếu nó có thể được chơi golf hơn nữa. Đầu vào cần phải được đính kèm trong dấu ngoặc kép.

Lưu 2 byte nhờ @isaacg!

Trong mã giả 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
                )

Kiểm tra nó ở đây .

Perl, 37 byte

Mã 36 byte + dòng lệnh 1 byte (-F)

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

Ví dụ sử dụng:

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

MATL , 19 byte

Vt'8549176320'&m2$S

Hãy thử trực tuyến!

Giải trình

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

Thạch, 11 byte

“U1°ŀ”OṾf@€

Hãy thử nó ở đây.

Giải trình

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

Toán học 35 78 47 byte

31 byte được lưu nhờ một gợi ý của LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitschia số thành các chữ số sau đó được sắp xếp theo tên của chúng bằng tiếng Anh. FromDigitslắp ráp các chữ số thành một số cơ sở 10.

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

8549176320

C, 142 141 117

Vượt qua tham số như long long *để f(); hàm sửa đổi tham số:

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 longlà cần thiết vì trường hợp thử nghiệm cuối cùng tràn ra intkhi được sắp xếp.

Python 2 - 95 byte

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

Cố gắng chơi gôn thêm ... Tôi nghĩ rằng dòng 2 là không cần thiết và điều này có thể trở thành 1 lambda.

EDIT: 49 phiên bản char trong các bình luận, thx đến xnor và vaultah để được giúp đỡ.

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

Hình thức dài và giải thích

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

Lấy đầu vào làm tham số cho tập lệnh:

  SELECT &1 FROM dual

"tạo" các hàng bằng cách sử dụng kết nối dựa trên độ dài của đầu vào:

  CONNECT BY LEVEL <= LENGTH(&1)

Xé từng chữ số từ chuỗi cho từng vị trí:

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

Chuyển đổi chữ số thành ngày Julian và quay lại Char để đánh vần:

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

Kiểm tra số không - trường hợp đặc biệt.

  DECODE(s,0,'zero'

Sử dụng hàm LISTAGG để nối các hàng lại thành một danh sách hàng đơn, được phân cách bằng dấu phẩy, được sắp xếp theo thứ tự abc

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

Luôn luôn vui vẻ khi cố gắng tinh chỉnh SQL cho những thứ như thế này ... :) thực sự kiểm tra kiến ​​thức của tôi về bugger ...

Ruby, 60 byte

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

Vợt, 142 130 byte

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

Trong đó các chuyển đổi dài hơn gần một nửa chiều dài ( 76 64 byte).

TSQL, 260 byte

Đã sử dụng sắp xếp bong bóng đảo ngược để tránh tham chiếu đến độ dài, để lưu một số byte

Chơi gôn

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 @

Ung dung:

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)

Nhấn mạnh vào việc sử dụng các kiểu số nguyên làm đầu vào và đầu ra được thêm 37 byte

ClojureScript, 45 byte

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

Sử dụng một số chuỗi khó khăn-> chuyển đổi int từ Javascript bị rò rỉ, do đó, Clojure không hợp lệ.

Firebird, 317 byte

Chơi gôn

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

Ung dung:

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

Không có chức năng phân chia trong Firebird. Thay vào đó tôi đã tạo một truy vấn đệ quy để lặp đi lặp lại ký tự tiếp theo. Sau đó chọn lại những người trong khi sắp xếp theo thứ tự thích hợp của chúng tôi. Cuối cùng ghép các kết quả đó lại với nhau trong một danh sách. Ghi đè dấu phân cách dấu phẩy mặc định bằng trống. Tôi có thể lưu 11 byte bằng cách tạo một bảng giả mới thay vì rdb$databasenhưng tôi nghĩ rằng điều đó có thể trái với quy tắc.

Phổ ZX, mã máy, 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

Yếu tố, 128

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

Hoan hô các nội dung! : D

PHP, 126 byte

Theo như tôi biết thì php không có bất kỳ nội dung nào thực sự có ích với điều này (điều tốt nhất tôi có thể làm khi sử dụng một usort (str_split ()) dài hơn 5 byte) vì vậy điều duy nhất tôi hài lòng trong câu trả lời này là các trò chơi đã chơi với $ i để lưu một vài byte khi lặp lại.

<?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←⍕⍵]}

Giải trình:

• n←⍕⍵: lấy đại diện chuỗi của nvà lưu trữ nó trongn
• '8549176320'⍋: tìm một hoán vị của ncác loại sắp xếp ntheo thứ tự 8549176320.
• n[... ]: Sắp xếp lại ntheo hoán vị đó
• ⍎: đánh giá kết quả (để biến nó trở lại thành một số)

Clojure, 53 byte

Vâng, danh sách ý tưởng hiểu từ giải pháp Haskell dường như là ngắn nhất:

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

Cách tiếp cận ban đầu của tôi dài hơn 1 byte:

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

Bạn có thể xem cả hai chức năng trực tuyến tại đây: https://ideone.com/afac5n

Lisp thường gặp, 104

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

Bị đánh cắp

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

Chuyển đổi số nguyên dưới dạng chuỗi, sắp xếp các ký tự bằng cách sử dụng phép string<=so sánh trong khi sử dụng :keyhàm tùy chỉnh để chuyển đổi một ký tự đã cho thành biểu diễn tiếng Anh của giá trị số mà nó đại diện. Thông thường tôi sẽ không sử dụng một chức năng chính hoạt động nhiều như chức năng này, nhưng nó tốn ít byte hơn so với trang trí / sắp xếp / không trang trí.

Python 3, 234 byte

Đây là bản dịch trực tiếp câu trả lời Yếu tố của tôi , chỉ để cho vui.

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

Các ngữ nghĩa của việc đánh giá các đối tượng zip và bản đồ "lười biếng" là phần tinh tế khó tìm thấy nhất của phân ngựa chính hiệu trong vũ trụ. Đôi khi, s = map(f, x)sẽ không cho phép sđược sử dụng đúng cách hoặc hoàn toàn.

Pyke, 14 byte

.#uЀB`@

Hãy thử nó ở đây!

C, 80 byte

Lấy một chuỗi chứa một số trong cơ sở 10 và in ra 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)]))

Lấy một chuỗi làm đầu vào và đầu ra một chuỗi.

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

Hãy thử trực tuyến!

Sử dụng chức năng so sánh do người dùng định nghĩa để điều chỉnh thứ tự sắp xếp.

Đầu ra

101         110
31948       84913
5544        5544
1234567890  8549176320