Inspiré par le malheureux tri des chiffres sans utiliser de tableau , mais je pensais que cela faisait un meilleur code de golf que la question SO.

Étant donné un entier positif, triez les chiffres de cet entier.

Le score le plus bas gagne!

1. Commencez avec 0 points.
2. Ajoutez un point par caractère.
3. Ajoutez 20 points pour chaque tableau que vous utilisez.
4. Ajoutez 10 points pour chaque chaîne à plusieurs caractères de votre code. (Sauf l'entrée initiale tant qu'elle est convertie en entier sans aucune autre opération sur elle.)
5. Ajoutez 32 points si le nombre maximum de chiffres que votre programme peut gérer est limité par votre programme (par opposition à la machine).
6. Soustrayez 10 points si votre code peut changer la direction du tri en fonction d'un autre argument (tout ce que vous voulez, mais par exemple 0 pour le tri décroissant et 1 pour le croissant).

Chaque langue est différente, mais l'idée est d'éviter tout type de piratage à plusieurs chiffres.

Exemple:

Entrée : 52146729

Sortie : 97654221 ou 12245679

Remarques:

1. Utilisez toutes les capacités de tri intégrées fournies par votre langage de programmation, mais si cette fonction de tri implique des chaînes ou des tableaux, prenez la peine!
2. Vous pouvez écrire la solution en tant que fonction qui prend directement un entier ou en tant que programme qui prend un argument de argv, un fichier ou un flux et le convertit en entier. Tant que vous le convertissez immédiatement en entier et supprimez l'entrée char * d'origine sans effectuer d'autres opérations dessus, aucune pénalité ne s'applique.
3. Les pénalités s'appliquent non seulement aux littéraux de chaîne dans le texte de votre programme, mais à toute partie de votre fonctionnalité de programme qui peut sans doute entrer ou sortir une chaîne ou itérable. Par exemple, JavaScript String.prototype.splita au moins une chaîne en entrée ( this) et un tableau en sortie, donc +30 pour l'utiliser.
4. J'ai essayé de faire en sorte que ces règles guident le principe de la conception de l'algorithme, pas les E / S initiales / finales (d'où la note # 2). Je ne pense pas que la pénalité devrait s'appliquer à int(input())même si inputla signature indique qu'elle renvoie une chaîne, tant que cette expression est le point d'entrée initial du programme. De même, si la sortie finale du programme est print(x)et xdoit être une chaîne, la pénalité ne s'applique pas à l'opération de transtypage de chaîne de dernier fossé. Cela dit, je n'ai explicitement jamais dit qu'il fallait que ce soit un programme ou d'où les E / S devaient venir ou aller. Une fonction qui prend un intet renvoie un intservirait et ne souffrirait pas de ces ambiguïtés.

GolfScript, 11 4

(4 + 10 (chaîne) - 10 (option inverse))

Entrée sur STDIN.

~`$%

Le format d'entrée est le suivant:

(1 or -1) (the number)

1trier normalement, -1inverser. 4 caractères - 10 pour l'option inverse = score de -6.

L'entrée est techniquement une chaîne, donc je ne sais pas si cela compte pour +10. J'interprète la règle comme "une chaîne déclarée dans votre programme" (car elle dit "dans votre code").

Ancienne réponse (score de 11):

$

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

exemple:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Une réponse qui n'esquive pas la question.

Une explication a été demandée, ici elle n'est pas golfée. C'est une sorte de bulle très inefficace.

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

Des réponses plus courtes existent dans Haskell, équivalentes à certaines des autres publiées, par exemple:

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

... marque 52 + 20 = 72, ou ceci, marquant 45 + 20 = 65:

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

... mais l'esprit de la question - pas de tableaux, de chaînes ou de caractères - est plus intéressant.

Ensemble C + x86, 636

Je sais que ça ne va pas gagner mais c'était tellement anormal et tordu que je devais le partager. Pas de tableaux ou de chaînes (tant que vous ne comptez pas les arguments d'entrée). Le nombre de chiffres est limité par la plage de 32 bits.

Voici donc une petite explication sur ce que j'ai fait:

Je pensais que je ferais cela sans utiliser de tableaux ou de chaînes, puis la récursivité est venue à l'esprit, mais bien sûr, avec la récursivité, je ne serais pas en mesure d'échanger les valeurs d'autres appels récursifs ... et c'est alors que j'ai réalisé que il y avait un moyen. Lier mon programme C avec une fonction d'assemblage Je pourrais sauter dans la pile et retourner un pointeur vers le pointeur de base de l'appel souhaité, c'est ce que fait la fonction "recursionStackAt". Bien sûr, recursionStackAt est une fonction très laide, son résultat ne dépend pas seulement de l'entrée ou de l'état du programme mais de l'appelant lui-même. Notez que c'est ce qui m'a fait changer les index de 0 à 1.

Sans plus tarder, voici le code:

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

Et bien sûr le code d'assemblage x86 (AT&T sintax, btw) pour la fonction recursionStackAt:

.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

Quelques exemples sur la sortie: (1 signifie augmenter et 0 diminuer)

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

Voici la version obscurcie (qui est illisible mais fonctionne bien):

http://pastebin.com/XkYt9DLy (code C) http://pastebin.com/h0S0dfeU (code x86)

Donc, si LibreOffice ne ment pas, mon code obscurci se compose de 646 caractères (sans espaces, dois-je les compter?) Et avec toutes les autres conditions remplies, j'obtiens -10 pour le choix croissant / décroissant.

Oh, et pour compiler cela, vous devriez le faire (sur les systèmes de type Unix)

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

Notez que l'indicateur -m32 est uniquement si vous êtes sur une machine 64 bits. Vous avez également besoin des bibliothèques 32 bits pour le compiler.

Bash (écho) (0 + 7 + 0 + 0 + 32-10) = 29

Sorta:

echo $*

Usage:

sorta 5
5

Utilisez "-e" pour trier en sens inverse:

sorta -e 3
3

• produit le résultat correct pour les entiers positifs 1-9, plus 0
• évite tout type de piratage itérable de chiffres.
• 7 caractères (+7)
• pas de tableaux
• pas de chaînes multi-caractères
• nombre maximum de chiffres qu'il peut gérer: 1 (+32)
• peut éventuellement inverser le tri (-10)

EDIT: changé "chat" en "écho" pour que cela fonctionne réellement. EDIT 2: Ajout de "$ *" et le mettre dans le script "sorta"

Python3

Mes fonctionnalités de script:

Pas de tableaux

Pas de chaînes

La complexité est O (n): j'ai utilisé countingsort (modifié par moi pour ne pas utiliser de tableaux, mais des nombres premiers pour compter les occurrences)

Aucune limitation de taille

Caractères: 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 caractères - 10 pour le revers)

Je pense que cela pourrait un peu contourner les règles, mais voilà, c'est vendredi ...

Je suppose que l'utilisation de bibliothèques standard est autorisée. Mon interprétation de la bibliothèque standard pour bashest coreutils:

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

• Pas de tableaux - les flux sont utilisés à la place
• Pas de guillemets == pas de chaînes multi-caractères
• Aucune limite à la longueur d'entrée / sortie
• l'argument optionnel "-r" inverse la sortie.

Entrée de stdin. Utilisé:

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

C - 64 caractères, 64 points

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

Vous vous demandez peut-être comment cela fonctionne sans aucun en-tête. Simple, compilez avec:

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

Non-golfé:

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

J'ai également décidé d'inclure le tri des caractères, juste parce que je le pouvais.

Essais:

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

fonction c (arc petit-endien), 131 108 caractères

Aucun défi de tri n'est complet sans une réponse sleepsort . Celui-ci prendra jusqu'à 10 secondes pour revenir, mais cela fonctionne, et je pense qu'il est entièrement conforme aux spécifications. Cette fonction prend un seul paramètre int et renvoie un entier avec les chiffres décimaux triés:

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

_{nouvelles lignes et indentation ajoutées pour plus de lisibilité}

Appelez comme suit:

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

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

Java: 262 points

Ouais, ouais je sais, c'est sans espoir, mais quand même ..

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

Analyse (marquage):

1. Commençant par 0. (score = 0)
2. 262 caractères au total. (score = 0 + 262 = 262)
3. +10 - pour l'utilisation StringBuffer(je l'ai utilisé parce qu'il est plus court que StringBuilder) (score = 262 + 10 = 272)
4. -10 - pour rendre la sortie flexible. J'ai considéré 0 = décroissant , 1 = croissant , revenons donc à 262!

Usage:

Lorsque vous essayez de compiler le G.javafichier dans l'invite de commande, cela génère beaucoup de problèmes (erreurs). Alors, la solution?

Compilez la G.javaclasse dans un IDE comme NetBeansou Eclipseou même BlueJ. Il devrait se compiler sans problème (ignorer les avertissements).

Ensuite, cette classe doit être appelée par une main()méthode de toute autre classe (ou même de cette classe elle-même). Je lui mets une autre classe, donc je ne l'ajoute pas à mon nombre de personnages. Compilez l'autre classe de manière similaire (sans utiliser cmd). Maintenant, la main()méthode dans l' autre classe devrait ressembler à ceci:

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

Excluant les espaces inutiles, les commentaires et les sauts de ligne, c'est encore 93 caractères. Je ne l'ajoute pas à mon personnage parce que c'est juste pour une démonstration via la console.

Production:

ZERO ie 0est considéré. En supposant que la classe externe est Helper.java, et qu'elle a été compilée avec succès, quelques exemples via la console sont:

INPUT :C: ...> java Helper 008321
OUTPUT:001238

INPUT :C: ...> java Helper 79359105
OUTPUT:01355799

Lorsqu'elle est changée en 0c.- à- d. Décroissante ...

INPUT :C: ...> java Helper 008321
OUTPUT:832100

INPUT :C: ...> java Helper 79359105
OUTPUT:99755310

REMARQUES:

1. Je n'ai déclaré explicitement aucun tableau dans G.java. C'est la classe principale .
2. J'utilise le tri par insertion pour trier le nombre en chiffres.
3. Le nombre peut être de la longueur maximale -Integer.MAX_VALUE car c'est la taille maximale que tout tableau peut contenir (en Java).
4. Cette réponse peut être raccourcie (je crois) alors aidez-moi (améliorez ma première réponse).
5. Darn ces grands dieux qui ont accidentellement créé un langage aussi long mais aussi génial que Java (et qui sont également venus avec des conventions de code)!

TeX / LaTeX (332)

Si le code réel est placé dans un package s, le fichier LaTeX principal semble agréable et facile. Le nombre est simplement donné en mathématiques. Si le nombre est négatif, l'ordre de tri est inversé. Le code du package speut également être utilisé avec du TeX simple, exemple ci-dessous.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

Le packages (une ligne, les fins de ligne ne sont pas nécessaires):

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

Résultat:

Résultat: désespéré

• En utilisant TeX ordinaire avec etexou pdftex, le fichier peut être réduit à:

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

  Octets: 318 octets ( s.sty) + 24 octets pour le reste sans le nombre

• Les tableaux ne sont pas utilisés: 0

• Je ne vois pas de chaînes multi-caractères: 0

• Le nombre n'est pas limité par l'algorithme. Le plus grand nombre TeX est 2 ³¹ - 1 = 2147483647. L'exemple utilise un nombre à 66 chiffres, beaucoup plus grand: 0

• Si un moins est donné, l'ordre de tri revient à l'ordre décroissant: −10

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

Algorithme:

Les chiffres deviennent des caractères actifs en mode mathématique. Chaque chiffre se souvient et recueille chaque utilisation dans une macro. Après le mode mathématique, les macros sont sorties avec les chiffres dans l'ordre croissant.

Le changement de direction se fait par un texte de droite à gauche, une fonctionnalité e-TeX.

Version dégolfée du code ens.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}%
  }%
}

Reproduire

Il existe des compilateurs LaTeX en ligne, une liste peut être trouvée ici . J'ai essayé le premier élément de la liste, le servlet LaTeX sur sciencesoft.at . Il peut être utilisé sans signature et il peut également créer des URL permanentes: source et résultat sous forme d'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;}

L'observateur avisé notera que cet algorithme de tri s'exécute en temps O (n) sur le nombre de chiffres n.

L'observateur pragmatique notera que cet algorithme de tri s'exécute dans le temps proportionnellement à la plage d'entiers signés sur la plateforme, qu'il mute l'état global qui doit être réinitialisé entre les exécutions, et que de nombreux autres sacrifices ont été consentis en faveur de la brièveté.

La version non golfée n'est pas exactement équivalente, mais elle transmet mieux l'algorithme réel impliqué.

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

Voici un faisceau de test pour la fonction:

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

Haskell - 96

96 caractères, pas de tableaux, pas de chaînes, pas de limite entière, ne peut pas inverser

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

Exemples:

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

Celui-ci est un tri par insertion, effectué directement sur les entiers eux-mêmes. Ceci est similaire à l'autre entrée Haskell qui est du type à bulles, bien que je jure que j'y travaillais avant de voir celle-ci.

Petit guide:

• ddivise un nombre en unités et en dizaines, c'est-à-dire: d 135est la paire(13,5)
• a%xest trié insertion de chiffre adans le nombrex
• a&xtrie xen insérant le chiffre des unités dans ale résultat et le reste
• s xtrie x en lançant la &récursivité sur 0 etx

L'astuce est que le deuxième argument de %et &n'est pas xdirectement, mais xdivMod'd utilisantd

Python3.3 61 points

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

Ce programme accepte l'entrée comme une chaîne, qui compte comme une chaîne car elle n'est pas immédiatement transformée en entier. +10

La chaîne est triée dans un tableau +10

Ce tableau est réuni en une chaîne +10

Remarque: Le ''utilisé pour joindre le contenu du tableau n'est pas une chaîne à plusieurs caractères, donc +10 n'est pas ajouté au score.

Le programme se compose de 31 caractères. +31

31 + 10 + 10 + 10 = 61 points

J, 10 caractères (+ 1 chaîne) score = 20

s=./:~&.":

Usage:

   s 52146729
12245679

Fonctionne pour tous les nombres 32 bits.

Explication:

/:~trier &.sous ":format. Ma version précédente utilisait également un tableau, mais ils sont coûteux, alors maintenant je dois simplement utiliser une chaîne et trier les caractères par ordre alphabétique. ":convertit le nombre entré en chaîne et /:~trie les chiffres par ordre croissant. Étant donné que le tri est effectué au format «sous», lorsque le tri est terminé, la chaîne est reconvertie en nombre. Ajouter la possibilité de revenir en arrière coûterait probablement plus cher qu'il n'en économise, donc je n'ai pas pris la peine.

L'argument pourrait être avancé que, puisque J, comme APL et K, est un langage basé sur un tableau, l'entrée unique est un tableau de 1 élément, mais j'ai choisi de ne pas adopter une vue aussi dure lors du calcul de mon score.

La limite de 32 bits est imposée par J, plutôt que par mon programme. Tout supérieur et J bascule les nombres en notation scientifique. La question de savoir si la pénalité de 32 points s'applique dans ce cas n'est pas claire, mais même si les deux pénalités précédentes s'appliquent (je ne pense pas qu'elles devraient), le score monte à 72 et bat toujours confortablement la grande majorité des autres réponses.

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

• Pas de tableaux (des itérateurs et un dictionnaire sont utilisés à la place)
• Pas de chaînes multi-caractères (sauf sortie)
• Pas de nombre artificiel maximum de chiffres
• Pas d'inversion

Il fonctionne en créant un dictionnaire mappant les 10 chiffres à 0. Ensuite, il itère sur la longueur du nombre ( log10(i)), extrait chaque chiffre ( (i / (10 ** c)) % 10) et incrémente le compteur de ce chiffre dans le dictionnaire. Enfin, il crée une chaîne faite en itérant sur les 10 chiffres et pour chaque chiffre donnant une instance du chiffre sous forme de chaîne.

Je pourrais changer la dernière ligne print"".join(d[n]*str(n)for n in xrange(10))qui serait de 16 caractères de moins, mais utiliserais des chaînes à plusieurs caractères.

C (jusqu'à C90) ou C ++, 78 66 points

La fonction afin de trier un entier est appelée 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;}

Notation:

• 66 personnages (+66)
• 0 tableaux (+0)
• 0 chaîne (+0)
• Plage définie par la machine (taille de int) (+0)
• Un seul sens de tri (-0)

Ancienne version (78 points, fonctionne également avec les versions C ++ et C plus modernes)

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

Non golfé

using System.Linq;

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

Tester

Ordinaire:

app.exe 52313698

Renversé:

app.exe 52313698-

Points: (J'espère avoir bien compris le système de points - n'hésitez pas à corriger)

• Caractères: 149
• Cordes: 10 + 10
• Matrices: +20
• Commande: -10
• Total: 149 + 10 + 20-10 = 179

C # avec LINQPAD - 123

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

Tester

Ordinaire:

lprun.exe sorta.linq 52313698

Renversé:

lprun.exe sorta.linq 52313698-

Points:

• Caractères: 122
• Cordes: 10 + 10
• Matrices: +20
• Commande: -10
• Total: 122 + 10 + 20-10 = 152

Java 1469

Une solution sans chaîne ni tableau en Java. 1437 caractères + 32 car il ne prend que Long.MAX_VALUE en entrée. En utilisant Double, je pourrais passer à plus de 300 chiffres à la place, mais ce serait trop fastidieux à mettre en œuvre. Tout ce qui est plus grand que cela nécessiterait BigInteger et AFAIK qui utilise des tableaux en interne. Si vous utilisez moins de 19 chiffres pour l'entrée, la sortie aura des zéros non significatifs. Une entrée négative donnera tous les zéros et tout ce qui n'est pas un nombre provoquera une exception.

Pour le type que j'ai utilisé le plus facilement possible, c'est donc assez inefficace. (devrait être O (n * n))

input:  9212458743185751943
output: 1112233444555778899

Je sais que cela ne se compare pas vraiment aux solutions dans d'autres langages mais je pense que c'est au moins le plus court que je puisse obtenir en Java. (si quelqu'un sait comment obtenir ce raccourci, n'hésitez pas à le modifier / commenter)

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

Le fichier '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}

La course:

$ 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

Le seul tableau utilisé est ARGV et ce n'est pas utile pour le tri, c'est seulement l'accès aux paramètres de ligne de commande et ces valeurs sont dans des variables non-tableau où elles sont réellement nécessaires pour les calculs. Je pense que cela ne comptera pas contre cette solution. Le calcul suivant ne prend pas en compte le tableau ARGV:

111 (caractères) - 10 (peut inverser)

Je ne vois rien sur les fonctions de tri dans la question, alors ... (je vais supprimer la réponse si elle plie ou enfreint les règles, faites-le moi savoir)

JavaScript 56 96

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

JavaScript 69 109 (réversible)

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

Peut être joué un peu au golf en utilisant les fonctions de flèche EcmaScript 6 :

ES6 50 90

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

ES6 63 103 (réversible) (73-10)

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

SED 67 caractères (score de 67 ou 107)

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

Cela utilise un tri à bulles pour plus de concision. Le score serait de 107 si chaque modèle d'expression régulière et chaque remplacement comptent comme une chaîne (c'est-à-dire 67 + (10 * 4))

Nombre de chiffres manipulés limité par la mémoire (et probablement la patience)

Fonction lambda Python (réversible), 69

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

• 39 caractères (+39)
• Deux chaînes multi-caractères: n (entrée) et ''.join(...) (+20)
• Une liste: sorted(...) (+20)
• Peut inverser la direction en fonction du paramètre d (-10)

Fonction lambda Python (non réversible), 67

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

EDIT: L'entrée doit être une chaîne. J'envisage la peine d'utiliser cette chaîne directement.

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

La version non golfifiée (stylistiquement mais aussi lexicalement mais fonctionnellement identique):

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

Les chiffres d'un nombre négatif sont traités comme ayant une valeur négative, et les chiffres sont triés les moins significatifs en premier (c'est-à-dire petit-boutien). Exemples:

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

Il y a 136 caractères dans la version golfée, y compris les espaces. Il n'utilise aucune chaîne et aucun tableau et gère les entiers de précision arbitraire, y compris les entiers négatifs. Le tri est paramétré sur un prédicat binaire qui définit un ordre total sur les entiers dans [-9, 9], incluant mais sans s'y limiter <et >:

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

Cela donne un score de 126.

JavaScript 416/185

Pas de tableaux, pas de chaînes, pas de contrainte de longueur arbitraire ...

Mais trier vers le haut / vers le bas aurait utilisé plus de 10 caractères ^^ Mais j'ai trouvé l'idée de compter les chiffres et de les imprimer intéressante - peut-être que quelqu'un peut utiliser cette idée dans GolfScript et gagner le prix ;-)

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

Le même code plus court, en utilisant eval: (mais cela serait probablement envisagé en utilisant des chaînes ...)

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

Points:

• 192 (192 caractères)
• 40 (2 tableaux: argv (v) et a)
• 0 (pas de chaînes multi-caractères)
• 0 (ce n'est pas limité à n chiffres)

• -10 (tri inverse si le nombre (argv [1]) est négatif)

  = 222 points

Indicateurs nécessaires pour se débarrasser des 1000 avertissements du compilateur: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"Mieux" lisible:

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

Assez peu golfé:

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

Y a-t-il une raison pour laquelle je ne vois pas déjà cette solution?

Rubis

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

Je ne sais pas comment marquer cela. Le fractionnement générerait un tableau, mais au-delà, je ne sais pas .. 38 caractères + 2x20 pour les tableaux? Ou doit-il inclure tous les tableaux que le tri pourrait créer en interne?

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 caractères + 10 pour l'utilisation de la chaîne n
(Je ne sais pas si l'utilisation de la replacefonction etstring fonction qui renvoie n quantité de caractères x est comptée comme une chaîne supplémentaire).

Il compte la quantité d'un certain chiffre en comparant la longueur de la chaîne d'origine avec la même chaîne avec le certain chiffre remplacé. Ensuite, il attache ce nombre de chiffres à n.

Tri-sommeil Python 3 (168)

Sans liste ni boucle, seulement des générateurs.

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

pourrait probablement être amélioré.

Raquette 97

97 points (87 +20 pour deux chaînes, -10 pour le tri, pas de tableaux)

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

Cela utilise des listes de caractères, vous devez donc lui donner une fonction de comparaison de caractères comme char<?ou char>?. Je pense que cela passe aussi comme non golfé car il n'y a pas grand-chose à faire que d'ajouter des espaces et d'augmenter les noms de variables. Mon ancienne version est peut-être plus honorable :)

Ancienne version sans cordes:

110 points (120 octets (utf-8) - 10 pour permettre de changer l'ordre de tri. Il n'utilise ni chaînes ni tableaux)

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

Non golfé:

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

Je l'ai testé avec le 100 000e numéro de fibonacci:

(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

Et la même chose dans l'ordre inverse:

(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