배열을 사용하지 않고 잘못 정렬 된 숫자 자릿수에서 영감을 얻었 지만 SO 질문보다 코드 골프가 더 좋다고 생각했습니다.

양의 정수가 주어지면 해당 정수의 숫자를 정렬하십시오.

최저 점수가 이깁니다!

1. 0 포인트로 시작하십시오.
2. 문자 당 하나의 포인트를 추가하십시오.
3. 사용하는 각 배열에 20 포인트를 추가하십시오.
4. 코드에서 각 다중 문자 문자열에 10 점을 추가하십시오. (다른 입력 작업없이 정수로 변환되는 한 초기 입력은 제외)
5. 프로그램이 처리 할 수있는 최대 자릿수가 기계와 달리 프로그램에 의해 제한되는 경우 32 점을 추가하십시오.
6. 코드가 다른 인수가 주어지면 정렬 방향을 변경할 수있는 경우 10 점을 뺍니다 (원하는대로 내림차순은 0, 오름차순은 1).

모든 언어는 다르지만 아이디어는 반복 가능한 숫자 해커를 피하는 것입니다.

예:

입력 : 52146729

출력 : 97654221 또는 12245679

노트:

1. 프로그래밍 언어가 제공하는 내장 정렬 기능을 사용하십시오. 그러나 해당 정렬 기능에 문자열이나 배열이 포함되어 있으면 페널티를받습니다!
2. 정수를 직접받는 함수 또는 argv, 파일 또는 스트림에서 인수를 가져 와서 정수로 변환하는 프로그램으로 솔루션을 작성할 수 있습니다. 정수로 즉시 변환하고 추가 작업을 수행하지 않고 원래 문자 * 입력을 삭제하면 벌칙이 적용되지 않습니다.
3. 처벌은 프로그램 텍스트의 문자열 리터럴뿐만 아니라 문자열 또는 반복 가능한 문자열을 입력하거나 출력하는 프로그램 기능의 모든 부분에 적용됩니다. 예를 들어, JavaScript String.prototype.split에는 입력 ( this) 으로 하나 이상의 문자열이 있고 출력으로 배열이 있으므로이를 사용하려면 +30입니다.
4. 이러한 규칙을 초기 / 최종 I / O (따라서 주 # 2)가 아닌 알고리즘 설계의 원칙으로 안내하려고했습니다. '표현식이 프로그램 의 초기 진입 점 인 한 문자열을 반환한다고 int(input())하더라도 페널티가 적용되지 않는다고 생각합니다 . 프로그램의 최종 출력 인 경우 마찬가지로, 그리고 문자열이어야합니다, 형벌은 최후의 문자열 캐스팅 작업에 적용되지 않습니다. 그러나 나는 분명히 이것이 프로그램 이거나 I / O가 어디에서 왔거나 어디로 가야 한다고 말한 적이 없습니다 . and를 반환하는 함수 는 서브를 제공하며 이러한 모호성으로 고통받지 않습니다.inputprint(x)xintint

골프 스크립트, 11 4

(4 + 10 (문자열)-10 (역 옵션))

STDIN에 입력하십시오.

~`$%

입력 형식은 다음과 같습니다.

(1 or -1) (the number)

1정상적으로 정렬하려면 -1반대 방향으로 4 자-역방향 옵션의 경우 10 = 점수 -6

입력은 기술적으로 문자열이므로 +10에 해당되는지 확실하지 않습니다. 규칙을 "프로그램에서 선언 된 문자열"로 해석하고 있습니다 ( "코드에서"라고 표시되어 있기 때문에).

기존 답변 (11 점) :

$

하스켈 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);
} 

물론 recursionStackAt 함수의 x86 (AT & T sintax, btw) 어셈블리 코드 :

.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 비트 라이브러리가 필요합니다.

배쉬 (에코) (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 : "$ *"추가하고 "sorta"스크립트에 넣습니다

파이썬 3

내 스크립트 기능 :

배열 없음

문자열이 없습니다

복잡도는 O (n)입니다. countssort를 사용했습니다 (배열을 사용하지 않도록 수정되었지만 소수는 수 를 계산합니다)

크기 제한 없음

문자 : 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 자)

나는 이것이 규칙을 약간 구부릴지도 모른다고 생각하지만 금요일에 간다.

표준 라이브러리를 사용할 수 있다고 가정합니다. 표준 라이브러리에 대한 나의 해석 bash은 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 매개 변수를 사용하고 10 진수가 정렬 된 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 : ...> 자바 도우미 008321
OUTPUT:001238

INPUT :C : ...> 자바 도우미 79359105
OUTPUT:01355799

0즉 내림차순으로 변경하면 ...

INPUT :C : ...> 자바 도우미 008321
OUTPUT:832100

INPUT :C : ...> 자바 도우미 79359105
OUTPUT:99755310

노트:

1. 에서 명시 적으로 배열을 선언하지 않았습니다 G.java. 이것이 핵심 클래스입니다.
2. 삽입 정렬을 사용하고 있습니다 을 하여 숫자를 숫자로 정렬합니다.
3. 숫자가 될 수의 최대 길이 - Integer.MAX_VALUE즉 어떤 배열 (자바) 저장할 수있는 최대 크기 때문이다.
4. 이 답변은 단축 될 수 있으므로 (믿습니다) 저를 도와주세요 (첫 번째 답변 개선).
5. 자바처럼 길고도 훌륭한 언어를 우연히 만든 위대한 신들 (그리고 코드 규약을 세운 위대한 신들)!

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

결과:

점수 : 절망

• etex또는로 일반 TeX를 사용 pdftex하면 파일을 다음과 같이 줄일 수 있습니다.

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

  바이트 : 318 바이트 ( s.sty) + 나머지 24 바이트는 숫자없이

• 배열은 사용되지 않습니다 : 0

• 다중 문자 문자열이 표시되지 않습니다 : 0

• 이 수는 알고리즘에 의해 제한되지 않습니다. 가장 큰 TeX 숫자는 2 ^31-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 컴파일러가 있으며 여기 에서 목록을 찾을 수 있습니다 . sciencesoft.at 의 목록에서 첫 번째 항목 인 LaTeX 서블릿을 사용해 보았습니다 . 서명하지 않고 사용할 수 있으며 영구 URL ( source 및 result as image)을 만들 수도 있습니다 .

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있습니다.

실용 관찰자는이 정렬 알고리즘이 플랫폼에서 부호있는 정수의 범위에 비례하여 시간에 따라 실행되며 실행 사이에 다시 초기화해야하는 전역 상태를 변경하고 다른 많은 희생이 간결성을 위해 만들어 졌다는 점에 주목할 것입니다.

ungolfed 버전은 정확히 동일하지는 않지만 실제 알고리즘을 더 잘 전달합니다.

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&xx단위 숫자를 삽입 a하고 결과와 나머지 부분에 반복 하여 정렬
• s x&0 에서 재귀를 시작하여 x를 정렬 하고x

트릭의 두 번째 인수한다는 것입니다 %및 &아닌 x직접하지만, xdivMod'd 사용하여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 비트 숫자에서 작동합니다.

설명:

/:~최대 정렬 &.아래 ":형식입니다. 이전 버전에서도 배열을 사용했지만 비용이 많이 들기 때문에 문자열을 사용하고 문자를 알파벳순으로 정렬하면됩니다. ":입력 된 숫자를 문자열로 변환하고/:~ 숫자를 오름차순으로 정렬합니다. 정렬은 '언더'형식으로 수행되므로 정렬이 완료되면 문자열이 다시 숫자로 변환됩니다. 되돌릴 수있는 기능을 추가하면 절약하는 것보다 비용이 많이 들기 때문에 귀찮게하지 않았습니다.

APL 및 K와 같은 J는 배열 기반 언어이므로 단일 입력은 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의 문자열 및 배열이없는 솔루션입니다. 입력으로 Long.MAX_VALUE까지만 걸리므로 1437 자 + 32 자입니다. Double을 사용하면 대신 300 자리를 넘을 수 있지만 구현하기에는 너무 지루합니다. 그보다 큰 것은 내부적으로 배열을 사용하는 BigInteger 및 AFAIK가 필요합니다. 입력에 19 자리 미만을 사용하면 출력 앞에 0이 표시됩니다. 음수 입력은 모두 0을 제공하고 숫자가 아닌 것은 예외를 발생시킵니다.

내가 생각할 수있는 가장 쉬운 것을 사용했기 때문에 꽤 비효율적입니다. (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 (chars)-10 (반전 가능)

질문에서 정렬 기능에 대해 아무것도 보지 못했기 때문에 ... (규칙이 구부러 지거나 규칙을 위반하면 답을 제거하겠습니다.

자바 스크립트 56 96

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

자바 스크립트 (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))

메모리로 제한되어 처리 된 자릿수 (및 인내심)

파이썬 람다 함수 (가역), 69

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

• 39 자 (+39)
• 두 개의 다중 문자 문자열 : n(입력) 및 ''.join(...) (+20)
• 한 목록 : sorted(...) (+20)
• 파라미터 (-10) 에 따라 방향을 바꿀 수 있습니다d

파이썬 람다 함수 (가역 불가), 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 (형식적으로나 어휘 적으로, 기능적으로 동일 함) 버전 :

(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 점을줍니다.

자바 스크립트 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 문자 + 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에 첨부합니다.

파이썬 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>? . 공백을 추가하고 변수 이름을 늘리는 것보다 많지 않기 때문에 이것이 또한 ungolfed로 전달된다고 생각합니다. 내 이전 버전은 아마도 더 존경받을 것입니다 :)

문자열이없는 이전 버전 :

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