Bir dizi kullanarak-olmadan-numaralar-basamak- kötü-kader esinlenerek esinlenerek , ama SO sorudan daha iyi bir kod golf yaptığını düşündüm.

Pozitif bir tamsayı verildiğinde, o tamsayıdaki basamakları sıralayın.

En düşük puan kazanır!

1. 0 puanla başlayın.
2. Karakter başına bir nokta ekleyin.
3. Kullandığınız her dizi için 20 puan ekleyin.
4. Kodunuzdaki her çok karakterli dize için 10 nokta ekleyin. (İlk giriş dışında, üzerinde başka bir işlem yapılmadan bir tam sayıya dönüştürüldüğü sürece.)
5. Programınızın kullanabileceği maksimum basamak sayısı programınızla sınırlıysa (makinenin aksine) 32 puan ekleyin.
6. Kodunuz başka bir bağımsız değişken verilen sıralamanın yönünü değiştirebilirse 10 puan çıkarın (ne isterseniz, ancak örneğin azalan sıralama için 0 ve artan için 1).

Her dil farklıdır, ancak fikir, her türlü basamaklı hack'lerden kaçınmaktır.

Misal:

Giriş : 52146729

Çıktı : 97654221 veya 12245679

Notlar:

1. Programlama dilinizin sağladığı herhangi bir yerleşik sıralama özelliğini kullanın, ancak bu sıralama özelliği dizeler veya diziler içeriyorsa cezayı alın!
2. Çözümü, bir tamsayıyı doğrudan alan bir işlev olarak ya da argv, bir dosya veya akıştan bağımsız değişken alan ve bir tamsayıya dönüştüren bir program olarak yazabilirsiniz. Hemen bir tamsayıya dönüştürdüğünüz ve üzerinde başka bir işlem yapmadan orijinal karakter * girişini attığınız sürece herhangi bir ceza uygulanmaz.
3. Cezalar yalnızca program metninizdeki dize değişmez değerleri için değil, program özelliğinizin bir dizeyi veya yinelenebilir bir şekilde girilen veya çıkaran herhangi bir bölümü için de geçerlidir. Örneğin, JavaScript'in String.prototype.splitinput ( this) olarak en az bir dizesi ve output olarak bir Array'ı vardır, dolayısıyla bunu kullanmak için +30'dur.
4. Ben bu kuralları ilk / son I / O (dolayısıyla nota 2) değil, algoritma tasarımı ilkesi rehberlik yapmaya çalıştım. Bu ifade programın ilk giriş noktası olduğu sürece, imzasının bir dize döndürdüğünü söylüyorsa int(input())bile cezanın uygulanması gerektiğini düşünmüyorum . Benzer şekilde, programın son çıktısı bir dize ise ve olması gerekiyorsa, ceza son hendek döküm işlemi için geçerli değildir. Bütün bunlar, bunun bir program olması gerektiğini ya da G / Ç'nin gelmesi ya da gitmesi gerektiğini açıkça söylemedim . Anı alan ve döndüren bir işlev bu belirsizlikten muzdarip olmazdı.inputprint(x)xintint

GolfScript, 11 4

(4 + 10 (dize) - 10 (ters seçenek))

STDIN girişi.

~`$%

Girdi biçimi şudur:

(1 or -1) (the number)

1normal sıralama, -1tersine çevirme. 4 karakter - ters seçenek için 10 = -6 puanı.

Giriş teknik olarak bir dizedir, bu yüzden bunun +10 için geçerli olup olmadığından emin değilim. Kuralı "programınızda bildirilen bir dize" olarak yorumluyorum ("kodunuzda" yazdığı için).

Eski cevap (11 puan):

$

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}

misal:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Soruyu atlatmayan bir cevap.

Bir açıklama istendi, burada çözüldü. Bu çok verimsiz bir kabarcık türüdür.

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

Haskell'de yayınlanan diğerlerinden bazılarına eşdeğer daha kısa cevaplar vardır, örneğin:

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

... puanlar 52 + 20 = 72 ya da bu puan 45 + 20 = 65:

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

... ama sorunun ruhu - diziler, dizeler veya karakterler yok - daha ilginç.

C + x86 montajı, 636

Bunun kazanamayacağını biliyorum ama paylaşmak çok doğal ve bükülmüştü. Diziler veya dizeler yok (giriş bağımsız değişkenlerini saymadığınız sürece). Basamak sayısı 32 bit aralığı ile sınırlıdır.

İşte yaptığım şeyle ilgili küçük bir açıklama:

Bunu diziler veya dizeler kullanmadan yapacağımı sanıyordum ve sonra özyineleme akla geldi, ama elbette özyineleme ile diğer özyinelemeli çağrılardan değerleri değiştiremem ... ve sonra bunu fark ettim bir yol vardı. C programımı bir montaj işlevi ile bağlama Yığının içine atlayabilir ve istenen çağrının temel işaretçisine bir işaretçi döndürebilir, "recursionStackAt" işlevinin yaptığı şey budur. Elbette özyinelemeStackAt çok çirkin bir işlevdir, sonucu yalnızca girdinin veya programın durumuna değil, arayanın kendisine de bağlıdır. Dizinleri 0'a göre 1'e değiştirdiğimi unutmayın.

Daha fazla uzatmadan, işte 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);
} 

Ve elbette recursionStackAt işlevi için x86 (AT&T sintax, btw) montaj kodu:

.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

Çıktıya bazı örnekler: (1 artış ve 0 azalma anlamına gelir)

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

İşte gizlenmiş sürümü (okunamaz ancak iyi çalışıyor):

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

LibreOffice yalan söylemezse, kodum 646 karakterden (boşluklar olmadan, onları saymalıyım?) Oluşur ve diğer tüm koşullarla birlikte artan / azalan seçim için -10 alırım.

Oh, ve bunu derlemek için yapmalısın (Unix benzeri sistemlerde)

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

-M32 bayrağının yalnızca 64 bit bir makinedeyseniz olduğunu unutmayın. Ayrıca derlemek için 32 bit kitaplıklara ihtiyacınız vardır.

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

Sorta:

echo $*

Kullanımı:

sorta 5
5

Tersine sıralamak için "-e" kullanın:

sorta -e 3
3

• 1-9 arasındaki pozitif tamsayılar için doğru sonucu üretir, artı 0
• her türlü basamaklı hack'lerden kaçınır.
• 7 karakter (+7)
• diziler yok
• çok karakterli dizeler yok
• işleyebileceği maksimum basamak sayısı: 1 (+32)
• isteğe bağlı olarak sıralamayı tersine çevirebilir (-10)

EDIT: "kedi", "yankı" olarak değiştirildi, böylece gerçekten işe yarayacak. DÜZENLEME 2: "$ *" eklendi ve "sorta" komut dosyasına koy

Python3

Komut dosyam özellikleri:

Diziler yok

Dizgi yok

Karmaşıklık O (n): Countingsort kullandım (dizileri kullanmamak için değiştirdim, ancak occourences'ı saymak için asal sayılar )

Boyut sınırlaması yok

Karakterler: 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 karakter - 10 geri için)

Sanırım bu kuralları biraz büküyor olabilir, ama işte Cuma günü ...

Standart kütüphanelerin kullanımına izin verildiğini varsayıyorum. İçin standart kütüphanenin Benim yorumlama bashDİR coreutils:

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

• Diziler yok - bunun yerine akışlar kullanılıyor
• Tırnak yok == çok karakterli dizeler yok
• Giriş / çıkış uzunluğunda sınır yok
• isteğe bağlı arg "-r" çıktıyı ters çevirir.

Stdin'den girdi. Kullanımda:

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

C - 64 karakter, 64 puan

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

Bunu herhangi bir başlık olmadan nasıl çalıştıracağımı merak edebilirsiniz. Basit, derleme:

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

Un-golfed:

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

Ben de yapabildiğim için karakter sıralaması eklemeye karar verdim.

Test çalıştırmaları:

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

c fonksiyonu (küçük endian kemer), 131 108 karakter

Sleepsort yanıtı olmadan hiçbir sıralama zorluğu tamamlanmış değildir . Bu geri dönmek 10 saniye kadar sürecek, ama işe yarıyor ve bence tamamen spec içinde. Bu işlev tek bir int parametresi alır ve ondalık basamakları sıralanmış bir int döndürür:

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

_{okunabilirlik için satırsonu ve girinti eklendi}

Aşağıdaki gibi arayın:

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

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

Java: 262 puan

Evet, evet biliyorum, umutsuz, ama yine de ..

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

Analiz (işaretleme):

1. 0 ile başlayan puan. (Puan = 0)
2. Toplam 262 karakter. (puan = 0 + 262 = 262)
3. +10 - kullanmak için StringBuffer( daha kısa olduğu için kullandım StringBuilder) (puan = 262 + 10 = 272)
4. -10 - çıkışı esnek hale getirmek için. Ben kabul ettik 0 = inen , 1 = artan yüzden geri 262'ye,!

Kullanımı:

G.javaDosyayı komut isteminde derlemeye çalıştığınızda , çok fazla sorun (hata) oluşturur. Peki, çözüm?

Derleme G.javagibi bir IDE sınıf NetBeansveya Eclipsehatta BlueJ. Sorunsuz bir şekilde derlenmelidir (uyarıları dikkate almayın).

Daha sonra, bu sınıf, main()başka herhangi bir sınıftan (hatta bu sınıfın kendisinden) bir yöntemle çağrılmalıdır . Başka bir sınıfa koyuyorum, bu yüzden karakter sayımıma eklemiyorum. Diğer sınıfı benzer şekilde derleyin (kullanmadan cmd). Şimdi diğer sınıftaki main()yöntem şöyle olmalıdır:

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

Gereksiz boşluklar, yorumlar ve satır sonları hariç, 93 karakter daha. Karakterime eklemiyorum çünkü bu sadece konsol üzerinden gösteri içindir.

Çıktı:

SIFIR yani 0dikkate alınır. Dış sınıf olduğunu varsayalım ve Helper.javabaşarıyla derlendi, konsoldan birkaç örnek:

INPUT :C: ...> java Yardımcısı 008321
OUTPUT:001238

INPUT :C: ...> java Yardımcısı 79359105
OUTPUT:01355799

0Yani azalan olarak değiştiğinde ...

INPUT :C: ...> java Yardımcısı 008321
OUTPUT:832100

INPUT :C: ...> java Yardımcısı 79359105
OUTPUT:99755310

NOTLAR:

1. Açıkça herhangi bir dizi ilan etmedi G.java. Yani ana sınıfı.
2. Rakam basamaklı sıralamak için ekleme sıralama kullanıyorum .
3. Sayı maksimum uzunluktan olabilir - Integer.MAX_VALUEçünkü bu, herhangi bir dizinin tutabileceği maksimum boyuttur (Java'da).
4. Bu cevap kısaltılabilir (inanıyorum) bu yüzden lütfen bana yardım et (ilk cevabımı geliştir).
5. Yanlışlıkla Java gibi uzun ama büyük bir dil yaratan (ve ayrıca kod sözleşmeleri yapan) büyük Tanrıları lanetleyin!

TeX / LaTeX (332)

Gerçek kod bir pakete skonursa, ana LaTeX dosyası güzel ve kolay görünür. Sayı sadece matematik olarak verilir. Sayı negatifse, sıralama düzeni tersine çevrilir. Paket kodu sayrıca aşağıda açık olan düz TeX ile de kullanılabilir.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

Pakets (bir satır, satır sonu gerekli değildir):

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

Sonuç:

Puan: umutsuz

• etexVeya ile düz TeX kullanarak pdftexdosya şuna indirilebilir:

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

  Bayt: Numara olmadan kalanlar için 318 bayt ( s.sty) + 24 bayt

• Diziler kullanılmaz: 0

• Çok karakterli dizeler görmüyorum: 0

• Sayı algoritma ile sınırlı değildir. En Tex numarası 2 ³¹ - 1 = 2147483647 örnek 66 haneli bir numara kullanan, bir şekilde daha büyük bir: 0

• Eksi verilirse, sıralama düzeni azalan şekilde döndürülür: −10

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

Algoritma:

Rakamlar matematik modunda etkin karakterler haline getirilir. Her basamak bir makrodaki her bir kullanımı hatırlar ve toplar. Matematik modundan sonra, makrolar basamaklar artan sırada görüntülenir.

Yön değişikliği, bir e-TeX özelliği olan sağdan sola metinle yapılır.

Degolfed sürümü kods.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}%
  }%
}

Üreyen

Bazı çevrimiçi LaTeX derleyicileri var, bir liste burada bulunabilir . Listedeki ilk öğeyi sciencesoft.at üzerinde LaTeX sunucu uygulamasını denedim . İmzalamadan kullanılabilir ve kalıcı URL'ler de oluşturabilir: resim olarak kaynak ve sonuç .

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

Zeki gözlemci, bu sıralama algoritmasının O (n) zamanında basamak sayısı üzerinde çalıştığını not edecektir n.

Pragmatik gözlemci, bu sıralama algoritmasının zaman içinde platformdaki işaretli tamsayılarla orantılı olarak çalıştığını, çalışmalar arasında yeniden başlatılması gereken küresel durumu değiştirdiğini ve kısaca lehine başka birçok fedakarlık yapıldığını not edecektir.

Çözülmemiş versiyon tam olarak eşdeğer değildir, ancak gerçek algoritmayı daha iyi taşır.

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

İşlev için bir test bandı:

#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 karakter, dizi yok, dize yok, tamsayı sınırı yok, tersine çeviremez

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

Örnekler:

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

Bu, doğrudan tamsayıların kendileri üzerinde gerçekleştirilen ekleme sıralamasıdır. Bu, kabarcık sıralaması olan diğer Haskell girişine benzer, yemin ederim ki bunu görmeden önce üzerinde çalışıyordum.

Kısa kılavuz:

• dbir sayıyı birimlere ve onlarca böler, yani: d 135çift(13,5)
• a%xasayıya rakamın eklenmesix
• a&xxbirim hanesini girerek sıralara ve sonuç ve geri kalan kısmının recursing
• s x&0 üzerinde özyinelemeyi başlatarak x'i sıralar vex

Hile ikinci argüman olduğunu %ve &değil xdoğrudan, ama xdivMod'd kullanarakd

Python3.3 61 puan

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

Bu program, girdiyi hemen bir tamsayıya değiştirilmediği için dize olarak sayan bir dize olarak alır. 10

Dize, +10 dizisine ayrılır

Bu dizi +10 dizesine birleştirilir

Not:'' Dizinin içeriğini katılmak için kullanılan bu yüzden 10 puan eklenmez, çoklu karakter dizesi değil.

Program 31 karakterden oluşmaktadır. 31

31 + 10 + 10 + 10 = 61 puan

J, 10 karakter (+ 1 dize) puanı = 20

s=./:~&.":

Kullanımı:

   s 52146729
12245679

Tüm 32 bit sayılar için çalışır.

Açıklama:

/:~yukarı sıralamak &.altında ":formatında. Önceki sürümüm de bir dizi kullandı, ancak pahalılar, bu yüzden şimdi sadece bir dize kullanmam ve karakterleri alfabetik olarak sıralamam gerekiyor. ":girilen sayıyı bir dizgiye dönüştürür ve /:~basamakları artan düzende sıralar. Sıralama 'altında' biçiminde yapıldığından, sıralama bittiğinde, dize bir sayıya dönüştürülür. Geri çevirme yeteneğini eklemek muhtemelen tasarruf ettiğinden daha pahalıya mal olacak, bu yüzden rahatsız etmedim.

Argüman, J, APL ve K gibi, dizi tabanlı bir dil olduğu için, tek girişin 1 öğeden oluşan bir dizi olduğu, ancak puanımı hesaplarken böyle sert bir görünüm almamayı seçtiğimde yapılabilir.

32-bit sınırı, programımdan ziyade J tarafından uygulanır. Herhangi bir yüksek ve J sayıları bilimsel gösterime geçirir. Bu durumda 32 puanlık cezanın geçerli olup olmadığı sorusu net değildir, ancak önceki cezaların her ikisi de geçerli olsa bile (yapmaları gerektiğini düşünmüyorum) puan 72'ye kadar yükselir ve hala diğerinin büyük çoğunluğunu rahatça yener. Yanıtlar.

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

• Dizi yok (bunun yerine yineleyiciler ve sözlük kullanılıyor)
• Çok karakterli dizeler yok (çıktı hariç)
• Yapay maksimum basamak sayısı yok
• Geri dönüş yok

Tüm 10 basamağı 0 ile eşleştirerek bir sözlük oluşturarak çalışır. Daha sonra sayının uzunluğu ( log10(i)) üzerinde yinelenir , her bir basamağı ( (i / (10 ** c)) % 10) çıkarır ve sözlükteki o basamağın sayacını artırır. Son olarak, 10 basamağın tamamını yineleyerek yapılan bir dize oluşturur ve her basamak için basamağın bir örneğini dize olarak verir.

Son satırı print"".join(d[n]*str(n)for n in xrange(10))16 karakter daha az değiştirebilirdim, ancak çok karakterli dizeler kullanırdım.

C (C90'a kadar) veya C ++, 78 66 puan

Böylece tamsayı sırala işlevi çağrılır 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;}

puanlama:

• 66 Karakter (+66)
• 0 diziler (+0)
• 0 dize (+0)
• Makine tarafından tanımlanan aralık (boyutu int) (+0)
• Sadece bir sıralama yönü (-0)

Eski sürüm (78 puan, C ++ ve daha modern C sürümleriyle de çalışır)

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

Ölçek

Normal:

app.exe 52313698

ters:

app.exe 52313698-

Puanlar: (Umarım puan sistemini doğru bir şekilde anladım - düzeltmekten çekinmeyin)

• Karakterler: 149
• Dizeler: 10 + 10
• Diziler: +20
• Sipariş: -10
• Toplam: 149 + 10 + 20-10 = 179

LINQPAD ile C # - 123

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

Ölçek

Normal:

lprun.exe sorta.linq 52313698

ters:

lprun.exe sorta.linq 52313698-

Puanlar:

• Karakterler: 122
• Dizeler: 10 + 10
• Diziler: +20
• Sipariş: -10
• Toplam: 122 + 10 + 20-10 = 152

Java 1469

Java'da dize ve dizi içermeyen bir çözüm. 1437 karakter + 32, çünkü giriş olarak yalnızca Long.MAX_VALUE kadar sürer. Double kullanarak 300'den fazla basamağa gidebilirim ama bu çok fazla yorucu olurdu. Bundan daha büyük herhangi bir şey, dahili olarak dizileri kullanan BigInteger ve AFAIK'e ihtiyaç duyar. Giriş için 19'dan az basamak kullanırsanız, çıkışın başında sıfır olur. Negatif girdi tüm sıfırları verir ve sayı olmayan her şey bir istisnaya neden olur.

Sıralayabildiğim kadar kolay kullanabildiğim için oldukça verimsiz. (O (n * n) olmalıdır)

input:  9212458743185751943
output: 1112233444555778899

Bunun diğer dillerdeki çözümlerle gerçekten karşılaştırılmadığını biliyorum, ancak bunun en azından Java'da alabileceğim en kısa şey olduğunu hissediyorum. (eğer kimse bunu daha da kısaltacağını biliyorsa, düzenleme / yorum yapmaktan çekinmeyin)

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

'X' dosyası:

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}

Koşmak:

$ 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

Kullanılan tek dizi ARGV'dir ve bu sıralamada yardımcı değildir, sadece komut satırı parametrelerine erişimdir ve bu değerler aslında hesaplamalar için gerekli olan dizi dışı değişkenlerde bulunur. Bence bu, bu çözüme sayılmaz. Aşağıdaki hesaplama ARGV dizisini dikkate almaz:

111 (karakter) - 10 (tersine çevirebilir)

Sorudaki işlevleri sıralamakla ilgili bir şey görmüyorum, bu yüzden ...

JavaScript 56 96

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

JavaScript 69 109 (ters çevrilebilir)

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

EcmaScript 6 ok işlevleri kullanılarak biraz golf oynayabilir :

ES6 50 90

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

ES6 63 103 (tersinir) (73-10)

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

SED 67 Karakterleri (67 veya 107 puanı)

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

Bu kısalık için bir kabarcık tür kullanır. Her normal ifade modeli ve değiştirme bir dize olarak sayılırsa puan 107 olur (yani 67 + (10 * 4))

Bellek ile sınırlı işlenen basamak sayısı (ve muhtemelen sabır)

Python lambda fonksiyonu (tersinir), 69

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

• 39 karakter (+39)
• İki çoklu karakter dizisi: n(giriş) ve''.join(...) (+20)
• Bir liste: sorted(...) (+20)
• Parametreye bağlı olarak yönü tersine çevirebilir d (-10)

Python lambda fonksiyonu (geri çevrilemez), 67

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

EDIT: Giriş bir dize olmalıdır. Bu dizeyi doğrudan kullanmanın cezasını düşünüyorum.

Yaygın 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))))

Çözülmemiş (stilistik ve aynı zamanda sözlüksel, fakat işlevsel olarak aynı) versiyon:

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

Negatif bir sayının rakamları negatif değere sahip olarak kabul edilir ve rakamlar en az anlamlı-önce sıralanır (yani, küçük endian). Örnekler:

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

Golflü versiyonda boşluk da dahil olmak üzere 136 karakter vardır. Dizeler ve diziler kullanmaz ve negatif tamsayılar da dahil olmak üzere keyfi tamsayıları işler. Sıralama içinde tamsayılar üzerinde toplam sipariş tanımlayan bir ikili yüklem üzerinde parametre belirlenmiştir [-9, 9]dahil ancak bunlarla sınırlı olmamak üzere <ve >:

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

Bu 126 puan verir.

JavaScript 416/185

Diziler Yok, Dizeler Yok, Keyfi Uzunluk Kısıtlaması Yok ...

Ancak yukarı / aşağı sıralama 10'dan fazla karakter kullanacaktı ^ ^ Ama rakamları sayma ve onları ilginç bir şekilde basma fikrini buldum - belki birisi bu fikri GolfScript'te kullanabilir ve ödülü kazanabilir ;-)

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

Eval kullanarak aynı kod daha kısa: (ama muhtemelen dizeleri kullanarak düşünülecektir ...)

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

Puanlar:

• 192 (192 Karakter)
• 40 (2 Dizi: argv (v) ve a)
• 0 (çoklu karakter dizisi yok)
• 0 (n basamakla sınırlı değildir)

• -10 (sayı (argv [1]) negatifse tersi sıralar)

  = 222 Puan

1000 derleyici uyarısından kurtulmak için gereken işaretler: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"Daha iyi" okunabilir:

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

Biraz soluksuz:

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

Bu çözümü görmememin bir nedeni var mı?

Yakut

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

Bunu nasıl puanlayacağından emin değilim. Bölünme bir dizi oluşturur, ancak bunun ötesinde emin değilim .. Diziler için 38 karakter + 2x20? Yoksa, dahili olarak yaratabilecek tüm dizileri içermeli mi?

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

Dize kullanımı için 66 karakter + 10 n
( x karakterini döndüren replaceişlev ve stringişlev kullanımının fazladan bir dize olarak sayıldığını bilmiyorum ).

Orijinal dizenin uzunluğunu, aynı dizeyle değiştirilen belirli bir rakamla karşılaştırarak belirli bir basamak miktarını sayar. Sonra n'ye bu miktarda rakam ekler.

Python 3 pijama (168)

Hiçbir liste veya döngü olmadan, sadece jeneratörler.

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

muhtemelen geliştirilebilir.

Raket 97

97 puan (iki dize için 87 +20, sıralama için -10, diziler yok)

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

Bu, karakter listelerini kullanır, böylece ona bir char karşılaştırma işlevi vermeniz gerekir. char<? veyachar>? . Bunun boşluksuz olarak da geçtiğini hissediyorum çünkü boşluk eklemek ve değişken adlarını artırmaktan başka bir şey yapmıyor. Eski sürümüm belki daha şerefli :)

Dizesiz eski sürüm:

110 puan (120 bayt (utf-8) - 10, sıralama düzenini değiştirmeye izin vermek için. Dizgisiz ve dizi kullanmaz)

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

100.000'inci fibonacci numarasıyla test ettim:

(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

Ve aynı şey ters sırada:

(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