정수 목록 정렬


22

도전

정말 간단합니다. 숫자 목록을 정렬하십시오.

세부

내장 정렬 함수 / 라이브러리 등을 사용하지 않고 (예 : list.sort()Python) 숫자 목록을 오름차순으로 정렬해야합니다 .

입력 / 출력은 사람이 읽을 수있는 한 원하는 방법으로 수행 할 수 있습니다.

표준 허점은 항상 허용되지 않습니다.

바이트 단위의 최단 코드가 이깁니다.

사용한 정렬 방법 (버블, 삽입, 선택 등)을 설명 / 목록으로 작성해야합니다.

입력에 중복이 포함되지 않습니다.

샘플 입력 / 출력

입력: 99,-2,53,4,67,55,23,43,88,-22,36,45

산출: -22,-2,4,23,36,43,45,53,55,67,88,99

참고 : 숫자 목록 정렬 과 거의 반대


8
이것이 중복되지 않으면 매우 놀랐지 만 확인할 시간이 없습니다. 어쨌든 "내장 정렬 기능"을 더 잘 정의해야합니다. 모든 값을 인덱싱하는 함수를 사용할 수 있습니까? [7 2 4 1] -> [4 2 3 1]. 또한 CSV 목록을 괄호 안에 넣을 수 있습니까? 또한 특정 입력 형식은 일부 언어에 매우 적합하고 다른 언어에는 적합하지 않습니다. 이로 인해 입력 구문 분석이 일부 제출의 경우 큰 부분이되고 다른 경우에는 필요하지 않습니다.
Stewie Griffin

1
@StewieGriffin 많은 정렬 문제를 보았지만 기본 정수 목록 만 정렬하는 것은 없습니다. 일부 언어에서는 쉬우 며 다른 언어에서는 훨씬 더 어려운 과제가 많이 있습니다.
Michelfrancis Bustillos

이것은매우 유사하지만, O (Nlog (N))의 제한이있다.
Nathan Merrill

2
이 질문 과 매우 밀접한 관련 있지만 여기의 일부 답변 (예 : Dennis '범위 필터링)은 입력이 정수가되어야하기 때문에 속임수로 마감하기 위해 투표하지 않습니다.
피터 테일러

관련 : youtube.com/user/AlgoRythmics/videos — 헝가리어 춤을 통해 분류 알고리즘을 가르치는 Youtube 채널!
sergiol

답변:


23

05AB1E , 2 바이트

암호:

ϧ

젤리 답변 과 동일한 알고리즘 입니다. 입력의 모든 순열을 계산하고 가장 작은 순열을 표시합니다.

온라인으로 사용해보십시오!


보다 효율적인 방법은 다음과 같습니다.

E[ß,Ž

선택 정렬을 수행합니다 . CP-1252 인코딩을 사용합니다 .

온라인으로 사용해보십시오!


6
내가 2보다 적게받는 것을 보지 않기 때문에 이것을 일시적으로 받아들입니다.
Michelfrancis Bustillos

6
@MichelfrancisBustillos 글쎄, 그들이했다면 내장 된 것입니까?
Destructible Lemon

방금 1 분 전에 05AB1E / Base를 살펴본 후 이것을 보았습니다. 일치?
facepalm42

17

젤리, 3 바이트

Œ!Ṃ

입력 목록의 모든 순열을 생성 한 후 사 전적으로 가장 작은 순열을 선택합니다. 매우 효율적입니다.

독립적으로 동일한 아이디어를 가진 @Adnan에게 크레딧.

온라인으로 사용해보십시오!


젤리, 4 바이트

ṂrṀf

이렇게하면 목록의 최소값에서 목록의 최대 값까지의 범위가 만들어진 다음 원래 목록에없는 범위 요소가 삭제됩니다. 이것은 매우 작은 버킷으로 기술적으로 버킷 정렬 입니다. 이 특정 변형의 이름을 알지 못합니다.

온라인으로 사용해보십시오!

작동 원리

ṂrṀf  Main link. Argument: A (list/comma-separated string)

Ṃ     Compute the minimum of A.
  Ṁ   Compute the maximum of A.
 r    Yield the inclusive range from the minimum to the maximum.
   f  Filter the range by presence in A.

O ( 아주 ). 많은 종류를 사용합니다.
mbomb007

22
O. 매우 사용합니다. 많은 종류. 몹시 놀라게 하다! (죄송합니다, 무엇?)
Dennis

나는 알고리즘의 복잡성이별로 좋지 않다. 이것이 O (n!) 일까?
FlipTack

2
@FlipTack 나도 아니에요. n 이 있기 때문에 아마도 조금 더 높습니다 ! 길이의 배열 N .
데니스

1
가장 작은 사전 식으로 선택하는 것만으로 n (n * n!)입니다. 배열을 순차적으로 비교해야하며 사전 식 비교는 O (n)입니다. 효율적으로 수행된다면 O (n * n!)에서도 생성이 가능합니다. 그래서 잘 구현된다면 알고리즘은 단지 O (n * n!)입니다
PunPun1000

12

파이썬, 46 45 바이트

lambda l:[l.pop(l.index(min(l)))for _ in 1*l]

간단한 선택 정렬.


4
l[:]1*l
feersum

9

Brachylog , 12 7 바이트

p.'(s>)

이것은 순열 정렬을 사용하는데, 이것은 끔찍하지만 Pyth보다 짧습니다!

설명

p.       Unifies the output with a permutation of the input
  '(  )  True if what's inside the parentheses cannot be proven, else backtrack and
         try with another permutation of the input.
    s    Take an ordered subset from the output
     >   True if the first element is bigger than the second (hence not sorted)
         We don't need to check that the subset is 2 elements long because > will be false
         for inputs that are not 2 elements long anyway

9

하스켈, 38 바이트

h%t|(a,b)<-span(<h)t=a++h:b
foldr(%)[]

이진 함수 %새로운 요소를 삽입 h정렬 된리스트로 t분할하여 t프리픽스로 a소자 <h와 접 b소자 >h에서, 스틱 h사이.

작업 foldr(%)[] 다음의 입력리스트에서 반복 삽입 소자 빈에서 정렬 된리스트를 만든다.

이것은 직접 재귀 구현보다 1 바이트 짧습니다.

f(h:t)|(a,b)<-span(<h)$f t=a++h:b
f x=x

41 바이트에 대한 또 다른 전략 :

f[]=[]
f l|x<-minimum l=x:f(filter(/=x)l)

그래서이다 en.wikipedia.org/wiki/Insertion_sort가 함께 %삽입하고 내부 루프와 foldr외부 루프로 적용한다.
Peter Cordes

8

자바 스크립트 (ES6), 51 바이트

a=>a.map(_=>m=Math.min(...a.filter(e=>e>m)),m=-1/0)

각 루프는 지금까지 찾지 못한 가장 작은 숫자를 찾습니다.


이에를 호출하면 [1,2,3,4,5,4,3,2,1]생산[1, 2, 3, 4, 5, Infinity, Infinity, Infinity, Infinity]
벤자민 Gruenbaum

@BenjaminGruenbaum "입력에 중복이 포함되지 않습니다."
Neil

나는 다른 접근 방식을 가진 동일한 바이트 수를 가지고 있습니다
Bálint

실제로, 1 바이트 더 적다
Bálint


8

파이썬 2, 34 바이트

def f(s):m=min(s);print m;f(s-{m})

입력을 세트로 가져 와서 요소를 증가하는 순서대로 인쇄하고 오류로 종료합니다.

정리 종료는 41 바이트로 수행 할 수 있습니다.

def f(s):
 if s:m=min(s);print m;f(s-{m})

또는

l=input()
while l:m=min(l);print m;l-={m}

입력은 39 바이트 또는 Python 3.5에서 38 바이트의 목록으로 사용할 수 있습니다.

def f(l):m=min(l);print m;f(set(l)-{m})
def f(l):m=min(l);print(m);f({*l}-{m})

이것은 en.wikipedia.org/wiki/Selection_sort 이며, 내부 루프로 m=min(s)/ s - (m)를 사용 하여 정렬되지 않은 요소에서 최소값을 찾고 제거하고 외부로 재귀를 사용합니다.
Peter Cordes

8

하스켈, 42 41 38 바이트

f u=filter(`elem`u)[(minBound::Int)..]

모든 정수 (루프에서 64 비트로 서명 됨)를 반복하고있는 정수를 유지합니다. u . 물론 그것은 적당한 시간 안에 끝나지 않습니다.

이전 버전은 반복 [minimum u..maximum u] 는 동일한 최악의 실행 시간을 갖습니다.

편집 : @xnor은 바이트를 저장했습니다. 감사!


filter더 짧은 것입니다 :f u=filter(`elem`u)[minimum u..maximum u]
xnor

얼마나 무력인가! 않는 [minimum u..]유형의 이유로 작동하지?
xnor

@ xnor : 그렇게 생각합니다. 호출 할 때 f [1,3,0]요소가 기본적으로 Integer바인딩되지 않은 유형으로 설정 되므로 ..절대 끝나지 않습니다. f ([1, 3, 0]::[Int])다음 과 같이 호출해야한다면 바이트 주석에 유형 주석이 포함되어야합니다.
nimi

두 번 이상 발생하는 요소를 어떻게 감지합니까?
feersum

1
@feersum : 그렇지는 않지만 "입력에는 중복이 포함되지 않습니다"라는 문제가 있습니다.
nimi

8

Oracle SQL 11.2, 205 바이트

WITH s AS(SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))),v(p,f)AS(SELECT e,e FROM s UNION ALL SELECT p||','||e,e FROM v,s WHERE e+0>f)SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1);         

언 골프

WITH 
s AS  -- Split the string using ',' as separator
(     -- ||'' cast the xml type to varchar
  SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))
),  
v(p,f) AS  -- Recursive view : p = sorted string, f last number added
(
  SELECT e,e FROM s -- use each number as seed
  UNION ALL         -- only add a number if it is > the last added
  SELECT p||','||e,e FROM v,s WHERE e+0>f  -- +0 is needed to compare int and not strings
)  
-- The valid string has the same length as the input
SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1)          

어떤 정렬 방법인지 ORDER BY는 모르겠지만 잊어 버렸습니다.


나는 SQL을 거의 알지 못하지만 의견에서 나머지 정렬되지 않은 요소에서 최소 또는 최대를 선택하고 정렬 된 목록의 끝에 추가한다고 생각합니다. 이것은 이것을 en.wikipedia.org/wiki/Selection_sort로 만듭니다 .
Peter Cordes

8

x86-16 머신 코드 (BubbleSort int8_t), 20 19 바이트

x86-64 / 32 머신 코드 (JumpDownSort) 21 19 바이트

변경 로그:

  • lodsb/ cmp [si],al아이디어에 대한 @ ped7g 덕분에 포인터 증가 / 재설정과 함께 사용했습니다. 필요하지 않음 al/ ah더 큰 정수에 거의 동일한 코드를 사용할 수 있습니다.

  • 새로운 (그러나 관련) 알고리즘, 많은 구현 변경 사항 : Bubbly SelectionSort를 사용하면 바이트 또는 dword에 대해 더 작은 x86-64 구현이 가능합니다. x86-16에서 손익분기 점 (바이트 또는 단어). 또한 내 BubbleSort에있는 size = 1의 버그를 피하십시오. 아래를 참조하십시오.

  • 새로운 min을 찾을 때마다 스왑이있는 Bubbly Selection Sort는 이미 알려진 알고리즘 인 JumpDown Sort입니다. Bubble Sort : Archaeological Algorithmic Analysis ( 거품 정렬 : 고고학 알고리즘 분석)에 언급되어 있습니다.


8 비트 부호있는 정수를 제자리에 정렬합니다 . (서명되지 않은 코드 크기는 동일 jge합니다.jae . . 중복은 문제가되지 않습니다. 16 비트 회전을 사용하여 8 (메모리 대상 포함)로 교체합니다.

Bubble Sort 는 성능을 저하 시키지만 기계 코드에서 구현하는 것이 가장 작은 것 중 하나라는 것을 읽었습니다. 인접한 요소를 바꾸는 특별한 트릭이있을 때 특히 그렇습니다. 이것은 거의 유일한 장점이지만 때로는 (실제 임베디드 시스템에서) 매우 짧은 목록에 사용하기에 충분한 이점입니다.

나는 스왑없이 초기 종료를 생략했다 . 나는 Wikipedia의 "최적화 된"BubbleSort 루프 n − 1를 사용했다.n 번째로 않으므로 외부 루프 카운터가 내부 루프의 상한입니다.

NASM 목록 ( nasm -l /dev/stdout) 또는 일반 소스

 2 address  16-bit       bubblesort16_v2:
 3          machine      ;; inputs: pointer in ds:si,  size in in cx
 4          code         ;; requires: DF=0  (cld)
 5          bytes        ;; clobbers: al, cx=0
 6                       
 7 00000000 49               dec     cx          ; cx = max valid index.  (Inner loop stops 1 before cx, because it loads i and i+1).
 8                       .outer:                 ; do{
 9 00000001 51               push    cx          ;   cx = inner loop counter = i=max_unsorted_idx
10                       .inner:                 ;   do{
11 00000002 AC               lodsb               ;     al = *p++
12 00000003 3804             cmp     [si],al     ;     compare with *p (new one)
13 00000005 7D04             jge     .noswap
14 00000007 C144FF08         rol     word [si-1], 8    ; swap
15                       .noswap:
16 0000000B E2F5             loop    .inner      ;   } while(i < size);
17 0000000D 59               pop     cx          ;  cx = outer loop counter
18 0000000E 29CE             sub     si,cx       ;  reset pointer to start of array
19 00000010 E2EF             loop    .outer      ; } while(--size);
20 00000012 C3               ret

22 00000013  size = 0x13 = 19 bytes.

cx내부 루프 주위의 push / pop은 cx= outer_cx 와 함께 0까지 실행됨을 의미합니다 .

참고 rol r/m16, imm88086 지시되지 않고, 그것은 나중에 (186 또는 286)를 첨가하고 있지만, 이것은 코드 8086, 단지 16 비트 86 되려고 아니다. SSE4.1 인 경우phminposuw 이 도움이 사용하겠습니다.

32 비트 버전 (여전히 8 비트 정수에서 작동하지만 32 비트 포인터 / 카운터로 작동)은 20 바이트 (피연산자 크기 접두어 rol word [esi-1], 8)

버그 : size = 1은 size = 65536으로 취급됩니다. cx = 0으로 외부 do / while에 들어가는 것을 막을 수있는 것은 없습니다. (일반적으로 사용 jcxz합니다.) 그러나 다행히 19 바이트 JumpDown Sort는 19 바이트이며 그 문제는 없습니다.


원본 x86-16 20 바이트 버전 (Ped7g 아이디어 제외). 공간 절약을 위해 생략 된 설명 은 편집 기록 을 참조하십시오 .


공연

부분적으로 겹치는 저장소 / 다시로드 (메모리 대상 회전)는 최신 x86 CPU (주문 Atom 제외)에서 저장소 전달을 중단시킵니다. 높은 값이 위쪽으로 버블 링되는 경우이 추가 대기 시간은 루프로 전달되는 종속성 체인의 일부입니다. 저장 / 재로드는 첫 번째 위치 (Haswell의 5주기 저장 전달 대기 시간)에서 빨라지지만 전달 중단은 최대 13주기와 비슷합니다. 비 순차적 실행은 이것을 숨기는 데 어려움이 있습니다.

참조 : 종류의 문자열을 정렬 거품 : 스택 오버플로를 비슷한 구현이의 버전하지만, 초기 아웃로 더 스왑이 필요 없을 때. 스왑을 위해 xchg al, ah/ mov [si], ax를 사용하는데 , 이는 1 바이트 더 길며 일부 CPU에서 부분 레지스터 스톨이 발생합니다. (그러나 여전히 메모리 -dst 회전보다 낫습니다.이 경우 값을 다시로드해야합니다.) 내 의견에는 몇 가지 제안이 있습니다 ...


x86-64 / x86-32 JumpDown 정렬, 19 바이트 (정렬 int32_t)

x86-64 시스템 V 호출 규칙을 사용하여 C에서 호출 가능
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (return value = max (array [])).

이것은 https://en.wikipedia.org/wiki/Selection_sort 이지만 min 요소의 위치를 ​​기억하는 대신 현재 후보를 배열로 바꾸십시오 . min (unsorted_region)을 찾으면 일반 선택 정렬과 같이 정렬 된 영역의 끝에 저장하십시오. 이것은 정렬 된 영역을 하나씩 증가시킵니다. (코드에서, rsi정렬 된 영역의 끝을지나 하나를 가리키고 , lodsd이를 진행 mov [rsi-4], eax시키고 분을 다시 저장합니다.)

Jump Down Sort라는 이름은 Bubble Sort : Archaeological Algorithmic Analysis에서 사용 됩니다. 높은 요소는 위쪽으로 점프하고 아래쪽이 아닌 끝이 정렬되어 있기 때문에 내 정렬이 실제로 점프 업 정렬이라고 생각합니다.

이 교환 설계로 인해 어레이의 정렬되지 않은 부분이 대부분 역순으로 정렬되어 나중에 스왑이 많이 발생합니다. (큰 후보로 시작하고 낮은 후보와 낮은 후보를 계속보고 있기 때문에 계속 스와핑을 계속합니다.) 요소를 다른 방향으로 옮기더라도 "거품"이라고했습니다. 요소를 움직이는 방식도 거꾸로 삽입 정렬과 비슷합니다. 실제로 작동하려면 GDB를 사용 display (int[12])buf하고 내부 loop명령 에 중단 점을 설정 한 후 c(계속)을 사용하십시오. return을 눌러 반복하십시오. "display"명령은 GDB가 중단 점에 도달 할 때마다 전체 배열 상태를 인쇄하도록합니다.

xchgmem을 사용하면 암시 적 lock접두사가있어 속도가 느려집니다. 아마도 효율적인로드 / 스토어 스왑보다 약 10 배 정도 느립니다. xchg m,rSkylake에서 처리량은 23c 당 하나이지만 효율적인 스왑 (reg, mem)을위한 tmp reg를 사용하여로드 / 저장 / mov는 클럭 당 하나의 요소를 이동할 수 있습니다. loop명령이 빠르고 내부 루프를 병목 현상이 발생하지 않는 AMD CPU의 경우 더 나쁜 비율 일 수 있지만 스왑이 일반적이기 때문에 분기 누락이 여전히 큰 병목 현상이 발생합니다 (분류되지 않은 영역이 작을수록 더 일반적입니다) ).

 2 Address               ;; hybrib Bubble Selection sort
 3        machine         bubblyselectionsort_int32:   ;; working, 19 bytes.  Same size for int32 or int8
 4        code               ;; input: pointer in rsi, count in rcx
 5        bytes              ;; returns: eax = max
 6                       
 7                           ;dec  ecx           ; we avoid this by doing edi=esi *before* lodsb, so we do redundant compares
 8                                               ; This lets us (re)enter the inner loop even for 1 element remaining.
 9                       .outer:
10                           ; rsi pointing at the element that will receive min([rsi]..[rsi+rcx])
11 00000000 56               push   rsi
12 00000001 5F               pop    rdi
13                           ;mov    edi, esi     ; rdi = min-search pointer
14 00000002 AD               lodsd
16 00000003 51               push   rcx          ; rcx = inner counter
17                       .inner:                   ; do {
18                           ; rdi points at next element to check
19                           ; eax = candidate min
20 00000004 AF               scasd                 ; cmp eax, [rdi++]
21 00000005 7E03             jle  .notmin
22 00000007 8747FC           xchg   [rdi-4], eax   ; exchange with new min.
23                         .notmin:
24 0000000A E2F8             loop  .inner          ; } while(--inner);
26                           ; swap min-position with sorted position
27                           ; eax = min.  If it's not [rsi-4], then [rsi-4] was exchanged into the array somewhere
28 0000000C 8946FC           mov    [rsi-4], eax
29 0000000F 59               pop   rcx           ; rcx = outer loop counter = unsorted elements left
30 00000010 E2EE             loop  .outer        ; } while(--unsorted);
32 00000012 C3               ret

34 00000013 13           .size: db $ - bubblyselectionsort_int32
           0x13 = 19 bytes long

에 대한 동일한 코드 크기 int8_t: 사용 lodsb/ scasb, AL및 변경 [rsi/rdi-4]-1 . 동일한 기계 코드는 8/32 비트 요소에 대해 32 비트 모드에서 작동합니다. 8/16 비트 요소의 16 비트 모드는 오프셋을 변경 한 상태에서 다시 빌드해야합니다 (16 비트 주소 지정 모드는 다른 인코딩을 사용함). 그러나 여전히 19 바이트입니다.

dec ecx이동하기 전에 방금로드 한 요소와 비교 하여 초기 를 피합니다 . 외부 루프의 마지막 반복에서 마지막 요소를로드하고 자체보다 작은 지 확인한 다음 수행됩니다. 이렇게하면 BubbleSort가 실패하는 size = 1로 작동 할 수 있습니다 (크기 = 65536으로 처리).

이 호출자를 사용하여이 버전 (GDB)을 테스트 했습니다. 온라인으로 사용해보십시오! . 이것을 TIO에서 실행할 수 있지만 물론 디버거 또는 인쇄는 없습니다. 여전히 _start호출은 exit-status = 가장 큰 요소 = 99로 종료되므로 작동하는 것을 볼 수 있습니다.


내부 루프 루프 조건을 개선 할 여지가있을 수 있습니다. 많은 바이트를 사용하고있는 것 같습니다. 푸시 / 팝 cxloop둘 다에 사용할 수 있습니까? 어쩌면 배열의 앞뒤로 다른 방법으로 루프를 설정하여 인덱스를 0으로 세웁니다. (그리고 bx정렬 된 부분이 당신이 향하는 끝 부분에 있기 때문에 증가 합니다).
Peter Cordes

1
19B로 낮추었지만 많은 변경 사항과 입력 regs도 필요합니다 (일부 변경은 아마도 필요하지는 않지만 이전 실험에서 그대로 유지되었습니다). 답으로 pastebin에서 확인할 수 있습니다. pastebin.com/0VMzdUjj
Ped7g

@ Ped7g : 니스! sub si, cx색인 대신 포인터를 사용하여 외부 루프의 일부로 간주 했지만 lodsb/을 생각하지 않았습니다 cmp [si], al. 나는 생각하고 있었다 lodsw/ dec si또는 lodsb/ xchg al,ah한 정지 설정에cmp ah,al
피터 코르

@ Ped7g : 아, 당신의 버전은을 요구 cld하거나, 우리는 호출 규칙의 일부를 만들 수 있다고 생각합니다. DF클리어 된 AFAIK 는 16 비트 호출 규칙의 표준 부분이 아니며 32/64에 불과합니다. 아니면 부트 로더에서 가정 할 수 없다는 것입니까? 그러나 사용자 정의 레지스터 호출 규칙을 사용하면 함수만큼 코드 조각이 많으므로 DF = 0이 필요하지 않은 이유는 무엇입니까? (그리고 우리가 원한다면 ES = DS이므로 더 편리한 scasb것이 아니라 대신에 lodsb가능합니다.)
Peter Cordes

1
@ Ped7g : 나는 16 비트 규칙에 대해 전혀 모른다. 내가 아는 것은 DF가 항상 지워 졌다고 가정 할 수는 없다는 것이다. 그러나 나는 그것이 주로 부트 로더 컨텍스트에 있다고 생각합니다. 실제 DOS에서 작성한 것을 실행 한 적이 없습니다. 나는 Atari Mega 4 STe (68000/68020)에 있었고 Linux (Pentium MMX에서)에 있었으므로 SO 질문이 내 목을 때릴 때까지 16 비트 x86을 완전히 피할 수있었습니다.
Peter Cordes

6

C, 72 바이트

i,j;a(int*l,int n){for(i=0;i=i?:--n;j>l[n]?l[i]=l[n],l[n]=j:0)j=l[--i];}

버블 정렬. 첫 번째 인수는 배열에 대한 포인터이고 두 번째 인수는 배열의 길이입니다. gcc와 함께 작동합니다.


이것은 실제로 읽을 수있는 ungolfed 버전이 필요합니다. 삼항 연산자의 시작 / 종료 위치를 추적하기는 정말 어렵습니다.
Peter Cordes

5

MATL , 11 10 바이트

Y@t!d0>AY)

입력의 모든 순열을 극도로 비효율적으로 검사합니다.

온라인으로 사용해보십시오!

설명

        % Implicitly grab input array
Y@      % Compute all permutations (each permutation as a row)
t       % Duplicate this matrix
!d      % Transpose and take the differences between the values
0>A     % Find the rows where all differences are > 0
Y)      % Return only the row where this is true
        % Implicitly display the result

5

루비, 40 바이트

선택 정렬 익명의 기능; 리스트를 인수로 사용합니다.

->a{r=[];r<<a.delete(a.min)while[]!=a;r}

4

파이썬, 120 바이트

def f(a):import time,threading;[threading.Thread(None,lambda b=b,c=min(a):print(time.sleep(b-c)or b)).start()for b in a]

아마도 가장 짧은 대답은 아니지만이 알고리즘이 여기에 속한다고 생각합니다. 정수 목록으로 호출하면 정렬 된 방식으로 stdout에 인쇄됩니다. 그래도 너무 큰 숫자로는 시도하지 않을 것입니다.


좋은 첫 포스트! 그리고 좋은 사용자 이름. : P
Rɪᴋᴇʀ

4

MIPS, 68 바이트

얼마 전에 최적화되지 않은 간단한 거품 정렬 구현을 작성했습니다. 바이트 수는 목록 주소와 목록 길이가 이미 메모리에 있다고 가정하고 loop에서 시작 하고 끝납니다 li $v0, 10.

 Address    Code        Basic                     Source

0x00400000  0x3c011001  lui $1,4097           5    main:   la      $s0, list       # List address
0x00400004  0x34300000  ori $16,$1,0               
0x00400008  0x2411000a  addiu $17,$0,10       6            li      $s1, 10         # List length
0x0040000c  0x24080000  addiu $8,$0,0         8    loop:   li      $t0, 0          # swapped
0x00400010  0x24090001  addiu $9,$0,1         9            li      $t1, 1          # for loop "i"
0x00400014  0x1131000b  beq $9,$17,11         11   for:    beq     $t1, $s1, fend  # break if i==length
0x00400018  0x00095080  sll $10,$9,2          13           sll     $t2, $t1, 2     # Temp index, multiply by 4
0x0040001c  0x01505020  add $10,$10,$16       14           add     $t2, $t2, $s0   # Combined address
0x00400020  0x8d4b0000  lw $11,0($10)         15           lw      $t3, 0($t2)     # list[i]
0x00400024  0x8d4cfffc  lw $12,-4($10)        16           lw      $t4, -4($t2)    # list[i-1]
0x00400028  0x21290001  addi $9,$9,1          18           addi    $t1, $t1, 1     # i++
0x0040002c  0x016c082a  slt $1,$11,$12        20           ble     $t4, $t3, for   # if list[i-1] > list[i]
0x00400030  0x1020fff8  beq $1,$0,-8               
0x00400034  0xad4bfffc  sw $11,-4($10)        21           sw      $t3, -4($t2)    # swap and store
0x00400038  0xad4c0000  sw $12,0($10)         22           sw      $t4, 0($t2)     
0x0040003c  0x24080001  addiu $8,$0,1         23           li      $t0, 1          # swapped=true
0x00400040  0x08100005  j 0x00400014          24           j       for
0x00400044  0x20010001  addi $1,$0,1          26   fend:   subi    $s1, $s1, 1     # length--
0x00400048  0x02218822  sub $17,$17,$1             
0x0040004c  0x1500ffef  bne $8,$0,-17         27           bnez    $t0, loop       # Repeat if swapped==true
0x00400050  0x2402000a  addiu $2,$0,10        29           li      $v0, 10        
0x00400054  0x0000000c  syscall               30           syscall

이제 x86으로 물에서 날아 오기를 기다립니다.


1
swapped=true초기 체크 아웃을 생략하고 어레이 크기에 따라 카운트 다운 할 수 있습니다 . 8 비트 정수를 정렬하는 20 바이트 x86-16 버전을 참조하십시오 . 어떤 시점에서 32 비트 정수를 정렬하는 일반 32 또는 64 비트 x86 버전을 만들 수도 있지만 16 비트 모드의 8 비트 정수는 x86에 좋은 장소입니다.
Peter Cordes

4

Awk, 66 바이트

{b=$0;a[b]}m<b{m=b}n>b{n=b}END{for(i=n;i<=m;i++)if(i in a)print i}

awk의 배열은 C 배열이 아닌 사전과 같습니다. 인덱스는 비 연속적 일 수 있으며 필요에 따라 커지고 생성됩니다. 따라서 a입력에 대한 배열 을 작성합니다 . 각 행은 키입니다. 그리고 최소값과 최대 값을 저장합니다. 그런 다음 min에서 max로 반복하고에 존재하는 모든 키를 인쇄합니다 a. b의 반복 사용을 피하는 것입니다 $0.


4

파이썬 3, 91 62 47 바이트

def f(z):
 while z:m=min(z);z.remove(m);yield m

골프 도움말을위한 wnnmawSeeq 에게 감사합니다 .

인수 z는 목록이어야합니다. 이것은 선택 정렬의 변형입니다.

나는 확실히 방법을 모르겠어요 min에 대해 스택까지 built-in sorting functions확실 어떻게 파이썬 구현을 아니에요 때문에 min. 이 솔루션은 여전히 ​​괜찮습니다. 의견이나 PPCG 채팅 에서 골프 제안을 환영합니다.


사용중인 정렬 유형을 명시하십시오.
Michelfrancis Bustillos

@MichelfrancisBustillos 나는 이것이 어떤 알고리즘인지 솔직히 잊어 버렸습니다. 선택 정렬 일 수 있습니까?
Sherlock9

1
호기심에서 직접 목록을 작성하는 것이 어떻습니까? 문제는 개방 입력 형식을 허용
wnnmaw

1
@wnnmaw Dang, 그것을 작성했지만 게시하는 것을 잊었습니다. 알림 주셔서 감사합니다 : D
Sherlock9

흠, 아마def f(z):\nwhile z:m=min(z);z.remove(m);yield m
seequ

4

MATL , 11 바이트

`t4#X<2#)tn

온라인으로 사용해보십시오!

이것은 O ( n 2 ) 인 다음 절차에 따라 정렬됩니다 .

  1. 배열의 최소값을 취하십시오.
  2. 배열에서 해당 값을 제거하고 후속 표시를 위해 저장하십시오.
  3. 배열이 비워 질 때까지 나머지 배열에 동일한 절차를 적용하십시오.
  4. 모든 번호를 획득 한 순서대로 표시하십시오.

MATL은 스택 기반입니다. 나머지 값을 가진 배열은 스택의 맨 위에 유지됩니다. 제거 된 값은 순서대로 아래에 있습니다. 프로그램이 끝나면 모든 값이 표시됩니다. 상단의 배열도 표시되지만 비어 있기 때문에 표시되지 않습니다.

`        % Do...while loop
  t      %   Duplicate. Implicitly take input in the first iteration
  4#X<   %   Compute index of mininum of the array
  2#)    %   Push the minimum, and then the array with remaining entries
  tn     %   Duplicate and push number of elements, to be used as loop condition
         % Implicitly end do...while loop
         % Implicitly display stack contents

3

Pyth- 15 13 11 10 바이트

@Jakube 덕분에 2 바이트가 절약되었습니다.

보고 소트.

f!s>VTtT.p

여기에서 온라인으로 사용해보십시오 .

나는 h우리가 복제본이 없다고 보장 되는 cuz를 필요로하지 않는다 .


@Jakube 어리석은 느낌, 감사합니다.
Maltysen

@ 답변에서 언급 한 것처럼 OP에 따라 중복이 보장되지 않습니다.
Maltysen

미안합니다! 그 시점을 놓쳤다.
Suever

3

정말 6 바이트

,;l@╨m

온라인으로 사용해보십시오!

이것은 다른 많은 답변과 동일한 작업을 수행합니다. 모든 순열을 생성하고 최소값을 선택하십시오. 아래 솔루션에서 작업하는 동안 이것이 작동한다는 것을 잊었습니다.

설명:

,;l@╨m
,;l@    push len(input), input
    ╨m  minimum permutation

진지하게, 25 바이트 (비경쟁)

방금 수정 한 셔플 명령의 버그가 아닌 경우 경쟁이 치열합니다.

,1WX╚;;pX@dXZ`i@-0<`MπYWX

온라인으로 사용해보십시오! 이것은 최고의 정렬 알고리즘을 구현합니다 : Bogosort !

설명:

,1WX╚;;pX@dXZ`i@-0<`MπYWX
,                          get input
 1W                    WX  do-while:
   X                         discard
    ╚                        shuffle
     ;;                      dupe twice
       pX@dX                 remove first element of first dupe and last element of second dupe
            Z                zip
             `i@-0<`MπY      test if all differences are positive (if any are not, the list is not sorted), negate (1 if not sorted else 0)

3

MATL, 17 16 바이트

@LuisMendo 덕분에 null 배열을 생성하여 1 바이트를 절약했습니다.

vTbtX<-QI$(f8M+q

버킷 정렬. 2 31 -1 보다 큰 범위에서 시도하지 마십시오 .

온라인으로 사용해보십시오!

설명

v                  % push an empty array
 T                 % push 1
  b                % bubble the input array up to the top of the stack
   t               % duplicate it
    X<             % find the minimum
      -            % subtract min from input array
       Q           % and increment to adjust for 1-based indexing
        I$(        % resulting array used as indices of empty array 
                   % (the [] way up at the top) that are assigned 1 (from T)
           f       % find the nonzero indices
            8M     % magically retrieve the 4th previous function input :/
                     (aka, the min input array value)
              +    % add it to the indices
               q   % and decrement

TIL :

  • 다음을 사용하여 MATL에서 빈 배열을 초기화 할 수 있습니다. []MATLAB에서와 같이 하고 확장 할
  • 사용하는 방법 (할당 인덱싱
  • M자동 클립 보드 를 사용하는 방법

새로운 날, 새로운 TIL :

  • vertcat 스택에 연결할 아무것도 없으면 마술처럼 빈 배열을 만듭니다.

TIL에 추가하십시오 : 이니셜 [] 은로 대체 될 수 있습니다 v. 기본 입력 v수는 스택의 요소 수이기 때문입니다.
Luis Mendo

@LuisMendo Sooo ... 스택에 배열이 하나 있다면 ...? 조사 중.
비커

그런 다음 아무것도하지 않습니다. 다음과 같이 생각하십시오vertcat(STACK{:})
Luis Mendo


3

R, 68 바이트

정렬 된 목록 인 입력 i및 출력 o을 가져옵니다.

o<-i
for(j in 1:length(i)){
x<-(i-min(i))==0
o[j]<-i[x]
i<-i[!x]
}
o

설명:

o<-i                      # Defines output as o
 for(j in 1:length(i)){   # Initializes loop for length of input
  x<-(i-min(i))==0        # Generates logical vector by finding the value 0 
                          # of input less the minimum of input. 
   o[j]<-i[x]             # Puts the smallest value at position j
    i<-i[!x]              # Removes the smallest value from input
      }                   # Ends loop
       o                  # Returns sorted list

순열을 피하면 큰 목록을 비교적 빠르게 정렬 할 수 있습니다. "트릭"은 입력에서 가장 작은 값을 빼면 가장 작은 값과 가장 작은 값의 위치를 ​​결정하는 단일 0이됩니다.


3

자바 8, 112 92 바이트

다른 선택 정렬이 있습니다. 입력은 List t정수이며 정렬 된 출력은 표준 출력으로 인쇄됩니다.

t->{for(;0<t.size();System.out.println(t.remove(t.indexOf(java.util.Collections.min(t)))));}

최신 정보

  • -20 [16-08-21] 람다 사용

비선형 안녕하세요, PPCG에 오신 것을 환영합니다!
isaacg

프로그래밍 퍼즐 및 코드 골프에 오신 것을 환영합니다! 코드에서 변수 t가 존재 한다고 가정하여 코드를 스 니펫으로 만듭니다. 제출물 은 우리를 활용하는 완전한 프로그램 또는 기능 이어야 합니다default I/O formats. We also require imports to factor into the byte count. Let me know if you have any questions!
Alex A.

Thanks for the resources! I modified my answer to be a function and to include the import.
NonlinearFruit

2

Retina, 95

Modified bubble sort. I suspect there are much better ways to do this, even without the retina sort builtin.

-\d+
$*n
\d+
$*11
+`(1+) (n+)
$2 $1
+`\b(n+) (\1n+)|(1+)(1+) \3\b
$2$3 $1$3$4
1(1*)
$.1
n+
-$.&
  • Stage 1 - convert -ve integers to unary with n as the digit; drop the - signs.
  • Stage 2 - convert +ve and zero integers to unary with 1 as the digit; add 1 to each one, so that zero is represented by 1.
  • Stage 3 - Move all -ves to the front.
  • Stage 4 - Sort: move all -ves with the largest magnitude (i.e. smallest numerical) ahead of higher -ves. Move smaller +ves ahead of larger +ves.
  • Stage 5 - Remove 1 from, and convert +ve unaries back to decimal.
  • Stage 6 - convert -ve unaries back to decimal, including sign.

Try it online.



@LeakyNun 목록의 마지막 요소를 정렬하지 않습니다.
mbomb007

@ mbomb007 맞아요.
Leaky Nun

2

Ruby, 22 bytes

빠른 순열 정렬. O (n!) 시간과 공간에서 실행됩니다.

->a{a.permutation.min}

2

Clojure, 73 35 bytes

Bogosort :)

#(if(apply < %)%(recur(shuffle %)))

Earlier version:

#(reduce(fn[r i](let[[a b](split-with(partial > i)r)](concat a[i]b)))[]%)

Reduces to a sorted list r by splitting it into "smaller than i" and "larger than i" parts. I guess this is the insertion sort.


Nice! I did not know you could recur on an anonymous function. Also didn't know about shuffle.
Matias Bjarland

2

Ruby, 26 24 bytes

Selection sort, similar to Value Ink's answer, but using a different approach for greater golfiness.

According to the specification: "Input/output can be done in any method you choose, as long as it is human readable". I think this fits the description, output is an array of arrays with a single element.

->l{l.map{l-l-=[l.min]}}

example:

->l{l.map{l-l-=[l.min]}}[[2,4,3,1]]
=> [[1], [2], [3], [4]]

2

Java 7, 106 104 bytes

void a(int[]a){for(int b=a.length-1,d=0,c=0,e;d<b*b;c=++d%b)if(a[c]>a[c+1]){e=a[c];a[c++]=a[c];a[c]=e;}}

Here's a good ole bubble sort. The function parameter is modified in place so I don't have to return anything. Still trying to squeeze some bytes out of this so I can beat the java lambda that someone posted.

-1 byte thanks to Geobits for pointing out that normal swapping beats xor'ing
-1 byte thanks to Leaky Nun for pointing out that I can move all the int declarations into the for-loop

Try it online!


2

Ruby, 22 bytes

->a{[*a.min..a.max]&a}

Builds an array out of the range between the minimum and maximum elements of the input array. Returns the intersection between the two arrays.


I guess that's a kind of en.wikipedia.org/wiki/Counting_sort.
Peter Cordes

@PeterCordes That was kinda the point
dkudriavtsev

The question asks you to describe what kind of sort it is, so I thought it was useful to link to the well-known algorithm as well as just describing what it actually does.
Peter Cordes

True. Thanks @PeterCordes
dkudriavtsev
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.