配列を使用せずに数字の数字を並べ替えるという不運に触発されましたが、SOの質問よりも優れたコードゴルフだと思いました。

正の整数を指定して、その整数の桁をソートします。

最低スコアが勝ちます！

1. 0ポイントから始めます。
2. 1文字につき1ポイントを追加します。
3. 使用する配列ごとに20ポイントを追加します。
4. コードの複数文字列ごとに10ポイントを追加します。（他の操作を行わずに整数に変換される限り、初期入力を除きます。）
5. プログラムが処理できる最大桁数が（マシンではなく）プログラムによって制限されている場合は、32ポイントを追加します。
6. コードで別の引数を指定して並べ替えの方向を変更できる場合は、10ポ​​イントを減算します（たとえば、降順の並べ替えの場合は0、昇順の場合は1）。

言語はすべて異なりますが、アイデアは反復可能な数字のハッカーを避けることです。

例：

入力：52146729

出力：97654221または12245679

ノート：

1. プログラミング言語が提供する組み込みの並べ替え機能を使用しますが、その並べ替え機能に文字列または配列が含まれる場合は、ペナルティがかかります！
2. ソリューションは、整数を直接取得する関数として、またはargv、ファイルまたはストリームから引数を取得して整数に変換するプログラムとして作成できます。すぐに整数に変換し、それ以上の操作を行わずに元のchar *入力を破棄する限り、ペナルティは適用されません。
3. このペナルティは、プログラムテキスト内の文字列リテラルだけでなく、文字列または反復可能オブジェクトを間違いなく入力または出力するプログラム機能のすべての部分に適用されます。たとえば、JavaScriptにString.prototype.splitは入力（this）として少なくとも1つの文字列があり、出力として配列があるため、それを使用する場合は+30です。
4. これらのルールが、初期/最終I / Oではなく、アルゴリズム設計の原則をガイドするようにしました（したがって、注2）。その式がプログラムの最初のエントリポイントである限り、の署名が文字列を返すと言ってint(input())も、ペナルティは適用されるべきではないと思います。プログラムの最終的な出力がある場合は同様に、そして文字列でなければなりません、ペナルティが土壇場の文字列の鋳造作業には適用されません。とは言っても、これはプログラムである必要があるとか、I / Oを出入りさせる必要があるとは、明示的に言ったことはありません。を受け取り、を返す関数は機能し、これらのあいまいさの影響を受けません。inputprint(x)xintint

GolfScript、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

-m32フラグは、64ビットマシンを使用している場合にのみ注意してください。また、コンパイルするには32ビットライブラリが必要です。

バッシュ（エコー）（0 + 7 + 0 + 0 + 32-10）= 29

ソルタ：

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

• 配列なし-代わりにストリームが使用されます
• 引用符なし==複数文字列なし
• 入出力の長さに制限はありません
• オプションの引数「-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パラメータを取り、ソートされた10進数で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);
}

Java：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でクラスをコンパイルしますNetBeansEclipse、あるいは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文字です。これはコンソールを介したデモンストレーション用であるため、キャラクターに追加していません。

出力：

ZERO ie 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のように長くてすばらしい言語を偶然作成してしまった（そしてコード規約を思いついた）偉大な神々をDarしましょう！

TeX / LaTeX（332）

実際のコードがパッケージsに入れられている場合、メインのLaTeXファイルは見た目が良くて簡単に見えます。数は単に数学として与えられています。数値が負の場合、ソート順は逆になります。パッケージのコードはs、プレーンTeXでも使用できます。例を以下に示します。

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

パッケージs（1行、行末は不要）：

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

結果：

スコア：絶望的

• etexまたはpdftexで単純なTeXを使用すると、ファイルを次のように縮小できます。

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

  バイト：318バイト（s.sty）+ 数字のない残りの部分は24バイト

• 配列は使用されません：0

• 複数文字の文字列が表示されない：0

• 数はアルゴリズムによって制限されません。TeXの最大数は2 ^31です - = 2147483647 1の例では、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サーブレットを試しました。署名なしで使用できます。また、永続的なURLを作成することもできます： sourceおよびresult as 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数を単位と10に分割します。つまり：d 135はペアです(13,5)
• a%x数字aへの数字の挿入をソートしますx
• a&xx単位の桁を挿入してソートしますa、その結果、残りの上に再帰
• s x&0で再帰を開始してxをソートし、x

秘Theは、%andの2番目の引数&ではありません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ビット数で機能します。

説明：

/:~フォーマットの&.下でソートし":ます。以前のバージョンでも配列を使用していましたが、コストがかかるため、文字列を使用してアルファベット順に文字を並べ替える必要があります。":入力された数値を文字列に変換し、/:~数値を、数字を昇順でソートします。並べ替えは「アンダー」形式で行われるため、並べ替えが完了すると、文字列は再び数値に変換されます。リバースする機能を追加すると、おそらくそれが節約できる以上の費用がかかるので、私は気にしませんでした。

Jは、APLやKと同様に配列ベースの言語であるため、単一の入力は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桁すべてを反復処理することで作成された文字列を作成し、各桁に対して文字列として数字の1つのインスタンスを生成します。

最後の行を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）
• 1つのソート方向のみ（-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の文字列と配列のないソリューション。入力としてLong.MAX_VALUEまでしか使用しないため、1437文字+ 32。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（reversable）（73から10）

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

SED 67 Chars（スコア67または107）

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

これは、簡潔にするためにバブルソートを使用します。各正規表現パターンと置換が文字列としてカウントされる場合、スコアは107になります（つまり、67 +（10 * 4））

メモリによって制限される処理される桁数（そしておそらく忍耐）

Pythonラムダ関数（可逆）、69

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

• 39文字（+39）
• 2つのマルチ文字列：（n入力）および''.join(...) （+20）
• 1つのリスト：sorted(...) （+20）
• パラメーターに応じて方向を反転できますd （-10）

Pythonラムダ関数（不可逆）、67

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

編集：入力は文字列でなければなりません。その文字列を直接使用することのペナルティを検討しています。

Common 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
（replace関数の使用とstring n文字の文字xを返す関数の余分な文字列としてカウントされる）。

元の文字列の長さと、特定の数字を置き換えた同じ文字列の長さを比較することにより、特定の数字の量をカウントします。次に、その桁数をnに付加します。

Python 3スリープソート（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ポイント（2つの文字列で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