nErstellen Sie bei einer nicht negativen Ganzzahl ( ) eine Funktion, die nin alphabetischer Reihenfolge entsprechend der Literalschreibung jeder Ziffer in zurückgegeben wird n.

Beispiele:

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

Hinweis: Die Operationen in diesem Beispiel dienen nur der Veranschaulichung und müssen nicht in die Ausgabe einbezogen werden. Es muss nur die alphabetisch sortierte Nummer zurückgegeben werden.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

Bearbeiten: Die Eingabe kann in einem beliebigen Format erfolgen, das am besten zu Ihrer Sprache passt, und die Ausgabe kann auf ähnliche Weise erstellt werden, indem Sie von der Funktion zurückkehren oder drucken. Die Eingabe ist immer eine natürliche Zahl (einschließlich 0) und enthält keine führenden 0en.

Relevanter OEIS-Eintrag (A057846) gefunden von @DomHastings

Perl 6 ,  32  28 Bytes

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

Erläuterung:

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

Prüfung:

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

Erklärt

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

Probieren Sie es online aus

Dank Adnan 1 Byte gespeichert

JavaScript (ES6), 54

Bearbeiten Sie dieselbe Zeichenanzahl, aber vermeiden Sie die globale Variablez

Eingabe / Ausgabe als Zeichenketten

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

Prüfung

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

Wie @nimi angedeutet hat, ist die Verwendung eines Listenverständnisses kürzer als das Verfassen von Funktionen:

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

Als referenz meine version:

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

Die pointfree Version ist etwas länger:

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

Ganz einfach: Filtern Sie die Ziffern in der richtigen Reihenfolge und verketten Sie das Ergebnis.

Pyth, 12 10 Bytes

ox`C" Ȁ\0

Ich bin mir nicht sicher, ob ich weiter Golf spielen kann. Die Eingabe muss in Anführungszeichen gesetzt werden.

2 Bytes gespart dank @isaacg!

Im pythonischen Pseudocode:

                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
                )

Teste es hier .

Perl, 37 Bytes

36 Byte Code + 1 Byte Befehlszeile (-F)

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

Anwendungsbeispiel:

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

MATL , 19 Bytes

Vt'8549176320'&m2$S

Probieren Sie es online!

Erläuterung

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 Bytes

“U1°ŀ”OṾf@€

Probieren Sie es hier aus.

Erläuterung

“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 gespart dank eines Vorschlags von LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitszerlegt die Nummer in Ziffern, die dann in Englisch nach ihren Namen sortiert werden. FromDigitssetzt die Ziffern zu einer Zahl zur Basis 10 zusammen.

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

8549176320

C 142, 141, 117

Parameter übergeben long long *an f(); Die Funktion ändert den 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 longist notwendig, da der letzte Testfall intbeim Sortieren übergelaufen ist .

Python 2 - 95 Bytes

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

Weiteres Golfen versuchen ... Ich denke, die Linie 2 ist unnötig und dies kann zu 1 Lambda werden.

BEARBEITEN: 49 char Version in Kommentaren, danke an xnor und vaultah für Hilfe.

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

Lange Form und Erklärung

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

Holen Sie sich die Eingabe als Parameter zum Skript:

  SELECT &1 FROM dual

"Erstelle" Zeilen mit connect by basierend auf der Länge der Eingabe:

  CONNECT BY LEVEL <= LENGTH(&1)

Ziehen Sie jede Ziffer für jede Position aus der Zeichenfolge heraus:

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

Konvertieren Sie die Ziffer in das julianische Datum und zurück zu Char, um die Rechtschreibung zu erhalten:

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

Auf Null prüfen - Sonderfall.

  DECODE(s,0,'zero'

Verwenden Sie die LISTAGG-Funktion, um die Zeilen wieder in eine einzelne Zeilenliste zu verknüpfen, die durch Kommas getrennt und alphabetisch sortiert ist

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

Es macht immer Spaß, SQL für solche Dinge zu optimieren ... :) testet wirklich mein Wissen über den Bugger ...

Ruby, 60 Bytes

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

Schläger, 142 130 Bytes

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

Davon Umwandlungen sind über fast die Hälfte der Länge ( 76 64 Bytes).

TSQL, 260 Bytes

Verwendet umgekehrte Blasensortierung, um die Länge zu vermeiden und einige Bytes zu sparen

Golf gespielt:

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)

Indem Sie darauf bestehen, Integer-Typen als Ein- und Ausgabe zu verwenden, werden 37 Byte hinzugefügt

ClojureScript, 45 Bytes

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

Verwendet eine beschissene String-> Int-Konvertierung von Javascript, so dass es kein gültiges Clojure ist.

Firebird, 317 Bytes

Golf gespielt:

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

In Firebird gibt es keine Split-Funktionalität. Stattdessen habe ich eine rekursive Abfrage erstellt, um das nächste Zeichen immer wieder abzurufen. Wählen Sie diese dann erneut aus, während Sie nach der richtigen Reihenfolge sortieren. Verketten Sie diese Ergebnisse schließlich wieder zu einer Liste. Überschreiben Sie das Standardkommatrennzeichen mit Leerzeichen. Ich könnte 11 Bytes einsparen, indem rdb$databaseich stattdessen eine neue Dummy-Tabelle erstelle, aber ich dachte, das verstößt möglicherweise gegen die Regeln.

ZX Spectum, Maschinencode, 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

Faktor 128

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

Hurra für Builtins! : D

PHP, 126 Bytes

Soweit ich weiß, hat PHP keine eingebauten Funktionen, die wirklich helfen könnten (das Beste, was ich mit einem Usort (str_split ()) tun konnte, war 5 Bytes länger). Das Einzige, worüber ich mich in dieser Antwort freue, ist die Spiele, die mit $ i gespielt wurden, um ein paar Bytes bei der Iteration zu sparen.

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

Erläuterung:

• n←⍕⍵: Liefert die String-Darstellung von n und speichere sie inn
• '8549176320'⍋: finden Sie eine Permutation ndieser Artn angegebenen Reihenfolge 8549176320.
• n[...] : Nach ndieser Permutation neu ordnen
• ⍎: bewerte das Ergebnis (um es wieder in eine Zahl umzuwandeln)

Clojure, 53 Bytes

Nun, die Idee des Listenverständnisses aus der Haskell-Lösung scheint die kürzeste zu sein:

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

Mein ursprünglicher Ansatz ist 1 Byte länger:

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

Sie können beide Funktionen online hier sehen: 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)))))))

Ungolfed

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

Ganzzahl als Zeichenfolge konvertieren, Zeichen anhand des string<=Vergleichs sortieren und dabei eine benutzerdefinierte :keyFunktion verwenden, mit der ein bestimmtes Zeichen als englische Darstellung des von ihm repräsentierten numerischen Werts konvertiert wird. Normalerweise würde ich keine Schlüsselfunktion verwenden, die so viel bewirkt wie diese, aber sie kostet weniger Byte als dekorieren / sortieren / undekorieren.

Python 3, 234 Bytes

Dies ist eine direkte Übersetzung meiner Factor-Antwort , nur zum Spaß.

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

Die Semantik der Auswertung von "faulen" Karten- und Zip-Objekten ist das subtilste, schwer zu findende, Fehler auslösende Stück echter Pferdekot im Universum. Manchmal kann s = map(f, x)es nicht srichtig oder überhaupt nicht verwendet werden.

Pyke, 14 Bytes

.#uЀB`@

Probieren Sie es hier aus!

C 80 Bytes

Nimmt eine Zeichenfolge mit einer Zahl in der Basis 10 und druckt auf 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)]))

Nimmt einen String als Eingabe und gibt einen String aus.

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

Probieren Sie es online!

Verwendet eine benutzerdefinierte Vergleichsfunktion, um die Sortierreihenfolge anzupassen.

Ausgabe

101         110
31948       84913
5544        5544
1234567890  8549176320