Lấy cảm hứng từ cách sắp xếp không hợp lệ-số-chữ số-chữ số mà không sử dụng một mảng , nhưng tôi nghĩ rằng nó đã tạo ra một golf mã tốt hơn câu hỏi SO.

Cho một số nguyên dương, sắp xếp các chữ số trong số nguyên đó.

Điểm số thấp nhất chiến thắng!

1. Bắt đầu với 0 điểm.
2. Thêm một điểm cho mỗi nhân vật.
3. Thêm 20 điểm cho mỗi mảng bạn sử dụng.
4. Thêm 10 điểm cho mỗi chuỗi nhiều ký tự trong mã của bạn. (Ngoại trừ đầu vào ban đầu miễn là nó được chuyển đổi thành một số nguyên mà không có bất kỳ thao tác nào khác được thực hiện trên nó.)
5. Thêm 32 điểm nếu số chữ số tối đa mà chương trình của bạn có thể xử lý bị giới hạn bởi chương trình của bạn (trái ngược với máy).
6. Trừ 10 điểm nếu mã của bạn có thể thay đổi hướng sắp xếp đưa ra một đối số khác (bất cứ điều gì bạn muốn, nhưng ví dụ 0 cho sắp xếp giảm dần và 1 cho tăng dần.)

Mỗi ngôn ngữ là khác nhau, nhưng ý tưởng là để tránh bất kỳ loại tin tặc lặp đi lặp lại nào.

Thí dụ:

Đầu vào : 52146729

Đầu ra : 97654221 hoặc 12245679

Ghi chú:

1. Sử dụng bất kỳ khả năng sắp xếp tích hợp nào mà ngôn ngữ lập trình của bạn cung cấp, nhưng nếu tính năng sắp xếp đó liên quan đến chuỗi hoặc mảng, hãy chịu phạt!
2. Bạn có thể viết giải pháp dưới dạng một hàm lấy một số nguyên trực tiếp hoặc như một chương trình lấy một đối số từ argv, một tệp hoặc luồng và chuyển đổi nó thành một số nguyên. Miễn là bạn chuyển đổi nó thành một số nguyên ngay lập tức và loại bỏ đầu vào char * ban đầu mà không thực hiện thêm bất kỳ thao tác nào trên nó, không áp dụng hình phạt nào.
3. Các hình phạt không chỉ áp dụng cho chuỗi ký tự trong văn bản chương trình của bạn, mà bất kỳ phần nào trong tính năng chương trình của bạn được cho là đầu vào hoặc đầu ra một chuỗi hoặc lặp lại. Ví dụ: JavaScript String.prototype.splitcó ít nhất một chuỗi là input ( this) và Array là đầu ra, vì vậy +30 để sử dụng chuỗi đó.
4. Tôi đã cố gắng thực hiện các quy tắc này hướng dẫn nguyên tắc thiết kế thuật toán, chứ không phải I / O ban đầu / cuối cùng (do đó lưu ý # 2). Tôi không nghĩ rằng hình phạt nên áp dụng cho int(input())ngay cả khi inputchữ ký của nó nói rằng nó trả về một chuỗi, miễn là biểu thức đó là điểm vào ban đầu của chương trình. Tương tự, nếu đầu ra cuối cùng của chương trình là print(x)và xphải là một chuỗi, hình phạt sẽ không áp dụng cho hoạt động đúc chuỗi cuối mương. Tất cả những gì đã nói, tôi rõ ràng không bao giờ nói rằng đây phải là một chương trình hoặc nơi mà I / O phải đến hoặc đi. Một chức năng nhận intvà trả về intsẽ phục vụ và sẽ không phải chịu những sự mơ hồ này.

GolfScript, 11 4

(4 + 10 (chuỗi) - 10 (tùy chọn đảo ngược))

Đầu vào trên STDIN.

~`$%

Định dạng đầu vào là đây:

(1 or -1) (the number)

1để sắp xếp bình thường, -1để đảo ngược. 4 ký tự - 10 cho tùy chọn đảo ngược = điểm -6.

Đầu vào về mặt kỹ thuật là một chuỗi, vì vậy tôi không chắc liệu nó có được tính cho +10 hay không. Tôi đang diễn giải quy tắc là "một chuỗi được khai báo trong chương trình của bạn" (vì nó nói "trong mã của bạn").

Câu trả lời cũ (điểm 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}

thí dụ:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

Một câu trả lời không né tránh câu hỏi.

Một lời giải thích đã được yêu cầu, ở đây nó là vô căn cứ. Đó là một loại bong bóng rất không hiệu quả.

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

Câu trả lời ngắn hơn tồn tại trong Haskell, tương đương với một số câu hỏi khác được đăng, ví dụ:

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

... Điểm 52 + 20 = 72 hoặc điểm này, đạt 45 + 20 = 65:

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

... nhưng tinh thần của câu hỏi - không có mảng, chuỗi hoặc ký tự - thú vị hơn.

Lắp ráp C + x86, 636

Tôi biết điều này sẽ không chiến thắng nhưng nó cảm thấy rất không tự nhiên và vặn vẹo đến mức tôi phải chia sẻ nó. Không có mảng hoặc chuỗi (miễn là bạn không đếm các đối số đầu vào). Số chữ số được giới hạn bởi phạm vi 32 bit.

Vì vậy, đây là một lời giải thích nhỏ về những gì tôi đã làm:

Tôi nghĩ rằng tôi sẽ làm điều này mà không sử dụng bất kỳ mảng hoặc chuỗi nào, và sau đó đệ quy xuất hiện trong tâm trí, nhưng tất nhiên, với đệ quy tôi sẽ không thể trao đổi giá trị từ các cuộc gọi đệ quy khác ... và sau đó là khi tôi nhận ra rằng có một cách Liên kết chương trình C của tôi với chức năng lắp ráp Tôi có thể nhảy lên trong ngăn xếp và trả về một con trỏ tới con trỏ cơ sở của cuộc gọi mong muốn, đó là chức năng "recursionStackAt". Tất nhiên recursionStackAt là một hàm rất xấu, kết quả của nó không chỉ phụ thuộc vào trạng thái đầu vào hoặc chương trình mà phụ thuộc vào chính người gọi. Lưu ý rằng đó là những gì khiến tôi thay đổi các chỉ mục từ 0 dựa trên 1 dựa.

Nếu không có thêm rắc rối, đây là mã:

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

Và dĩ nhiên, mã lắp ráp x86 (AT & T sintax, btw) cho hàm 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

Một số ví dụ về đầu ra: (1 có nghĩa là tăng và 0 giảm)

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

Đây là phiên bản bị xáo trộn (không thể đọc được nhưng hoạt động tốt):

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

Vì vậy, nếu LibreOffice không nói dối mã bị xáo trộn của tôi bao gồm 646 ký tự (không có dấu cách, tôi có nên đếm chúng không?) Và với tất cả các điều kiện khác được đáp ứng, tôi nhận được -10 cho lựa chọn giảm / giảm.

Ồ, và để biên dịch cái này bạn nên làm (Trên các hệ thống giống Unix)

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

Lưu ý rằng cờ -m32 chỉ khi bạn sử dụng máy 64 bit. Bạn cũng cần các thư viện 32 bit để biên dịch nó.

Bash (tiếng vang) (0 + 7 + 0 + 0 + 32-10) = 29

Sắp xếp

echo $*

Sử dụng:

sorta 5
5

Sử dụng "-e" để sắp xếp ngược lại:

sorta -e 3
3

• tạo kết quả chính xác cho các số nguyên dương 1-9, cộng với 0
• tránh mọi loại tin tặc có thể lặp lại.
• 7 ký tự (+7)
• không có mảng
• không có chuỗi nhiều ký tự
• số chữ số tối đa có thể xử lý: 1 (+32)
• có thể tùy ý đảo ngược sắp xếp (-10)

EDIT: đã thay đổi "cat" thành "echo" để nó thực sự hoạt động. EDIT 2: Đã thêm "$ *" và đặt nó vào tập lệnh "sorta"

Python3

Tính năng kịch bản của tôi:

Không có mảng

Không có chuỗi

Độ phức tạp là O (n): Tôi đã sử dụng Countingsort (được sửa đổi bởi tôi để không sử dụng mảng, nhưng số nguyên tố để đếm số lần xuất hiện)

Không giới hạn về kích thước

Nhân vật: 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 ký tự - 10 cho đảo ngược)

Tôi nghĩ rằng điều này có thể sẽ bẻ cong các quy tắc một chút, nhưng đến đây, thứ Sáu của nó ...

Tôi cho rằng sử dụng các thư viện tiêu chuẩn được cho phép. Giải thích của tôi về thư viện tiêu chuẩn cho bashlà coreutils:

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

• Không có mảng - luồng được sử dụng thay thế
• Không có dấu ngoặc kép == không có chuỗi nhiều ký tự
• Không giới hạn chiều dài đầu vào / đầu ra
• tùy chọn arg "-r" đảo ngược đầu ra.

Đầu vào từ stdin. Đang sử dụng:

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

C - 64 ký tự, 64 điểm

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

Bạn có thể tự hỏi làm thế nào tôi có thể làm việc này mà không có bất kỳ tiêu đề. Đơn giản, biên dịch với:

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

Chưa chơi gôn:

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

Tôi cũng quyết định bao gồm việc sắp xếp các nhân vật, chỉ vì tôi có thể.

Chạy thử:

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

Hàm c (vòm nhỏ cuối), 131 108 ký tự

Không có thử thách sắp xếp nào được hoàn thành mà không có câu trả lời ngủ . Cái này sẽ mất tới 10 giây để quay lại, nhưng nó hoạt động và tôi nghĩ nó hoàn toàn nằm trong thông số kỹ thuật. Hàm này lấy một tham số int duy nhất và trả về một int với các chữ số thập phân được sắp xếp:

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

_{dòng mới và thụt lề được thêm vào để dễ đọc}

Gọi như sau:

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

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

Java: 262 điểm

Vâng, vâng tôi biết, nó vô vọng, nhưng vẫn ..

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

Phân tích (đánh dấu):

1. Bắt đầu bằng 0. (điểm = 0)
2. Tổng cộng có 262 ký tự. (điểm = 0 + 262 = 262)
3. +10 - để sử dụng StringBuffer(Tôi đã sử dụng nó vì nó ngắn hơn StringBuilder) (điểm = 262 + 10 = 272)
4. -10 - để làm cho đầu ra linh hoạt. Tôi đã xem xét 0 = giảm dần , 1 = tăng dần , vì vậy hãy quay lại mức 262!

Sử dụng:

Khi bạn thử và biên dịch G.javatệp trong dấu nhắc lệnh, nó sẽ tạo ra rất nhiều vấn đề (lỗi). Vậy, giải pháp nào?

Biên dịch G.javalớp trong một IDE như NetBeanshoặc Eclipsehoặc thậm chí BlueJ. Nó sẽ biên dịch mà không gặp rắc rối nào (bỏ qua mọi cảnh báo).

Sau đó, lớp này được gọi bằng một main()phương thức từ bất kỳ lớp nào khác (hoặc thậm chí chính lớp đó). Tôi đang đặt nó vào một lớp khác, vì vậy tôi không thêm nó vào số lượng nhân vật của mình. Biên dịch lớp khác theo cách tương tự (không sử dụng cmd). Bây giờ main()phương thức trong lớp khác sẽ là một cái gì đó như:

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

Không bao gồm các khoảng trắng, bình luận và ngắt dòng không cần thiết, đó là 93 ký tự khác. Tôi không thêm nó vào nhân vật của mình vì đây chỉ là để trình diễn thông qua bảng điều khiển.

Đầu ra:

ZERO tức 0là được xem xét. Giả sử lớp bên ngoài là Helper.javavà nó đã được biên dịch thành công, một vài ví dụ thông qua bảng điều khiển là:

INPUT :C: ...> Trình trợ giúp java 008321
OUTPUT:001238

INPUT :C: ...> Trình trợ giúp java 79359105
OUTPUT:01355799

Khi thay đổi thành 0tức là giảm dần ...

INPUT :C: ...> Trình trợ giúp java 008321
OUTPUT:832100

INPUT :C: ...> Trình trợ giúp java 79359105
OUTPUT:99755 310

GHI CHÚ:

1. Tôi đã không tuyên bố rõ ràng bất kỳ mảng trong G.java. Đó là lớp học cốt lõi .
2. Tôi đang sử dụng sắp xếp chèn để sắp xếp chữ số.
3. Số có thể có độ dài tối đa - Integer.MAX_VALUEbởi vì đó là kích thước tối đa mà bất kỳ mảng nào có thể giữ (trong Java).
4. Câu trả lời này có thể được rút ngắn (tôi tin) vì vậy hãy giúp tôi (cải thiện câu trả lời đầu tiên của tôi).
5. Các vị thần vĩ đại đã vô tình tạo ra một ngôn ngữ dài nhưng tuyệt vời như Java (và cũng là người đã đưa ra các quy ước về mã)!

TeX / LaTeX (332)

Nếu mã thực tế được đặt trong một gói s, thì tệp LaTeX chính trông đẹp và dễ dàng. Con số chỉ được đưa ra như toán học. Nếu số âm, thứ tự sắp xếp bị đảo ngược. Mã của gói scũng có thể được sử dụng với TeX đơn giản, ví dụ bên dưới.

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

Góis (một dòng, kết thúc dòng là không cần thiết):

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

Kết quả:

Điểm: vô vọng

• Sử dụng TeX đơn giản với etexhoặc pdftex, tệp có thể được giảm xuống:

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

  Byte: 318 byte ( s.sty) + 24 byte cho phần còn lại không có số

• Mảng không được sử dụng: 0

• Tôi không thấy chuỗi nhiều ký tự: 0

• Số lượng không bị giới hạn bởi thuật toán. Số TeX lớn nhất là 2 ³¹ - 1 = 2147483647. Ví dụ sử dụng số 66 chữ số, lớn hơn: 0

• Nếu một điểm trừ được đưa ra, thì thứ tự sắp xếp được hoàn nguyên về mức giảm dần: 10

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

Thuật toán:

Các chữ số được thực hiện các ký tự hoạt động trong chế độ toán học. Mỗi chữ số ghi nhớ và thu thập mỗi tập quán trong một macro. Sau chế độ toán học, các macro được xuất ra với các chữ số theo thứ tự tăng dần.

Việc thay đổi hướng được thực hiện bằng văn bản từ phải sang trái, một tính năng e-TeX.

Phiên bản khử mã của mã trongs.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}%
  }%
}

Sinh sản

Có một số trình biên dịch LaTeX trực tuyến, một danh sách có thể được tìm thấy ở đây . Tôi đã thử mục đầu tiên trong danh sách, LaTeX servlet trên scaticsoft.at . Nó có thể được sử dụng mà không cần ký và nó cũng có thể tạo các URL vĩnh viễn: nguồn và kết quả dưới dạng hình ảnh .

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

Người quan sát sắc sảo sẽ lưu ý rằng thuật toán sắp xếp này chạy trong thời gian O (n) trên số chữ số trong n.

Người quan sát thực dụng sẽ lưu ý rằng thuật toán sắp xếp này chạy theo thời gian tỷ lệ thuận với phạm vi số nguyên đã ký trên nền tảng, nó biến đổi trạng thái toàn cầu phải được khởi tạo lại giữa các lần chạy và nhiều sự hy sinh khác đã được thực hiện theo hướng ngắn gọn.

Phiên bản không có bản quyền không chính xác tương đương, nhưng tốt hơn là chuyển tải thuật toán thực tế có liên quan.

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

Đây là một khai thác thử nghiệm cho chức năng:

#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 ký tự, không có mảng, không có chuỗi, không có giới hạn số nguyên, không thể đảo ngược

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

Ví dụ:

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

Đây là loại sắp xếp chèn, được thực hiện trực tiếp trên chính số nguyên. Điều này tương tự với mục Haskell khác là sắp xếp bong bóng, mặc dù tôi thề tôi đã làm việc với nó trước khi tôi thấy mục đó.

Hướng dẫn ngắn gọn:

• dchia một số thành đơn vị và hàng chục, nghĩa là: d 135là cặp(13,5)
• a%xđược sắp xếp chèn chữ số avào sốx
• a&xsắp xếp xbằng cách chèn chữ số đơn vị vào avà đệ quy trên kết quả và phần còn lại
• s xsắp xếp x bằng cách khởi động &đệ quy trên 0 vàx

Bí quyết là đối số thứ hai của %và &không xtrực tiếp, nhưng xdivMod'd sử dụngd

Python3.3 61 điểm

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

Chương trình này nhận đầu vào dưới dạng một chuỗi, được tính là một chuỗi vì nó không được thay đổi thành một số nguyên ngay lập tức. +10

Chuỗi được sắp xếp thành một mảng +10

Mảng này được nối với nhau thành một chuỗi +10

Lưu ý: Các ''sử dụng để tham gia các nội dung của mảng không phải là một chuỗi ký tự đa, vì vậy 10 không được thêm vào điểm số.

Chương trình bao gồm 31 nhân vật. +31

31 + 10 + 10 + 10 = 61 điểm

J, 10 ký tự (+ 1 chuỗi) điểm = 20

s=./:~&.":

Sử dụng:

   s 52146729
12245679

Hoạt động cho tất cả các số 32 bit.

Giải trình:

/:~sắp xếp &.theo ":định dạng. Phiên bản trước của tôi cũng sử dụng một mảng, nhưng chúng rất tốn kém vì vậy bây giờ tôi chỉ cần sử dụng một chuỗi và sắp xếp các ký tự theo thứ tự bảng chữ cái. ":chuyển đổi số được nhập thành một chuỗi và /:~sắp xếp các chữ số theo thứ tự tăng dần. Bởi vì việc sắp xếp được thực hiện theo định dạng 'dưới', khi sắp xếp xong, chuỗi được chuyển đổi trở lại thành một số. Thêm khả năng đảo ngược có thể sẽ tốn nhiều tiền hơn tiết kiệm, vì vậy tôi không bận tâm.

Có thể đưa ra lập luận rằng vì J, như APL và K, là ngôn ngữ dựa trên mảng, đầu vào duy nhất là một mảng gồm 1 mục, nhưng tôi đã chọn không xem quan điểm khắc nghiệt như vậy khi tính điểm của mình.

Giới hạn 32 bit được áp đặt bởi J, thay vì chương trình của tôi. Bất kỳ cao hơn và J chuyển các số sang ký hiệu khoa học. Không rõ câu hỏi có áp dụng hình phạt 32 điểm trong trường hợp này hay không, nhưng ngay cả khi cả hai hình phạt trước đó được áp dụng (tôi không nghĩ là họ nên), điểm số lên tới 72 và vẫn thoải mái đánh bại đại đa số người khác câu trả lời.

Con trăn 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]))

• Không có mảng (lặp và từ điển được sử dụng thay thế)
• Không có chuỗi nhiều ký tự (ngoại trừ đầu ra)
• Không có số chữ số tối đa nhân tạo
• Không đảo ngược

Nó hoạt động bằng cách tạo một từ điển ánh xạ tất cả 10 chữ số thành 0. Sau đó, nó lặp lại theo chiều dài của số ( log10(i)), trích xuất từng chữ số ( (i / (10 ** c)) % 10) và tăng bộ đếm cho chữ số đó trong từ điển. Cuối cùng, nó tạo ra một chuỗi được tạo bằng cách lặp trên tất cả 10 chữ số và cho mỗi chữ số mang lại một thể hiện của chữ số là một chuỗi.

Tôi có thể thay đổi dòng cuối cùng print"".join(d[n]*str(n)for n in xrange(10))sẽ ít hơn 16 ký tự, nhưng sẽ sử dụng chuỗi nhiều ký tự.

C (tối đa C90) hoặc C ++, 78 66 điểm

Hàm sắp xếp một số nguyên được gọi 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;}

Ghi điểm:

• 66 ký tự (+66)
• 0 mảng (+0)
• 0 chuỗi (+0)
• Phạm vi được xác định bởi máy (kích thước của int) (+0)
• Chỉ có một hướng sắp xếp (-0)

Phiên bản cũ (78 điểm, cũng hoạt động với C ++ và các phiên bản C hiện đại hơn)

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

Không chơi gôn

using System.Linq;

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

Kiểm tra

Bình thường:

app.exe 52313698

Đảo ngược:

app.exe 52313698-

Điểm: (Tôi hy vọng tôi hiểu đúng hệ thống điểm - hãy thoải mái sửa)

• Chars: 149
• Chuỗi: 10 + 10
• Mảng: +20
• Đặt hàng: -10
• Tổng cộng: 149 + 10 + 20-10 = 179

C # với LINQPAD - 123

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

Kiểm tra

Bình thường:

lprun.exe sorta.linq 52313698

Đảo ngược:

lprun.exe sorta.linq 52313698-

Điểm:

• Chars: 122
• Chuỗi: 10 + 10
• Mảng: +20
• Đặt hàng: -10
• Tổng cộng: 122 + 10 + 20-10 = 152

Java 1469

Một giải pháp chuỗi và mảng miễn phí trong Java. 1437 ký tự + 32 vì chỉ mất tối đa Long.MAX_VALUE làm đầu vào. Thay vào đó, bằng cách sử dụng Double, tôi có thể chuyển đến hơn 300 chữ số nhưng điều đó sẽ quá tẻ nhạt để thực hiện. Bất cứ điều gì lớn hơn thế sẽ cần BigInteger và AFAIK sử dụng mảng bên trong. Nếu bạn sử dụng ít hơn 19 chữ số cho đầu vào, đầu ra sẽ có các số 0 đứng đầu. Đầu vào tiêu cực sẽ cung cấp cho tất cả các số 0 và bất cứ thứ gì không phải là số sẽ gây ra ngoại lệ.

Đối với loại tôi đã sử dụng dễ dàng nhất tôi có thể nghĩ vì vậy nó khá kém hiệu quả. (nên là O (n * n))

input:  9212458743185751943
output: 1112233444555778899

Tôi biết điều này không thực sự so sánh với các giải pháp trong các ngôn ngữ khác nhưng tôi cảm thấy ít nhất đây là giải pháp ngắn nhất tôi có thể có được trong Java. (nếu bất cứ ai biết làm thế nào để có được điều này thậm chí ngắn hơn, vui lòng chỉnh sửa / nhận xét)

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

Tệp '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}

Việc chạy:

$ 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

Mảng duy nhất được sử dụng là ARGV và điều này không giúp ích gì trong việc sắp xếp, nó chỉ là quyền truy cập vào các tham số dòng lệnh và các giá trị này nằm trong các biến không phải là mảng thực sự cần thiết cho việc tính toán. Tôi nghĩ rằng điều này sẽ không được tính vào giải pháp này. Tính toán sau không đưa mảng ARGV vào tài khoản:

111 (ký tự) - 10 (có thể làm ngược lại)

Tôi không thấy bất cứ điều gì về cách sắp xếp các chức năng trong câu hỏi, vì vậy ... (Tôi sẽ xóa câu trả lời nếu nó bẻ cong hoặc phá vỡ các quy tắc, cho tôi biết)

JavaScript 56 96

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

JavaScript 69 109 (có thể đảo ngược)

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

Có thể đánh gôn xuống một chút bằng các hàm mũi tên EcmaScript 6 :

ES6 50 90

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

ES6 63 103 (có thể đảo ngược) (73-10)

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

SED 67 Chars (điểm 67 hoặc 107)

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

Điều này sử dụng một loại bong bóng cho ngắn gọn. Điểm sẽ là 107 nếu mỗi mẫu biểu thức chính quy và số thay thế được tính là một chuỗi (tức là 67 + (10 * 4))

Số chữ số được xử lý giới hạn bởi bộ nhớ (và có lẽ là sự kiên nhẫn)

Hàm lambda Python (có thể đảo ngược), 69

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

• 39 ký tự (+39)
• Hai chuỗi nhiều char: n(đầu vào) và ''.join(...) (+20)
• Một danh sách: sorted(...) (+20)
• Có thể đảo ngược hướng tùy thuộc vào tham số d (-10)

Hàm lambda Python (không thể đảo ngược), 67

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

EDIT: Đầu vào phải là một chuỗi. Tôi đang xem xét hình phạt của việc sử dụng chuỗi đó trực tiếp.

Lisp thường gặp - 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))))

Phiên bản không được chỉnh sửa (theo kiểu cách cũng như từ vựng, nhưng giống nhau về chức năng):

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

Các chữ số của một số âm được coi là có giá trị âm và các chữ số được sắp xếp ít nhất có ý nghĩa đầu tiên (nghĩa là đầu cuối nhỏ). Ví dụ:

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

Có 136 ký tự trong phiên bản golf, bao gồm cả khoảng trắng. Nó sử dụng không có chuỗi và không có mảng và xử lý các số nguyên có độ chính xác tùy ý, bao gồm các số nguyên âm. Việc sắp xếp được tham số hóa trên một vị từ nhị phân xác định tổng thứ tự trên các số nguyên trong [-9, 9], bao gồm nhưng không giới hạn ở <và >:

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

Điều này cho điểm 126.

JavaScript 416/185

Không mảng, không chuỗi, không ràng buộc độ dài tùy ý ...

Nhưng việc sắp xếp lên / xuống sẽ sử dụng hơn 10 ký tự ^^ Nhưng tôi thấy ý tưởng đếm chữ số và in chúng thú vị - có lẽ ai đó có thể sử dụng ý tưởng này trong GolfScript và giành giải thưởng ;-)

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

Cùng một mã ngắn hơn, sử dụng eval: (nhưng điều đó có thể sẽ được xem xét bằng cách sử dụng chuỗi ...)

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

Điểm:

• 192 (192 ký tự)
• 40 (2 Mảng: argv (v) và a)
• 0 (không có nhiều chuỗi char)
• 0 (không giới hạn ở n chữ số)

• -10 (sắp xếp ngược lại nếu số (argv [1]) âm)

  = 222 điểm

Cờ cần thiết để thoát khỏi 1000 cảnh báo trình biên dịch: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"Tốt hơn" có thể đọc được:

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

Hơi vô dụng:

static int a[10],r=1;
o(n,c){
    while(n--) printf("%""i",c);
}
p(){
    int n;
    for(n=r<0?9:0;n>=0&&n<10;n+=r) o(a[n],n);
}
main(int _,char**v){
    char*s=v[1];
    if(*s=='-'){
        r=-1;
        ++s;
    }
    do ++a[*s-'0']; while(*++s);
    p();
}

Có một lý do tôi không thấy giải pháp này đã?

Hồng ngọc

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

Tôi không chắc làm thế nào để ghi điểm này. Sự phân chia sẽ tạo ra một mảng, nhưng ngoài điều đó không chắc chắn .. 38 ký tự + 2x20 cho các mảng? Hoặc nó nên bao gồm tất cả các mảng sắp xếp có thể tạo ra bên trong?

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 ký tự + 10 cho việc sử dụng chuỗi n
(Không biết việc sử dụng replacehàm và stringhàm trả về n lượng ký tự x có được tính là một chuỗi bổ sung không).

Nó đếm số lượng của một chữ số nhất định bằng cách so sánh độ dài của chuỗi gốc với cùng một chuỗi với chữ số nhất định được thay thế. Sau đó, nó gắn số lượng chữ số đó vào n.

Python 3 ngủ (168)

Hoàn toàn không có danh sách hoặc vòng lặp, chỉ có máy phát điện.

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

có lẽ có thể được cải thiện.

Vợt 97

97 điểm (87 +20 cho hai chuỗi, -10 cho sắp xếp, không có mảng)

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

Cái này sử dụng danh sách các ký tự, vì vậy bạn cần cung cấp cho nó một hàm so sánh char như char<?hoặc char>?. Tôi cảm thấy điều này cũng trôi qua như không có ý nghĩa vì nó không phải làm gì nhiều ngoài việc thêm khoảng trắng và tăng tên biến. Phiên bản cũ của tôi có lẽ vinh dự hơn :)

Phiên bản cũ không có chuỗi:

110 điểm (120 byte (utf-8) - 10 để cho phép thay đổi thứ tự sắp xếp. Nó không sử dụng chuỗi và không có mảng)

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

Ung dung:

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

Tôi đã thử nó với số thứ 100.000 của Wikipedia:

(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

Và tương tự theo thứ tự ngược lại:

(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