将数字重新排列为字母顺序


24

给定一个非负整数(nn,请根据中每个数字的文字拼写,创建一个按字母顺序返回的函数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)


1
我也可以将数字作为字符串并输出字符串吗?
ThreeFx

1
@nimi 00....
TuxCrafting '16

5
您可能想要指定输入为十进制,否则将使用一元代码得到一些厚脸皮的答案...
Martin Ender 2016年

6
这有点令人困惑:您在注释中写道,您希望数字类型可以用作函数的输入和输出,但是也可以打印结果。因此,如果输出为849,这是否意味着我们可以打印数字849而不是字符串"849"?IMO这只是一个非常麻烦的I / O格式(不好!)。
林恩

1
前导零重要吗?例如001输出什么?如果它们是有意义的,而结果不是1,大多数语言将需要字符串作为输入,原因很简单,即它是粗糙,不切实际的,并且通常几乎不可能要求解析器在基数为10的数字中保留前导零。

Answers:


12

Perl 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

8

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个字节


8

JavaScript(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>


2
喜欢这个,使用输入的数字作为字符串的索引z...
Dom Hastings

6

Haskell,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

直截了当:以正确的顺序过滤数字,然后将结果连接起来。


5

Pyth,12个 10字节

ox`C" Ȁ\0

不确定是否可以进一步打高尔夫球。输入需要用引号引起来。

感谢@isaacg,节省了2个字节!

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

在这里测试


@busukxuan我也得到14个字节:p。
阿德南

@Adnan然后恢复为数字。似乎没有办法压缩这些数字……
busukxuan

2
保存2个字节通过替换549176320C" »Ä\0
isaacg

@isaacg谢谢!我尝试几次将其转换为256基,但是结果是错误的。您是如何做到的?
busukxuan

1
您必须通过将空字节替换为来转义空字节\0。那可能就是您遇到的问题。
isaacg '16

4

Perl,37个字节

36字节代码+ 1字节命令行(-F)

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

用法示例:

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

3

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

3

果冻,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.

3

Mathematica 35 78 47字节

感谢LIAMnYP的建议,节省了31个字节!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigits将数字分解为数字,然后根据其英文名称进行排序。FromDigits将数字组合成以10为底的数字。


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

8549176320


通过使用“ SortBy”,您就不会出现将单词转换回数字的问题。FromDigits@SortBy[IntegerName]@IntegerDigits@#&
LLlAMnYP'7

Interpreter速度也很慢,所以这是额外的好处。
LLlAMnYP'7

了不起的进步。
DavidC

Mtmca中的11个字节(无论何时出现)。
迈克尔·斯特恩

3

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

Python 2-95个字节

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

尝试进一步打高尔夫球...我认为2号线是不必要的,这可以变成1 lambda。

编辑:在注释中的49字符版本,向xnor和Vault寻求帮助。


lambda n:''.join(sorted(`n`,key="8549176320".find))
vaultah '16

4
@vaultah不错的解决方案,您应该发布它!我认为您可以省略,8从而find得出-1。
xnor

1
哦,这很聪明。最短的时间是lambda n: "".join(sorted(n,key="549176320".find)),与您建议的Vault类似。您应该发布它!
杰里米(Jeremy)

1
@Jeremy您应该在您的帖子中编辑该版本。
DJMcMayhem

2
至少要摆脱多余的空格...缩进可以用单个空格完成。这也是无效的,因为OP指出输出必须是数字类型。
Mego 2016年

2

-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根据输入的长度“创建”行:

  CONNECT BY LEVEL <= LENGTH(&1)

从每个位置的字符串中抽出每个数字:

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

将数字转换为儒略日期,然后返回Char以进行拼写:

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

检查零-特殊情况。

  DECODE(s,0,'zero'

使用LISTAGG函数将行连接回单个行列表,以逗号分隔,按字母顺序排列

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

尝试对诸如此类的东西进行SQL调整总是很有趣... :)确实测试了我对bugger的了解...


1

Ruby,60个字节

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

1

球拍,142个 130字节

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

其中转换几乎超过 长度的一半(76 64字节)。


(+ 1 answer)球拍!

@cat对我来说,继续练习Racket是很有用的,因为这是在我的同事留给我的这些可怕的程序性遗留Java(和不太传统的Python)程序上工作时保持功能编程知识的一种方法。我可以大声说说拥有对象并不一定会使程序成为面向对象的,但我要做的只是让我在Racket上解决问题而已。
史蒂文H.

嗯。也许您可以让自己的上级让您像使用胶水一样将Scala用于实现和Java。:)

顺便说一句,如果您喜欢Forth并且从内到外阅读Lisp会使您的眼睛有点疲倦,则应该检查Factor,这是Lisp和CLOS,但使用的是Forth-y后缀和无点伪装。

1

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个字节


DECLARE @ varchar(99)=1010.o是否101会自动变成字符串?

另外,stuff客观上来说,这是一个糟糕的函数名。squash要么shovepack会更好:P

@cat是的,它会自动转换为字符串,但是根据描述文件,这将是作弊行为。我同意,东西是个愚蠢的名字
t-clausen.dk

1
我的意思是,我们最好只调用每个函数,stuff因为函数就是这样做的:它们在做事。然后你的代码可以像stuff(stuff(4, 5, stuff), stuff(stuff()).(stuff())()); stuff(stuff)

1

ClojureScript,45个字节

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

使用一些从Javascript泄漏中获取的string-> int转换,因此它不是有效的Clojure。


1

火鸟,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但是我认为这可能违反了规则。


1

ZX Spectum,机器代码,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


使用Gnome-sort可以将其缩短,并将table缩短1个字节。即将推出新版本...
Johan Koelman '16

这里的Gnome-sort更长,但还有其他优化。
Johan Koelman '16

0

因子128

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

万岁内置!:D


0

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

0

APL,23个字节

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

说明:

  • n←⍕⍵:获取的字符串表示形式n并将其存储在n
  • '8549176320'⍋:找到给定顺序的n那种n排列8549176320
  • n[... ]n按该排列重新排序
  • :评估结果(将其转换为数字)

由于I / O可能是字符串,因此可以删除。通过去除转换为tradfn {}而代。最后,除去0在年底为不公开,各种各样的:n['854917632'⍋n←⍞]
亚当

0

Clojure,53个字节

好吧,Haskell解决方案中的列表理解想法似乎是最短的:

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

我原来的方法是长1个字节:

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

您可以在此处在线查看两个功能:https//ideone.com/afac5n


0

普通Lisp,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功能对字符进行排序,同时使用自定义函数将给定字符转换为其表示的数值的英文表示形式。通常情况下,我不会使用一个功能与此功能相同的键功能,但是它的字节数要比装饰/排序/取消装饰字样少。


0

Python 3,234个字节

这是我的Factor答案的直接翻译,只是为了好玩。

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

评估“惰性”地图和zip对象的语义是宇宙中最微妙的,难以发现错误的真正马粪便。有时,s = map(f, x)不允许s或根本不允许使用。




0

Python 2.7.11,67个字节

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

将字符串作为输入并输出一个字符串。


0

Python 3,74个字节

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

您可能可以使用lambda来保存一些字节
Daniel Daniel

0

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
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.