Inspirado pela má sorte de digitar um número de dígitos sem usar uma matriz , mas achei que ele produzia um código de golfe melhor do que a questão SO.

Dado um número inteiro positivo, classifique os dígitos nesse número inteiro.

Menor pontuação ganha!

1. Comece com 0 pontos.
2. Adicione um ponto por caractere.
3. Adicione 20 pontos para cada matriz que você usa.
4. Adicione 10 pontos para cada seqüência de caracteres múltiplos no seu código. (Exceto a entrada inicial, desde que seja convertida em um número inteiro sem nenhuma outra operação feita.)
5. Adicione 32 pontos se o número máximo de dígitos que seu programa puder manipular for limitado pelo programa (em oposição à máquina).
6. Subtraia 10 pontos se o seu código puder alterar a direção da classificação dada outro argumento (o que você quiser, mas por exemplo 0 para classificação decrescente e 1 para ascendente).

Cada idioma é diferente, mas a idéia é evitar qualquer tipo de invasão de dígitos iteráveis.

Exemplo:

Entrada : 52146729

Saída : 97654221 ou 12245679

Notas:

1. Use qualquer recurso interno de classificação que sua linguagem de programação ofereça, mas se esse recurso envolver seqüências de caracteres ou matrizes, tome a penalidade!
2. Você pode escrever a solução como uma função que pega um número inteiro diretamente ou como um programa que pega um argumento do argv, um arquivo ou fluxo e o converte em um número inteiro. Contanto que você o converta em um número inteiro imediatamente e descarte a entrada char * original sem executar nenhuma operação adicional, nenhuma penalidade será aplicada.
3. As penalidades se aplicam não apenas aos literais de cadeia de caracteres no texto do programa, mas a qualquer parte do recurso do programa que indiscutivelmente insira ou produza uma cadeia ou iterável. Por exemplo, o JavaScript String.prototype.splittem pelo menos uma string como input ( this) e uma Matriz como saída, então +30 para usá-lo.
4. Eu tentei fazer essas regras guiarem o princípio do design do algoritmo, não a E / S inicial / final (daí a nota 2). Eu não acho que a penalidade deva ser aplicada int(input())mesmo que inputa assinatura diga que retorna uma string, desde que essa expressão seja o ponto de entrada inicial do programa. Da mesma forma, se a saída final do programa é print(x)e xdeve ser uma sequência, a penalidade não se aplica à operação de conversão de sequência da última vala. Tudo o que foi dito, eu nunca disse explicitamente que esse tinha que ser um programa ou de onde a E / S tinha que vir ou ir. Uma função que recebe inte retorna um intserviria e não sofreria com essas ambiguidades.

GolfScript, 11 4

(4 + 10 (sequência) - 10 (opção inversa))

Entrada em STDIN.

~`$%

O formato de entrada é este:

(1 or -1) (the number)

1ordenar normalmente, -1reverter. 4 caracteres - 10 para a opção inversa = pontuação de -6.

A entrada é tecnicamente uma string, então não tenho certeza se isso conta com +10. Estou interpretando a regra como "uma string declarada no seu programa" (já que diz "no seu código").

Resposta antiga (pontuação 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}

exemplo:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Uma resposta que não se esquiva da pergunta.

Uma explicação foi solicitada, aqui é não destruída. É um tipo de bolha muito 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)

Respostas mais curtas existem em Haskell, equivalente a algumas das outras postadas, por exemplo:

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

... pontuação 52 + 20 = 72, ou isso, pontuação 45 + 20 = 65:

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

... mas o espírito da pergunta - sem matrizes, strings ou caracteres - é mais interessante.

Montagem C + x86, 636

Eu sei que isso não vai ganhar, mas parecia tão antinatural e distorcido que eu tive que compartilhar. Sem matrizes ou strings (contanto que você não conte os argumentos de entrada). O número de dígitos é limitado pelo intervalo de 32 bits.

Então, aqui está uma pequena explicação sobre o que eu fiz:

Pensei em fazer isso sem usar matrizes ou seqüências de caracteres e, em seguida, a recursão veio à mente, mas é claro, com a recursão, não seria capaz de trocar valores de outras chamadas recursivas ... e foi quando percebi que havia um caminho. Vinculando meu programa C com uma função assembly, eu poderia pular a pilha e retornar um ponteiro para o ponteiro base da chamada desejada, é isso que a função "recursionStackAt" faz. É claro que recursionStackAt é uma função muito feia, seu resultado não depende apenas do estado da entrada ou do programa, mas do próprio chamador. Observe que foi isso que me fez mudar os índices de 0 para 1 com base.

Sem mais delongas, aqui está o 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);
} 

E, claro, o código de montagem x86 (AT&T sintax, btw) para a função 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

Alguns exemplos na saída: (1 significa aumentar e 0 diminuir)

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

Aqui está a versão ofuscada (que é ilegível, mas funciona bem):

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

Portanto, se o LibreOffice não está mentindo, meu código ofuscado consiste em 646 caracteres (sem espaços, devo contá-los?) E com todas as outras condições atendidas, recebo um -10 para a opção crescente / decrescente.

Ah, e para compilar isso, você deve fazer (em sistemas similares ao Unix)

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

Observe que o sinalizador -m32 é apenas se você estiver em uma máquina de 64 bits. Você também precisa das bibliotecas de 32 bits para compilá-lo.

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

Sorta:

echo $*

Uso:

sorta 5
5

Use "-e" para ordenar ao contrário:

sorta -e 3
3

• produz o resultado correto para números inteiros positivos 1-9, mais 0
• evita qualquer tipo de invasão de dígitos iteráveis.
• 7 caracteres (+7)
• sem matrizes
• sem cadeias de caracteres múltiplos
• número máximo de dígitos que ele pode manipular: 1 (+32)
• opcionalmente, pode reverter a classificação (-10)

EDIT: alterado "cat" para "eco", para que realmente funcionasse. EDIT 2: Adicionado "$ *" e colocado no script "sorta"

Python3

Meu script apresenta:

Sem matrizes

Sem strings

A complexidade é O (n): usei countingsort (modificado por mim para não usar matrizes, mas números primos para contar ocorrências)

Sem limitações de tamanho

Personagens: 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 reverso)

Eu acho que isso pode estar distorcendo um pouco as regras, mas aqui vai, é sexta-feira ...

Presumo que o uso de bibliotecas padrão seja permitido. Minha interpretação da biblioteca padrão para bashé coreutils:

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

• Nenhuma matriz - os fluxos são usados ​​no lugar
• Sem aspas == sem cadeias de caracteres múltiplos
• Sem limite para o comprimento de entrada / saída
• arg "-r" opcional inverte a saída.

Entrada de stdin. Em uso:

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

C - 64 caracteres, 64 pontos

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

Você pode se perguntar como eu faço isso funcionar sem nenhum cabeçalho. Simples, compile com:

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

Sem golfe:

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

Também decidi incluir a classificação dos personagens, apenas porque eu podia.

Execuções de teste:

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

função c (arco little-endian), 131 108 caracteres

Nenhum desafio de classificação está completo sem uma resposta do tipo dorminhoco . Este levará 10 segundos para retornar, mas funciona, e acho que está dentro das especificações. Essa função usa um único parâmetro int e retorna um int com os dígitos decimais classificados:

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

_{novas linhas e recuo adicionados para facilitar a leitura}

Ligue da seguinte maneira:

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

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

Java: 262 pontos

Sim, sim, eu sei, é impossível, mas ainda assim ..

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álise (marcação):

1. Começando com 0. (pontuação = 0)
2. 262 caracteres no total. (pontuação = 0 + 262 = 262)
3. +10 - para usar StringBuffer(usei porque é mais curto que StringBuilder) (pontuação = 262 + 10 = 272)
4. -10 - para tornar a saída flexível. Eu considerei 0 = descendente , 1 = ascendente , então voltemos para 262!

Uso:

Quando você tenta compilar o G.javaarquivo no prompt de comando, ele gera muitos problemas (erros). Então, a solução?

Compilar a G.javaclasse em um IDE como NetBeansou Eclipseou mesmo BlueJ. Ele deve compilar sem problemas (ignore todos os avisos).

Então, essa classe deve ser chamada por um main()método de qualquer outra classe (ou mesmo da própria classe). Estou colocando em outra classe, por isso não estou adicionando à minha contagem de caracteres. Compile a outra classe de maneira semelhante (sem usar cmd). Agora o main()método na outra classe deve 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'
}

Excluindo espaços desnecessários, comentários e quebras de linha, são outros 93 caracteres. Não estou adicionando ao meu personagem, porque isso é apenas para demonstração através do console.

Resultado:

ZERO, ou seja, 0é considerado. Supondo que a classe externa seja Helper.javae tenha sido compilada com êxito, alguns exemplos no console são:

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

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

Quando alterado para 0ie descendente ...

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

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

NOTAS:

1. Não declarei explicitamente nenhuma matriz G.java. Essa é a classe principal .
2. Estou usando a classificação por inserção para classificar o número digitado.
3. O número pode ter o tamanho máximo - Integer.MAX_VALUEporque esse é o tamanho máximo que qualquer matriz pode conter (em Java).
4. Esta resposta pode ser abreviada (acredito), por isso me ajude (melhore minha primeira resposta).
5. Amaldiçoe aqueles grandes deuses que acidentalmente criaram uma linguagem tão longa e ótima como o Java (e também que criaram convenções de código)!

TeX / Látex (332)

Se o código real estiver em um pacote s, o arquivo principal do LaTeX parecerá fácil e agradável. O número é dado apenas como matemática. Se o número for negativo, a ordem de classificação será revertida. O código do pacote stambém pode ser usado com TeX simples, exemplo mais abaixo.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

O pacotes (uma linha, as extremidades da linha não são necessárias):

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

Pontuação: sem esperança

• Usando TeX comum com etexou pdftex, o arquivo pode ser reduzido para:

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

  Bytes: 318 bytes ( s.sty) + 24 bytes para o restante sem o número

• Matrizes não são usadas: 0

• Não vejo cadeias de caracteres múltiplos: 0

• O número não é limitado pelo algoritmo. O maior número TeX é 2 ³¹ - 1 = 2147483647. O exemplo usa um número de 66 dígitos, muito maior: 0

• Se um sinal de menos é dado, a ordem de classificação é revertida para decrescente: -10

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

Algoritmo:

Os dígitos são transformados em caracteres ativos no modo matemático. Cada dígito lembra e coleta cada uso em uma macro. Após o modo matemático, as macros são exibidas com os dígitos em ordem crescente.

A mudança de direção é feita pelo texto da direita para a esquerda, um recurso e-TeX.

Versão degolfada do código ems.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}%
  }%
}

Reprodução

Existem alguns compiladores LaTeX online, uma lista pode ser encontrada aqui . Tentei o primeiro item da lista, servlet LaTeX em sciencesoft.at . Ele pode ser usado sem assinatura e também pode criar URLs permanentes: origem e resultado como imagem .

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 observador astuto notará que esse algoritmo de classificação é executado em O (n) tempo no número de dígitos em n.

O observador pragmático observará que esse algoritmo de classificação é executado no tempo proporcional ao intervalo de números inteiros assinados na plataforma, que muda o estado global que deve ser reinicializado entre as execuções e que muitos outros sacrifícios foram feitos em favor da brevidade.

A versão não-gasta não é exatamente equivalente, mas transmite melhor o algoritmo real envolvido.

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

Aqui está um equipamento de teste para a função:

#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, sem matrizes, sem strings, sem limite de número inteiro, não podem reverter

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

Exemplos:

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

Este é um tipo de inserção, realizado diretamente nos próprios números inteiros. Isso é semelhante à outra entrada de Haskell, que é do tipo bolha, apesar de eu jurar que estava trabalhando nela antes de ver essa.

Breve guia:

• ddivide um número em unidades e dezenas, ou seja: d 135é o par(13,5)
• a%xé ordenada inserção de dígito ano númerox
• a&xclassifica xinserindo o dígito das unidades ae recorrendo no resultado e no restante
• s xclassifica x iniciando a &recursão em 0 ex

O truque é que o segundo argumento de %e &não é xdiretamente, mas xdivMod'd usandod

Python3.3 61 pontos

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

Este programa recebe a entrada como uma string, que conta como uma string porque não é alterada para um número inteiro imediatamente. +10

A sequência é classificada em uma matriz +10

Essa matriz é unida em uma sequência +10

Nota: O ''usado para unir o conteúdo da matriz não é uma cadeia de caracteres múltiplos, portanto +10 não é adicionado à pontuação.

O programa consiste em 31 caracteres. +31

31 + 10 + 10 + 10 = 61 pontos

J, 10 caracteres (+ 1 corda) pontuação = 20

s=./:~&.":

Uso:

   s 52146729
12245679

Funciona para todos os números de 32 bits.

Explicação:

/:~classificar &.em ":formato. Minha versão anterior também usava uma matriz, mas eles são caros, portanto agora eu preciso usar apenas uma string e classificar os caracteres em ordem alfabética. ":converte o número que é inserido em uma sequência e /:~classifica os dígitos em ordem crescente. Como a classificação é feita no formato 'sob', quando a classificação é concluída, a sequência é convertida novamente em um número. Adicionar a capacidade de reverter provavelmente custaria mais do que economiza, então não me incomodei.

Pode-se argumentar que, como J, como APL e K, é uma linguagem baseada em array, a entrada única é um array de 1 item, mas optei por não adotar uma visão tão dura ao calcular minha pontuação.

O limite de 32 bits é imposto por J, e não pelo meu programa. Qualquer valor mais alto e J muda os números para notação científica. Não está claro se a penalidade de 32 pontos se aplica neste caso, mas mesmo que as duas penalidades anteriores se apliquem (acho que não deveriam), a pontuação sobe para 72 e ainda bate confortavelmente na grande maioria das outras. respostas.

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

• Nenhuma matriz (iteradores e um dicionário são usados)
• Nenhuma sequência de caracteres múltiplos (exceto a saída)
• Nenhum número máximo artificial de dígitos
• Sem reversão

Ele funciona criando um dicionário mapeando todos os 10 dígitos para 0. Em seguida, itera sobre o comprimento do número ( log10(i)), extrai cada dígito ( (i / (10 ** c)) % 10) e incrementa o contador desse dígito no dicionário. Por fim, ele cria uma sequência feita repetindo todos os 10 dígitos e para cada dígito produzindo uma instância do dígito como uma sequência.

Eu poderia alterar a última linha para a print"".join(d[n]*str(n)for n in xrange(10))qual seriam 16 caracteres a menos, mas usaria cadeias de caracteres múltiplos.

C (até C90) ou C ++, 78 66 pontos

A função que classifica um número inteiro é chamada 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;}

Pontuação:

• 66 caracteres (+66)
• 0 matrizes (+0)
• 0 strings (+0)
• Intervalo definido pela máquina (tamanho de int) (+0)
• Apenas uma direção de classificação (-0)

Versão antiga (78 pontos, funciona também com C ++ e versões C mais 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)));}}

Sem golfe

using System.Linq;

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

Teste

Normal:

app.exe 52313698

Invertida:

app.exe 52313698-

Pontos: (espero ter entendido o sistema de pontos corretamente - sinta-se à vontade para corrigir)

• Chars: 149
• Cordas: 10 + 10
• Matrizes: +20
• Ordem: -10
• Total: 149 + 10 + 20-10 = 179

C # com LINQPAD - 123

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

Teste

Normal:

lprun.exe sorta.linq 52313698

Invertida:

lprun.exe sorta.linq 52313698-

Pontos:

• Chars: 122
• Cordas: 10 + 10
• Matrizes: +20
• Ordem: -10
• Total: 122 + 10 + 20-10 = 152

Java 1469

Uma solução livre de string e array em Java. 1437 caracteres + 32 porque leva apenas Long.MAX_VALUE como entrada. Ao usar o Double, eu poderia ir para mais de 300 dígitos, mas isso seria muito tedioso para implementar. Qualquer coisa maior que isso precisaria do BigInteger e do AFAIK que usam matrizes internamente. Se você usar menos de 19 dígitos para a entrada, a saída terá zeros à esquerda. A entrada negativa fornecerá todos os zeros e qualquer coisa que não seja um número causará uma exceção.

Para o tipo que eu usei o mais fácil que eu consegui pensar, é bastante ineficiente. (deve ser O (n * n))

input:  9212458743185751943
output: 1112233444555778899

Sei que isso realmente não se compara às soluções em outras linguagens, mas acho que pelo menos é o mais curto possível em Java. (se alguém souber como reduzir ainda mais esse problema, fique à vontade para 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

O arquivo '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}

A corrida:

$ 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

A única matriz usada é o ARGV e isso não ajuda na classificação, apenas o acesso aos parâmetros da linha de comando e esses valores estão em variáveis ​​que não são da matriz, onde são realmente necessários para os cálculos. Eu acho que isso não conta contra essa solução. O cálculo a seguir não leva em consideração o array ARGV:

111 (caracteres) - 10 (pode fazer o inverso)

Não vejo nada sobre a classificação de funções na pergunta, então ... (removerei a resposta se ela dobrar ou quebrar as regras, avise-me)

JavaScript 56 96

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

JavaScript 69 109 (reversível)

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

Pode jogar um pouco de golfe usando as funções de seta do EcmaScript 6 :

ES6 50 90

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

ES6 63 103 (reversível) (73-10)

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

Caracteres SED 67 (pontuação 67 ou 107)

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

Isso usa uma classificação de bolha por questões de concisão. A pontuação seria 107 se cada padrão de expressão regular e substituição contar como uma string (ou seja, 67 + (10 * 4))

Número de dígitos manipulados limitados pela memória (e provavelmente paciência)

Função lambda Python (reversível), 69

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

• 39 caracteres (+39)
• Duas seqüências de vários caracteres: n(entrada) e ''.join(...) (+20)
• Uma lista: sorted(...) (+20)
• Pode reverter a direção dependendo do parâmetro d (-10)

Função lambda Python (não reversível), 67

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

EDIT: Entrada deve ser uma seqüência de caracteres. Estou considerando a penalidade de usar essa string diretamente.

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

A versão não-golfe (estilisticamente, bem como lexicamente, mas 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))))

Os dígitos de um número negativo são tratados como tendo valor negativo, e os dígitos são classificados com o menor número de significantes primeiro (isto é, little-endian). Exemplos:

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

Existem 136 caracteres na versão em golf, incluindo espaço em branco. Ele não usa seqüências de caracteres nem matrizes e lida com números inteiros de precisão arbitrária, incluindo números negativos. A classificação é parametrizada em um predicado binário que define uma ordem total dos números inteiros [-9, 9], incluindo, mas não se limitando a, <e >:

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

Isso dá uma pontuação de 126.

JavaScript 416/185

Sem matrizes, sem strings, sem restrições arbitrárias de comprimento ...

Mas classificar para cima / para baixo teria usado mais de 10 caracteres ^^ Mas achei a ideia de contar dígitos e imprimi-los interessantes - talvez alguém possa usar essa idéia no GolfScript e ganhar o prêmio ;-)

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

O mesmo código mais curto, usando eval: (mas isso provavelmente seria considerado usando strings ...)

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

Pontos:

• 192 (192 caracteres)
• 40 (2 matrizes: argv (v) e a)
• 0 (sem seqüências de caracteres múltiplos)
• 0 (não se limita a n dígitos)

• -10 (classifica ao contrário se o número (argv [1]) for negativo)

  = 222 pontos

Sinalizadores necessários para se livrar dos 1000 avisos do compilador: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

Legível "Melhor":

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

Um pouco não-destruído:

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

Existe uma razão para eu não ver esta solução já?

Rubi

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

Não tenho certeza de como pontuar isso. A divisão geraria uma matriz, mas além disso não tenho certeza .. 38 caracteres + 2x20 para matrizes? Ou deve incluir todas as matrizes que esse tipo pode criar 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 o uso de string n
(não sei se o uso da replacefunção estring função que retorna n quantidade de caractere x é contado como uma sequência extra).

Ele conta a quantidade de um determinado dígito comparando o comprimento da string original com a mesma string com o dígito substituído. Em seguida, anexa essa quantidade de dígitos a n.

Sleepsort em Python 3 (168)

Com absolutamente nenhuma lista ou loop, apenas geradores.

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

provavelmente poderia ser melhorado.

Raquete 97

97 pontos (87 +20 para duas strings, -10 para classificação, sem matrizes)

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

Isso usa listas de caracteres, então você precisa atribuir a ele uma função de comparação de caracteres, como char<?ouchar>? . Eu sinto que isso também passa despercebido, já que não há muito o que fazer, além de adicionar espaços e aumentar nomes de variáveis. Minha versão antiga é talvez mais honrosa :)

Versão antiga sem strings:

110 pontos (120 bytes (utf-8) - 10 para permitir alterar a ordem de classificação. Ele não usa seqüências de caracteres nem matrizes)

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

Ungolfed:

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

Eu testei com o 100.000º número 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

E o mesmo em ordem oposta:

(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