Натхненний нещасним сортуванням цифр-цифр-без використання-масиву , але я подумав, що це поліпшив гольф коду, ніж питання ТАК.

Давши додатне ціле число, відсортуйте цифри в цьому цілому.

Найнижчий рахунок виграє!

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має щонайменше один рядок як input ( this) та масив як вихід, тому +30 для його використання.
4. Я намагався змусити ці правила керуватися принципом проектування алгоритму, а не початковим / кінцевим введенням-виведенням (звідси примітка №2). Я не думаю, що покарання повинно застосовуватися, int(input())навіть якщо inputпідпис каже, що він повертає рядок, доки цей вираз є початковою точкою входу програми. Так само, якщо кінцевим результатом програми є print(x)і xповинен бути рядок, штраф не застосовується до операції лиття рядка останнього канаву. Коли я говорив, я прямо ніколи не говорив, що це повинна бути програма або там, де введення-виведення повинне бути або прийти. Функція, яка приймає 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)

... але дух питання - ні масивів, рядків чи символів - цікавіший.

С + x86 збірка, 636

Я знаю, що це не виграє, але це було настільки неприродно і перекручено, що мені довелося поділитися цим. Немає масивів чи рядків (доки ви не рахуєте вхідні аргументи). Кількість цифр обмежена 32-бітовим діапазоном.

Ось ось невелике пояснення того, що я зробив:

Я думав, що буду це робити, не використовуючи жодних масивів чи рядків, і тоді на думку прийшов рекурсія, але, звичайно, з рекурсією я не зміг би поміняти значення з інших рекурсивних викликів ... і тоді, коли зрозумів, що був спосіб. Пов'язуючи свою програму C з функцією складання, я міг підскочити в стек і повернути вказівник на базовий покажчик потрібного виклику, ось що робить функція "recursionStackAt". Звичайно, rekursionStackAt - це дуже потворна функція, її результат залежить не тільки від стану входу чи програми, але і від самого виклику. Зауважте, що саме це змусило мене змінити індекси з 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 за вибір / зменшення вибору.

О, і для компіляції цього ви повинні зробити (на Unix-подібних системах)

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

Зауважте, що прапор -m32 використовується лише в тому випадку, якщо ви працюєте на 64-бітній машині. Також вам потрібні 32-бітні бібліотеки для їх компіляції.

Bash (відлуння) (0 + 7 + 0 + 0 + 32-10) = 29

Сорта:

echo $*

Використання:

sorta 5
5

Використовуйте "-e" для сортування у зворотному напрямку:

sorta -e 3
3

• дає правильний результат для натуральних чисел 1-9 плюс 0
• уникає будь-якого ітерабельного хакерства.
• 7 символів (+7)
• немає масивів
• відсутні рядки з декількома символами
• максимальна кількість цифр, з якими вона може працювати: 1 (+32)
• може за бажанням змінити сортування (-10)

EDIT: змінив "cat" на "echo", щоб він насправді спрацював. EDIT 2: Додано "$ *" і введено його в "сорта" сценарій

Python3

Мої сценарії:

Немає масивів

Ніяких струн

Складність становить O (n): я використовував підрахунок стилів (модифікований мною не для використання масивів, а простих чисел стилів для підрахунку окулянтів)

Без обмежень у розмірі

Персонажі: 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 символи - 10 для зворотного)

Я думаю, що це може трохи зігнути правила, але ось ця п’ятниця ...

Я припускаю, що використання стандартних бібліотек дозволено. Моя інтерпретація стандартної бібліотеки для bashIS coreutils:

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

• Ні масивів - потоки не використовуються
• Без лапок == немає рядків з декількома символами
• Немає обмеження довжини вводу / виводу
• необов'язковий arg "-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 функція (мало-ендіанська арка), 131 108 символів

Жоден виклик сортування не може бути завершеним без спального місця відповіді . Для повернення цього знадобиться до 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);
}

Ява: 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файл у командному рядку, він генерує безліч проблем (помилок). Отже, рішення?

Компіляція 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}%
  }%
}

Розмноження

Є кілька онлайн-компіляторів LaTeX, список можна знайти тут . Я спробував перший пункт у списку, LaTeX сервлет на sciencesoft.at . Він може використовуватися без підписання, а також може створювати постійні URL-адреси: джерело та результат у вигляді зображення .

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

Хаскелл - 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 сортує х, натискаючи на & рекурсії на 0 іx

Хитрість полягає в тому, що другий аргумент %і &не є xбезпосередньо, а xвикористовує divMod'dd

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 елемента, але я вирішив не сприймати такий різкий погляд при підрахунку моєї оцінки.

32-бітний ліміт накладається J, а не моя програма. Будь-який вищий і J перемикає числа на наукові позначення. З питання, чи застосовується покарання в 32 бали, незрозуміло, але навіть якщо застосовуються обидва попередніх штрафних санкцій (я не думаю, що вони повинні), оцінка піднімається до 72 і все ще комфортно б’є переважну більшість інших відповіді.

Пітон 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

Ява 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, і це не допомагає в сортуванні, це лише доступ до параметрів командного рядка, і ці значення містяться в змінних без масиву, де насправді необхідні для розрахунків. Я думаю, що це не буде рахуватися з цим рішенням. Наступний розрахунок не враховує масив 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 :

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 символів (оцінка 67 або 107)

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

Для короткості використовується сортування бульбашок. Оцінка буде 107, якщо кожен шаблон регулярного вираження та заміна вважаються рядком (тобто 67 + (10 * 4))

Кількість цифр, оброблених обмеженою пам'яттю (і, напевно, терпінням)

Функція лямбда Python (оборотна), 69

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

• 39 знаків (+39)
• Дві рядки з декількома знаками: n(введення) та ''.join(...) (+20)
• Один список: sorted(...) (+20)
• Може змінити напрямок в залежності від параметра d (-10)

Функція лямбда Python (нереверсивна), 67

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

EDIT: Введення має бути рядок. Я розглядаю покарання безпосередньо використовувати цей рядок.

Лист звичайний - 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))))

Нефіфікована (стилістична, а також лексично, але функціонально однакова) версія:

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

Цифри від’ємного числа трактуються як негативні, а цифри сортуються найменш-значущі-перші (тобто мало-ендіанські). Приклади:

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 символів, включаючи пробіли. Він не використовує рядків і жодних масивів, а також обробляє цілі числа довільної точності, включаючи від’ємні цілі числа. Сортування налаштовано на бінарний предикат, який визначає загальне впорядкування цілих чисел у [-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 масиви: argv (v) та a)
• 0 (без мультипотокових рядків)
• 0 (не обмежується n цифрами)

• -10 (сортує зворотний, якщо число (argv [1]) від’ємне)

  = 222 бали

Прапори, необхідні для позбавлення від попереджень 1000 компілятора: 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();}

Дещо незворушний:

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 символів + 2х20 для масивів? Або він повинен включати всі масиви, які сортування можуть створювати внутрішньо?

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функції, що повертає n кількість символів x, зараховується як зайвий рядок).

Він підраховує суму певної цифри, порівнюючи довжину вихідного рядка з тим самим рядком із заміненою певною цифрою. Потім він додає цю кількість цифр до n.

Пітон 3 спальних місця (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>? . Я відчуваю, що це також переходить як неробочий, оскільки це не багато чого, ніж додавати пробіли та збільшувати назви змінних. Моя стара версія, мабуть, більш почесна :)

Стара версія без рядків:

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

Безголівки:

(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