Negatif olmayan bir tamsayı ( n) verildiğinde n, her bir basamağın tam anlamıyla yazımına göre, alfabetik sırayla dönen bir işlev oluşturun n.

Örnekler:

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

Not: Örnekteki işlemler yalnızca açıklama amaçlıdır ve çıktıya dahil edilmesi gerekmez. Yalnızca alfabetik olarak sıralanmış sayının döndürülmesi gerekir.

Bu kod golf, yani bayt cinsinden en kısa kod kazanır.

Düzenleme: Giriş, dileğinize en uygun olan herhangi bir formatta alınabilir ve işlevden veya baskıdan geri döndürülerek çıktı benzer şekilde üretilebilir. Girdi her zaman doğal bir sayı olacaktır (0 dahil) ve baştaki 0'lar içermez.

@DomHastings tarafından bulunan ilgili OEIS girişi (A057846)

Perl 6 ,  32  28 bayt

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

Açıklama:

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

Ölçek:

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

•OWÿ¾•vy†J

Açıklaması

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

Çevrimiçi deneyin

Adnan sayesinde 1 bayt kaydedildi

JavaScript (ES6), 54

Düzenleme aynı karakter sayımı, ancak küresel değişkeni kaçınarakz

Dizge olarak giriş / çıkış

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

Ölçek

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 bayt

@Nimi'nin önerdiği gibi, bir liste kavrama kullanmak, oluşturma işlevlerinden daha kısadır:

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

Referans için referans:

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

Noktasız versiyon biraz daha uzun:

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

Basit: Rakamları doğru sırayla filtreleyin ve ardından sonucu bir araya getirin.

Pyth, 12 10 bayt

ox`C" Ȁ\0

Daha fazla golf oynayabildiğinden emin değilim. Girişin tırnak içine alınması gerekir.

@İsaacg sayesinde 2 bayt kurtarıldı!

Pythonic sözde kodunda:

                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
                )

Burada test et .

Perl, 37 bayt

36 bayt kodu + 1 bayt komut satırı (-F)

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

Kullanım örneği:

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

MATL , 19 bayt

Vt'8549176320'&m2$S

Çevrimiçi deneyin!

açıklama

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

Jöle, 11 bayt

“U1°ŀ”OṾf@€

Burada dene.

açıklama

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

LIAMnYP'nin önerisi sayesinde 31 bayt kaydedildi!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitssayıyı, adlarına göre İngilizce olarak sıralanan rakamlara böler. FromDigitsRakamları 10 taban numarasına monte eder.

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

8549176320

C, 142 141 117

Olarak parametre geçmek long long *için f(); işlev parametreyi değiştirir:

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 longson test durumu intsıralandığında bir taşma nedeniyle gereklidir .

Python 2 - 95 bayt

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

Daha fazla golf oynamaya çalışılıyor ... 2. hattın gereksiz olduğunu düşünüyorum ve bu 1 lambda olabilir.

EDIT: yorumlarda 49 char sürümü, yardım için xnor ve vaultah thx.

- Oracle 11 (SQL): 164 bayt

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

Uzun biçim ve açıklama

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

Girdiyi komut dosyası olarak parametre olarak alın:

  SELECT &1 FROM dual

giriş uzunluğuna göre connect kullanarak "create" satırları:

  CONNECT BY LEVEL <= LENGTH(&1)

Her pozisyon için dizeden her basamağı çıkartın:

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

Rakamı Julian tarihine çevirin ve heceleme için Char'a dönün:

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

Sıfırın kontrol et - özel durum.

  DECODE(s,0,'zero'

Satırları tek bir satır listesine, virgülle ayrılmış ve alfabetik olarak sıralı şekilde birleştirmek için LISTAGG işlevini kullanın

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

Böyle şeyler için SQL'i ayarlamaya çalışmak her zaman eğlencelidir ... :) gerçekten böcek bilgimi sınar ...

Ruby, 60 bayt

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

Raket, 142 130 bayt

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

Bunların dönüşümleri neredeyse uzunluğunun yarısından fazladır ( 76 64 byte).

TSQL, 260 bayt

Uzunluğa atıftan kaçınmak, bazı byte'ları kurtarmak için ters çevrilmiş kabarcık sıralama

golfed:

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 @

Ungolfed:

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)

Tam sayı türlerini giriş ve çıkış olarak kullanmak için ısrar ediyor

ClojureScript, 45 bayt

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

Javascript sızıntısından bir miktar string-> int dönüşümü kullanır, bu yüzden geçerli bir Clojure değil.

Firebird, 317 bayt

golfed:

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

Ungolfed:

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

Firebird'de bölünmüş işlev yoktur. Bunun yerine bir sonraki karakteri tekrar tekrar almak için özyinelemeli bir sorgu oluşturdum. Ardından uygun siparişimize göre sıralama yaparken bunları tekrar seçin. Sonunda bu sonuçları bir listede tekrar birleştirin. Varsayılan virgül sınırlayıcıyı boşluk ile geçersiz kıl. Bunun yerine yeni bir kukla masa oluşturarak 11 bayt kurtarabilirdim rdb$databaseama bunun kurallara aykırı olabileceğini düşündüm.

ZX Spectum, makine kodu, 53 48 47 45 44 bayt

    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

Faktör, 128

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

Yerleşikler için Yaşasın! : D

PHP, 126 bayt

Bildiğim kadarıyla php bu konuda gerçekten yardımcı olacak herhangi bir yapıya sahip değil (bir usort (str_split ()) kullanarak yapabileceğim en iyi 5 bayt uzunluğundaydı), bu yüzden bu cevap içinde mutlu olduğum tek şey oyunlarda birkaç bayttan tasarruf etmek için $ i ile oynanan oyunlar.

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

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

Açıklama:

• n←⍕⍵: string temsili olsun nve saklayınn
• '8549176320'⍋: emri verilen nbu türlerin bir permütasyonu bulmak .n8549176320
• n[... ]: nbu permütasyonla yeniden düzenle
• ⍎: sonucu değerlendirin (sayıya döndürmek için)

Clojure, 53 bayt

Eh, Haskell çözümünden liste anlama fikri en kısa gibi görünüyor:

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

Orijinal yaklaşımım 1 bayt daha uzun:

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

Her iki işlevi de çevrimiçi olarak burada görebilirsiniz: https://ideone.com/afac5n

Ortak Lisp, 104

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

Ungolfed

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

Tamsayı dizge olarak dönüştürün, belirli bir karakteri temsil ettiği sayısal değerin İngilizce gösterimi olarak dönüştüren string<=özel bir :keyişlev kullanırken karşılaştırmayı kullanarak karakterleri sıralayın . Genelde bunun kadar önemli bir anahtar işlevi kullanmazdım, ancak bayt olarak dekore / sort / undecorate'den daha ucuza geliyor.

Python 3, 234 bayt

Bu , sadece eğlence için, Faktör cevabımın doğrudan çevirisidir .

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

"Tembel" harita ve fermuar nesnelerinin değerlendirilmesinin semantiği, evrendeki en zor bulunanı bulmakta zorlanmaya sebep olan hakiki at dışkı parçasıdır. Bazen, düzgün bir şekilde veya hiç kullanılmasına s = map(f, x)izin vermeyebilir s.

Pyke, 14 bayt

.#uЀB`@

Burada dene!

C, 80 bayt

Taban 10'da sayı içeren bir dize alır ve yazdırır 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 bayt

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

Bir dizeyi girdi olarak alır ve bir dizge çıkarır.

Python 3, 74 bayt

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

PHP , 107 bayt

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

Çevrimiçi deneyin!

Sıralama düzenini ayarlamak için kullanıcı tanımlı bir karşılaştırma işlevi kullanır.

Çıktı

101         110
31948       84913
5544        5544
1234567890  8549176320