Zainspirowany niefortunnym sortowaniem liczb-cyfr-bez-użycia-macierzy , ale pomyślałem, że to lepszy kod do gry w golfa niż pytanie SO.

Biorąc pod uwagę dodatnią liczbę całkowitą, posortuj cyfry w tej liczbie całkowitej.

Najniższy wynik wygrywa!

1. Zacznij od 0 punktów.
2. Dodaj jeden punkt na znak.
3. Dodaj 20 punktów za każdą używaną tablicę.
4. Dodaj 10 punktów za każdy ciąg wieloznakowy w kodzie. (Z wyjątkiem początkowego wejścia, o ile jest ono konwertowane na liczbę całkowitą bez żadnych innych operacji na nim wykonanych).
5. Dodaj 32 punkty, jeśli maksymalna liczba cyfr obsługiwanych przez Twój program jest ograniczona przez Twój program (w przeciwieństwie do maszyny).
6. Odejmij 10 punktów, jeśli Twój kod może zmienić kierunek sortowania, podając inny argument (cokolwiek chcesz, ale na przykład 0 dla sortowania malejącego i 1 dla rosnąco).

Każdy język jest inny, ale chodzi o to, by unikać wszelkiego rodzaju hackerów z cyframi wielokrotnymi.

Przykład:

Wejście : 52146729

Wyjście : 97654221 lub 12245679

Uwagi:

1. Użyj wbudowanych funkcji sortowania dostępnych w języku programowania, ale jeśli ta funkcja sortowania obejmuje łańcuchy lub tablice, weź karę!
2. Możesz napisać rozwiązanie jako funkcję, która pobiera liczbę całkowitą bezpośrednio, lub jako program, który pobiera argument z argv, pliku lub strumienia i konwertuje go na liczbę całkowitą. Tak długo, jak natychmiast zamienisz go na liczbę całkowitą i odrzucisz oryginalne wejście char * bez wykonywania dalszych operacji na nim, nie będzie obowiązywać kara.
3. Kary mają zastosowanie nie tylko do literałów łańcuchowych w tekście programu, ale także do dowolnej części funkcji programu, która prawdopodobnie wprowadza lub wyprowadza ciąg znaków lub jest iterowalna. Na przykład JavaScript String.prototype.splitma co najmniej jeden ciąg jako input ( this) i tablicę jako wynik, więc +30 za użycie tego.
4. Starałem się, aby te reguły kierowały zasadą projektowania algorytmów, a nie początkowymi / końcowymi operacjami wejścia / wyjścia (stąd uwaga 2). Nie sądzę, że kara powinna obowiązywać, int(input())nawet jeśli inputpodpis mówi, że zwraca ciąg znaków, o ile to wyrażenie jest początkowym punktem wejścia programu. Podobnie, jeśli końcowym wyjściem programu jest print(x)i xmusi być ciąg, kara nie dotyczy operacji odlewania ciągu z ostatniego rowu. To powiedziawszy, ja nigdy nie powiedziałem, że to musi być program, albo skąd I / O musiało pochodzić lub iść. Funkcja, która przyjmuje inti zwraca an int, służyłaby i nie cierpiałaby z powodu tych dwuznaczności.

GolfScript, 11 4

(4 + 10 (ciąg znaków) - 10 (opcja odwrotna))

Wejście na STDIN.

~`$%

Format wejściowy jest następujący:

(1 or -1) (the number)

1sortować normalnie, -1odwracać. 4 znaki - 10 dla opcji odwrotnej = wynik -6.

Dane wejściowe są technicznie ciągiem, więc nie jestem pewien, czy to się liczy +10. Interpretuję regułę jako „ciąg zadeklarowany w twoim programie” (ponieważ mówi „w kodzie”).

Stara odpowiedź (wynik 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}

przykład:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Odpowiedź, która nie unika pytania.

Poproszono o wyjaśnienie, tutaj nie jest golfem. Jest to bardzo nieefektywny rodzaj bąbelków.

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

W Haskell istnieją krótsze odpowiedzi, odpowiadające niektórym innym, np .:

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

... zdobywa 52 + 20 = 72 lub więcej punktów 45 + 20 = 65:

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

... ale duch pytania - brak tablic, ciągów znaków lub znaków - jest bardziej interesujący.

C + x86, 636

Wiem, że to nie wygra, ale czułem się tak nienaturalnie i pokręcony, że musiałem się tym podzielić. Brak tablic lub łańcuchów (o ile nie policzysz argumentów wejściowych). Liczba cyfr jest ograniczona przez zakres 32 bitów.

Oto małe wyjaśnienie tego, co zrobiłem:

Myślałem, że zrobię to bez użycia tablic lub ciągów, a potem przyszła mi do głowy rekurencja, ale oczywiście przy rekursji nie byłbym w stanie zamienić wartości z innych wywołań rekurencyjnych ... i wtedy zdałem sobie sprawę, że był sposób. Łącząc mój program C z funkcją asemblacji, mogłem wskoczyć na stos i zwrócić wskaźnik do wskaźnika podstawowego żądanego wywołania, właśnie to robi funkcja „recursionStackAt”. Oczywiście recursionStackAt jest bardzo brzydką funkcją, jej wynik zależy nie tylko od stanu wejścia lub programu, ale od samego programu wywołującego. Zauważ, że to spowodowało, że zmieniłem indeksy z 0 na 1 w oparciu.

Bez zbędnych ceregieli, oto kod:

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

I oczywiście kod zestawu x86 (AT&T sintax, btw) dla funkcji 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

Kilka przykładów na wyjściu: (1 oznacza zwiększenie, a 0 zmniejszenie)

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

Oto zaciemniona wersja (która jest nieczytelna, ale działa dobrze):

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

Więc jeśli LibreOffice nie kłamie, mój zaciemniony kod składa się z 646 znaków (bez spacji, czy powinienem je policzyć?) I przy spełnieniu wszystkich pozostałych warunków dostaję -10 za zwiększenie / zmniejszenie wyboru.

Aha, i aby to skompilować, powinieneś zrobić (w systemach uniksopodobnych)

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

Pamiętaj, że flaga -m32 jest dostępna tylko na komputerze 64-bitowym. Potrzebne są również biblioteki 32-bitowe, aby je skompilować.

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

Sortuj:

echo $*

Stosowanie:

sorta 5
5

Użyj „-e”, aby posortować w odwrotnej kolejności:

sorta -e 3
3

• daje poprawny wynik dla dodatnich liczb całkowitych 1-9 plus 0
• unika wszelkiego rodzaju hackerów z powtarzalnymi cyframi.
• 7 znaków (+7)
• bez tablic
• bez ciągów wieloznakowych
• maksymalna liczba cyfr, które może obsłużyć: 1 (+32)
• opcjonalnie może odwrócić sortowanie (-10)

EDYCJA: zmieniono „cat” na „echo”, aby faktycznie działało. EDYCJA 2: Dodano „$ *” i umieściłem w skrypcie „sorta”

Python3

Moje funkcje skryptu:

Brak tablic

Bez zobowiązań

Złożoność to O (n): Użyłem countingsort (zmodyfikowany przeze mnie, aby nie używać tablic, ale liczby pierwsze do liczenia wystąpień)

Bez ograniczeń wielkości

Znaki: 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 znaki - 10 dla rewersu)

Wydaje mi się, że może to trochę naginać zasady, ale oto nadchodzi piątek ...

Zakładam, że korzystanie ze standardowych bibliotek jest dozwolone. Moja interpretacja standardowej biblioteki bashto coreutils:

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

• Bez tablic - zamiast tego używane są strumienie
• Brak cudzysłowów == brak ciągów wieloznakowych
• Bez ograniczenia długości wejścia / wyjścia
• opcjonalny argument „-r” odwraca dane wyjściowe.

Dane wejściowe ze standardowego wejścia. W użyciu:

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

C - 64 znaki, 64 punkty

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

Możesz się zastanawiać, jak to działa bez żadnych nagłówków. Prosty, kompiluj z:

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

Bez golfa:

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

Postanowiłem również włączyć sortowanie znaków, tylko dlatego, że mogłem.

Przebiegi testowe:

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

funkcja c (łuk little-endian), 131 108 znaków

Żadne wyzwanie sortowania nie jest kompletne bez odpowiedzi sleepsort . Ten powrót potrwa do 10 sekund, ale działa, i myślę, że jest w pełni zgodny ze specyfikacją. Ta funkcja przyjmuje pojedynczy parametr int i zwraca liczbę int z posortowanymi cyframi dziesiętnymi:

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

_{dodano nowe linie i wcięcia dla czytelności}

Zadzwoń w następujący sposób:

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

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

Java: 262 punkty

Tak, tak, wiem, to beznadziejne, ale nadal…

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

Analiza (oznaczenie):

1. Począwszy od 0. (wynik = 0)
2. Łącznie 262 znaków. (wynik = 0 + 262 = 262)
3. +10 - za użycie StringBuffer(użyłem go, ponieważ jest krótszy niż StringBuilder) (wynik = 262 + 10 = 272)
4. -10 - dla uelastycznienia wyjścia. Rozważyłem 0 = malejąco , 1 = rosnąco , więc wróć do 262!

Stosowanie:

Podczas próby skompilowania G.javapliku w wierszu polecenia generuje wiele problemów (błędów). Więc rozwiązanie?

Skompilować G.javaklasy w IDE jak NetBeanslub Eclipsenawet BlueJ. Powinien się kompilować bez żadnych problemów (zignoruj ​​wszelkie ostrzeżenia).

Następnie ta klasa powinna zostać wywołana przez main()metodę z dowolnej innej klasy (lub nawet samej klasy). Umieszczam to w innej klasie, więc nie dodam tego do mojej liczby postaci. Skompiluj drugą klasę w podobny sposób (bez użycia cmd). Teraz main()metoda w drugiej klasie powinna wyglądać mniej więcej tak:

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

Pomijając niepotrzebne spacje, komentarze i podziały wierszy, to kolejne 93 znaki. Nie dodam go do mojej postaci, ponieważ jest to tylko demonstracja za pośrednictwem konsoli.

Wynik:

ZERO tj. 0Jest brane pod uwagę. Załóżmy, że klasa zewnętrzna jest Helper.javai została pomyślnie skompilowana, kilka przykładów za pośrednictwem konsoli to:

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

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

Po zmianie na 0np. Malejąco ...

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

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

UWAGI:

1. Nie zgłosiłem jawnie żadnej tablicy G.java. To jest klasa podstawowa .
2. Korzystam z sortowania przez wstawianie, aby posortować numer cyfrowo.
3. Liczba może mieć maksymalną długość - Integer.MAX_VALUEponieważ jest to maksymalny rozmiar, jaki może pomieścić dowolna tablica (w Javie).
4. Ta odpowiedź może zostać skrócona (uważam), więc proszę, pomóż mi (popraw moją pierwszą odpowiedź).
5. Do diabła z tymi wielkimi bogami, którzy przypadkowo stworzyli tak długi, ale świetny język, taki jak Java (a także wymyślili konwencje kodu)!

TeX / LaTeX (332)

Jeśli rzeczywisty kod zostanie umieszczony w pakiecie s, główny plik LaTeX wygląda ładnie i łatwo. Liczba jest podana tylko jako matematyka. Jeśli liczba jest ujemna, kolejność sortowania jest odwrócona. Kod pakietu smoże być również używany z prostym TeXem, przykład poniżej.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

Pakiets (jedna linia, końce linii nie są potrzebne):

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

Wynik:

Wynik: beznadziejny

• Używając zwykłego TeXa z etexlub pdftex, plik można zredukować do:

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

  Bajty: 318 bajtów ( s.sty) + 24 bajty dla reszty bez liczby

• Tablice nie są używane: 0

• Nie widzę ciągów wieloznakowych: 0

• Liczba nie jest ograniczona przez algorytm. Największy numer TeX to 2 ³¹ - 1 = 2147483647. W przykładzie użyto 66-cyfrowej liczby, znacznie większej: 0

• Jeśli podano minus, kolejność sortowania jest przywracana do malejącej: −10

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

Algorytm:

Cyfry stają się aktywnymi postaciami w trybie matematycznym. Każda cyfra zapamiętuje i gromadzi każde użycie w makrze. Po trybie matematycznym makra są wyprowadzane z cyframi w porządku rosnącym.

Zmiana kierunku odbywa się za pomocą tekstu od prawej do lewej, funkcji e-TeX.

Odmolona wersja kodu ws.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}%
  }%
}

Reprodukcja

Istnieje kilka internetowych kompilatorów LaTeX, ich listę można znaleźć tutaj . Próbowałem pierwszego elementu na liście, serwletu LaTeX na sciencesoft.at . Można go używać bez podpisywania, a także tworzyć trwałe adresy URL: źródło i wynik jako obraz .

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

Bystry obserwator zauważy, że ten algorytm sortowania działa w czasie O (n) od liczby cyfr w n.

Pragmatyczny obserwator zauważy, że ten algorytm sortowania działa w czasie proporcjonalnym do zakresu podpisanych liczb całkowitych na platformie, że mutuje stan globalny, który należy ponownie zainicjować między seriami, i że wiele innych poświęceń zostało dokonanych na korzyść zwięzłości.

Wersja bez golfa nie jest dokładnie równoważna, ale lepiej przekazuje faktyczny algorytm.

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

Oto uprząż testowa dla funkcji:

#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 znaków, bez tablic, bez ciągów, bez limitu liczb całkowitych, nie można odwrócić

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

Przykłady:

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

Ten jest sortowany przez wstawianie, wykonywany bezpośrednio na samych liczbach całkowitych. Jest to podobne do innego wpisu Haskell, który jest typu bąbelkowego, chociaż przysięgam, że nad nim pracowałem, zanim go zobaczyłem.

Krótki przewodnik:

• ddzieli liczbę na jednostki i dziesiątki, tzn .: d 135jest parą(13,5)
• a%x posortowane jest wstawianie cyfry a do liczbyx
• a&x sortuje x , wstawiając cyfrę jednostek ai powtarzając wynik i resztę
• s xsortuje x, rozpoczynając &rekurencję od 0 ix

Sztuka polega na tym, że drugi argument %i &nie jest xbezpośrednio, ale xużywa divModd

Python3.3 61 punktów

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

Ten program przyjmuje dane wejściowe jako ciąg, który liczy się jako ciąg, ponieważ nie jest on natychmiast zmieniany na liczbę całkowitą. +10

Ciąg jest sortowany w tablicy +10

Ta tablica jest łączona w ciąg +10

Uwaga:'' używanych do łączenia zawartości tablicy nie jest multi ciąg znaków, więc +10 nie jest dodawany do wyniku.

Program składa się z 31 znaków. +31

31 + 10 + 10 + 10 = 61 punktów

J, 10 znaków (+ 1 ciąg) wynik = 20

s=./:~&.":

Stosowanie:

   s 52146729
12245679

Działa dla wszystkich liczb 32-bitowych.

Wyjaśnienie:

/:~sortuj &.według ":formatu. Moja poprzednia wersja również używała tablicy, ale są one kosztowne, więc teraz muszę po prostu użyć łańcucha i posortować znaki alfabetycznie. ":konwertuje liczbę wprowadzoną na ciąg i /:~sortuje cyfry w porządku rosnącym. Ponieważ sortowanie odbywa się w formacie „pod”, po zakończeniu sortowania ciąg znaków jest konwertowany z powrotem na liczbę. Dodanie możliwości cofania prawdopodobnie kosztowałoby więcej niż oszczędza, więc nie zawracałem sobie głowy.

Można argumentować, że ponieważ J, podobnie jak APL i K, jest językiem opartym na tablicach, pojedyncze dane wejściowe to tablica 1 elementu, ale zdecydowałem się nie brać tak surowego widoku przy obliczaniu mojego wyniku.

Limit 32-bitowy jest narzucony przez J, a nie przez mój program. Każda wyższa i J przełącza liczby na notację naukową. Pytanie, czy w tym przypadku ma zastosowanie kara 32 punktowa, nie jest jasne, ale nawet jeśli obowiązują obie poprzednie kary (nie sądzę, że powinny), wynik wzrasta do 72 i nadal wygodnie pokonuje zdecydowaną większość pozostałych odpowiedzi

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

• Brak tablic (zamiast tego używane są iteratory i słownik)
• Bez ciągów wieloznakowych (z wyjątkiem danych wyjściowych)
• Brak sztucznej maksymalnej liczby cyfr
• Bez cofania

Działa poprzez utworzenie słownika odwzorowującego wszystkie 10 cyfr na 0. Następnie iteruje się na całej długości liczby ( log10(i)), wyodrębniając każdą cyfrę ((i / (10 ** c)) % 10 ) i zwiększając licznik tej cyfry w słowniku. Wreszcie tworzy ciąg utworzony przez iterację wszystkich 10 cyfr i dla każdej cyfry, dając jedno wystąpienie cyfry jako ciąg.

Mógłbym zmienić ostatni wiersz, do print"".join(d[n]*str(n)for n in xrange(10))którego byłoby 16 znaków mniej, ale używałbym ciągów wieloznakowych.

C (do C90) lub C ++, 78 66 punktów

Wywoływana jest funkcja sortowania liczby całkowitej 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;}

Punktacja:

• 66 znaków (+66)
• 0 tablic (+0)
• 0 ciągów (+0)
• Zasięg określony przez maszynę (wielkość int ) (+0)
• Tylko jeden kierunek sortowania (-0)

Stara wersja (78 punktów, działa również z C ++ i nowszymi wersjami C)

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

Nie grał w golfa

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

Normalna:

app.exe 52313698

Wywrócony:

app.exe 52313698-

Punkty: (Mam nadzieję, że dobrze zrozumiałem system punktowy - nie krępuj się poprawiać)

• Znaki: 149
• Ciągi: 10 + 10
• Tablice: +20
• Zamówienie: -10
• Razem: 149 + 10 + 20-10 = 179

C # z LINQPAD - 123

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

Test

Normalna:

lprun.exe sorta.linq 52313698

Wywrócony:

lprun.exe sorta.linq 52313698-

Zwrotnica:

• Znaki: 122
• Ciągi: 10 + 10
• Tablice: +20
• Zamówienie: -10
• Razem: 122 + 10 + 20-10 = 152

Java 1469

Rozwiązanie bez ciągów i macierzy w Javie. 1437 znaków + 32, ponieważ jako dane wejściowe zajmuje tylko Long.MAX_VALUE. Używając Double mogę zamiast tego przejść do ponad 300 cyfr, ale byłoby to zbyt żmudne do wdrożenia. Wszystko większe niż to wymagałoby BigInteger i AFAIK, który korzysta z tablic wewnętrznie. Jeśli użyjesz mniej niż 19 cyfr na wejściu, dane wyjściowe będą miały zera na początku. Ujemne wejście da wszystkie zera, a cokolwiek innego niż liczba spowoduje wyjątek.

Do tego rodzaju, którego użyłem najłatwiejszego, jaki mogłem wymyślić, więc jest dość nieefektywny. (powinno być O (n * n))

input:  9212458743185751943
output: 1112233444555778899

Wiem, że tak naprawdę nie ma porównania z rozwiązaniami w innych językach, ale wydaje mi się, że przynajmniej jest to najkrótsza możliwa do uzyskania w Javie. (jeśli ktoś wie, jak to zrobić jeszcze krócej, możesz go edytować / komentować)

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

Plik „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}

Bieg:

$ 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

Jedyną zastosowaną tablicą jest ARGV i to nie pomaga w sortowaniu, jest to tylko dostęp do parametrów wiersza poleceń, a te wartości są w zmiennych innych niż tablica, gdzie są rzeczywiście potrzebne do obliczeń. Myślę, że to się nie liczy na to rozwiązanie. Poniższe obliczenia nie uwzględniają tablicy ARGV:

111 (znaki) - 10 (można cofać)

W pytaniu nie widzę nic na temat funkcji sortowania, więc ...

JavaScript 56 96

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

JavaScript 69 109 (odwracalny)

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

Można nieco pograć w golfa za pomocą funkcji strzałek EcmaScript 6 :

ES6 50 90

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

ES6 63 103 (dwustronny) (73-10)

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

SED 67 znaków (ocena 67 lub 107)

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

Używa to sortowania bąbelkowego dla zwięzłości. Wynik wyniósłby 107, gdyby każdy wzorzec wyrażenia regularnego i zamiana liczyły się jako ciąg (tj. 67 + (10 * 4))

Liczba obsługiwanych cyfr ograniczona przez pamięć (i prawdopodobnie cierpliwość)

Funkcja lambda Python (odwracalna), 69

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

• 39 znaków (+39)
• Dwa ciągi wieloznakowe: n(wejście) i ''.join(...) (+20)
• Jedna lista: sorted(...) (+20)
• Może odwrócić kierunek w zależności od parametru d (-10)

Funkcja lambda Python (nieodwracalna), 67

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

EDYCJA: Dane wejściowe powinny być ciągiem. Rozważam karę za bezpośrednie użycie tego ciągu.

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

Wersja niefolifikowana (stylistycznie i leksykalnie, ale funkcjonalnie identyczna):

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

Cyfry liczby ujemnej są traktowane jako mające wartość ujemną, a cyfry są sortowane od najmniej znaczącej do pierwszej (tj. Little-endian). Przykłady:

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

W wersji golfowej jest 136 znaków, w tym spacja. Nie używa ciągów ani tablic, i obsługuje liczby całkowite o dowolnej dokładności, w tym liczby całkowite ujemne. Sortowanie jest parametryzowane w predykacie binarnym, który określa całkowite uporządkowanie liczb całkowitych, w [-9, 9]tym między innymi <i >:

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

Daje to wynik 126.

JavaScript 416/185

Bez tablic, bez łańcuchów, bez ograniczeń arbitralnych długości ...

Ale sortowanie w górę / w dół zajęłoby więcej niż 10 znaków ^^ Ale pomysł liczenia cyfr i drukowania ich był interesujący - może ktoś może użyć tego pomysłu w GolfScript i wygrać nagrodę ;-)

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

Ten sam kod krótszy, przy użyciu eval: (ale można by to uznać za użycie ciągów ...)

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

Zwrotnica:

• 192 (192 znaków)
• 40 (2 tablice: argv (v) i a)
• 0 (bez ciągów wieloznakowych)
• 0 (nie ogranicza się do n cyfr)

• -10 (sortuje do tyłu, jeśli liczba (argv [1]) jest ujemna)

  = 222 punkty

Flagi potrzebne do pozbycia się 1000 ostrzeżeń kompilatora: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

„Lepszy” czytelny:

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

Nieco golfisty:

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

Czy istnieje powód, dla którego nie widzę już tego rozwiązania?

Rubin

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

Nie jestem pewien, jak to zdobyć. Podział wygenerowałby tablicę, ale poza tym nie jestem pewien. 38 znaków + 2x20 dla tablic? A może powinien zawierać wszystkie tablice, które mogą tworzyć wewnętrznie?

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 znaków + 10 za użycie łańcucha n
(Nie wiem, czy użycie replacefunkcji i stringfunkcji zwracającej n ilości znaku x jest liczone jako dodatkowy ciąg).

Liczy ilość określonej cyfry, porównując długość oryginalnego łańcucha z tym samym łańcuchem z określoną cyfrą zamienioną. Następnie dołącza tę liczbę cyfr do n.

Python 3 sleepsort (168)

Bez absolutnie żadnej listy ani pętli, tylko generatory.

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

prawdopodobnie można by to poprawić.

Rakieta 97

97 punktów (87 +20 za dwa ciągi, -10 za sortowanie, brak tablic)

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

Używa list znaków, więc musisz nadać mu funkcję porównywania znaków, taką jak char<?lub char>?. Wydaje mi się, że to również przechodzi jako niezamieszkane, ponieważ nie ma wiele do roboty niż dodawanie spacji i zwiększanie nazw zmiennych. Moja stara wersja jest chyba bardziej honorowa :)

Stara wersja bez ciągów:

110 punktów (120 bajtów (utf-8) - 10 za umożliwienie zmiany kolejności sortowania. Nie używa ciągów ani tablic)

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

Nie golfowany:

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

Przetestowałem to na 100 000. liczbie Fibonacciego:

(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

I to samo w odwrotnej kolejności:

(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