Inspiriert von dem unglücklichen Sortieren von Zahlen ohne Verwendung eines Arrays , dachte ich, es wäre ein besserer Code als SO-Frage.

Sortieren Sie bei einer positiven Ganzzahl die Ziffern in dieser Ganzzahl.

Die niedrigste Punktzahl gewinnt!

1. Beginnen Sie mit 0 Punkten.
2. Fügen Sie einen Punkt pro Zeichen hinzu.
3. Fügen Sie für jedes verwendete Array 20 Punkte hinzu.
4. Fügen Sie 10 Punkte für jede Zeichenfolge in Ihrem Code hinzu. (Mit Ausnahme der anfänglichen Eingabe, solange diese in eine Ganzzahl konvertiert wird, ohne dass andere Operationen daran vorgenommen werden.)
5. Fügen Sie 32 Punkte hinzu, wenn die maximale Anzahl von Stellen, die Ihr Programm verarbeiten kann, durch Ihr Programm begrenzt ist (im Gegensatz zur Maschine).
6. Subtrahieren Sie 10 Punkte, wenn Ihr Code die Sortierrichtung mit einem anderen Argument ändern kann (was auch immer Sie wollen, aber zum Beispiel 0 für absteigende Sortierung und 1 für aufsteigende Sortierung.)

Jede Sprache ist anders, aber die Idee ist es, jede Art von Hackerei zu vermeiden, die sich durch Ziffern wiederholen lässt.

Beispiel:

Eingabe : 52146729

Ausgabe : 97654221 oder 12245679

Anmerkungen:

1. Verwenden Sie alle integrierten Sortierfunktionen, die Ihre Programmiersprache bietet. Wenn diese Sortierfunktion jedoch Zeichenfolgen oder Arrays umfasst, müssen Sie den Abzug in Kauf nehmen!
2. Sie können die Lösung als Funktion schreiben, die direkt eine Ganzzahl annimmt, oder als Programm, das ein Argument aus argv, einer Datei oder einem Stream annimmt und in eine Ganzzahl konvertiert. Solange Sie es sofort in eine Ganzzahl konvertieren und die ursprüngliche char * -Eingabe verwerfen, ohne weitere Vorgänge auszuführen, wird keine Strafe fällig.
3. Die Strafen gelten nicht nur für Zeichenfolgenliterale in Ihrem Programmtext, sondern für alle Teile Ihres Programms, die möglicherweise eine Zeichenfolge eingeben oder ausgeben oder iterierbar sind. Zum Beispiel hat JavaScript String.prototype.splitmindestens einen String als input ( this) und ein Array als output, also +30, um das zu benutzen.
4. Ich habe versucht, diese Regeln so zu gestalten, dass sie das Prinzip des Algorithmusdesigns leiten, nicht die anfängliche / endgültige E / A (daher Anmerkung 2). Ich denke nicht, dass die Strafe gelten sollte, int(input())selbst wenn inputdie Signatur besagt, dass eine Zeichenfolge zurückgegeben wird, solange dieser Ausdruck der erste Einstiegspunkt des Programms ist. Wenn die endgültige Ausgabe des Programms eine Zeichenfolge ist print(x)und sein xmuss, gilt die Strafe ebenfalls nicht für die String-Casting-Operation des letzten Graben. Trotzdem habe ich ausdrücklich nie gesagt, dass dies ein Programm sein muss oder woher die E / A kommen oder gehen müssen. Eine Funktion, die eine annimmt intund eine zurückgibt, intwürde dienen und unter diesen Mehrdeutigkeiten nicht leiden.

GolfScript, 11 4

(4 + 10 (Zeichenfolge) - 10 (umgekehrte Option))

Eingang bei STDIN.

~`$%

Das Eingabeformat lautet wie folgt:

(1 or -1) (the number)

1 normal sortieren, -1 umkehren. 4 Zeichen - 10 für umgekehrte Option = Punktzahl von -6.

Die Eingabe ist technisch gesehen eine Zeichenfolge, daher bin ich mir nicht sicher, ob dies für +10 gilt. Ich interpretiere die Regel als "in Ihrem Programm deklarierte Zeichenfolge" (da dort "in Ihrem Code" steht).

Alte Antwort (11 Punkte):

$

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}

Beispiel:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Eine Antwort, die der Frage nicht ausweicht.

Eine Erklärung wurde angefordert, hier ist es ungolfed. Es ist eine sehr ineffiziente Blasenart.

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

In Haskell gibt es kürzere Antworten als in einigen anderen Veröffentlichungen, z.

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

... 52 + 20 = 72 Punkte oder 45 + 20 = 65 Punkte:

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

... aber der Sinn der Frage - keine Arrays, Strings oder Zeichen - ist interessanter.

C + x86-Baugruppe, 636

Ich weiß, das wird nicht gewinnen, aber es fühlte sich so unnatürlich und verdreht an, dass ich es teilen musste. Keine Arrays oder Strings (solange Sie die Eingabeargumente nicht zählen). Die Anzahl der Stellen wird durch den 32-Bit-Bereich begrenzt.

Hier ist eine kleine Erklärung, was ich getan habe:

Ich dachte, ich würde dies tun, ohne Arrays oder Zeichenfolgen zu verwenden, und dann kam mir die Rekursion in den Sinn, aber natürlich konnte ich mit der Rekursion keine Werte aus anderen rekursiven Aufrufen austauschen ... und dann wurde mir dies klar Es gab einen Weg. Wenn ich mein C-Programm mit einer Assembly-Funktion verbinde, kann ich in den Stapel springen und einen Zeiger auf den Basiszeiger des gewünschten Aufrufs zurückgeben. Das macht die Funktion "recursionStackAt". Natürlich ist recursionStackAt eine sehr hässliche Funktion, deren Ergebnis nicht nur von der Eingabe oder dem Programmstatus abhängt, sondern auch vom Aufrufer selbst. Beachten Sie, dass ich deshalb die Indizes von 0 auf 1 geändert habe.

Ohne weiteres hier der Code:

#include <stdio.h>
#include <stdlib.h>

int numberToSort;
int totalLength = 0;
int decreasing;

int* recursionStackAt(int pos); //Here's the magic

void swapAtStack(int pos1, int pos2) {
    int a = *(recursionStackAt(pos1)+3);
    *(recursionStackAt(pos1)+3) = *(recursionStackAt(pos2)+3);
    *(recursionStackAt(pos2)+3) = a;
}

int getAt(i) {
    return *(recursionStackAt(i)+3);
}

void printNumber(int len) {
    int i = 0;
    for(i = 1; i <= len; ++i) {
        printf("%d",*(recursionStackAt(i)+3));
    }
    printf("\n");
}

void computeNextDigit(int remainingNumber, int nextDigit) {

    if(remainingNumber == 0) {
        //Bubble sort cause I was lazy and it's quite compact
        ++totalLength;

        int i, j;

        for(i = 1; i <= totalLength; ++i)
            for(j = 1; j <= totalLength-1; ++j) {
                if(decreasing) {
                    if(getAt(j) > getAt(j+1)) 
                        swapAtStack(j,j+1);
                }
                else { 
                    if(getAt(j) < getAt(j+1))
                        swapAtStack(j,j+1);
                }
            }

        printNumber(totalLength);   
    }
    else {
        ++totalLength;
        computeNextDigit(remainingNumber/10, remainingNumber%10);
    }
}

int main(int argc, char* argv[]) {
    if(argc == 3) {
        numberToSort = atoi(argv[1]);
        decreasing = atoi(argv[2]);
    }
    else exit(1);
    computeNextDigit(numberToSort/10, numberToSort%10);
} 

Und natürlich den x86-Assemblycode (AT & T sintax, btw) für die recursionStackAt-Funktion:

.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

Einige Beispiele zur Ausgabe: (1 bedeutet Erhöhen und 0 Verringern)

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

Hier ist die verschleierte Version (die nicht lesbar ist, aber gut funktioniert):

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

Also, wenn LibreOffice nicht lügt, besteht mein verschleierter Code aus 646 Zeichen (ohne Leerzeichen, sollte ich sie zählen?) Und wenn alle anderen Bedingungen erfüllt sind, erhalte ich eine -10 für die zunehmende / abnehmende Auswahl.

Oh, und um dies zu kompilieren, sollten Sie tun (auf Unix-ähnlichen Systemen)

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

Beachten Sie, dass das Flag -m32 nur angezeigt wird, wenn Sie sich auf einem 64-Bit-Computer befinden. Sie benötigen auch die 32-Bit-Bibliotheken, um es zu kompilieren.

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

Sorta:

echo $*

Verwendung:

sorta 5
5

Verwenden Sie "-e", um in umgekehrter Reihenfolge zu sortieren:

sorta -e 3
3

• ergibt das richtige Ergebnis für positive ganze Zahlen von 1 bis 9 plus 0
• vermeidet jede Art von ziffernwidriger Hackerei.
• 7 Zeichen (+7)
• keine Arrays
• Keine Zeichenketten
• maximale Anzahl von Stellen, die es verarbeiten kann: 1 (+32)
• kann optional die Sortierung umkehren (-10)

BEARBEITEN: "cat" wurde in "echo" geändert, damit es tatsächlich funktioniert. BEARBEITEN 2: "$ *" hinzugefügt und in "sorta" -Skript eingefügt

Python3

Mein Skript beinhaltet:

Keine Arrays

Keine Schnüre

Komplexität ist O (n): Ich habe countingsort verwendet (von mir geändert, um keine Arrays zu verwenden, sondern Primzahlen, um Vorkommen zu zählen)

Keine Größenbeschränkungen

Zeichen: 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 Zeichen - 10 für die Rückseite)

Ich denke, das könnte die Regeln ein wenig biegen, aber jetzt ist es Freitag ...

Ich gehe davon aus, dass die Verwendung von Standardbibliotheken erlaubt ist. Meine Interpretation der Standardbibliothek für bashist coreutils:

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

• Keine Arrays - stattdessen werden Streams verwendet
• Keine Anführungszeichen == keine Zeichenketten
• Keine Begrenzung der Ein- / Ausgabelänge
• Optionales Argument "-r" kehrt die Ausgabe um.

Eingabe von stdin. In Benutzung:

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

C - 64 Zeichen, 64 Punkte

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

Sie fragen sich vielleicht, wie ich das ohne Überschriften zum Laufen bringe. Einfach, kompilieren mit:

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

Nicht golfen:

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

Ich habe auch beschlossen, die Zeichen zu sortieren, nur weil ich konnte.

Testläufe:

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

c-Funktion (Little-Endian-Bogen), 131 108 Zeichen

Ohne eine Antwort von sleepsort ist keine Sortieraufgabe vollständig . Die Rückkehr dauert bis zu 10 Sekunden, aber es funktioniert, und ich denke, es liegt voll im Rahmen der Spezifikationen. Diese Funktion nimmt einen einzelnen int-Parameter und gibt ein int mit den sortierten Dezimalstellen zurück:

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

_{Zeilenumbrüche und Einrückungen zur besseren Lesbarkeit hinzugefügt}

Rufen Sie wie folgt an:

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

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

Java: 262 Punkte

Ja, ja, ich weiß, es ist hoffnungslos, aber immer noch ..

class G{Object m(StringBuffer s,int o){for(int i=1;i<s.length();i++){int j=i-1,t=s.charAt(i),u=s.charAt(j);boolean c=o==0?t>u:t<u;for(;j>-1&c;){s.setCharAt(j+1,s.charAt(j));c=--j>-1;c=c?(o==0?t>s.charAt(j):t<s.charAt(j)):c;}s.setCharAt(++j,(char)t);}return s;}}

Analyse (Kennzeichnung):

1. Beginnend mit 0. (score = 0)
2. Insgesamt 262 Zeichen. (Punktzahl = 0 + 262 = 262)
3. +10 - für die Verwendung StringBuffer(Ich habe es verwendet, weil es kürzer ist alsStringBuilder ) (Punktzahl = 262 + 10 = 272)
4. -10 - um die Ausgabe flexibel zu gestalten. Ich habe 0 = absteigend , 1 = aufsteigend angenommen , also zurück zu 262!

Verwendung:

Wenn Sie versuchen, die G.javaDatei in der Eingabeaufforderung zu kompilieren, treten eine Menge Probleme (Fehler) auf. Also die Lösung?

Kompilieren Sie die G.javaKlasse in einer IDE wie NetBeansoder Eclipseoder sogar BlueJ. Es sollte sich problemlos kompilieren lassen (Warnungen ignorieren).

Dann sollte diese Klasse von einer main()Methode einer anderen Klasse (oder sogar dieser Klasse selbst) aufgerufen werden . Ich stelle es in eine andere Klasse, also zähle ich es nicht zu meiner Charakterzahl. Kompilieren Sie die andere Klasse auf ähnliche Weise (ohne zu verwenden cmd). Jetzt sollte die main()Methode in der anderen Klasse ungefähr so ​​aussehen:

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

Ohne unnötige Leerzeichen, Kommentare und Zeilenumbrüche sind es weitere 93 Zeichen. Ich füge es meinem Charakter nicht hinzu, da dies nur zur Demonstration über die Konsole dient.

Ausgabe:

NULL dh 0wird berücksichtigt. Angenommen, die externe Klasse ist Helper.javaund wurde erfolgreich kompiliert, sind einige Beispiele über die Konsole:

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

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

Wenn geändert, 0dh absteigend ...

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

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

ANMERKUNGEN:

1. Ich habe in kein Array explizit deklariert G.java. Das ist die Kernklasse .
2. Ich benutze Einfügesortierung , um die Zahl zu sortieren.
3. Die Anzahl kann von der maximalen Länge sein -Integer.MAX_VALUE da dies die maximale Größe ist, die ein Array aufnehmen kann (in Java).
4. Diese Antwort kann gekürzt werden (glaube ich), bitte helfen Sie mir (verbessern Sie meine erste Antwort).
5. Verdammt noch mal diese großartigen Götter, die versehentlich eine so lange, aber großartige Sprache wie Java erschaffen haben (und die sich auch Code-Konventionen einfallen ließen)!

TeX / LaTeX (332)

Wenn der eigentliche Code in einem Paket enthalten ist s, sieht die Haupt-LaTeX-Datei gut und einfach aus. Die Zahl wird nur als Mathe angegeben. Wenn die Zahl negativ ist, wird die Sortierreihenfolge umgekehrt. Der Code des Pakets skann auch mit normalem TeX verwendet werden, Beispiel weiter unten.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

Das Pakets (eine Zeile, Zeilenenden werden nicht benötigt):

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

Ergebnis:

Ergebnis: hoffnungslos

• Wenn Sie TeX mit etexoder verwenden pdftex, kann die Datei reduziert werden auf:

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

  Bytes: 318 Bytes ( s.sty) + 24 Bytes für den Rest ohne die Nummer

• Arrays werden nicht verwendet: 0

• Ich sehe keine Zeichenfolgen mit mehreren Zeichen: 0

• Die Anzahl ist nicht durch den Algorithmus begrenzt. Die größte TeX-Nummer ist 2 ³¹ - 1 = 2147483647. Im Beispiel wird eine 66-stellige Zahl verwendet, die viel größer ist als 0

• Wenn ein Minus angegeben wird, wird die Sortierreihenfolge auf absteigend zurückgesetzt: -10

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

Algorithmus:

Die Ziffern werden im Mathematikmodus zu aktiven Zeichen. Jede Ziffer speichert und sammelt die einzelnen Verwendungen in einem Makro. Nach dem Mathe-Modus werden die Makros mit den Ziffern in aufsteigender Reihenfolge ausgegeben.

Die Richtungsänderung erfolgt durch Text von rechts nach links, eine e-TeX-Funktion.

Entgolfte Version des Codes 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}%
  }%
}

Fortpflanzung

Es gibt einige Online-LaTeX-Compiler, eine Liste finden Sie hier . Ich habe das erste Element auf der Liste ausprobiert, das LaTeX-Servlet auf sciencesoft.at . Es kann ohne Signatur verwendet werden und es können auch permanente URLs erstellt werden: Quelle und Ergebnis als Bild .

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

Der aufmerksame Beobachter wird feststellen, dass dieser Sortieralgorithmus in der Zeit 0 (n) für die Anzahl der Ziffern in ausgeführt wird n.

Der pragmatische Beobachter wird bemerken, dass dieser Sortieralgorithmus zeitproportional zum Bereich der vorzeichenbehafteten ganzen Zahlen auf der Plattform abläuft, dass er den globalen Zustand mutiert, der zwischen den Läufen neu initialisiert werden muss, und dass viele andere Opfer zugunsten der Kürze erbracht wurden.

Die ungolfed-Version ist nicht genau gleichwertig, vermittelt aber besser den tatsächlichen Algorithmus.

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

Hier ist ein Testgeschirr für die Funktion:

#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 Zeichen, keine Arrays, keine Strings, kein Integer-Limit, kann nicht rückgängig gemacht werden

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

Beispiele:

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

Dies ist die Einfügesorte, die direkt an den ganzen Zahlen selbst ausgeführt wird. Dies ähnelt dem anderen Haskell-Eintrag, der eine Art Blase ist, obwohl ich schwöre, dass ich daran gearbeitet habe, bevor ich diesen gesehen habe.

Kurzanleitung:

• d teilt eine Zahl in Einheiten und Zehner, dh: d 135 ist das Paar(13,5)
• a%x ist die sortierte Einfügung der Ziffer a in die Nummerx
• a&x sortiert x durch Einfügen der Einheitenziffer in adas Ergebnis und den Rest
• s x sortiert x durch Anstoß des & Rekursion auf 0 undx

Der Trick ist, dass das zweite Argument von %und &nicht xdirekt ist, sondern xdivMod verwendetd

Python3.3 61 Punkte

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

Dieses Programm nimmt die Eingabe als Zeichenfolge auf, die als Zeichenfolge zählt, da sie nicht sofort in eine Ganzzahl geändert wird. +10

Die Zeichenfolge wird in ein Array sortiert +10

Dieses Array wird zu einer Zeichenfolge zusammengefügt +10 zusammengefügt

Hinweis: Die'' Zeichenfolge, mit der der Inhalt des Arrays verknüpft wird, besteht nicht aus mehreren Zeichen. Daher wird der Punktzahl nicht +10 hinzugefügt.

Das Programm besteht aus 31 Zeichen. +31

31 + 10 + 10 + 10 = 61 Punkte

J, 10 Zeichen (+ 1 Zeichenfolge) = 20

s=./:~&.":

Verwendung:

   s 52146729
12245679

Funktioniert für alle 32-Bit-Nummern.

Erläuterung:

/:~sortiere &.nach ":Format. Meine Vorgängerversion verwendete ebenfalls ein Array, aber es ist teuer. Jetzt muss ich nur noch eine Zeichenfolge verwenden und die Zeichen alphabetisch sortieren. ":konvertiert die eingegebene Zahl in einen String und/:~ sortiert die Ziffern in aufsteigender Reihenfolge. Da die Sortierung im Unterformat erfolgt, wird die Zeichenfolge nach Abschluss der Sortierung wieder in eine Zahl umgewandelt. Das Hinzufügen der Fähigkeit zum Rückwärtsfahren würde wahrscheinlich mehr kosten als es spart, also habe ich mich nicht darum gekümmert.

Man könnte argumentieren, dass J wie APL und K eine Array-basierte Sprache ist und die einzelne Eingabe ein Array mit 1 Element ist, aber ich habe mich dafür entschieden, bei der Berechnung meiner Punktzahl nicht so hart zu denken.

Das 32-Bit-Limit wird von J und nicht von meinem Programm vorgegeben. Je höher und J schaltet die Zahlen in wissenschaftliche Notation. Aus der Frage, ob die 32-Punkte-Strafe in diesem Fall gilt, ist nicht ersichtlich, aber selbst wenn beide vorherigen Strafen gelten (ich glaube nicht, dass sie das sollten), steigt die Punktzahl auf 72 und schlägt die überwiegende Mehrheit der anderen immer noch deutlich Antworten.

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

• Keine Arrays (stattdessen werden Iteratoren und ein Wörterbuch verwendet)
• Keine Zeichenketten (außer Ausgabe)
• Keine künstliche maximale Anzahl von Ziffern
• Keine Umkehrung

Es erstellt ein Wörterbuch, das alle 10 Ziffern auf 0 abbildet. Anschließend durchläuft es die Länge der Zahl ( log10(i)), extrahiert jede Ziffer ( (i / (10 ** c)) % 10) und erhöht den Zähler für diese Ziffer im Wörterbuch. Schließlich wird eine Zeichenfolge erstellt, indem alle 10 Ziffern durchlaufen werden und für jede Ziffer eine Instanz der Ziffer als Zeichenfolge ausgegeben wird.

Ich könnte die letzte Zeile ändern, print"".join(d[n]*str(n)for n in xrange(10))die 16 Zeichen weniger sein würde, würde aber Zeichenfolgen mit mehreren Zeichen verwenden.

C (bis C90) oder C ++ 78 66 Punkte

Die Funktion zum Sortieren einer Ganzzahl wird aufgerufen 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;}

Wertung:

• 66 Zeichen (+66)
• 0 Arrays (+0)
• 0 Zeichenfolgen (+0)
• Maschinell definierter Bereich (Größe von int ) (+0)
• Nur eine Sortierrichtung (-0)

Alte Version (78 Punkte, funktioniert auch mit C ++ und neueren C-Versionen)

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

Nicht golfen

using System.Linq;

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

Prüfung

Normal:

app.exe 52313698

Rückgängig gemacht:

app.exe 52313698-

Punkte: (Ich hoffe, ich habe das Punktesystem richtig verstanden - zögern Sie nicht zu korrigieren)

• Zeichen: 149
• Streicher: 10 + 10
• Arrays: +20
• Bestellung: -10
• Gesamt: 149 + 10 + 20-10 = 179

C # mit LINQPAD - 123

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

Prüfung

Normal:

lprun.exe sorta.linq 52313698

Rückgängig gemacht:

lprun.exe sorta.linq 52313698-

Punkte:

• Zeichen: 122
• Streicher: 10 + 10
• Arrays: +20
• Bestellung: -10
• Gesamt: 122 + 10 + 20-10 = 152

Java 1469

Eine string- und arrayfreie Lösung in Java. 1437 Zeichen + 32, da nur Long.MAX_VALUE als Eingabe benötigt wird. Mit Double könnte ich stattdessen auf über 300 Stellen wechseln, aber das wäre zu mühsam, um es zu implementieren. Für alles, was größer ist, sind BigInteger und AFAIK erforderlich, die intern Arrays verwenden. Wenn Sie weniger als 19 Stellen für die Eingabe verwenden, hat die Ausgabe führende Nullen. Negative Eingabe gibt alle Nullen und alles, was keine Zahl ist, löst eine Ausnahme aus.

Für die Sorte, die ich am einfachsten fand, ist es ziemlich ineffizient. (sollte O (n * n) sein)

input:  9212458743185751943
output: 1112233444555778899

Ich weiß, dass dies nicht wirklich mit den Lösungen in anderen Sprachen zu vergleichen ist, aber ich denke, dass dies zumindest die kürzeste ist, die ich in Java bekommen kann. (Wenn jemand weiß, wie man das noch kürzer macht, kann er es gerne bearbeiten / kommentieren)

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

Die 'x'-Datei:

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}

Der Lauf:

$ 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

Das einzige Array, das verwendet wird, ist ARGV. Dies ist keine Hilfe beim Sortieren, sondern nur der Zugriff auf die Befehlszeilenparameter. Diese Werte befinden sich in Nicht-Array-Variablen, die für Berechnungen tatsächlich benötigt werden. Ich denke, das wird gegen diese Lösung nicht zählen. Die folgende Berechnung berücksichtigt das ARGV-Array nicht:

111 (Zeichen) - 10 (kann umkehren)

Ich sehe nichts über Sortierfunktionen in der Frage, also ... (Ich werde die Antwort entfernen, wenn sie die Regeln verbiegt oder bricht, lass es mich wissen.)

JavaScript 56 96

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

JavaScript 69 109 (umschaltbar)

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

Kann mit den EcmaScript 6-Pfeilfunktionen ein wenig runtergolfen werden :

ES6 50 90

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

ES6 63 103 (umschaltbar) (73-10)

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

SED 67-Zeichen (67 oder 107 Punkte)

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

Hierbei wird der Kürze halber eine Blasensorte verwendet. Der Wert wäre 107, wenn jedes reguläre Ausdrucksmuster und jede Ersetzung als Zeichenfolge gezählt wird (dh 67 + (10 * 4)).

Anzahl der Stellen, die vom Arbeitsspeicher begrenzt werden (und wahrscheinlich Geduld)

Python-Lambda-Funktion (reversibel), 69

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

• 39 Zeichen (+39)
• Zwei Zeichenketten: n(Eingabe) und ''.join(...) (+20)
• Eine Liste: sorted(...) (+20)
• Kann je nach Parameter die Richtung umkehren d (-10)

Python-Lambda-Funktion (nicht reversibel), 67

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

BEARBEITEN: Die Eingabe sollte eine Zeichenfolge sein. Ich denke über die Strafe nach, diese Saite direkt zu benutzen.

Common Lisp - 126

(defun s(n p)(labels((a(n)(if(= 0 n)()(cons(mod n 10)(a (floor n 10)))))(b(a)(if(null a)0(+(car a)(* 10(b(cdr a)))))))(b(sort(a n) p))))

Die ungolfifizierte (sowohl stilistisch als auch lexikalisch, aber funktional identische) Version:

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

Die Ziffern einer negativen Zahl werden als negativ behandelt, und die Ziffern werden mit der niedrigsten Signifikanz zuerst sortiert (dh Little-Endian). Beispiele:

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

Die Golfversion enthält 136 Zeichen, einschließlich Leerzeichen. Es verwendet keine Zeichenfolgen und keine Arrays und verarbeitet Ganzzahlen mit beliebiger Genauigkeit, einschließlich negativer Ganzzahlen. Die Sortierung wird anhand eines binären Prädikats parametrisiert, das eine Gesamtreihenfolge für die Ganzzahlen in definiert [-9, 9], einschließlich, aber nicht beschränkt auf <und >:

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

Dies ergibt eine Punktzahl von 126.

JavaScript 416/185

Keine Arrays, keine Strings, keine willkürliche Längenbeschränkung ...

Aber das Sortieren nach oben / unten hätte mehr als 10 Zeichen gekostet ^^ Aber ich fand die Idee, Ziffern zu zählen und auszudrucken, interessant - vielleicht kann jemand diese Idee in GolfScript verwenden und den Preis gewinnen ;-)

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

Derselbe Code kürzer mit eval: (aber das würde wahrscheinlich mit Strings in Betracht gezogen werden ...)

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

Punkte:

• 192 (192 Zeichen)
• 40 (2 Arrays: argv (v) und a)
• 0 (keine Zeichenketten)
• 0 (es ist nicht auf n Ziffern beschränkt)

• -10 (wird umgekehrt sortiert, wenn die Zahl (argv [1]) negativ ist)

  = 222 Punkte

Flags, die benötigt werden, um die 1000 Compiler-Warnungen loszuwerden: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"Besser" lesbar:

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

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

Gibt es einen Grund, warum ich diese Lösung nicht schon sehe?

Rubin

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

Bin mir nicht sicher, wie ich das bewerten soll. Die Aufteilung würde ein Array erzeugen, aber darüber hinaus nicht sicher .. 38 Zeichen + 2x20 für Arrays? Oder sollte es alle Arrays enthalten, die von sort intern erstellt werden?

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 Zeichen + 10 für die Verwendung von Zeichenfolge n
(Weiß nicht, ob die Verwendung der replaceFunktion undstring Funktion, die n Zeichen x zurückgibt, als zusätzliche Zeichenfolge gezählt wird).

Es zählt die Menge einer bestimmten Ziffer, indem es die Länge der ursprünglichen Zeichenfolge mit derselben Zeichenfolge vergleicht, wobei die bestimmte Ziffer ersetzt wird. Dann hängt es diese Anzahl von Ziffern an n an.

Python 3 Schlafort (168)

Mit absolut keiner Liste oder Schleife, nur Generatoren.

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

könnte wahrscheinlich verbessert werden.

Schläger 97

97 Punkte (87 + 20 für zwei Zeichenfolgen, -10 für das Sortieren, keine Arrays)

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

Dies verwendet Listen von Zeichen, so dass Sie ihm eine Zeichenvergleichsfunktion wie char<?oder geben müssenchar>? . Ich fühle, dass dies auch als ungolfed gilt, da es nicht viel zu tun gibt, als Leerzeichen hinzuzufügen und Variablennamen zu erhöhen. Meine alte Version ist vielleicht ehrenwerter :)

Alte Version ohne Zeichenketten:

110 Punkte (120 Bytes (utf-8) - 10, um die Sortierreihenfolge zu ändern. Es werden keine Zeichenfolgen und keine Arrays verwendet.)

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

Ich habe es mit der 100.000sten Fibonacci-Zahl getestet:

(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

Und das gleiche in umgekehrter Reihenfolge:

(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