음수가 아닌 정수 ( n)가 주어진 경우 n의 각 숫자의 문자 철자에 따라 알파벳 순서로 반환되는 함수를 만듭니다 n.

예 :

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

참고 : 예제의 조작은 단지 예시 일 뿐이며 출력에 포함될 필요는 없습니다. 알파벳순으로 정렬 된 숫자 만 반환하면됩니다.

이것은 코드 골프이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

편집 : 입력 한 언어에 가장 적합한 원하는 형식으로 입력 할 수 있으며, 기능에서 복귀하거나 인쇄하여 출력을 유사하게 생성 할 수 있습니다. 입력은 항상 자연수 (0 포함)이며 선행 0을 포함하지 않습니다.

@DomHastings가 찾은 관련 OEIS 항목 (A057846)

펄 6 ,  32  28 바이트

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

설명:

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

테스트:

#! /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 바이트

•OWÿ¾•vy†J

설명

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

온라인으로 사용해보십시오

Adnan 덕분에 1 바이트 절약

자바 스크립트 (ES6), 54

동일한 문자 수를 편집 하지만 전역 변수는 피하십시오z

문자열로 입력 / 출력

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

테스트

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>

하스켈, 62 51 44 바이트

@nimi가 제안했듯이 목록 이해 기능을 사용하는 것이 함수 작성보다 짧습니다.

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

참고로 내 버전 :

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

포인트 프리 버전이 조금 더 깁니다 :

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

간단 : 숫자를 올바른 순서로 필터링 한 다음 결과를 연결합니다.

Pyth, 12 10 바이트

ox`C" Ȁ\0

더 골프를 칠 수 있는지 확실하지 않습니다. 입력은 따옴표로 묶어야합니다.

@isaacg 덕분에 2 바이트가 절약되었습니다!

파이썬 의사 코드에서 :

                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
                )

여기에서 테스트하십시오 .

펄, 37 바이트

36 바이트 코드 + 1 바이트 명령 줄 (-F)

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

사용 예 :

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

MATL , 19 바이트

Vt'8549176320'&m2$S

온라인으로 사용해보십시오!

설명

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

젤리, 11 바이트

“U1°ŀ”OṾf@€

여기에서 시도하십시오.

설명

“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 바이트

LIAMnYP의 제안으로 31 바이트가 절약되었습니다!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigits숫자를 숫자로 나누고 이름에 따라 영어로 정렬됩니다. FromDigits숫자를 10 진수로 어셈블합니다.

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

8549176320

C, 142 (141) 117

매개 변수 long long *를 f(); 이 함수는 매개 변수를 수정합니다.

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 long마지막 테스트 케이스 int가 정렬 될 때 오버플로 된 이후 필요합니다 .

파이썬 2-95 바이트

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

추가 골프를 시도 중 ... 2 번 줄은 불필요하며 1 번 람다가 될 수 있습니다.

편집 : 댓글 49 문자 버전, 도움을 위해 xnor 및 vaultah에 thx.

-Oracle 11 (SQL) : 164 바이트

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

긴 형식과 설명

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

스크립트에 입력을 매개 변수로 가져 오십시오.

  SELECT &1 FROM dual

입력 길이에 따라 연결을 사용하여 "생성"행 :

  CONNECT BY LEVEL <= LENGTH(&1)

각 위치의 문자열에서 각 숫자를 제거하십시오.

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

숫자를 율리우스 력 날짜로 변환하고 다시 문자로 변환하여 철자를 얻으십시오.

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

0이 아닌 특별한 경우를 확인하십시오.

  DECODE(s,0,'zero'

LISTAGG 함수를 사용하여 쉼표로 구분되고 사전 순으로 정렬 된 행을 단일 행 목록으로 다시 연결하십시오.

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

이 같은 것들에 대해 SQL을 조정하려고하는 것은 항상 재미 있습니다 ... :) 실제로 내 버거에 대한 지식을 테스트합니다 ...

루비, 60 바이트

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

라켓 142 130 바이트

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

어떤 변환이 길이의 거의 절반 이상 ( 76 64 바이트)입니다.

TSQL, 260 바이트

길이를 참조하지 않고 바이트를 절약하기 위해 리버스 버블 정렬을 사용했습니다.

골프 :

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 @

언 골프 드 :

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)

입력 및 출력으로 정수 유형 사용을 주장하여 추가 된 37 바이트

ClojureScript, 45 바이트

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

자바 스크립트에서 나사 식 문자열-> 정수 변환을 통해 누출을 사용하므로 유효한 Clojure가 아닙니다.

파이어 버드, 317 바이트

골프 :

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

언 골프 드 :

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에는 분할 기능이 없습니다. 대신 다음 문자를 반복해서 얻기 위해 재귀 쿼리를 만들었습니다. 그런 다음 올바른 순서대로 정렬하면서 다시 선택하십시오. 마지막으로 결과를 다시 목록으로 연결하십시오. 기본 쉼표 구분자를 공백으로 대체하십시오. 대신 새 더미 테이블을 만들어 11 바이트를 절약 할 수는 rdb$database있지만 규칙에 위배 될 수 있다고 생각했습니다.

ZX 스펙트럼, 머신 코드, 53 48 47 45 44 바이트

    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

계수, 128

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

내장을위한 만세! :디

PHP, 126 바이트

내가 아는 한 PHP에는 실제로 이것에 도움이되는 내장 기능이 없습니다 (usort (str_split ())을 사용하여 할 수있는 최선은 5 바이트 더 길었습니다).이 답변에서 내가 만족하는 유일한 것은 게임은 $ 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 바이트

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

설명:

• n←⍕⍵:의 문자열 표현을 가져옵니다 n 저장n
• '8549176320'⍋: 순서대로 주어진 n종류 의 순열을 찾습니다.n8549176320 .
• n[... ]: 재주문n 순열에 의한
• ⍎: 결과를 평가합니다 (숫자로 다시 변환).

클로저, 53 바이트

하스켈 솔루션의 목록 이해 아이디어가 가장 짧은 것 같습니다.

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

내 원래 접근 방식은 1 바이트 더 깁니다.

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

https://ideone.com/afac5n 에서 두 기능을 온라인으로 볼 수 있습니다.

커먼 리스프, 104

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

언 골프

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

정수를 문자열 로 변환하고 주어진 문자를 숫자 값의 영어 표현으로 변환하는 string<=사용자 정의 :key함수를 사용하여 비교를 사용하여 문자를 정렬 하십시오. 일반적으로 이만큼 중요한 키 기능을 사용하지 않지만 데코레이션 / 정렬 / 데코레이션보다 바이트 단위로 비용이 적게 듭니다.

파이썬 3, 234 바이트

이것은 단지 재미를 위해 나의 Factor answer 의 직접 번역입니다 .

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

"게으른 (lazy)"맵 및 zip 객체 평가의 의미는 우주에서 가장 미묘한 찾기 어려운 버그를 유발하는 말의 배설물입니다. 때때로, 제대로 또는 전혀 사용 s = map(f, x)하도록 허용되지 않습니다 s.

파이크, 14 바이트

.#uЀB`@

여기 사용해보십시오!

C, 80 바이트

기본 10의 숫자가 포함 된 문자열을 가져와 다음 위치에 인쇄합니다 stdio.

F(char*i){for(char*p,d,*o="8549176320";*o;++o)for(p=i;d=*p++;d-*o||putchar(d));}

파이썬 2.7.11, 67 바이트

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

문자열을 입력으로 받아서 문자열을 출력합니다.

파이썬 3, 74 바이트

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

PHP , 107 바이트

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

온라인으로 사용해보십시오!

사용자 정의 비교 기능을 사용하여 정렬 순서를 조정하십시오.

산출

101         110
31948       84913
5544        5544
1234567890  8549176320