受到命运多亏的不使用数组而对数字进行排序的启发，但我认为它比SO问题更好地编写了代码。

给定正整数，请对该整数排序。

最低分获胜！

1. 从0分开始。
2. 每个字符加一分。
3. 为您使用的每个数组加20点。
4. 为您的代码中的每个多字符字符串加10点。（除了初始输入，只要将其转换为整数而不对其进行任何其他操作即可。）
5. 如果程序可以处理的最大位数受程序限制（与机器相反），则加32点。
6. 如果您的代码可以根据给定的另一个参数更改排序的方向，则减去10分（无论您要使用什么，例如，降序排序为0，升序排序为1）。

每种语言都不尽相同，但其主旨是避免任何形式的可迭代数字黑客。

例：

输入：52146729

输出：97654221或12245679

笔记：

1. 使用您的编程语言提供的任何内置排序功能，但是如果排序功能涉及字符串或数组，则要加分！
2. 您可以将解决方案编写为直接接受整数的函数，也可以编写为接受argv，文件或流中的参数并将其转换为整数的程序。只要立即将其转换为整数并丢弃原始char *输入而无需对其进行任何进一步的操作，就不会受到任何惩罚。
3. 处罚不仅适用于程序文本中的字符串文字，而且适用于程序功能的任何可能输入或输出字符串或可迭代的部分。例如，JavaScript String.prototype.split至少有一个字符串作为输入（this）和一个数组作为输出，因此使用+30即可。
4. 我试图使这些规则指导算法设计的原理，而不是初始/最终I / O（因此请注意＃2）。我认为，int(input())即使input的签名说它返回的是字符串，只要该表达式是程序的初始入口点，也不应适用该惩罚。同样，如果程序的最终输出是print(x)并且x必须是字符串，则惩罚不适用于最后一个字符串的强制转换操作。话虽如此，我从来没有明确地说过这必须是一个程序或I / O必须来自或离开的地方。接受int并返回的函数将起作用int，并且不会遭受这些歧义的困扰。

高尔夫脚本11 4

（4 + 10（字符串）-10（反向选项））

在STDIN上输入。

~`$%

输入格式是这样的：

(1 or -1) (the number)

1 正常排序 -1反转。4个字符-反向选项10个=得分为-6。

从技术上说，输入是一个字符串，所以我不确定这是否等于+10。我将规则解释为“在程序中声明的字符串”（因为它说“在代码中”）。

旧答案（11分）：

$

哈斯克尔106

t=10;d=divMod;s z|z<w z=s$w z|t>0=z
w x|x<t=x|y>z=(q*t+y)*t+z|t>0=y+t*(w v)where{(v,y)=d x t;(q,z)=d v t}

例：

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

一个不回避问题的答案。

已要求作出解释，此处已取消解释。这是一种非常低效的气泡排序。

-- t=10 - alias for 10. d=divMod - alias for divMod.
-- The alias for '10' turns out to be unnecessary; inlining it
-- and using '1>0' for True has the same character count. It's
-- a relic of earlier versions of the code.

-- 's': if no digits need swapped, return the number,
-- otherwise return 's' applied to the number with
-- that pair of digits swapped.
sort z=
  let temp=sort_pair z
  -- because we are sorting in descending order,
  -- sorting a pair of digits always increases the number.
  -- testing > costs one less char than ==.
  if z<temp then
    -- golfed version uses guards instead of if/else to save space.
    -- t>0 is '10 > 0', which is 'True', in fewer chars.
    sort temp
  else
    z
-- 'w': recursively swap one pair of out of order digits, or
-- return the original number if no pairs needed swapped.
sort_pair x=
  -- haskell does the assignments below lazily, they aren't
  -- calculated unless I use them. 'divMod' lets me do this
  -- with fewer chars.
  let y = x `mod` 10 -- last digit
      v = x `div` 10 -- all but last digit
      z = v `mod` 10 -- second last digit
      q = v `div` 10 -- all but last 2 digits
  in
  if x < 10 then
    x
  else if y > z then
    -- last 2 digits are out of order. swap them & return
    -- This is rearranged using Horner's method to save space
    -- http://en.wikipedia.org/wiki/Horner%27s_method
    -- ... although it turns out not to save anything, it's a relic.
    (q * 10 + y)*10 + z
  else
    -- last digit is ok, so try sort_pair on remaining digits
    let temp = sort_pair v in
    -- put last digit back on the end and return
    -- having the bracketed expression last here
    -- let me remove a space before 'where'
    y+(10*temp)

Haskell中存在较短的答案，相当于发布的其他一些答案，例如：

import Data.List;s=read.sort.show::Integer->Integer

...得分52 + 20 = 72，或者得分45 + 20 = 65：

import Data.List;main=interact(reverse.sort)

...但是问题的实质-没有数组，字符串或字符-更有趣。

C + x86组件，636

我知道这不会赢，但是感觉太不自然了，我不得不分享。没有数组或字符串（只要不计算输入参数）。其位数受32位范围的限制。

所以这是我所做的一些解释：

我以为我会在不使用任何数组或字符串的情况下执行此操作，然后想到了递归，但是当然，有了递归，我将无法从其他递归调用中交换值……然后我意识到有办法 将我的C程序与汇编函数链接起来后，我可以跳入堆栈并返回指向所需调用的基本指针的指针，这就是“ recursionStackAt”函数的作用。当然recursionStackAt是一个非常丑陋的函数，它的结果不仅取决于输入或程序的状态，还取决于调用者本身。请注意，这就是让我将索引从0更改为1的原因。

事不宜迟，这里是代码：

#include <stdio.h>
#include <stdlib.h>

int numberToSort;
int totalLength = 0;
int decreasing;

int* recursionStackAt(int pos); //Here's the magic

void swapAtStack(int pos1, int pos2) {
    int a = *(recursionStackAt(pos1)+3);
    *(recursionStackAt(pos1)+3) = *(recursionStackAt(pos2)+3);
    *(recursionStackAt(pos2)+3) = a;
}

int getAt(i) {
    return *(recursionStackAt(i)+3);
}

void printNumber(int len) {
    int i = 0;
    for(i = 1; i <= len; ++i) {
        printf("%d",*(recursionStackAt(i)+3));
    }
    printf("\n");
}

void computeNextDigit(int remainingNumber, int nextDigit) {

    if(remainingNumber == 0) {
        //Bubble sort cause I was lazy and it's quite compact
        ++totalLength;

        int i, j;

        for(i = 1; i <= totalLength; ++i)
            for(j = 1; j <= totalLength-1; ++j) {
                if(decreasing) {
                    if(getAt(j) > getAt(j+1)) 
                        swapAtStack(j,j+1);
                }
                else { 
                    if(getAt(j) < getAt(j+1))
                        swapAtStack(j,j+1);
                }
            }

        printNumber(totalLength);   
    }
    else {
        ++totalLength;
        computeNextDigit(remainingNumber/10, remainingNumber%10);
    }
}

int main(int argc, char* argv[]) {
    if(argc == 3) {
        numberToSort = atoi(argv[1]);
        decreasing = atoi(argv[2]);
    }
    else exit(1);
    computeNextDigit(numberToSort/10, numberToSort%10);
} 

当然，recursionStackAt函数的x86（AT＆T sintax，btw）汇编代码：

.text
    .align 4
    .globl  recursionStackAt
    .type   recursionStackAt, @function
recursionStackAt:
        pushl %ebp
        movl %esp,%ebp
        pushl %esi
        movl $0, %esi #i = 0
        movl (%ebp), %eax #pointer
while:  
        cmp %esi, 8(%ebp)
        je endwhile
        movl (%eax),%eax
        incl %esi
        jmp while
endwhile:
        popl %esi
        movl %ebp, %esp
        popl %ebp
        ret

输出上的一些示例：（1表示增加，0表示减少）

$ ./sortasort 6543210 1
0123456
$ ./sortasort 32507345 1
02334557
$ ./sortasort 32507345 0
75543320

这是混淆的版本（不可读，但工作正常）：

http://pastebin.com/XkYt9DLy（C代码） http://pastebin.com/h0S0dfeU（x86代码）

因此，如果LibreOffice不撒谎，我的混淆代码由646个字符组成（没有空格，我应该算出它们吗？），并且在满足所有其他条件的情况下，对于递增/递减选择​​，我会得到-10。

哦，要编译它，您应该这样做（在类Unix系统上）

gcc -c [-m32] recursionStackAt.s 
gcc -o sortasort [-m32] sortasort.c recursionStackAt.o

请注意，仅当您使用64位计算机时，-m32标志才可用。您还需要32位库进行编译。

重击（回声）（0 + 7 + 0 + 0 + 32-10）= 29

Sorta：

echo $*

用法：

sorta 5
5

使用“ -e”进行反向排序：

sorta -e 3
3

• 对正整数1-9加0产生正确的结果
• 避免任何形式的可迭代数字黑客。
• 7个字符（+7）
• 没有数组
• 没有多字符字符串
• 它可以处理的最大位数：1（+32）
• 可以选择颠倒排序（-10）

编辑：将“猫”更改为“回声”，所以它实际上可以工作。编辑2：添加了“ $ *”，并将其放入“ sorta”脚本

Python3

我的脚本功能：

没有数组

没有字符串

复杂度为O（n）：我使用了countingsort（由我修改为不使用数组，但使用质数来计数出现次数）

大小无限制

字元：260 234

n=int(input())
def C(n,k):
    return (n//(10**(k-1)))%10
P=lambda l:((((29-6*l%2,19-2*l%2)[l<9],13-2*l%2)[l<7],2*l-1)[l<5],2)[l==1]

p=1
while n>=1:
    c =C(n,1)
    p*=P(c+1)
    n=n//10
f=1
k=r=0
while p>2:
    if(p%P(f)==0):
        r+=(f-1)*10**k
        p=p//P(f)
        k+=1
    else: f+=1
print(r)

Bash + coreutils，14个（24个字符-反向10个字符）

我认为这可能会有点违反规则，但是，周五，这里...

我假设允许使用标准库。我对标准库的解释bash是coreutils：

fold -1|sort $1|tr -d\\n

• 没有数组-使用流代替
• 没有引号==没有多字符字符串
• 输入/输出长度无限制
• 可选的arg“ -r”反转输出。

来自stdin的输入。正在使用：

$ declare -i i=52146729
$ ./ksort.sh <<< $i
12245679 $ 
$ ./ksort.sh -r <<< $i
97654221 $ 
$ 

C-64个字符，64个点

main(int a,char**b){b++;qsort(*b,strlen(*b),1,strcmp);puts(*b);}

您可能想知道如何在没有任何标题的情况下使它工作。简单，编译：

gcc -include stdio.h stdlib.h string.h test.c -o test --std=gnu11 -Wall -g -O3

未打高尔夫球：

#include <stdio.h> 
#include <stdlib.h>
#include <string.h>

main(int a, char **b)
{
    b++;
    qsort(*b, strlen(*b), sizeof(char), strcmp);  // sizeof(char) is guaranteed to be 1 by standards
    puts(*b);
}

我也决定包括字符排序，只是因为我可以。

测试运行：

$ ./test 132815
112358
$ ./test 423791
123479
$ ./test 1234767189728975213132471243985123957120837412
0111111112222222233333344445556777777788889999
$ ./test 4789359uihjasvb8ygohq9poi3n4jiouy58g
3344557888999abgghhiiijjnooopqsuuvyy

c函数（小尾数法），131 108个字符

没有sleepsort答案，没有任何排序挑战是完整的。这一次最多可能需要10秒钟才能返回，但它确实有效，我认为它完全在规格范围内。此函数采用单个int参数，并返回带有排序的十进制数字的int：

c=0,d;
k(i){
    for(;i;i/=10,fork()?c++:(sleep(d),exit(d)))
        d=i%10;
    for(;c--;i=i*10+(d>>8&255))
        wait(&d);
    return i;
}

_{添加了换行符和缩进以提高可读性}

调用如下：

int main (int argc, char **argv) {
    int i = 52146729;

    printf("%d\n", k(i));
    return (0);
}

爪哇：262点

是的，我知道，这是没有希望的，但是仍然..

class G{Object m(StringBuffer s,int o){for(int i=1;i<s.length();i++){int j=i-1,t=s.charAt(i),u=s.charAt(j);boolean c=o==0?t>u:t<u;for(;j>-1&c;){s.setCharAt(j+1,s.charAt(j));c=--j>-1;c=c?(o==0?t>s.charAt(j):t<s.charAt(j)):c;}s.setCharAt(++j,(char)t);}return s;}}

分析（标记）：

1. 从0开始。（分数= 0）
2. 总共262个字符。（分数= 0 + 262 = 262）
3. +10- 使用StringBuffer（我之所以使用它是因为它比短StringBuilder）（得分= 262 + 10 = 272）
4. -10-用于使输出灵活。我考虑过0 =降序，1 =升序，所以回到262！

用法：

当您尝试G.java在命令提示符下编译文件时，它会产生很多问题（错误）。那么，解决方案呢？

编译G.java在IDE类像NetBeans或者Eclipse甚至BlueJ。它应该毫无问题地编译（忽略任何警告）。

然后，应使用main()其他任何类（甚至该类本身）中的方法来调用该类。我将其放置在另一个类中，因此没有将其添加到我的字符计数中。以类似的方式编译另一个类（不使用cmd）。现在，另一个类中的main()方法应类似于：

public static void main(String[]a){
    System.out.println(new G().m(new StringBuffer(a[0]),1));
    //for descending, put '0' instead of '1'
}

除去不必要的空格，注释和换行符，它是另外93个字符。我没有将其添加到角色中，因为这只是为了通过控制台进行演示。

输出：

零即被0考虑。假设外部类是Helper.java，并且已经成功编译，则通过控制台进行操作的一些示例是：

INPUT : C：...> Java帮助器008321
OUTPUT: 001238

INPUT :C：...> java帮手79359105
OUTPUT:01355799

当更改为0降序...

INPUT :C：...> Java帮助器008321
OUTPUT:832100

INPUT :C：...> java帮手79359105
OUTPUT:99755310

笔记：

1. 我没有在中明确声明任何数组G.java。那是核心课程。
2. 我正在使用插入排序对数字进行数字排序。
3. 该数字可以是最大长度 - Integer.MAX_VALUE因为这是任何数组可以容纳的最大大小（在Java中）。
4. 这个答案可以缩短（我相信），所以请帮助我（改善我的第一个答案）。
5. 真是令人震惊的伟大的上帝，他们无意间创造了Java这样冗长而伟大的语言（并且还提出了代码约定）！

TeX / LaTeX（332）

如果将实际代码放在package中s，则主LaTeX文件看起来很简单。该数字仅以数学形式给出。如果数字为负，则排序顺序相反。软件包的代码s也可以与普通的TeX一起使用，下面将进一步说明。

\documentclass{book}
\usepackage{s}
\begin{document}
  $52146729$

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

包装s（不需要一行，行尾）：

\TeXXeTstate1\everymath{\aftergroup\B\def~#1{\gdef#1{}\aftergroup#1}
~\a~\b~\c~\d~\e~\f~\g~\h~\i~\j\aftergroup\E\xdef\B{}\xdef\E{}}
\def~#1#2{\mathcode`#1"8000\lccode`~`#1\lowercase{\def~{\xdef#2{#2#1}}}}
~0\a~1\b~2\c~3\d~4\e~5\f~6\g~7\h~8\i~9\j\mathcode`-"8000\lccode`~`-
\lowercase{\def~{\xdef\B{\beginR}\xdef\E{\endR}}}

结果：

得分：无望

• 通过将普通TeX与etex或结合使用pdftex，文件可以简化为：

  <contents of s.sty>\rm\shipout\hbox{$<number>$}\bye

  字节：318字节（s.sty）+ 24字节，其余不包含数字

• 不使用数组：0

• 我看不到多字符字符串：0

• 数量不受算法限制。最大的TeX数是2 ³¹ - 1 = 2147483647的例子使用一个66位的数字，方式较大： 0

• 如果给出负号，则排序顺序将还原为降序：-10

0 + 318 + 24 + 0 + 0-10 = 332

算法：

在数学模式下，将数字设置为活动字符。每个数字记住并收集宏中的每种用法。在数学模式之后，宏将以数字升序输出。

方向更改是通过从右到左的文本（一种e-TeX功能）完成的。

去代码的版本s.sty

\TeXXeTstate = 1 % enable mixed direction typesetting
\everymath{%
  % \B and \E surround the number, they will be redefined
  % with right-to-left primitives to output the reverted number
  \xdef\B{}
  \xdef\E{}
  \aftergroup\B
  % the active character ~ is defined as help macro;
  % the argument is the collector macro
  \def~#1{%
    \gdef#1{}% initially the macro is empty
    \aftergroup#1%
  }%
  % the ten macros \a to \j form the result number
  ~\a~\b~\c~\d~\e~\f~\g~\h~\i~\j
  \aftergroup\E
}
% the active ~ is used as helper macro;
% first argument is the digit, the second argument is the collector macro
\def~#1#2{%
  \mathcode `#1  = "8000 % make digit active in math mode
  \lccode `~ = `#1 % trick for defining the active digit 
  \lowercase{%
    \def~{%
      \xdef#2{#2#1}% the digit adds itself to its collector macro
    }%
  }%
}
~0\a~1\b~2\c~3\d~4\e~5\f~6\g~7\h~8\i~9\j
% Defining the minus character as switch for descending digits:
\mathcode `- = "8000 % minus sign active in math mode
\lccode `~ = `- % trick for defining the active minus
\lowercase{%
  % the minus sign redefines the wrapper macros \B and \E that
  % surround the result number. These macros now uses
  % primitives for right-to-left typesetting.
  \def~{%
    \xdef\B{\beginR}%
    \xdef\E{\endR}%
  }%
}

重现

有一些在线LaTeX编译器，可以在此处找到列表。我尝试了列表中的第一项，即sciencesoft.at上的LaTeX servlet。它可以不经签名使用，还可以创建永久URL： 源和结果为image。

C-65

r,t,i;s(n){for(;++i;)for(t=n;t;t/=10)r=t%10-i?r:10*r+i;return r;}

机敏的观察者会注意到，这种排序算法会以O（n）的时间对中的位数进行运算n。

务实的观察者会注意到，这种排序算法的运行时间与平台上有符号整数的范围成正比，它使必须在运行之间重新初始化的全局状态发生突变，并且为简洁起见还做出了许多其他牺牲。

非高尔夫版本不是完全等效的，但可以更好地传达所涉及的实际算法。

int s(int n)
{
    int r = 0;
    int t;
    int i;
    for(i = 0; i < 10; i++)
    {
        for(t = n; t != 0; t /= 10)
        {
            if(t % 10 == i)
            {
                r = 10 * r + i;
            }
        }
    }
    return r;
}

这是该功能的测试工具：

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    if(argc != 2) return 1;
    printf("%d\n", s(atoi(argv[1])));
    return 0;
}

哈斯克尔-96

96个字符，没有数组，没有字符串，没有整数限制，不能反向

d=(`divMod`10)
a&(0,0)=a
a&(y,z)=(z%d a)&d y
a%(y,z)|z>a=10*(a%d y)+z|1<3=100*y+10*z+a
s=(0&).d

例子：

λ: s 52146729
12245679
λ: s 502010406072952146729521467295214672952146729
1111122222222224444455555666667777799999
λ: s 100
1

这是一种插入排序，直接对整数本身执行。这类似于另一个Haskell条目，它是冒泡排序，尽管我发誓我在看到它之前就已经在做它。

简要指南：

• d将数字分为单位和十进制，即：d 135是对(13,5)
• a%x排序位插入a到数x
• a&xx通过将单位数字插入a并对结果和余数递归进行排序
• s x通过从&0开始递归对x进行排序x

诀窍是，第二个参数%和&不x直接，但xdivMod'd使用d

Python3.3 61点

print(''.join(sorted(input())))

该程序将输入作为字符串输入，该输入计为字符串，因为它不会立即更改为整数。 +10

字符串被排序成一个数组 +10

此数组连接在一起成为字符串+10

注：该''用来连接阵列的内容是不是多字符串，所以+10不会加到得分。

该程序包含31个字符。+31

31 + 10 + 10 + 10 = 61点

J，10个字符（+1个字符串）得分= 20

s=./:~&.":

用法：

   s 52146729
12245679

适用于所有32位数字。

说明：

/:~&.按":格式排序。我以前的版本也使用数组，但是它们很昂贵，所以现在我只需要使用字符串并按字母顺序对字符进行排序。":将输入的数字转换为字符串，然后/:~的数字转换并将数字按升序排序。因为排序是以“ under”格式完成的，所以当排序完成时，字符串将转换回数字。添加反转功能可能会比节省的成本更多，因此我没有打扰。

可以这样说，因为像APL和K一样，J是基于数组的语言，所以单个输入是一个由1个项目组成的数组，但是我选择在计算分数时不采取这种苛刻的看法。

32位限制是由J而不是我的程序施加的。更高的数值，J会将数字切换为科学计数法。从这个问题尚不清楚，在这种情况下是否适用32分的罚分，但是即使先前的两项罚分都适用（我认为他们不应该这样做），得分也高达72分，仍然可以轻松击败其他大多数罚分答案。

Python 2.7：174

import math
i=input()
d={n:0for n in xrange(10)}
for n in(i/10**c%10for c in xrange(1+math.log10(i))):d[n]+=1
print"".join(str(n)for n in xrange(10)for c in xrange(d[n]))

• 没有数组（使用迭代器和字典代替）
• 没有多字符字符串（输出除外）
• 没有人为的最大位数
• 不可逆转

它通过创建将所有10位数字映射为0的字典来工作。然后在数字（log10(i)）的长度上进行迭代，提取出每个数字（(i / (10 ** c)) % 10），并在字典中为该数字递增计数器。最后，它通过遍历所有10个数字来创建一个字符串，并且对于每个数字，产生一个数字实例作为字符串。

我可以将最后一行更改为print"".join(d[n]*str(n)for n in xrange(10))少16个字符，但使用多字符字符串。

C（最高C90）或C ++， 78 66点

这样对整数排序的函数称为s。

s(i){t=10,a=i?s(i/t):0,b=i%t,c=a%t;return c>b?t*s(a-c+b)+c:t*a+b;}

得分：

• 66个字符（+66）
• 0个数组（+0）
• 0个字符串（+0）
• 机器定义的范围（大小为int）（+0）
• 仅一个分类方向（-0）

旧版本（78分，也可用于C ++和更现代的C版本）

int s(int i){int t=10,a=i?s(i/t):0,b=i%t,c=a%t;return c>b?t*s(a-c+b)+c:t*a+b;}

C＃-179

using System.Linq;class S{void Main(string[] a){Console.Write(string.Concat(string.Concat(a).Replace("-","").OrderBy(o=>a[0].Contains('-')?-o:o)));}}

未打高尔夫球

using System.Linq;

class S
{
    void Main(string[] a)
    {
        Console.Write(string.Concat( 
            string.Concat(a)
                .Replace("-", "")
                .OrderBy(o => a[0].Contains('-') ? -o : o )));
    }
}

测试

正常：

app.exe 52313698

反转：

app.exe 52313698-

分数：（ 我希望我能正确理解分数系统-随时纠正）

• 字符数：149
• 字串：10 + 10
• 数组：+20
• 订单：-10
• 总计：149 + 10 + 20-10 = 179

LINQPAD的 C＃-123

void Main(string[] a){Console.Write(string.Concat(string.Concat(a).Replace("-","").OrderBy(o=>a[0].Contains('-')?-o:o)));}

测试

正常：

lprun.exe sorta.linq 52313698

反转：

lprun.exe sorta.linq 52313698-

要点：

• 字符数：122
• 字串：10 + 10
• 数组：+20
• 订单：-10
• 总计：122 + 10 + 20-10 = 152

Java 1469

Java中无字符串和数组的解决方案。1437个字符+ 32个字符，因为它最多只需要Long.MAX_VALUE作为输入。通过使用Double，我可以改用300多个数字，但是实现起来太麻烦了。大于此的任何值都将需要BigInteger和AFAIK在内部使用数组。如果您输入的数字少于19位，则输出将带有前导零。负输入将全为零，任何非数字都将导致异常。

对于我使用的最简单的排序方式，它效率很低。（应为O（n * n））

input:  9212458743185751943
output: 1112233444555778899

我知道这与其他语言的解决方案并没有真正的比较，但是我觉得这至少是我能用Java获得的最短的解决方案。（如果有人知道如何使它更短，请随时进行编辑/评论）

class D
{
    long c,d,e,f,g,h,k,l,m,n,o,p,q,r,s,t,u,v,w;
    long x;

    public D(Long a)
    {
        x = a;
        c = g();
        d = g();
        e = g();
        f = g();
        g = g();
        h = g();
        k = g();
        l = g();
        m = g();
        n = g();
        o = g();
        p = g();
        q = g();
        r = g();
        s = g();
        t = g();
        u = g();
        v = g();
        w = g();
        int i=0;
        while(i++ < 19) s();
        System.out.printf("%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d",c,d,e,f,g,h,k,l,m,n,o,p,q,r,s,t,u,v,w);
    }

    long g()
    {
        if( x <= 0 ) return 0;
        long b = x % 10;
        x = x / 10; 
        return b;
    }

    void s()
    {
        if(c > d) {c += d; d = c - d; c -= d;}
        if(d > e) {d += e; e = d - e; d -= e;}
        if(e > f) {e += f; f = e - f; e -= f;}
        if(f > g) {f += g; g = f - g; f -= g;}
        if(g > h) {g += h; h = g - h; g -= h;}
        if(h > k) {h += k; k = h - k; h -= k;}
        if(k > l) {k += l; l = k - l; k -= l;}
        if(l > m) {l += m; m = l - m; l -= m;}
        if(m > n) {m += n; n = m - n; m -= n;}
        if(n > o) {n += o; o = n - o; n -= o;}
        if(o > p) {o += p; p = o - p; o -= p;}
        if(p > q) {p += q; q = p - q; p -= q;}
        if(q > r) {q += r; r = q - r; q -= r;}
        if(r > s) {r += s; s = r - s; r -= s;}
        if(s > t) {s += t; t = s - t; s -= t;}
        if(t > u) {t += u; u = t - u; t -= u;}
        if(u > v) {u += v; v = u - v; u -= v;}
        if(v > w) {v += w; w = v - w; v -= w;}
    }

    public static void main(String[] y)
    {
        D d = new D(Long.parseLong(y[0]));
    }
}

AWK-101

“ x”文件：

BEGIN{n=ARGV[1]
r=ARGV[2]
for(d=r;d<10;d++)for(p=1;p<=length(n);p++){D=r?d:9-d
if(D==substr(n,p,1))printf D}print}

运行：

$ awk -f x 52146729
97654221
$ awk -f x 52146729 0
97654221
$ awk -f x 52146729 1
12245679
$ awk -f x 1234567890123456789012345678901234567890
9999888877776666555544443333222211110000
$ awk -f x 1234567890123456789012345678901234567890 1
111122223333444455556666777788889999

唯一使用的数组是ARGV，这对排序没有帮助，它只能访问命令行参数，并且这些值在非数组变量中实际需要计算。我认为这将不反对这种解决方案。以下计算未考虑ARGV阵列：

111（字符）-10（可以反向）

我在问题中什么都没有看到，因此...（如果弯曲或破坏了规则，我将删除答案，让我知道）

JavaScript的56 96

function s(){alert(+prompt().split('').sort().join(''))}

JavaScript的69 109（可逆式）

function s(r){x=prompt().split('').sort();x=r?x.reverse():x;alert(+x.join(''))}

可以使用EcmaScript 6打高尔夫球 箭头功能：

ES6 50 90

s=()=>{alert(+prompt().split('').sort().join(''))}

ES6 63 103（可逆式）（73-10）

s=(r)=>{x=prompt().split('').sort();x=r?x.reverse():x;alert(+x.join(''))}

SED 67字符（得分67或107）

s/$/;0123456789/;:a;s/\(.\)\(.\)\(.*;.*\2.*\1\)/\2\1\3/;ta;s/;.*//;

为了简洁起见，使用了冒泡排序。如果每个正则表达式模式和替换项都计为字符串，则得分为107（即67 +（10 * 4））

受内存限制的位数（可能是耐心）

Python lambda函数（可逆），69

lambda n,d:''.join(sorted(n,reverse=d))

• 39个字符（+39）
• 两个多字符字符串：（n输入）和''.join(...) （+20）
• 一个清单： sorted(...) （+20）
• 可以根据参数（-10）反转d

Python lambda函数（不可逆），67

lambda n:''.join(sorted(n))

编辑：输入应为字符串。我正在考虑直接使用该字符串的惩罚。

普通Lisp-126

(defun s(n p)(labels((a(n)(if(= 0 n)()(cons(mod n 10)(a (floor n 10)))))(b(a)(if(null a)0(+(car a)(* 10(b(cdr a)))))))(b(sort(a n) p))))

未标准化的（在风格上和词汇上，但在功能上相同）版本：

(defun sorta (n p)
  (labels ((digits (n)
             (unless (zerop n)
               (multiple-value-bind (quotient remainder)
                   (truncate n 10)
                 (cons remainder (digits quotient)))))
           (digit-cat (digits)
             (if (null digits)
                 0
               (+ (car digits)
                  (* 10 (digit-cat (cdr digits)))))))
    (digit-cat (sort (digits n) p))))

负数的数字被视为具有负值，并且数字按最低有效位在前（即小尾数）排序。例子：

CL-USER> (sorta 1234 #'<)
=> 4321
CL-USER> (sorta 12344321 #'<)
=> 44332211
CL-USER> (sorta 12344321 #'>)
=> 11223344
CL-USER> (sorta -12344321 #'>)
=> -44332211
CL-USER> (sorta 0 #'>)
=> 0
CL-USER> (sorta 8675309 #'<)
=> 9876530

高尔夫版本中有136个字符，包括空格。它不使用任何字符串，也不使用任何数组，并且可以处理任意精度的整数，包括负整数。排序是在二进制谓词上进行参数化的，该谓词定义了中的整数的总排序[-9, 9]，包括但不限于<和>：

CL-USER> (sorta 3546219870 (lambda (a b)
                             (cond ((and (evenp a)
                                         (oddp b))
                                    t)
                                   ((and (evenp b)
                                         (oddp a))
                                    nil)
                                   (t
                                    (< a b)))))
=> 9753186420

这给出的分数是126。

JavaScript 416/185

没有数组，没有字符串，没有任意长度限制 ...

但是排序/排序会用掉10个以上的字符^^但是我发现了对数字进行计数并将其打印出来的想法很有趣-也许有人可以在GolfScript中使用此想法并赢得大奖;-)

var x=window.prompt(),y=0,z=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;
do
{
    z=x%10;
    x=(x-z)/10;
    if(!z)a++;
    if(z==1)b++;
    if(z==2)c++;
    if(z==3)d++;
    if(z==4)e++;
    if(z==5)f++;
    if(z==6)g++;
    if(z==7)h++;
    if(z==8)i++;
    if(z==9)j++;
}while(x);

while(a--)y=y*10;
while(b--)y=y*10+1;
while(c--)y=y*10+2;
while(d--)y=y*10+3;
while(e--)y=y*10+4;
while(f--)y=y*10+5;
while(g--)y=y*10+6;
while(h--)y=y*10+7;
while(i--)y=y*10+8;
while(j--)y=y*10+9;

alert(y);

使用eval：可以缩短相同的代码：（但是使用字符串可能会考虑...）

var i = window.prompt(),o=0,i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;
do
{
    eval("i"+i%10+"++");
    i = ~~(i/10);
} while (i > 0)

for(var j=0;j<10;j++) while (eval("i"+j+"--")>0) o = o*10+j;

alert(o);

C（222）

static int a[10],r=1;o(n,c){while(n--)printf("%""i",c);}p(){int n;for(n=r<0?9:0;n>=0&&n<10;n+=r)o(a[n],n);}main(int _,char**v){char*s=v[1];if(*s=='-'){r=-1;++s;}do++a[*s-'0'];while(*++s);p();}

要点：

• 192（192个字符）
• 40（2个数组：argv（v）和a）
• 0（无多字符字符串）
• 0（不限于n位数字）

• -10（如果数字（argv [1]）为负数，则反向排序）

  = 222点

摆脱1000个编译器警告所需的标志： gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

“更好”的可读性：

static int a[10],r=1;
o(n,c){while(n--)printf("%""i",c);}
p(){int n;for(n=r<0?9:0;n>=0&&n<10;n+=r)o(a[n],n);}
main(int _,char**v){char*s=v[1];if(*s=='-'){r=-1;++s;}do++a[*s-'0'];while(*++s);p();}

有点不符合要求：

static int a[10],r=1;
o(n,c){
    while(n--) printf("%""i",c);
}
p(){
    int n;
    for(n=r<0?9:0;n>=0&&n<10;n+=r) o(a[n],n);
}
main(int _,char**v){
    char*s=v[1];
    if(*s=='-'){
        r=-1;
        ++s;
    }
    do ++a[*s-'0']; while(*++s);
    p();
}

有没有我没有看到此解决方案的原因？

红宝石

pry(main)> 52146729.to_s.split("").sort.join.to_i
=> 12245679

不知道如何得分。拆分将生成一个数组，但是不能确定。38个字符+ 2x20的数组？还是应该包括所有可能在内部创建的排序数组？

VBScript-76（96？）

x = "7892347684578892348025023389054859034234"

for i=0 to 9:n=n&string(len(x)-len(replace(x,i,"")),""&i):next:x=n

' x -> 00002222233333344444455556777888888889999

66个字符+ 10个字符串的使用n
（不知道返回n个字符x 的replace函数和string函数的使用是否算作多余的字符串）。

它通过将原始字符串的长度与替换了特定数字的相同字符串进行比较来计算特定数字的数量。然后，它将那个数字附加到n上。

Python 3 sleepsort（168）

绝对没有列表或循环，只有生成器。

import math, threading
n=input()
if any(threading.Timer(x,lambda x:print(x,end='',flush=1),(x,)).start()for x in(n//10**i%10for i in range(math.log10(n)//1+1))):pass

可能会得到改善。

球拍97

97分（两个字符串为87 +20，排序为-10，无数组）

(define(s n <)(string->number(list->string(sort(string->list(number->string n))<))))

这使用字符列表，因此您需要给它一个字符比较函数，例如char<?或char>?。我觉得这也没有意义，因为除了添加空格和增加变量名外，没有其他事情要做。我的旧版本也许更光荣:)

没有字符串的旧版本：

110点（120字节（utf-8）-10，用于更改排序顺序。它不使用字符串也不使用数组）

(define(S d <)(foldl(λ(x a)(+(* a 10)x))0(sort(let L((l'())(
d d))(if(= d 0)l(L(cons(modulo d 10)l)(quotient d 10))))<)))

取消高尔夫：

(define (number-digit-sort number <)
  (foldl (λ (x a) (+ (* a 10) x))
         0
         (sort (let loop ((acc '()) (number number))
                 (if (= number 0)
                     acc
                     (loop (cons (modulo number 10) acc)
                           (quotient number 10))))
               <)))

我用第100,000个斐波那契数进行了测试：

(number-digit-sort (fibonacci 100000) <)
;==> 1111... basically it's the digits:
; 1 2135 times
; 2 2149 times
; 3 2096 times
; 4 2023 times
; 5 2053 times
; 6 2051 times
; 7 2034 times
; 8 2131 times
; 9 2118 times

和相反的顺序相同：

(number-digit-sort (fibonacci 100000) >)
; ==> 999... and the digest is
; 9 2118 times
; 8 2131 times
; 7 2034 times
; 6 2051 times
; 5 2053 times
; 4 2023 times
; 3 2096 times
; 2 2149 times
; 1 2135 times
; 0 2109 times