Ispirato dall'ordinamento sfortunato -a-numeri-cifre-senza-usare-un-array , ma ho pensato che rendesse il golf un codice migliore della domanda SO.

Dato un numero intero positivo, ordina le cifre in quel numero intero.

Il punteggio più basso vince!

1. Inizia con 0 punti.
2. Aggiungi un punto per personaggio.
3. Aggiungi 20 punti per ogni array che usi.
4. Aggiungi 10 punti per ogni stringa di più caratteri nel tuo codice. (Tranne l'input iniziale fintanto che viene convertito in un numero intero senza altre operazioni eseguite su di esso.)
5. Aggiungi 32 punti se il numero massimo di cifre che il tuo programma è in grado di gestire è limitato dal tuo programma (al contrario della macchina).
6. Sottrai 10 punti se il tuo codice può cambiare la direzione dell'ordinamento dato un altro argomento (qualunque cosa tu voglia, ma per esempio 0 per l'ordinamento decrescente e 1 per l'ascendente).

Ogni lingua è diversa, ma l'idea è quella di evitare qualsiasi tipo di pirateria informatica digeribile.

Esempio:

Ingresso : 52146729

Uscita : 97654221 o 12245679

Appunti:

1. Usa qualsiasi funzionalità di ordinamento integrata fornita dal tuo linguaggio di programmazione, ma se quella funzione di ordinamento comporta stringhe o array, prendi la penalità!
2. È possibile scrivere la soluzione come una funzione che accetta direttamente un numero intero o come programma che accetta un argomento da argv, un file o flusso e lo converte in un numero intero. Fintanto che lo converti immediatamente in un numero intero e scarti l'input char * originale senza eseguire ulteriori operazioni su di esso, non viene applicata alcuna penalità.
3. Le penalità si applicano non solo ai valori letterali delle stringhe nel testo del programma, ma a qualsiasi parte della funzione del programma che probabilmente inserisce o emette una stringa o iterabile. Ad esempio, JavaScript String.prototype.splitha almeno una stringa come input ( this) e una matrice come output, quindi +30 per usarla.
4. Ho cercato di fare in modo che queste regole guidino il principio della progettazione dell'algoritmo, non l'I / O iniziale / finale (da cui la nota n. 2). Non credo che la penalità debba essere applicata int(input())anche se inputla firma dice che restituisce una stringa, purché quell'espressione sia il punto di ingresso iniziale del programma. Allo stesso modo, se l'output finale del programma è print(x)e xdeve essere una stringa, la penalità non si applica all'operazione di lancio della stringa dell'ultimo fossato. Detto questo, non ho mai detto esplicitamente che questo doveva essere un programma o da dove l'I / O doveva venire o andare. Una funzione che accetta inte restituisce una intservirebbe e non soffrirebbe di queste ambiguità.

GolfScript, 11 4

(4 + 10 (stringa) - 10 (opzione inversa))

Ingresso su STDIN.

~`$%

Il formato di input è questo:

(1 or -1) (the number)

1per ordinare normalmente, -1per invertire. 4 caratteri - 10 per l'opzione inversa = punteggio di -6.

L'input è tecnicamente una stringa, quindi non sono sicuro che contenga +10. Sto interpretando la regola come "una stringa dichiarata nel tuo programma" (poiché dice "nel tuo codice").

Vecchia risposta (punteggio di 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}

esempio:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Una risposta che non schiva la domanda.

È stata richiesta una spiegazione, qui non è stata accettata. È una specie di bolla molto inefficiente.

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

Esistono risposte più brevi in ​​Haskell, equivalenti ad alcune delle altre pubblicate, ad esempio:

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

... segna 52 + 20 = 72, o questo, segnando 45 + 20 = 65:

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

... ma lo spirito della domanda - senza matrici, stringhe o caratteri - è più interessante.

Assemblaggio C + x86, 636

So che questo non vincerà, ma mi è sembrato così innaturale e contorto che ho dovuto condividerlo. Nessuna matrice o stringa (purché non contiate gli argomenti di input). Il numero di cifre è limitato dall'intervallo di 32 bit.

Quindi, ecco una piccola spiegazione su ciò che ho fatto:

Pensavo di farlo senza usare array o stringhe, e poi mi è venuta in mente la ricorsione, ma ovviamente con la ricorsione non sarei stato in grado di scambiare valori da altre chiamate ricorsive ... e poi è stato quando ho capito che c'era un modo. Collegando il mio programma C con una funzione di assemblaggio potrei saltare nello stack e restituire un puntatore al puntatore di base della chiamata desiderata, ecco cosa fa la funzione "recursionStackAt". Naturalmente recursionStackAt è una funzione molto brutta, il suo risultato non dipende solo dall'input o dallo stato del programma, ma dal chiamante stesso. Nota che questo è ciò che mi ha fatto cambiare gli indici da 0 in base a 1 in base.

Senza ulteriori indugi, ecco il codice:

#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 ovviamente il codice assembly x86 (AT&T sintax, btw) per la funzione 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

Alcuni esempi sull'output: (1 significa crescente e 0 decrescente)

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

Ecco la versione offuscata (che è illeggibile ma funziona bene):

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

Quindi se LibreOffice non sta mentendo il mio codice offuscato è composto da 646 caratteri (senza spazi, devo contarli?) E con tutte le altre condizioni soddisfatte ottengo un -10 per la scelta crescente / decrescente.

Oh, e per compilare questo dovresti fare (Sui sistemi simili a Unix)

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

Nota che il flag -m32 è solo se sei su un computer a 64 bit. È inoltre necessario compilare le librerie a 32 bit.

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

sorta:

echo $*

Uso:

sorta 5
5

Usa "-e" per ordinare al contrario:

sorta -e 3
3

• produce il risultato corretto per numeri interi positivi 1-9, più 0
• evita qualsiasi tipo di pirateria informatica digeribile.
• 7 caratteri (+7)
• nessun array
• nessuna stringa multi-carattere
• numero massimo di cifre che può gestire: 1 (+32)
• può facoltativamente invertire l'ordinamento (-10)

EDIT: cambiato "cat" in "echo" in modo che funzionasse davvero. EDIT 2: Aggiunto "$ *" e inserito nello script "sorta"

python3

Le mie funzionalità di script:

Nessun array

Niente stringhe

La complessità è O (n): ho usato countingsort (modificato da me per non usare array, ma numeri primi per contare le occorrenze)

Nessuna limitazione di dimensioni

Personaggi: 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 caratteri - 10 per il contrario)

Penso che questo potrebbe piegare un po 'le regole, ma qui va, è venerdì ...

Presumo che sia consentito l'uso di librerie standard. La mia interpretazione della libreria standard per bashè coreutils:

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

• Nessuna matrice: al suo posto vengono utilizzati i flussi
• Nessuna virgoletta == nessuna stringa di più caratteri
• Nessun limite alla lunghezza di input / output
• opzionale arg "-r" inverte l'output.

Input da stdin. In uso:

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

C - 64 caratteri, 64 punti

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

Potresti chiederti come faccio a farlo funzionare senza intestazioni. Semplice, compilare con:

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

Un-giocato a 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);
}

Ho anche deciso di includere l'ordinamento dei personaggi, proprio perché potevo.

Esecuzioni di test:

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

funzione c (arco little-endian), 131 108 caratteri

Nessuna sfida di ordinamento è completa senza una risposta sleepsort . Questo richiederà fino a 10 secondi per tornare, ma funziona e penso che sia completamente entro le specifiche. Questa funzione accetta un singolo parametro int e restituisce un int con le cifre decimali ordinate:

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

_{newline e rientro aggiunti per la leggibilità}

Chiama come segue:

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

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

Java: 262 punti

Sì, sì, lo so, è senza speranza, ma comunque ..

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

Analisi (marcatura):

1. A partire da 0. (punteggio = 0)
2. 262 caratteri in totale. (punteggio = 0 + 262 = 262)
3. +10 - per l'utilizzo StringBuffer(l'ho usato perché è più corto di StringBuilder) (punteggio = 262 + 10 = 272)
4. -10 - per rendere flessibile l'uscita. Ho considerato 0 = decrescente , 1 = crescente , quindi di nuovo a 262!

Uso:

Quando si tenta di compilare il G.javafile nel prompt dei comandi, vengono generati molti problemi (errori). Quindi, la soluzione?

Compilare la G.javaclasse in un IDE come NetBeanso Eclipseo addirittura BlueJ. Dovrebbe compilare senza alcun problema (ignorare eventuali avvisi).

Quindi, questa classe dovrebbe essere chiamata con un main()metodo da qualsiasi altra classe (o anche quella stessa classe). Lo sto mettendo in un'altra classe, quindi non lo aggiungo al mio conteggio dei personaggi. Compilare l'altra classe in modo simile (senza usare cmd). Ora il main()metodo nell'altra classe dovrebbe essere qualcosa del tipo:

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

Escludendo spazi, commenti e interruzioni di riga non necessari, sono altri 93 caratteri. Non lo sto aggiungendo al mio personaggio perché è solo per dimostrazione tramite console.

Produzione:

ZERO ie 0è considerato. Supponendo che la classe esterna sia Helper.java, ed è stata compilata con successo, alcuni esempi tramite console sono:

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

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

Se modificato in 0ovvero discendente ...

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

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

APPUNTI:

1. Non ho dichiarato esplicitamente alcun array in G.java. Questa è la classe principale .
2. Sto usando l'ordinamento di inserzione per ordinare il numero in termini di cifre.
3. Il numero può essere della lunghezza massima , Integer.MAX_VALUEpoiché è la dimensione massima che può contenere qualsiasi array (in Java).
4. Questa risposta può essere abbreviata (credo) quindi per favore aiutami (migliora la mia prima risposta).
5. Maledetti quei grandi dei che hanno accidentalmente creato un linguaggio così lungo ma fantastico come Java (e anche che hanno inventato convenzioni di codice)!

TeX / LaTeX (332)

Se il codice effettivo viene inserito in un pacchetto s, il file LaTeX principale risulta semplice e intuitivo. Il numero è appena indicato come matematica. Se il numero è negativo, l'ordinamento viene invertito. Il codice del pacchetto spuò essere utilizzato anche con TeX semplice, esempio più avanti.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

Il pacchettos (una riga, le estremità della riga non sono necessarie):

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

Risultato:

Punteggio: senza speranza

• Utilizzando semplicemente TeX con etexo pdftex, il file può essere ridotto a:

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

  Byte: 318 byte ( s.sty) + 24 byte per il resto senza il numero

• Le matrici non sono utilizzate: 0

• Non vedo stringhe multi-carattere: 0

• Il numero non è limitato dall'algoritmo. Il numero TeX più grande è 2 ³¹ - 1 = 2147483647. L'esempio utilizza un numero di 66 cifre, molto più grande: 0

• Se viene fornito un segno meno, l'ordinamento viene ripristinato in ordine decrescente: −10

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

Algoritmo:

Le cifre sono rese attive in modalità matematica. Ogni cifra ricorda e raccoglie ogni utilizzo in una macro. Dopo la modalità matematica, le macro vengono emesse con le cifre in ordine crescente.

Il cambio di direzione viene effettuato da testo da destra a sinistra, una funzione e-TeX.

Versione degradata del codice ins.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}%
  }%
}

riprodurre

Ci sono alcuni compilatori online LaTeX, un elenco può essere trovato qui . Ho provato il primo elemento dell'elenco, servlet LaTeX su sciencesoft.at . Può essere utilizzato senza firma e può anche creare URL permanenti: sorgente e risultato come immagine .

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'osservatore astuto noterà che questo algoritmo di ordinamento viene eseguito in tempo O (n) sul numero di cifre in n.

L'osservatore pragmatico noterà che questo algoritmo di ordinamento viene eseguito in un tempo proporzionale all'intervallo di numeri interi con segno sulla piattaforma, che muta lo stato globale che deve essere reinizializzato tra le esecuzioni e che molti altri sacrifici sono stati fatti a favore della brevità.

La versione non modificata non è esattamente equivalente, ma trasmette meglio l'algoritmo reale coinvolto.

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

Ecco un cablaggio di prova per la funzione:

#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 caratteri, nessuna matrice, nessuna stringa, nessun limite intero, non può invertire

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

Esempi:

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

Questo è l'ordinamento per inserzione, eseguito direttamente sugli interi stessi. Questo è simile all'altra voce di Haskell che è una specie di bolla, anche se giuro che ci stavo lavorando prima di vederlo.

Breve guida:

• ddivide un numero in unità e decine, ovvero: d 135è la coppia(13,5)
• a%xviene ordinato l'inserimento della cifra anel numerox
• a&xordina xinserendo la cifra delle unità ae ricorrendo al risultato e al resto
• s xordina x dando il via alla &ricorsione su 0 ex

Il trucco è che il secondo argomento di %e &non è xdirettamente, ma xdivMod'd usandod

Python3.3 61 punti

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

Questo programma accetta l'input come una stringa, che conta come una stringa perché non viene immediatamente modificato in un numero intero. +10

La stringa viene ordinata in un array +10

Questo array è unito in una stringa +10

Nota: il metodo ''utilizzato per unire i contenuti dell'array non è una stringa di più caratteri, quindi +10 non viene aggiunto al punteggio.

Il programma è composto da 31 caratteri. +31

31 + 10 + 10 + 10 = 61 punti

J, 10 caratteri (+ 1 stringa) punteggio = 20

s=./:~&.":

Uso:

   s 52146729
12245679

Funziona con tutti i numeri a 32 bit.

Spiegazione:

/:~ordinare &.sotto ":formato. Anche la mia versione precedente utilizzava un array, ma sono costosi, quindi ora devo solo usare una stringa e ordinare i caratteri in ordine alfabetico. ":converte il numero immesso in una stringa e /:~ordina le cifre in ordine crescente. Poiché l'ordinamento viene eseguito nel formato "sotto", al termine dell'ordinamento, la stringa viene riconvertita in un numero. L'aggiunta della capacità di invertire probabilmente costerebbe più di quanto risparmi, quindi non mi sono preoccupato.

Si potrebbe sostenere che poiché J, come APL e K, è un linguaggio basato su array, l'input singolo è un array di 1 elemento, ma ho scelto di non avere una visione così dura nel calcolo del mio punteggio.

Il limite a 32 bit è imposto da J, piuttosto che dal mio programma. Qualsiasi valore superiore e J commuta i numeri sulla notazione scientifica. Non è chiaro dalla domanda se in questo caso si applichi la penalità di 32 punti, ma anche se si applicano entrambe le penalità precedenti (non credo che dovrebbero) il punteggio sale a 72 e batte comunque comodamente la stragrande maggioranza dell'altro risposte.

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

• Nessuna matrice (al suo posto vengono utilizzati iteratori e un dizionario)
• Nessuna stringa multi-carattere (tranne l'output)
• Nessun numero massimo artificiale di cifre
• Nessuna inversione

Funziona creando un dizionario che associa tutte le 10 cifre a 0. Quindi scorre la lunghezza del numero ( log10(i)), estraendo ogni cifra ( (i / (10 ** c)) % 10) e incrementando il contatore per quella cifra nel dizionario. Infine crea una stringa creata ripetendo su tutte e 10 le cifre e per ogni cifra restituendo un'istanza della cifra come stringa.

Potrei cambiare l'ultima riga in print"".join(d[n]*str(n)for n in xrange(10))cui ci sarebbero 16 caratteri in meno, ma userei stringhe multi-carattere.

C (fino a C90) o C ++, 78 66 punti

La funzione quindi ordina un numero intero viene chiamato 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;}

punteggio:

• 66 personaggi (+66)
• 0 matrici (+0)
• 0 stringhe (+0)
• Intervallo definito dalla macchina (dimensione di int) (+0)
• Solo una direzione di ordinamento (-0)

Vecchia versione (78 punti, funziona anche con C ++ e versioni C più moderne)

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

Un-golfed

using System.Linq;

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

Test

Normale:

app.exe 52313698

invertito:

app.exe 52313698-

Punti: (spero di aver capito bene il sistema di punti - sentiti libero di correggere)

• Personaggi: 149
• Stringhe: 10 + 10
• Matrici: +20
• Ordine: -10
• Totale: 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)));}

Test

Normale:

lprun.exe sorta.linq 52313698

invertito:

lprun.exe sorta.linq 52313698-

Punti:

• Personaggi: 122
• Stringhe: 10 + 10
• Matrici: +20
• Ordine: -10
• Totale: 122 + 10 + 20-10 = 152

Java 1469

Una soluzione senza stringhe e array in Java. 1437 caratteri + 32 perché richiede solo fino a Long.MAX_VALUE come input. Usando Double potrei invece superare le 300 cifre, ma sarebbe troppo noioso da implementare. Qualunque cosa più grande di così avrebbe bisogno di BigInteger e AFAIK che utilizza array internamente. Se si utilizzano meno di 19 cifre per l'ingresso, l'uscita avrà zero iniziali. L'input negativo fornirà tutti gli zero e tutto ciò che non è un numero causerà un'eccezione.

Per il tipo che ho usato il più semplice che potessi pensare, quindi è abbastanza inefficiente. (dovrebbe essere O (n * n))

input:  9212458743185751943
output: 1112233444555778899

So che questo non è davvero paragonabile alle soluzioni in altre lingue, ma penso che questo sia il più breve che posso ottenere in Java. (se qualcuno sa come renderlo ancora più breve, sentiti libero di modificare / commentare)

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

Il file '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 corsa:

$ 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

L'unico array utilizzato è ARGV e questo non è di aiuto nell'ordinamento, è solo l'accesso ai parametri della riga di comando e questi valori sono in variabili non array dove effettivamente necessari per i calcoli. Penso che questo non conterà contro questa soluzione. Il seguente calcolo non tiene conto dell'array ARGV:

111 (caratteri) - 10 (può fare il contrario)

Non vedo nulla sulle funzioni di ordinamento nella domanda, quindi ... (Rimuoverò la risposta se piega o infrange le regole, fammi sapere)

JavaScript 56 96

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

JavaScript 69 109 (reversibile)

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

Può essere ridotto un po 'usando EcmaScript 6 funzioni freccia di :

ES6 50 90

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

ES6 63 103 (reversibile) (73-10)

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

SED 67 Chars (punteggio 67 o 107)

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

Questo utilizza un ordinamento a bolle per brevità. Il punteggio sarebbe 107 se ogni modello di espressione regolare e sostituzione contano come una stringa (ovvero 67 + (10 * 4))

Numero di cifre gestite limitato dalla memoria (e probabilmente pazienza)

Funzione Python lambda (reversibile), 69

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

• 39 caratteri (+39)
• Due stringhe multi-carattere: n(input) e''.join(...) (+20)
• Un elenco: sorted(...) (+20)
• Può invertire la direzione in base al parametro d (-10)

Funzione Python lambda (non reversibile), 67

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

EDIT: l'input dovrebbe essere una stringa. Sto considerando la pena di usare direttamente quella stringa.

Lisp comune - 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 versione non golfizzata (sia stilisticamente che lessicamente, ma funzionalmente identica):

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

Le cifre di un numero negativo vengono considerate come aventi valore negativo e le cifre vengono ordinate per prime meno significative (ovvero, little-endian). Esempi:

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

Ci sono 136 caratteri nella versione golfizzata, incluso lo spazio bianco. Non utilizza stringhe né array e gestisce numeri interi di precisione arbitraria, inclusi numeri interi negativi. L'ordinamento è parametrizzato su un predicato binario che definisce un ordinamento totale sugli interi in [-9, 9], inclusi ma non limitati 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

Questo dà un punteggio di 126.

JavaScript 416/185

Nessuna matrice, nessuna stringa, nessun vincolo di lunghezza arbitrario ...

Ma l'ordinamento su / giù avrebbe utilizzato più di 10 caratteri ^^ Ma ho trovato interessante l'idea di contare le cifre e stamparle - forse qualcuno può usare questa idea in GolfScript e vincere il 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);

Lo stesso codice più breve, usando eval: (ma che probabilmente verrebbe considerato usando le stringhe ...)

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

Punti:

• 192 (192 Chars)
• 40 (2 array: argv (v) e a)
• 0 (nessuna stringa multi char)
• 0 (non è limitato a n cifre)

• -10 (ordina il contrario se il numero (argv [1]) è negativo)

  = 222 punti

Bandiere necessarie per sbarazzarsi degli avvisi del compilatore 1000: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"Migliore" leggibile:

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

Abbastanza ungolfed:

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

C'è un motivo per cui non vedo già questa soluzione?

Rubino

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

Non sono sicuro di come segnare questo. La divisione genererebbe un array, ma oltre a ciò non è sicuro .. 38 caratteri + 2x20 per gli array? O dovrebbe includere tutti gli array che l'ordinamento potrebbe creare 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 caratteri + 10 per l'uso della stringa n
(Non so se l'uso della replacefunzione estring funzione che restituisce n quantità di carattere x viene conteggiato come una stringa aggiuntiva).

Conta la quantità di una determinata cifra confrontando la lunghezza della stringa originale con la stessa stringa con la determinata cifra sostituita. Quindi allega quella quantità di cifre a n.

Python 3 sleepsort (168)

Senza assolutamente elenco o loop, solo generatori.

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

potrebbe probabilmente essere migliorato.

Racchetta 97

97 punti (87 +20 per due stringhe, -10 per l'ordinamento, nessuna matrice)

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

Questo utilizza liste di caratteri, quindi è necessario dargli una funzione di confronto dei caratteri come char<?ochar>? . Sento che questo passa anche come non golfato poiché non c'è molto da fare che aggiungere spazi e aumentare i nomi delle variabili. La mia vecchia versione è forse più onorevole :)

Vecchia versione senza stringhe:

110 punti (120 byte (utf-8) - 10 per consentire la modifica del criterio di ordinamento. Non utilizza stringhe né array)

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

L'ho provato con il numero 100.000 di 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 lo stesso in ordine opposto:

(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