Inspirado por la desafortunada clasificación de un número de dígitos sin usar una matriz , pero pensé que era un código de golf mejor que la pregunta SO.

Dado un entero positivo, clasifique los dígitos en ese entero.

¡La puntuación más baja gana!

1. Comience con 0 puntos.
2. Agrega un punto por personaje.
3. Agregue 20 puntos por cada matriz que use.
4. Agregue 10 puntos por cada cadena de caracteres múltiples en su código. (Excepto la entrada inicial siempre que se convierta a un entero sin ninguna otra operación realizada en él).
5. Agregue 32 puntos si la cantidad máxima de dígitos que su programa puede manejar está limitada por su programa (en oposición a la máquina).
6. Resta 10 puntos si tu código puede cambiar la dirección del orden dado otro argumento (lo que quieras, pero por ejemplo 0 para el orden descendente y 1 para el ascendente).

Cada idioma es diferente, pero la idea es evitar cualquier tipo de piratería iterativa de dígitos.

Ejemplo:

Entrada : 52146729

Salida : 97654221 o 12245679

Notas:

1. Utilice las capacidades de clasificación incorporadas que proporciona su lenguaje de programación, pero si esa función de clasificación involucra cadenas o matrices, ¡tome la pena!
2. Puede escribir la solución como una función que toma un número entero directamente, o como un programa que toma un argumento de argv, un archivo o secuencia y lo convierte en un número entero. Siempre y cuando lo convierta a un entero de inmediato y descarte la entrada char * original sin realizar ninguna otra operación, no se aplica ninguna penalización.
3. Las penalizaciones se aplican no solo a los literales de cadena en el texto de su programa, sino a cualquier parte de su función de programa que posiblemente ingrese o genere una cadena o iterable. Por ejemplo, JavaScript String.prototype.splittiene al menos una cadena como entrada ( this) y una matriz como salida, por lo que +30 por usar eso.
4. He tratado de hacer que estas reglas guíen el principio del diseño del algoritmo, no la E / S inicial / final (de ahí la nota n. ° 2). No creo que la penalización deba aplicarse int(input())incluso si inputla firma dice que devuelve una cadena, siempre que esa expresión sea el punto de entrada inicial del programa. Del mismo modo, si el resultado final del programa es print(x)y xdebe ser una cadena, la penalización no se aplica a la última operación de conversión de cadenas. Dicho todo esto, nunca dije explícitamente que esto tenía que ser un programa o de dónde debía venir o ir la E / S. Una función que toma un inty devuelve un intserviría, y no sufriría estas ambigüedades.

GolfScript, 11 4

(4 + 10 (cadena) - 10 (opción inversa))

Entrada en STDIN.

~`$%

El formato de entrada es este:

(1 or -1) (the number)

1ordenar normalmente, -1revertir. 4 caracteres: 10 para la opción inversa = puntaje de -6.

La entrada es técnicamente una cadena, por lo que no estoy seguro de si eso cuenta para +10. Estoy interpretando la regla como "una cadena declarada en su programa" (ya que dice "en su código").

Respuesta anterior (puntaje 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}

ejemplo:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Una respuesta que no esquiva la pregunta.

Se solicitó una explicación, aquí no tiene golf. Es un tipo de burbuja muy ineficiente.

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

Existen respuestas más cortas en Haskell, equivalentes a algunas de las otras publicadas, por ejemplo:

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

... puntúa 52 + 20 = 72, o esto, puntúa 45 + 20 = 65:

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

... pero el espíritu de la pregunta, sin matrices, cadenas o caracteres, es más interesante.

Conjunto C + x86, 636

Sé que esto no va a ganar, pero se sintió tan poco natural y retorcido que tuve que compartirlo. Sin matrices ni cadenas (siempre que no cuente los argumentos de entrada). El número de dígitos está limitado por el rango de 32 bits.

Así que aquí hay una pequeña explicación sobre lo que hice:

Pensé que haría esto sin usar ninguna matriz o cadena, y luego me vino a la mente la recursión, pero, por supuesto, con la recursión no podría intercambiar valores de otras llamadas recursivas ... y fue cuando me di cuenta de que Había un camino. Al vincular mi programa C con una función de ensamblaje, podría saltar en la pila y devolver un puntero al puntero base de la llamada deseada, eso es lo que hace la función "recursionStackAt". Por supuesto, recursionStackAt es una función muy fea, su resultado no solo depende de la entrada o del estado del programa, sino también de la persona que llama. Tenga en cuenta que eso es lo que me hizo cambiar los índices de 0 a 1.

Sin más preámbulos, aquí está el código:

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

Y, por supuesto, el código de ensamblaje x86 (AT&T sintax, por cierto) para la función 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

Algunos ejemplos en la salida: (1 significa aumentar y 0 disminuir)

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

Aquí está la versión ofuscada (que es ilegible pero funciona bien):

http://pastebin.com/XkYt9DLy (código C) http://pastebin.com/h0S0dfeU (código x86)

Entonces, si LibreOffice no miente, mi código ofuscado consta de 646 caracteres (sin espacios, ¿debería contarlos?) Y con todas las demás condiciones cumplidas, obtengo un -10 para la opción de aumento / disminución.

Ah, y para compilar esto deberías hacer (en sistemas tipo Unix)

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

Tenga en cuenta que el indicador -m32 es solo si está en una máquina de 64 bits. También necesita las bibliotecas de 32 bits para compilarlo.

Bash (eco) (0 + 7 + 0 + 0 + 32-10) = 29

Sorta:

echo $*

Uso:

sorta 5
5

Use "-e" para ordenar en reversa:

sorta -e 3
3

• produce el resultado correcto para enteros positivos 1-9, más 0
• evita cualquier tipo de piratería informática de dígitos iterables.
• 7 caracteres (+7)
• sin matrices
• sin cadenas de caracteres múltiples
• Número máximo de dígitos que puede manejar: 1 (+32)
• opcionalmente puede revertir el orden (-10)

EDITAR: cambió "cat" a "echo" para que realmente funcione. EDITAR 2: Se agregó "$ *" y se colocó en el script "sorta"

Python3

Mi script presenta:

Sin matrices

Sin cadenas

La complejidad es O (n): utilicé el conteo (modificado por mí para no usar matrices, sino números primos para contar las ocurrencias)

Sin limitaciones de tamaño.

Caracteres: 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 caracteres - 10 para reversa)

Creo que esto podría estar doblando un poco las reglas, pero aquí va, es viernes ...

Supongo que el uso de bibliotecas estándar está permitido. Mi interpretación de la biblioteca estándar para bashes coreutils:

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

• Sin matrices: se utilizan secuencias en su lugar
• Sin comillas == sin cadenas de caracteres múltiples
• Sin límite de longitud de entrada / salida
• El argumento opcional "-r" invierte la salida.

Entrada de stdin. En uso:

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

C - 64 caracteres, 64 puntos

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

Quizás te preguntes cómo hago que esto funcione sin ningún encabezado. Simple, compilar con:

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

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

También decidí incluir la clasificación de los personajes, solo porque podía.

Pruebas de funcionamiento:

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

función c (arco little-endian), 131 108 caracteres

Ningún desafío de clasificación está completo sin una respuesta de sueño . Este tardará hasta 10 segundos en regresar, pero funciona, y creo que está completamente dentro de las especificaciones. Esta función toma un único parámetro int y devuelve un int con los dígitos decimales ordenados:

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

_{nuevas líneas y sangría agregadas para facilitar la lectura}

Llame de la siguiente manera:

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

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

Java: 262 puntos

Sí, sí, lo sé, es inútil, pero aún así ...

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

Análisis (marcado):

1. Comenzando con 0. (puntaje = 0)
2. 262 caracteres en total. (puntuación = 0 + 262 = 262)
3. +10 - por usar StringBuffer(lo usé porque es más corto que StringBuilder) (puntaje = 262 + 10 = 272)
4. -10 - para hacer que la salida sea flexible. He considerado 0 = descendente , 1 = ascendente , ¡así que vuelvo a 262!

Uso:

Cuando intenta compilar el G.javaarchivo en el símbolo del sistema, genera muchos problemas (errores). Entonces, la solución?

Compila la G.javaclase en un IDE como NetBeanso Eclipseo incluso BlueJ. Debe compilarse sin ningún problema (ignore cualquier advertencia).

Entonces, esta clase debería ser invocada por un main()método de cualquier otra clase (o incluso esa clase misma). Lo pongo en otra clase, así que no lo agrego a mi cuenta de personajes. Compile la otra clase de manera similar (sin usar cmd). Ahora el main()método en la otra clase debería ser algo como:

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

Excluyendo espacios innecesarios, comentarios y saltos de línea, son otros 93 caracteres. No lo agrego a mi personaje porque esto es solo para demostración a través de la consola.

Salida:

CERO,0 es decir, se considera. Suponiendo que la clase externa es Helper.java, y se ha compilado con éxito, algunos ejemplos a través de la consola son:

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

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

Cuando se cambia a 0ie, descendente ...

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

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

NOTAS

1. No declare explícitamente ninguna matriz en G.java. Esa es la clase principal .
2. Estoy usando la ordenación por inserción para ordenar el número en forma de dígitos.
3. El número puede ser de la longitud máxima , Integer.MAX_VALUEporque ese es el tamaño máximo que cualquier matriz puede contener (en Java).
4. Esta respuesta se puede acortar (creo), así que por favor ayúdame (mejora mi primera respuesta).
5. ¡Malditos sean esos grandes Dioses que accidentalmente crearon un lenguaje tan extenso pero excelente como Java (y también que inventaron convenciones de código)!

TeX / LaTeX (332)

Si el código real se coloca en un paquete s, entonces el archivo principal de LaTeX se ve agradable y fácil. El número solo se da como matemática. Si el número es negativo, se invierte el orden de clasificación. El código del paquete stambién se puede usar con TeX simple, ejemplo más abajo.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

El paquetes (una línea, los extremos de la línea no son necesarios):

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

Resultado:

Puntuación: sin esperanza

• Usando TeX simple con etexo pdftex, el archivo se puede reducir a:

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

  Bytes: 318 bytes ( s.sty) + 24 bytes para el resto sin el número

• Las matrices no se utilizan: 0

• No veo cadenas de caracteres múltiples: 0

• El número no está limitado por el algoritmo. El número TeX más grande es 2 ³¹ - 1 = 2147483647. El ejemplo usa un número de 66 dígitos, mucho más grande: 0

• Si se da un signo menos, el orden de clasificación se revierte a descendente: −10

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

Algoritmo:

Los dígitos se convierten en caracteres activos en modo matemático. Cada dígito recuerda y recoge cada uso en una macro. Después del modo matemático, las macros salen con los dígitos en orden ascendente.

El cambio de dirección se realiza mediante texto de derecha a izquierda, una función de e-TeX.

Versión degolfed del código 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}%
  }%
}

Reproducción

Hay algunos compiladores de LaTeX en línea, una lista se puede encontrar aquí . Probé el primer elemento de la lista, el servlet LaTeX en sciencesoft.at . Se puede usar sin firmar y también puede crear URL permanentes: fuente y resultado como imagen .

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

El observador astuto notará que este algoritmo de clasificación se ejecuta en tiempo O (n) en el número de dígitos n.

El observador pragmático notará que este algoritmo de clasificación se ejecuta en el tiempo proporcional al rango de enteros con signo en la plataforma, que muta el estado global que debe reinicializarse entre las ejecuciones, y que se han hecho muchos otros sacrificios a favor de la brevedad.

La versión sin golf no es exactamente equivalente, pero transmite mejor el algoritmo real involucrado.

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

Aquí hay un arnés de prueba para la función:

#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 caracteres, sin matrices, sin cadenas, sin límite de enteros, no se puede revertir

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

Ejemplos:

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

Este es un tipo de inserción, realizado directamente en los enteros mismos. Esto es similar a la otra entrada de Haskell que es de tipo burbuja, aunque juro que estaba trabajando en eso antes de verla.

Breve guía:

• ddivide un número en unidades y decenas, es decir: d 135es el par(13,5)
• a%xse ordena la inserción de un dígito aen el númerox
• a&xordena xinsertando el dígito de las unidades ay recurriendo al resultado y al resto
• s xordena x al iniciar la &recursividad en 0 yx

El truco es que el segundo argumento de %y &no es xdirectamente, sino xdivMod'd usandod

Python3.3 61 puntos

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

Este programa toma la entrada como una cadena, que cuenta como una cadena porque no se cambia a un entero de inmediato. +10

La cadena se ordena en una matriz +10

Esta matriz se une en una cadena +10

Nota: Lo que se ''usa para unir el contenido de la matriz no es una cadena de caracteres múltiples, por lo que no se agrega +10 a la partitura.

El programa consta de 31 caracteres. +31

31 + 10 + 10 + 10 = 61 puntos

J, 10 caracteres (+ 1 cadena) puntaje = 20

s=./:~&.":

Uso:

   s 52146729
12245679

Funciona para todos los números de 32 bits.

Explicación:

/:~ordenar &.bajo ":formato. Mi versión anterior también usaba una matriz, pero son costosos, así que ahora solo necesito usar una cadena y ordenar los caracteres alfabéticamente. ":convierte el número que se ingresa en una cadena y /:~clasifica los dígitos en orden ascendente. Debido a que la ordenación se realiza en formato 'bajo', cuando finaliza la ordenación, la cadena se convierte de nuevo en un número. Agregar la capacidad de revertir probablemente costaría más de lo que ahorra, por lo que no me molesté.

Se podría argumentar que dado que J, como APL y K, es un lenguaje basado en una matriz, la entrada única es una matriz de 1 elemento, pero elegí no tener una visión tan dura al calcular mi puntaje.

El límite de 32 bits lo impone J, en lugar de mi programa. Más alto y J cambia los números a notación científica. No queda claro a partir de la pregunta si la penalización de 32 puntos se aplica en este caso, pero incluso si se aplican las dos penalizaciones anteriores (no creo que deberían), el puntaje sube a 72 y aún así supera cómodamente a la gran mayoría de los demás respuestas

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

• Sin matrices (en su lugar se utilizan iteradores y un diccionario)
• Sin cadenas de caracteres múltiples (excepto salida)
• Sin número máximo artificial de dígitos
• Sin inversión

Funciona creando un diccionario que asigna los 10 dígitos a 0. Luego itera sobre la longitud del número ( log10(i)), extrae cada dígito ( (i / (10 ** c)) % 10) e incrementa el contador de ese dígito en el diccionario. Finalmente, crea una cadena hecha al iterar sobre los 10 dígitos, y para cada dígito produciendo una instancia del dígito como una cadena.

Podría cambiar la última línea con print"".join(d[n]*str(n)for n in xrange(10))16 caracteres menos, pero usaría cadenas de caracteres múltiples.

C (hasta C90) o C ++, 78 66 puntos

La función para ordenar un entero se llama 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;}

Puntuación:

• 66 personajes (+66)
• 0 matrices (+0)
• 0 cuerdas (+0)
• Rango definido por la máquina (tamaño de int) (+0)
• Solo una dirección de clasificación (-0)

Versión antigua (78 puntos, funciona también con C ++ y versiones C más modernas)

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

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

Prueba

Normal:

app.exe 52313698

Invertido:

app.exe 52313698-

Puntos: (Espero haber entendido bien el sistema de puntos; no dude en corregirlo)

• Caracteres: 149
• Cuerdas: 10 + 10
• Matrices: +20
• Orden: -10
• Total: 149 + 10 + 20-10 = 179

C # con LINQPAD - 123

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

Prueba

Normal:

lprun.exe sorta.linq 52313698

Invertido:

lprun.exe sorta.linq 52313698-

Puntos:

• Caracteres: 122
• Cuerdas: 10 + 10
• Matrices: +20
• Orden: -10
• Total: 122 + 10 + 20-10 = 152

Java 1469

Una solución libre de cadenas y matrices en Java. 1437 caracteres + 32 porque solo toma hasta Long.MAX_VALUE como entrada. Al usar Double, podría ir a más de 300 dígitos, pero eso sería demasiado tedioso para implementar. Cualquier cosa más grande que eso necesitaría BigInteger y AFAIK que usa matrices internamente. Si usa menos de 19 dígitos para la entrada, la salida tendrá ceros a la izquierda. La entrada negativa dará todos los ceros y cualquier cosa que no sea un número causará una excepción.

Para el tipo que usé lo más fácil que se me ocurrió, es bastante ineficiente. (debe ser O (n * n))

input:  9212458743185751943
output: 1112233444555778899

Sé que esto realmente no se compara con las soluciones en otros idiomas, pero creo que al menos es lo más corto que puedo obtener en Java. (si alguien sabe cómo hacer esto aún más corto, siéntase libre de editar / comentar)

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

El archivo '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 carrera:

$ 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

La única matriz utilizada es ARGV y esto no es de ayuda en la clasificación, solo es el acceso a los parámetros de la línea de comandos y estos valores están en variables que no son de la matriz donde realmente se necesitan para los cálculos. Creo que esto no contará en contra de esta solución. El siguiente cálculo no tiene en cuenta la matriz ARGV:

111 (caracteres) - 10 (puede hacer reversa)

No veo nada sobre las funciones de clasificación en la pregunta, así que ... (Voy a eliminar la respuesta si se dobla o rompe las reglas, hágamelo saber)

JavaScript 56 96

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

JavaScript 69 109 (reversible)

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

Se puede jugar un poco con las funciones de flecha de EcmaScript 6 :

ES6 50 90

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

ES6 63 103 (reversible) (73-10)

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

SED 67 Chars (puntaje 67 o 107)

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

Esto usa un tipo de burbuja por brevedad. La puntuación sería 107 si cada patrón de expresión regular y reemplazo cuentan como una cadena (es decir, 67 + (10 * 4))

Número de dígitos manejados limitados por la memoria (y probablemente paciencia)

Función Python lambda (reversible), 69

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

• 39 caracteres (+39)
• Dos cadenas de caracteres múltiples: n(entrada) y ''.join(...) (+20)
• Una lista: sorted(...) (+20)
• Puede invertir la dirección dependiendo del parámetro d (-10)

Función Python lambda (no reversible), 67

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

EDITAR: la entrada debe ser una cadena. Estoy considerando la pena de usar esa cadena directamente.

Lisp común - 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 versión no golfizada (tanto estilística como léxica, pero funcionalmente idéntica):

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

Los dígitos de un número negativo se tratan como que tienen un valor negativo, y los dígitos se ordenan menos significativos primero (es decir, little-endian). Ejemplos:

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

Hay 136 caracteres en la versión de golf, incluido el espacio en blanco. No utiliza cadenas ni matrices, y maneja enteros de precisión arbitraria, incluidos los enteros negativos. La ordenación se parametriza en un predicado binario que define un ordenamiento total en los enteros [-9, 9], incluidos, entre otros, <y >:

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

Esto le da un puntaje de 126.

JavaScript 416/185

Sin matrices, sin cadenas, sin restricciones de longitud arbitrarias ...

Pero ordenar arriba / abajo habría usado más de 10 caracteres ^^ Pero me pareció interesante la idea de contar dígitos e imprimirlos; tal vez alguien pueda usar esta idea en GolfScript y ganar el premio ;-)

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

El mismo código más corto, usando eval: (pero eso probablemente se consideraría usando cadenas ...)

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

Puntos:

• 192 (192 caracteres)
• 40 (2 matrices: argv (v) y a)
• 0 (sin cadenas de caracteres múltiples)
• 0 (no está limitado a n dígitos)

• -10 (ordena al revés si el número (argv [1]) es negativo)

  = 222 puntos

Se necesitaban banderas para deshacerse de las 1000 advertencias del compilador: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"Mejor" legible:

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

Algo descabellado:

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

¿Hay alguna razón por la que ya no veo esta solución?

Rubí

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

No estoy seguro de cómo calificar esto. La división generaría una matriz, pero más allá de eso no estoy seguro ... 38 caracteres + 2x20 para las matrices? ¿O debería incluir todos los arreglos que la clasificación podría crear internamente?

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 caracteres + 10 para el uso de cadena n
(no sé si el uso de la replacefunción y la stringfunción que devuelve n cantidad de caracteres x se cuenta como una cadena adicional).

Cuenta la cantidad de un cierto dígito comparando la longitud de la cadena original con la misma cadena con el cierto dígito reemplazado. Luego adjunta esa cantidad de dígitos a n.

Python 3 sleepsort (168)

Sin absolutamente ninguna lista o bucle, solo generadores.

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

Probablemente podría mejorarse.

Raqueta 97

97 puntos (87 +20 para dos cadenas, -10 para ordenar, sin matrices)

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

Utiliza listas de caracteres, por lo que debe asignarle una función de comparación de caracteres como char<?o char>?. Siento que esto también pasa desapercibido ya que no es mucho más que agregar espacios y aumentar los nombres de las variables. Mi versión anterior es quizás más honorable :)

Versión antigua sin cadenas:

110 puntos (120 bytes (utf-8) - 10 para permitir cambiar el orden de clasificación. No utiliza cadenas ni matrices)

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

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

Lo probé con el número 100,000 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

Y lo mismo en orden opuesto:

(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