Вдохновленный злополучной сортировкой чисел без чисел без использования массива , но я подумал, что это делает гольф лучше, чем 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имеет по крайней мере одну строку в качестве input ( this) и Array в качестве вывода, поэтому +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)

... но суть вопроса - без массивов, строк или символов - более интересна.

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 для увеличивающегося / уменьшающегося выбора.

О, и для компиляции вы должны это сделать (на Unix-подобных системах)

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

Обратите внимание, что флаг -m32 используется только в том случае, если вы работаете на 64-битной машине. Вам также нужны 32-битные библиотеки для его компиляции.

Баш (эхо) (0 + 7 + 0 + 0 + 32-10) = 29

Сорта:

echo $*

Использование:

sorta 5
5

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

sorta -e 3
3

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

РЕДАКТИРОВАТЬ: изменил «кошка» на «эхо», чтобы он действительно работал. РЕДАКТИРОВАТЬ 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

• Нет массивов - вместо них используются потоки
• Нет кавычек == нет многосимвольных строк
• Нет ограничений на длину ввода / вывода
• необязательный аргумент "-r" инвертирует вывод.

Ввод от стандартного ввода. В использовании:

$ 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

Un-golfed:

#include <stdio.h> 
#include <stdlib.h>
#include <string.h>

main(int a, char **b)
{
    b++;
    qsort(*b, strlen(*b), sizeof(char), strcmp);  // sizeof(char) is guaranteed to be 1 by standards
    puts(*b);
}

Я также решил включить сортировку символов, просто потому, что мог.

Тестовые прогоны:

$ ./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 символа. Я не добавляю это к своему персонажу, потому что это только для демонстрации через консоль.

Выход:

НОЛЬ, т.е. 0считается. Предположим, что внешний класс есть Helper.java, и он был успешно скомпилирован, несколько примеров через консоль:

INPUT :C: ...> Java помощник 008321
OUTPUT:001238

INPUT :C: ...> Java помощник 79359105
OUTPUT:01355799

Когда изменено на 0то есть, по убыванию ...

INPUT :C: ...> Java помощник 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.

Degolfed версия кода в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;
}

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

32-битный лимит налагается J, а не моей программой. Чуть выше и 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)));}}

Un-golfed

using System.Linq;

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

Тестовое задание

Обычный:

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, и это не помогает в сортировке, это только доступ к параметрам командной строки, и эти значения находятся в переменных, не являющихся массивами, где фактически необходимо для вычислений. Я думаю, что это не считается против этого решения. Следующий расчет не учитывает 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(''))}

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

РЕДАКТИРОВАТЬ: ввод должен быть строкой. Я рассматриваю наказание за использование этой строки напрямую.

Common Lisp - 126

(defun s(n p)(labels((a(n)(if(= 0 n)()(cons(mod n 10)(a (floor n 10)))))(b(a)(if(null a)0(+(car a)(* 10(b(cdr a)))))))(b(sort(a n) p))))

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

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

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

Он подсчитывает количество определенной цифры, сравнивая длину исходной строки с той же строкой с заменой определенной цифры. Затем он присоединяет это количество цифр к n.

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

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

Я проверил это с сотым тысячным числом Фибоначчи:

(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