แรงบันดาลใจจากการเรียงลำดับตัวเลขที่ไม่ดีโชคไม่ดีโดยใช้อาเรย์ แต่ฉันคิดว่ามันสร้างรหัสกอล์ฟที่ดีกว่าคำถาม SO

กำหนดจำนวนเต็มบวกให้เรียงตัวเลขในจำนวนเต็มนั้น

คะแนนต่ำสุดชนะ!

1. เริ่มต้นด้วย 0 คะแนน
2. เพิ่มหนึ่งจุดต่อตัวละคร
3. เพิ่ม 20 คะแนนสำหรับแต่ละอาร์เรย์ที่คุณใช้
4. เพิ่ม 10 คะแนนสำหรับแต่ละสายอักขระหลายตัวในรหัสของคุณ (ยกเว้นอินพุตเริ่มต้นตราบใดที่มันถูกแปลงเป็นจำนวนเต็มโดยไม่มีการดำเนินการอื่นใดกับมัน)
5. เพิ่ม 32 คะแนนหากจำนวนหลักสูงสุดที่โปรแกรมของคุณสามารถจัดการนั้นถูก จำกัด โดยโปรแกรมของคุณ (ตรงข้ามกับเครื่อง)
6. ลบ 10 คะแนนถ้ารหัสของคุณสามารถเปลี่ยนทิศทางของการเรียงลำดับที่กำหนดอาร์กิวเมนต์อื่น (สิ่งที่คุณต้องการ แต่ตัวอย่างเช่น 0 สำหรับการเรียงจากมากไปน้อยและ 1 สำหรับการเรียงจากมากไปหาน้อย)

ทุกภาษามีความแตกต่างกันไป แต่ความคิดคือการหลีกเลี่ยงการแฮ็กข้อมูลที่เป็นเลขตัวอื่น

ตัวอย่าง:

อินพุต : 52146729

เอาต์พุต : 97654221 หรือ 12245679

หมายเหตุ:

1. ใช้ความสามารถในการเรียงลำดับในภาษาการเขียนโปรแกรมของคุณ แต่ถ้าคุณสมบัติการเรียงนั้นเกี่ยวข้องกับสตริงหรืออาร์เรย์ให้รับโทษ!
2. คุณสามารถเขียนวิธีการแก้ปัญหาเป็นฟังก์ชั่นที่ใช้จำนวนเต็มโดยตรงหรือเป็นโปรแกรมที่ใช้อาร์กิวเมนต์จาก argv, ไฟล์หรือสตรีมและแปลงเป็นจำนวนเต็ม ตราบใดที่คุณแปลงเป็นจำนวนเต็มทันทีและยกเลิกอินพุต char * ต้นฉบับโดยไม่ต้องดำเนินการใด ๆ เพิ่มเติมจะไม่มีการลงโทษ
3. บทลงโทษไม่เพียง แต่จะนำไปใช้กับตัวอักษรสตริงในข้อความโปรแกรมของคุณ แต่ส่วนใดส่วนหนึ่งของคุณสมบัติโปรแกรมของคุณที่ป้อนหรือส่งออกสตริงหรือทำซ้ำได้ ตัวอย่างเช่น JavaScript String.prototype.splitมีสตริงอย่างน้อยหนึ่งรายการเป็นอินพุต ( this) และ Array เป็นเอาต์พุตดังนั้นจึงควรใช้กับ +30
4. ฉันได้พยายามสร้างกฎเหล่านี้เพื่อแนะนำหลักการของการออกแบบอัลกอริทึมไม่ใช่ I / O เริ่มต้น / ขั้นสุดท้าย (หมายเหตุที่ 2) ฉันไม่คิดว่าโทษที่ควรจะนำไปใช้กับint(input())แม้ว่าinputลายเซ็น 's บอกว่ามันจะส่งกลับสตริงตราบใดที่แสดงออกว่าเป็นจุดเริ่มต้นที่เริ่มต้นของโปรแกรม ในทำนองเดียวกันหากผลลัพธ์สุดท้ายของโปรแกรมคือprint(x)และxจะต้องเป็นสตริงการลงโทษไม่ได้นำไปใช้กับการดำเนินการคัดเลือกสตริงสุดท้ายคู ทั้งหมดที่กล่าวมาฉันไม่เคยบอกอย่างชัดเจนว่านี่เป็นโปรแกรมหรือที่ I / O ต้องมาจากหรือไป ฟังก์ชั่นที่รับintและคืนค่าintจะให้บริการและจะไม่ประสบกับความคลุมเครือเหล่านี้

GolfScript, 11 4

(4 + 10 (สตริง) - 10 (ตัวเลือกย้อนกลับ))

อินพุตบน STDIN

~`$%

รูปแบบอินพุตคือ:

(1 or -1) (the number)

1เพื่อจัดเรียงตามปกติ-1เพื่อย้อนกลับ 4 ตัวอักษร - 10 สำหรับตัวเลือกย้อนกลับ = คะแนน -6

อินพุตเป็นสตริงทางเทคนิคดังนั้นฉันไม่แน่ใจว่าจะนับเป็น +10 หรือไม่ ฉันตีความกฎว่า "สตริงที่ประกาศในโปรแกรมของคุณ" (เนื่องจากมีข้อความระบุว่า "ในรหัสของคุณ")

คำตอบเก่า (คะแนน 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}

ตัวอย่าง:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

คำตอบที่ไม่หลบคำถาม

มีการขอคำอธิบายที่นี่เป็นสิ่งที่ไม่ดี มันเป็นการจัดเรียงฟองที่ไม่มีประสิทธิภาพมาก

-- 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 ซึ่งเทียบเท่ากับบางคำตอบที่โพสต์เช่น:

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

... คะแนน 52 + 20 = 72 หรือนี่คะแนน 45 + 20 = 65:

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

... แต่วิญญาณของคำถาม - ไม่มีอาร์เรย์สตริงหรือตัวอักษร - น่าสนใจกว่า

ชุดประกอบ C + x86, 636

ฉันรู้ว่านี่จะไม่ชนะ แต่มันก็รู้สึกผิดธรรมชาติและบิดเบี้ยวมากจนฉันต้องแชร์มัน ไม่มีอาร์เรย์หรือสตริง (ตราบใดที่คุณไม่นับอาร์กิวเมนต์ที่ป้อนเข้า) จำนวนตัวเลขที่ถูก จำกัด โดยช่วง 32 บิต

ดังนั้นนี่คือคำอธิบายเล็กน้อยเกี่ยวกับสิ่งที่ฉันทำ:

ฉันคิดว่าฉันจะทำสิ่งนี้โดยไม่ใช้อาร์เรย์หรือสตริงใด ๆ จากนั้นการเรียกซ้ำจะเกิดขึ้นในใจ แต่แน่นอนว่าด้วยการเรียกซ้ำฉันจะไม่สามารถสลับค่าจากการโทรซ้ำอื่น ๆ ได้ ... แล้วก็เมื่อฉันตระหนักว่า มีวิธีคือ การเชื่อมโยงโปรแกรม C ของฉันกับฟังก์ชั่นการประกอบฉันสามารถกระโดดขึ้นไปในกองซ้อนและส่งกลับตัวชี้ไปยังตัวชี้พื้นฐานของการโทรที่ต้องการนั่นคือสิ่งที่ฟังก์ชั่น "recursionStackAt" ทำ แน่นอน recursionStackAt เป็นฟังก์ชั่นที่น่าเกลียดมากผลลัพธ์ไม่เพียงขึ้นอยู่กับสถานะอินพุตหรือสถานะของโปรแกรม แต่ขึ้นอยู่กับตัวเรียก โปรดทราบว่านั่นคือสิ่งที่ทำให้ฉันเปลี่ยนดัชนีจาก 0 เป็น 1 ตาม

โดยไม่ต้องกังวลใจต่อไปนี้เป็นรหัส:

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

และแน่นอนรหัสการประกอบ x86 (AT&T sintax, btw) สำหรับฟังก์ชัน 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

ตัวอย่างบางส่วนของผลลัพธ์: (1 หมายถึงเพิ่มขึ้นและลดลง 0)

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

นี่คือรุ่นที่สับสน (ซึ่งอ่านไม่ได้ แต่ใช้งานได้ดี):

http://pastebin.com/XkYt9DLy (รหัส C) http://pastebin.com/h0S0dfeU (รหัส x86)

ดังนั้นหาก LibreOffice ไม่ได้วางรหัสที่ยุ่งเหยิงของฉันประกอบด้วย 646 ตัวอักษร (ไม่มีช่องว่างฉันควรนับพวกเขาหรือไม่) และด้วยเงื่อนไขอื่น ๆ ทั้งหมดที่ฉันได้รับ -10 สำหรับตัวเลือกการเพิ่ม / ลด

โอ้และเพื่อรวบรวมสิ่งนี้คุณควรทำ (ในระบบที่เหมือนยูนิกซ์)

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

โปรดทราบว่าแฟล็ก -m32 นั้นต่อเมื่อคุณอยู่บนเครื่อง 64 บิต คุณต้องใช้ไลบรารี 32 บิตในการรวบรวม

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

sorta:

echo $*

การใช้งาน:

sorta 5
5

ใช้ "-e" เพื่อเรียงลำดับย้อนกลับ:

sorta -e 3
3

• สร้างผลลัพธ์ที่ถูกต้องสำหรับจำนวนเต็มบวก 1-9, บวก 0
• หลีกเลี่ยงการแฮ็กเกอร์ที่ทำซ้ำ ๆ ได้ทุกชนิด
• 7 ตัวอักษร (+7)
• ไม่มีอาร์เรย์
• ไม่มีสตริงหลายอักขระ
• จำนวนหลักสูงสุดที่สามารถจัดการได้: 1 (+32)
• สามารถเลือกที่จะย้อนกลับเรียง (-10)

แก้ไข: เปลี่ยน "cat" เป็น "echo" ดังนั้นจึงใช้งานได้จริง แก้ไข 2: เพิ่ม "$ *" และใส่ลงในสคริปต์ "sorta"

Python3

คุณสมบัติสคริปต์ของฉัน:

ไม่มีอาร์เรย์

ไม่มีสาย

ความซับซ้อนคือ O (n):ฉันใช้ countingsort (แก้ไขโดยฉันที่จะไม่ใช้อาร์เรย์ แต่เป็นจำนวนเฉพาะเพื่อนับโอกาส)

ไม่มีข้อ จำกัด ด้านขนาด

ตัวละคร: 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 chars - 10 สำหรับ reverse)

ฉันคิดว่านี่อาจเป็นการดัดกฎนิดหน่อย แต่ต่อไปนี้วันศุกร์ ...

ฉันถือว่าการใช้ไลบรารีมาตรฐานได้รับอนุญาต การตีความของฉันสำหรับห้องสมุดมาตรฐานสำหรับbashคือcoreutils:

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

• ไม่มีอาร์เรย์ - สตรีมถูกใช้แทน
• ไม่มีเครื่องหมายอัญประกาศ == ไม่มีสตริงอักขระหลายตัว
• ไม่จำกัดความยาวของอินพุต / เอาต์พุต
• ตัวเลือกหาเรื่อง "-r" ฝืนเอาท์พุท

ข้อมูลจาก stdin ในการใช้งาน:

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

C - 64 ตัวอักษร 64 คะแนน

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

คุณอาจสงสัยว่าฉันจะทำให้เรื่องนี้ทำงานได้อย่างไรโดยไม่มีส่วนหัว ง่ายรวบรวมด้วย:

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

ยกเลิกแข็งแรงเล่นกอล์ฟ:

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

ฉันยังตัดสินใจที่จะรวมการเรียงลำดับของตัวละครเพียงเพราะฉันทำได้

ทดสอบการทำงาน:

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

ฟังก์ชั่น c (arch-little-endian), 131 108 ตัวอักษร

ความท้าทายในการเรียงลำดับไม่สมบูรณ์หากไม่มีคำตอบsleepsort อันนี้จะใช้เวลาถึง 10 วินาทีในการกลับมา แต่มันใช้งานได้และฉันคิดว่ามันอยู่ในสเป็คอย่างสมบูรณ์ ฟังก์ชั่นนี้ใช้พารามิเตอร์ int เดียวและส่งกลับค่า int ด้วยตัวเลขทศนิยมเรียง:

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

_{เพิ่มการขึ้นบรรทัดใหม่และการเยื้องเพื่อให้อ่านง่าย}

โทรไปที่:

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

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

Java: 262 คะแนน

ใช่ฉันรู้ว่ามันหมดหวัง แต่ก็ยัง ..

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

การวิเคราะห์ (การทำเครื่องหมาย):

1. เริ่มต้นด้วย 0 (คะแนน = 0)
2. ทั้งหมด 262 ตัวอักษร (คะแนน = 0 + 262 = 262)
3. +10 - สำหรับการใช้StringBuffer(ฉันใช้เพราะสั้นกว่าStringBuilder) (คะแนน = 262 + 10 = 272)
4. -10 - เพื่อให้การส่งออกมีความยืดหยุ่น ฉันได้พิจารณา= 0 จากมากไปน้อย , 1 = น้อยไปมากเพื่อให้กลับไปที่ 262!

การใช้งาน:

เมื่อคุณพยายามรวบรวมG.javaไฟล์ใน command prompt มันจะสร้างปัญหามากมาย (ข้อผิดพลาด) ดังนั้นการแก้ปัญหา?

คอมไพล์G.javaชั้นในเช่น IDE NetBeansหรือหรือแม้กระทั่งEclipse BlueJมันควรรวบรวมโดยไม่มีปัญหาใด ๆ (ละเว้นคำเตือนใด ๆ )

จากนั้นคลาสนี้ควรถูกเรียกโดยmain()เมธอดจากคลาสอื่น ๆ (หรือคลาสนั้นเอง) ฉันกำลังเพิ่มคลาสอีกชั้นหนึ่งดังนั้นฉันจึงไม่เพิ่มในจำนวนตัวละครของฉัน คอมไพล์คลาสอื่นในลักษณะที่คล้ายกัน (โดยไม่ใช้cmd) ทีนี้main()วิธีในคลาสอื่นควรเป็นดังนี้:

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

ไม่รวมช่องว่างความคิดเห็นและตัวแบ่งบรรทัดที่ไม่จำเป็นนั้นเป็นตัวอักษรอีก 93 ตัว ฉันไม่ได้เพิ่มลงในตัวละครของฉันเพราะนี่เป็นเพียงการสาธิตผ่านคอนโซล

เอาท์พุท:

ZEROคือ0ถือว่า หากว่าคลาสภายนอกเป็นHelper.javaและได้รับการรวบรวมสำเร็จตัวอย่างผ่านคอนโซลคือ:

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

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

เมื่อเปลี่ยนเป็น0เช่นจากมากไปน้อย ...

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

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

หมายเหตุ:

1. ผมไม่ได้อย่างชัดเจนประกาศอาร์เรย์ใด ๆ G.javaใน นั่นคือแกนกลางระดับ
2. ฉันใช้การเรียงลำดับการแทรกเพื่อเรียงลำดับตัวเลขเป็นหลัก
3. จำนวนสามารถมีความยาวสูงสุด - Integer.MAX_VALUEเนื่องจากเป็นขนาดสูงสุดที่อาเรย์สามารถเก็บได้ (ใน Java)
4. คำตอบนี้สั้นลงได้ (ฉันเชื่อ) ดังนั้นโปรดช่วยฉัน (ปรับปรุงคำตอบแรกของฉัน)
5. คำสาปแช่งเหล่าทวยเทพผู้ยิ่งใหญ่ที่สร้างภาษาที่มีความยาวและยอดเยี่ยมเช่น Java (และผู้ที่คิดรหัสด้วย)

TeX / LaTeX (332)

หากใส่รหัสจริงลงในแพ็คเกจsไฟล์ LaTeX หลักจะดูดีและใช้งานง่าย จำนวนที่ได้รับเป็นเพียงคณิตศาสตร์ ถ้าจำนวนเป็นลบลำดับการเรียงจะถูกกลับรายการ รหัสของแพคเกจsยังสามารถใช้กับ TeX ธรรมดาตัวอย่างเพิ่มเติมด้านล่าง

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

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

แพคเกจs (หนึ่งบรรทัดไม่จำเป็นต้องจบบรรทัด):

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

ผลลัพธ์:

คะแนน:ไร้ความหวัง

• การใช้ TeX แบบธรรมดาด้วยetexหรือpdftexไฟล์สามารถลดเป็น:

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

  ไบต์: 318ไบต์ ( s.sty) + 24ไบต์สำหรับส่วนที่เหลือโดยไม่มีตัวเลข

• ไม่ใช้อาร์เรย์: 0

• ฉันไม่เห็นสตริงอักขระหลายตัว: 0

• จำนวนไม่ จำกัด โดยอัลกอริทึม หมายเลข TeX ที่ใหญ่ที่สุดคือ 2 ³¹ - 1 = 2147483647 ตัวอย่างใช้หมายเลข 66 หลักทางใหญ่กว่า: 0

• หากได้รับการลบแล้วลำดับการจัดเรียงจะถูกเปลี่ยนกลับเป็นจากมากไปน้อย: −10

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

ขั้นตอนวิธีการ:

ตัวเลขถูกสร้างเป็นอักขระที่ใช้งานในโหมดคณิตศาสตร์ ตัวเลขแต่ละตัวจะจดจำและรวบรวมประเพณีแต่ละอย่างในแมโคร หลังจากโหมดคณิตศาสตร์แมโครจะถูกแสดงผลด้วยตัวเลขตามลำดับจากน้อยไปมาก

การเปลี่ยนทิศทางทำได้ด้วยข้อความจากขวาไปซ้ายซึ่งเป็นคุณสมบัติ e-TeX

รหัสเวอร์ชันที่ถูกลดระดับลงแล้วs.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}%
  }%
}

การทำซ้ำ

มีบางคอมไพเลอร์น้ำยางออนไลน์, รายการสามารถพบได้ที่นี่ ฉันพยายามที่รายการแรกในรายการน้ำยางเซิร์ฟเล็ตบน sciencesoft.at มันสามารถนำมาใช้โดยไม่มีการลงนามและมันยังสามารถสร้าง URL ถาวร: แหล่งที่มาและส่งผลให้เกิดเป็นภาพ

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

ผู้สังเกตการณ์ที่ชาญฉลาดจะทราบว่านี้การเรียงลำดับขั้นตอนวิธีการทำงานใน O (n) nเวลาอยู่กับจำนวนของตัวเลขใน

ผู้สังเกตการณ์ในทางปฏิบัติจะสังเกตเห็นว่าอัลกอริธึมการเรียงลำดับนี้ทำงานในเวลาตามสัดส่วนของช่วงจำนวนเต็มที่ลงนามบนแพลตฟอร์มว่ามันจะเปลี่ยนแปลงสถานะโลกซึ่งจะต้องเริ่มต้นใหม่ระหว่างการวิ่งและการเสียสละอื่น ๆ

รุ่นที่ไม่ได้รับการตีกอล์ฟนั้นไม่เทียบเท่าอย่างแน่นอน

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

นี่คือสายรัดทดสอบสำหรับฟังก์ชั่น:

#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 ตัวอักษร, ไม่มีอาร์เรย์, ไม่มีสตริง, ไม่ จำกัด จำนวนเต็ม, ไม่สามารถย้อนกลับได้

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

ตัวอย่าง:

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

อันนี้คือการเรียงลำดับการแทรกดำเนินการโดยตรงกับจำนวนเต็มตัวเอง นี่คล้ายกับรายการ Haskell อื่น ๆ ซึ่งเป็นแบบฟองแม้ว่าฉันสาบานว่าฉันกำลังทำงานอยู่ก่อนที่จะเห็นรายการนั้น

คู่มือสั้น ๆ :

• dหารตัวเลขออกเป็นหน่วยและหลักสิบคือ: d 135เป็นคู่(13,5)
• a%xถูกจัดเรียงการแทรกของตัวเลขaลงในหมายเลขx
• a&xเรียงลำดับxโดยการใส่หน่วยลงในaและเรียกซ้ำในผลลัพธ์และส่วนที่เหลือ
• s xเรียงลำดับ x โดยเริ่มต้นการ&เรียกซ้ำตัวเองในวันที่ 0 และx

เคล็ดลับก็คืออาร์กิวเมนต์ที่สองของ%และ&ไม่ได้xโดยตรง แต่xdivMod จะใช้d

Python3.3 61 คะแนน

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

โปรแกรมนี้ใช้เวลาในการป้อนข้อมูลเป็นสตริงซึ่งนับเป็นสตริงเพราะมันจะไม่เปลี่ยนเป็นจำนวนเต็มทันที +10

สตริงถูกเรียงลำดับเป็นอาร์เรย์+10

อาร์เรย์นี้ถูกรวมเข้าด้วยกันเป็นสตริง+10

หมายเหตุ:การ''ใช้เพื่อเข้าร่วมเนื้อหาของอาร์เรย์ไม่ใช่สตริงอักขระหลายตัวดังนั้นจึงไม่เพิ่มคะแนน +10 ให้กับคะแนน

โปรแกรมประกอบด้วย 31 ตัวอักษร +31

31 + 10 + 10 + 10 = 61 คะแนน

J, 10 ตัวอักษร (+ 1 สตริง) คะแนน = 20

s=./:~&.":

การใช้งาน:

   s 52146729
12245679

ใช้งานได้กับหมายเลข 32 บิตทั้งหมด

คำอธิบาย:

/:~จัดเรียง&.ตาม":รูปแบบ รุ่นก่อนหน้าของฉันใช้อาร์เรย์ด้วยเช่นกัน แต่มันมีค่าใช้จ่ายสูงดังนั้นตอนนี้ฉันต้องใช้สตริงและจัดเรียงอักขระตามตัวอักษร ":แปลงตัวเลขที่ป้อนเข้าในสตริงและ/:~เรียงลำดับตัวเลขตามลำดับจากน้อยไปหามาก เนื่องจากการเรียงลำดับเสร็จแล้ว 'ภายใต้' รูปแบบเมื่อการเรียงลำดับเสร็จสิ้นสตริงจะถูกแปลงกลับเป็นตัวเลข การเพิ่มความสามารถในการย้อนกลับอาจมีค่าใช้จ่ายมากกว่าที่ประหยัดได้ดังนั้นฉันจึงไม่ต้องกังวล

ข้อโต้แย้งอาจเกิดขึ้นได้ตั้งแต่ J เช่น APL และ K เป็นภาษาที่ใช้อาเรย์อินพุตเดี่ยวเป็นอาร์เรย์ของ 1 รายการ แต่ฉันเลือกที่จะไม่ใช้มุมมองที่รุนแรงเช่นนี้เมื่อคำนวณคะแนนของฉัน

J กำหนดขีด จำกัด แบบ 32 บิตไม่ใช่โปรแกรมของฉัน สูงกว่าและ J สลับตัวเลขไปเป็นสัญกรณ์ทางวิทยาศาสตร์ มันไม่ชัดเจนจากคำถามที่ว่าการลงโทษแบบ 32 จุดมีผลในกรณีนี้หรือไม่แม้ว่าจะมีการลงโทษทั้งสองครั้งก่อนหน้านี้ก็ตาม (ฉันไม่คิดว่าควรจะ) คะแนนนั้นสูงถึง 72 และยังคงเต้นได้สะดวกสบาย คำตอบ

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

• ไม่มีอาร์เรย์ (ใช้ตัววนซ้ำและพจนานุกรมแทน)
• ไม่มีสตริงหลายอักขระ (ยกเว้นเอาต์พุต)
• ไม่มีจำนวนหลักสูงสุดเทียม
• ไม่มีการย้อนกลับ

มันทำงานได้โดยการสร้างการแมปพจนานุกรมทั้งหมด 10 หลักถึง 0 จากนั้นมันจะวนซ้ำตามความยาวของตัวเลข ( log10(i)) โดยแยกแต่ละหลัก ((i / (10 ** c)) % 10 ) และการเพิ่มตัวนับสำหรับตัวเลขนั้นในพจนานุกรม ในที่สุดมันจะสร้างสตริงที่ทำโดยวนซ้ำทั้ง 10 หลักและสำหรับแต่ละหลักที่ให้หนึ่งอินสแตนซ์ของตัวเลขเป็นสตริง

ฉันสามารถเปลี่ยนบรรทัดสุดท้ายเป็น print"".join(d[n]*str(n)for n in xrange(10))ซึ่งจะน้อยกว่า 16 ตัวอักษร แต่จะใช้สตริงหลายตัว

C (สูงถึง C90) หรือ C ++ 78 66 คะแนน

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

เกณฑ์การให้คะแนน:

• 66 ตัวละคร (+66)
• 0 อาร์เรย์ (+0)
• 0 สาย (+0)
• ช่วงที่กำหนดโดยเครื่อง (ขนาดของ int ) (+0)
• ทิศทางการเรียงลำดับเดียวเท่านั้น (-0)

เวอร์ชันเก่า (78 คะแนนใช้งานได้กับ C ++ และเวอร์ชัน 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)));}}

ยกเลิกแข็งแรงเล่นกอล์ฟ

using System.Linq;

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

ทดสอบ

ปกติ:

app.exe 52313698

ย้อนกลับ

app.exe 52313698-

คะแนน: (ฉันหวังว่าฉันเข้าใจระบบคะแนนอย่างถูกต้อง - อย่าลังเลที่จะแก้ไข)

• ตัวอักษร: 149
• สตริง: 10 + 10
• อาร์เรย์: +20
• คำสั่งซื้อ: -10
• รวม: 149 + 10 + 20-10 = 179

C # กับLINQPAD - 123

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

ทดสอบ

ปกติ:

lprun.exe sorta.linq 52313698

ย้อนกลับ

lprun.exe sorta.linq 52313698-

คะแนน:

• ตัวอักษร: 122
• สตริง: 10 + 10
• อาร์เรย์: +20
• คำสั่งซื้อ: -10
• รวม: 122 + 10 + 20-10 = 152

Java 1469

โซลูชันฟรีของสตริงและอาร์เรย์ใน Java 1437 ตัวอักษร + 32 เพราะมันใช้เวลานานถึง Long.MAX_VALUE เป็นอินพุต ด้วยการใช้ Double ฉันสามารถไปได้มากกว่า 300 หลักแทน แต่นั่นน่าเบื่อเกินกว่าที่จะใช้งาน อะไรที่ใหญ่กว่านั้นก็ต้องใช้ BigInteger และ AFAIK ที่ใช้อาร์เรย์ภายใน หากคุณใช้น้อยกว่า 19 หลักสำหรับการป้อนข้อมูลเอาท์พุทจะมีศูนย์นำ การป้อนข้อมูลเชิงลบจะให้ศูนย์ทั้งหมดและอะไรที่ไม่ใช่จำนวนจะทำให้เกิดข้อยกเว้น

สำหรับการเรียงลำดับฉันใช้วิธีที่ง่ายที่สุดที่ฉันคิดได้ดังนั้นมันจึงค่อนข้างไร้ประสิทธิภาพ (ควรเป็น O (n * n))

input:  9212458743185751943
output: 1112233444555778899

ฉันรู้ว่านี่ไม่ได้เปรียบเทียบกับโซลูชันในภาษาอื่น ๆ แต่ฉันรู้สึกว่าอย่างน้อยที่สุดก็สั้นที่สุดที่ฉันสามารถหาได้ใน Java (ถ้าใครรู้วิธีทำให้สั้นลงสามารถแก้ไข / คอมเม้นท์ได้)

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':

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}

วิ่ง:

$ 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

อาเรย์เดียวที่ใช้คือ ARGV และนี่ไม่ช่วยในการเรียงลำดับมันเป็นเพียงการเข้าถึงพารามิเตอร์ commandline และค่าเหล่านี้อยู่ในตัวแปรที่ไม่ใช่อาเรย์ที่จำเป็นสำหรับการคำนวณจริง ฉันคิดว่านี่จะไม่นับรวมกับโซลูชันนี้ การคำนวณต่อไปนี้ไม่ได้คำนึงถึงอาร์เรย์ ARGV:

111 (ตัวอักษร) - 10 (สามารถย้อนกลับได้)

ฉันไม่เห็นอะไรเกี่ยวกับฟังก์ชั่นการเรียงลำดับในคำถามดังนั้น ... (ฉันจะลบคำตอบถ้ามันโค้งหรือผิดกฎให้ฉันรู้)

JavaScript 56 96

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

JavaScript 69 109 (ย้อนกลับได้)

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

สามารถเล่นกอล์ฟได้เล็กน้อยโดยใช้ฟังก์ชั่น EcmaScript 6 arrow :

ES6 50 90

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

ES6 63 103 (ย้อนกลับได้) (73-10)

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

SED 67 Chars (คะแนน 67 หรือ 107)

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

สิ่งนี้ใช้การจัดเรียงฟองเพื่อความกระชับ คะแนนจะเป็น 107 ถ้าแต่ละรูปแบบการแสดงออกปกติและนับแทนเป็นสตริง (เช่น 67 + (10 * 4))

จำนวนตัวเลขที่จัดการได้ จำกัด ด้วยหน่วยความจำ (และอาจมีความอดทน)

ฟังก์ชั่น Python lambda (ย้อนกลับได้), 69

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

• 39 ตัวอักษร(+39)
• สองสตริง multi-char: n(อินพุต) และ''.join(...) (+20)
• หนึ่งรายการ: sorted(...) (+20)
• สามารถกลับทิศทางได้โดยขึ้นอยู่กับพารามิเตอร์d (-10)

ฟังก์ชั่น Python lambda (ไม่สามารถย้อนกลับได้), 67

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

แก้ไข: การป้อนข้อมูลควรเป็นสตริง ฉันกำลังพิจารณาโทษของการใช้สายนั้นโดยตรง

เสียงกระเพื่อมสามัญ - 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))))

เวอร์ชั่น ungolfified (stylistically และ lexically แต่เป็นเหมือนฟังก์ชันใช้งาน):

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

ตัวเลขของจำนวนลบจะถือว่าเป็นค่าลบและตัวเลขจะถูกจัดเรียงอย่างมีนัยสำคัญน้อยที่สุดก่อน (เช่น little-endian) ตัวอย่าง:

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

มี 136 อักขระในเวอร์ชัน golfed รวมถึงช่องว่าง มันใช้สตริงไม่และไม่มีอาร์เรย์และจัดการจำนวนเต็มความแม่นยำโดยพลการรวมถึงจำนวนเต็มลบ การเรียงลำดับถูกกำหนดพารามิเตอร์บนเพรดิเคตไบนารีซึ่งกำหนดการเรียงลำดับทั้งหมดบนจำนวนเต็ม[-9, 9]รวมถึง แต่ไม่ จำกัด เฉพาะ<และ>:

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

สิ่งนี้ให้คะแนน 126

JavaScript 416/185

ไม่มีอะเรย์, ไม่มีเงื่อนไข, ไม่มีข้อ จำกัด ด้านความยาว ...

แต่การเรียงลำดับขึ้น / ลงจะใช้อักขระมากกว่า 10 ตัว ^^ แต่ฉันพบความคิดในการนับตัวเลขและพิมพ์มันน่าสนใจ - บางทีใครบางคนสามารถใช้ความคิดนี้ใน GolfScript และชนะรางวัล ;-)

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: (แต่น่าจะพิจารณาว่าใช้สตริง ... )

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

คะแนน:

• 192 (192 ตัวอักษร)
• 40 (2 Arays: argv (v) และ a)
• 0 (ไม่มีสตริงอักขระถ่าน)
• 0 (ไม่ จำกัด ตัวเลข n)

• -10 (เรียงกลับกันถ้าจำนวน (argv [1]) เป็นลบ)

  = 222 คะแนน

การตั้งค่าสถานะจำเป็นต้องกำจัดคำเตือนของคอมไพเลอร์ 1,000 รายการ: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.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();}

ค่อนข้าง ungolfed:

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

มีเหตุผลที่ฉันไม่เห็นวิธีนี้หรือไม่?

ทับทิม

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

ไม่แน่ใจว่าจะทำคะแนนได้อย่างไร การแยกจะสร้างอาร์เรย์ แต่นอกเหนือจากนั้นไม่แน่ใจ .. 38 chars + 2x20 สำหรับอาร์เรย์? หรือควรรวมอาร์เรย์ทั้งหมดที่เรียงลำดับอาจสร้างขึ้นภายใน?

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 ตัวอักษร + 10 สำหรับการใช้งานของสตริงn
(ไม่ทราบว่าการใช้replaceฟังก์ชั่นและstringฟังก์ชั่นที่ส่งกลับจำนวนอักขระ x จำนวน n ถูกนับเป็นสตริงเสริม)

มันนับจำนวนตัวเลขที่แน่นอนโดยการเปรียบเทียบความยาวของสตริงเดิมกับสตริงเดียวกันกับตัวเลขที่แน่นอนแทนที่ จากนั้นจะแนบจำนวนหลักนั้นกับ n

Python 3 sleepsort (168)

ไม่มีรายการหรือวนซ้ำอย่างแน่นอน

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

อาจปรับปรุงได้

แร็กเก็ต 97

97 คะแนน (87 +20 สำหรับสองสาย -10 สำหรับการเรียงลำดับไม่มีอาร์เรย์)

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

สิ่งนี้ใช้รายการตัวอักษรดังนั้นคุณต้องให้ฟังก์ชันการเปรียบเทียบแบบ char char<?หรือchar>?หรือฉันรู้สึกว่าสิ่งนี้ผ่านไปโดยไม่อัปยศเพราะมันไม่ได้ทำอะไรมากไปกว่าการเพิ่มช่องว่างและเพิ่มชื่อตัวแปร รุ่นเก่าของฉันอาจจะมีเกียรติมากกว่า :)

รุ่นเก่าที่ไม่มีสตริง:

110 คะแนน (120 ไบต์ (utf-8) - 10 สำหรับการอนุญาตให้เปลี่ยนลำดับการเรียงโดยไม่ใช้สตริงและไม่มีอาร์เรย์)

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

(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

และเหมือนกันในลำดับตรงข้าม:

(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