도전

비어 있지 않은 정수 배열을 예로 들면 :

[5, 2, 7, 6, 4, 1, 3]

먼저 이전보다 큰 항목이없는 배열 (예 : 비 오름차순 배열)로 분할하십시오.

[5, 2] [7, 6, 4, 1] [3]

다음으로 각 배열을 반대로 바꿉니다.

[2, 5] [1, 4, 6, 7] [3]

마지막으로, 그것들을 모두 함께 연결하십시오 :

[2, 5, 1, 4, 6, 7, 3]

이것은 프로그램 출력 / 함수가 반환하는 것이어야합니다. 이 절차를 충분히 반복하면 배열이 완전히 정렬됩니다.

규칙

• 입력 및 출력은 표준 방법을 통해 제공 될 수 있으며 합리적인 배열 형식 일 수 있습니다.
• 입력 배열은 절대 비어 있지 않지만 음수 및 / 또는 중복이 포함될 수 있습니다.
• 각 정수의 절대 값은 항상 2 ³¹ 미만 입니다.

테스트 사례

바라건대 이들은 모든 에지 케이스를 다룹니다.

[1] -> [1]
[1, 1] -> [1, 1]
[1, 2] -> [1, 2]
[2, 1] -> [1, 2]
[2, 3, 1] -> [2, 1, 3]
[2, 1, 3] -> [1, 2, 3]
[2, 1, 2] -> [1, 2, 2]
[2, 1, 1] -> [1, 1, 2]
[3, 1, 1, 2] -> [1, 1, 3, 2]
[3, 2, 1, 2] -> [1, 2, 3, 2]
[3, 1, 2, 2] -> [1, 3, 2, 2]
[1, 3, 2, 2] -> [1, 2, 2, 3]
[1, 0, 5, -234] -> [0, 1, -234, 5]
[1, 0, 1, 0, 1] -> [0, 1, 0, 1, 1]
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
[5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
[2, 1, 5, 4, 3] -> [1, 2, 3, 4, 5]
[2, 3, 1, 5, 4] -> [2, 1, 3, 4, 5]
[5, 1, 4, 2, 3] -> [1, 5, 2, 4, 3]
[5, 2, 7, 6, 4, 1, 3] -> [2, 5, 1, 4, 6, 7, 3]
[-5, -2, -7, -6, -4, -1, -3] -> [-5, -7, -2, -6, -4, -3, -1]
[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9] -> [3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

채점

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

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

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

재귀 FTW! 여기서 사용되는 기본 알고리즘은 배열에서 현재 비 오름차순 실행을 추적하여 오름차순 요소가 발견 될 때마다 "반환"하는 것입니다. 우리는 항목이 다 떨어질 때까지 반복적으로 결과를 연결하여 반복적으로 수행합니다. 을 [n,...z]대신 하여 각 런을 역순으로 만들면 무료로 [...z,n]긴 시간 .reverse()을 피할 수 있습니다 .

테스트 스 니펫

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

g=a=>console.log("Input:",`[${a}]`,"Output:",`[${f(a)}]`)

g([1])
g([1,1])
g([1,2])
g([2,1])
g([3,2,1])
g([3,1,2])
g([3,1,1,2])
g([5,2,7,6,4,1,3])

<input id=I value="5, 2, 7, 6, 4, 1, 3">
<button onclick="g((I.value.match(/\d+/g)||[]).map(Number))">Run</button>

파이썬 3 , 63 바이트

f=lambda x,*p:x[:1]>p>()and p+f(x)or x and f(x[1:],x[0],*p)or p

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

젤리 , 8 바이트

Ṁ;<œṗ³UF

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

설명:

Ṁ;         Prepend the list [a1, a2… an] with its maximum.
  <        Elementwise compare this with the original list:
           [max(a) < a1, a1 < a2, …, a(n-1) < an, an]
           The first element is always 0.
   œṗ³     Partition the original list (³) at the indices
           of the non-zero values in the working list.
           (The spurious `an` at the end of the left argument,
           resulting from comparing lists of different sizes,
           is ignored by this operation, thankfully.)
      U    Reverse each part.
       F   Flatten.

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

물론, 이것은 이미 ETHproductions answer에 의해 극복 되었지만 재귀를 사용하지 않고 지금까지 얻을 수있는 최선입니다.

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

참고 : 모두 초기화 r와 o함께 동일한 개체에하는 것은 r = o = []위험한 생각처럼 보일 수 있습니다. 그러나 와의 첫 번째 반복에서 r자체 인스턴스 (의 첫 번째 요소 포함)가 즉시 지정 되므로 여기에서 그렇게하는 것이 안전합니다 .ar = [n, ...r]

테스트 사례

let f =

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

console.log(JSON.stringify(f([1])));
console.log(JSON.stringify(f([1, 1])));
console.log(JSON.stringify(f([1, 2])));
console.log(JSON.stringify(f([2, 1])));
console.log(JSON.stringify(f([2, 3, 1])));
console.log(JSON.stringify(f([2, 1, 3])));
console.log(JSON.stringify(f([2, 1, 2])));
console.log(JSON.stringify(f([2, 1, 1])));
console.log(JSON.stringify(f([3, 1, 1, 2])));
console.log(JSON.stringify(f([3, 2, 1, 2])));
console.log(JSON.stringify(f([3, 1, 2, 2])));
console.log(JSON.stringify(f([1, 3, 2, 2])));
console.log(JSON.stringify(f([1, 0, 5, -234])));
console.log(JSON.stringify(f([1, 0, 1, 0, 1])));
console.log(JSON.stringify(f([1, 2, 3, 4, 5])));
console.log(JSON.stringify(f([5, 4, 3, 2, 1])));
console.log(JSON.stringify(f([2, 1, 5, 4, 3])));
console.log(JSON.stringify(f([2, 3, 1, 5, 4])));
console.log(JSON.stringify(f([5, 1, 4, 2, 3])));
console.log(JSON.stringify(f([5, 2, 7, 6, 4, 1, 3])));
console.log(JSON.stringify(f([-5, -2, -7, -6, -4, -1, -3])));
console.log(JSON.stringify(f([14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9])));

MATL , 15 바이트

lidO>vYsGhXSOZ)

입력은 형식을 가진 열 벡터입니다 [5; 2; 7; 6; 4; 1; 3](세미콜론은 행 구분 기호 임).

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

[5; 2; 7; 6; 4; 1; 3]예를 들어 입력하십시오 .

설명

l     % Push 1
      % STACK: 1
i     % Push input
      % STACK: 1, [5; 2; 7; 6; 4; 1; 3]
d     % Consecutive differences
      % STACK: 1, [-3; 5; -1; -2; -3; 2]
O>    % Test if greater than 0, element-wise
      % STACK: 1, [0; 1; 0; 0; 0; 1]
v     % Concatenate vertically
      % STACK: [1; 0; 1; 0; 0; 0; 1]
Ys    % Cumulative sum
      % STACK: [1; 1; 2; 2; 2; 2; 3]
G     % Push input again
      % STACK: [1; 1; 2; 2; 2; 2; 3], [5; 2; 7; 6; 4; 1; 3]
h     % Concatenate horizontally
      % STACK: [1 5; 1 2; 2 7; 2 6; 2 4; 2 1; 3 3]
XS    % Sort rows in lexicographical order
      % STACK: [1 2; 1 5; 2 1; 2 4; 2 6; 2 7; 3 3]
OZ)   % Get last column. Implicitly display
      % STACK: [2; 5; 1; 4; 6; 7; 3]

매스 매 티카, 30 27 바이트

^{@Martin Ender 로 인해 3 바이트가 저장되었습니다 .}

Join@@Sort/@Split[#,#>#2&]&

익명의 기능. 숫자 목록을 입력으로 사용하고 숫자 목록을 출력으로 반환합니다.

파이썬 2, 100 바이트

정말 끔찍한 골프이지만 솔루션을 게시하고 싶었습니다 (데니스를 단순히 능가하지는 않습니다) ...

d=input();L=[];x=0;d+=-~d[-1],
for i in range(1,len(d)):
 if d[i]>d[i-1]:L+=d[x:i][::-1];x=i
print L

repl.it에서 테스트하십시오!

입력은와 같은 Python 목록 리터럴로 제공되어야합니다 [5, 3, 4, 2, 6, 1].

기본적인 아이디어는 파이썬의 슬라이싱 구문을 많이 사용하여 배열에서 필요한 각 섹션을 슬라이싱하고 반전시킨 다음 새 배열에 추가하는 것입니다.

파이크, 11 8 바이트 ( 이전 버전 )

$0m<fm_s

여기 사용해보십시오! (최신 버전에서 작동)

$        -     delta(input)
 0m<     -    map(i<0 for i in ^)
    f    -   split_at(input, ^)
     m_  -  map(reverse, ^)
       s - sum(^)

레티 나 163 바이트

예, 이것이 얼마나 무서운지 압니다. 제로와 네거티브를 지원하는 것은 매우 재미있었습니다. 바이트 수는 ISO 8859-1 인코딩을 가정합니다.

\d+
$*
(?<=-1*)1
x
-

x,1
x¶1
\b(1+),(1+\1)\b
$1¶$2
,,1
,¶1
x,(¶|$)
x¶¶
(?<=\b\1x+(?=,(x+))),\b
¶
O%$#`.(?=(.*))
$.1
+`¶
,
\bx
-x
(\w+)
$.1
^,
0,
,$
,0
,,
,0,
^$
0

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

설명:

\d+                         # Convert to unary
$*
(?<=-1*)1                   # Replace negatives with x's instead of 1's
x
-                           # Remove minus sign

x,1                         # Separate if negative before positive
x¶1
\b(1+),(1+\1)\b             # or greater positive follows a positive
$1¶$2
,,1                         # or positive follows a zero
,¶1
x,(¶|$)                     # or zero follows a negative
x¶¶
(?<=\b\1x+(?=,(x+))),\b     # or negative follows a negative of greater magnitude.
¶
O%$#`.(?=(.*))              # Swear at the input, then reverse each line
$.1
+`¶                         # Remove breaks, putting commas back
,
\bx                         # Put the minus signs back
-x
(\w+)                       # Replace unary with length of match (decimal)
$.1
^,                          # Do a bunch of replacements to resurrect lost zeros
0,
,$
,0
,,
,0,
^$
0

05AB1E , 19 18 16 14 바이트

Luis Mendo의 정렬 트릭을 사용하여 2 바이트 절약

ü‹X¸ì.pO¹)ø{ø¤

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

설명

입력 예 [5, 2, 7, 6, 4, 1, 3]

ü‹               # pair-wise less-than
                 # STACK: [0, 1, 0, 0, 0, 1]
  X¸ì            # prepend a 1
                 # STACK: [1, 0, 1, 0, 0, 0, 1]
     .p          # prefixes
       O         # sum
                 # STACK: [1, 1, 2, 2, 2, 2, 3]
        ¹        # push input
                 # STACK: [1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]
         )       # wrap stack in list
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]]
          ø      # zip
                 # STACK: [[1, 5], [1, 2], [2, 7], [2, 6], [2, 4], [2, 1], [3, 3]]
           {     # sort
                 # STACK: [[1, 2], [1, 5], [2, 1], [2, 4], [2, 6], [2, 7], [3, 3]]
            ø    # zip
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [2, 5, 1, 4, 6, 7, 3]]
             ¤   # tail
                 # OUTPUT: [2, 5, 1, 4, 6, 7, 3]

이전 16 바이트 솔루션

Dü‹X¸ì.pO.¡€g£í˜

자바 스크립트 (ECMA 6) 121 128 125 119 108 바이트

f=a=>{p=a[0],c=[],b=[];for(e of a){e>p&&b.push(c.reverse(c=[]));c.push(p=e)}return[].concat.call([],...b,c)}

Lambda 표현식은 단일 Array매개 변수 인을 사용 a합니다.

첫 번째 실수를 볼 수 있도록 도와 준 @ETHproductions에게 감사합니다.

루비, 60 55 바이트

s=->x{x.slice_when{|p,q|p<q}.map{|z|z.reverse}.flatten} 

도전이 요구 한 것. I는 람다 정의 된 s어레이를 취 x하며 단절 다음 요소는보다 큰 것보다 작은 조각으로 (슬라이스). 이것은 열거자를 돌려줍니다. 우리는 map을 호출 하고 조각의 순서를 뒤집을 수 있습니다. 마침내 모든 요소 를 flatten과 함께 가져 오기 전에 정의 된 순서대로 요소를 하나의 배열로 연결 합니다.

테스트

p s[[1]]===[1]
p s[[1, 1]]===[1, 1]
p s[[1, 2]]===[1, 2]
p s[[2, 1]]===[1, 2]
p s[[2, 3, 1]]===[2, 1, 3]
p s[[2, 1, 3]]===[1, 2, 3]
p s[[2, 1, 2]]===[1, 2, 2]
p s[[2, 1, 1]]===[1, 1, 2]
p s[[3, 1, 1, 2]]===[1, 1, 3, 2]
p s[[3, 2, 1, 2]]===[1, 2, 3, 2]
p s[[3, 1, 2, 2]]===[1, 3, 2, 2]
p s[[1, 3, 2, 2]]===[1, 2, 2, 3]
p s[[1, 0, 5, -234]]===[0, 1, -234, 5]
p s[[1, 0, 1, 0, 1]]===[0, 1, 0, 1, 1]
p s[[1, 2, 3, 4, 5]]===[1, 2, 3, 4, 5]
p s[[5, 4, 3, 2, 1]]===[1, 2, 3, 4, 5]
p s[[2, 1, 5, 4, 3]]===[1, 2, 3, 4, 5]
p s[[2, 3, 1, 5, 4]]===[2, 1, 3, 4, 5]
p s[[5, 1, 4, 2, 3]]===[1, 5, 2, 4, 3]
p s[[5, 2, 7, 6, 4, 1, 3]]===[2, 5, 1, 4, 6, 7, 3]
p s[[-5, -2, -7, -6, -4, -1, -3]]===[-5, -7, -2, -6, -4, -3, -1]
p s[[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9]]===[3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

Brachylog , 10 바이트

~c:{>=r}ac

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

설명

~c            Deconcatenate the Input
  :{>=r}a     Each resulting sublist must be non-increasing, and then reverse it
         c    Concatenate

Dyalog APL , 7 15 바이트

⎕ML←3많은 시스템에서 기본값 인이 필요합니다 . *

{∊⌽¨⍵⊂⍨1+⍵-⌊/⍵}

∊ 입대하다

⌽¨ 각각의 역전

⍵⊂⍨ 각 해당 요소가 이전 요소보다 큰 위치를 잘라서 분할 된 인수 *

1+ 하나 더하기

⍵- 인수 빼기

⌊/⍵ 논쟁의 가장 작은 요소

이전 7 바이트 솔루션은 양수가 아닌 정수로 실패합니다.

⎕ML←3많은 시스템에서 기본값 인이 필요합니다 . *

∊⌽¨⊆⍨⎕

∊ 입대하다

⌽¨ 각각의 역전

⊂⍨ 자체 파티션 된 *

* Partition ( ⊂)은 해당 왼쪽 인수가 이전 인수보다 큰 경우 오른쪽 인수를 잘라내는 함수입니다. (불행히도 음이 아닌 정수만 받아들이고 0은 특별한 의미를 갖습니다.) 버전 16부터이 기능은 ⊂모든 시스템 (어느 곳에서도 ⎕ML≠3)에서 glyph를 사용하여 사용할 수 있습니다 ⊆.

하스켈, 49 바이트

(a:b)%l|any(<a)l=l++b%[a]|1<2=b%(a:l)
_%l=l
(%[])

사용 예 : (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

재귀 적 접근. 이 함수 %는 입력 목록을 첫 번째 매개 변수로, 누적 l되지 않은 청크를 역순으로 추적 하는 누적기를 사용합니다. 입력 목록이 비어 있으면 기본 사례에 도달 한 다음 결과가 누산기입니다. 입력 목록이 비어 a있지 않고 첫 번째 요소 가 현재 청크 ( any(<a)l)에 맞지 않는 경우 누산기를 반환하고 목록의 나머지 부분과 a새 누산기 ( l++b%[a]) 로 재귀 호출을 추가하십시오 . 그렇지 않으면 목록의 나머지 부분을 재귀 적으로 호출하고 a누적 기 앞에 추가하십시오 ( b%(a:l)). 주 함수 는 빈 누산기를 사용하여 (%[])호출합니다 %.

레티 나 , 98 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

$

-(\d+)
$1$*-/
\d+
$*
S-`(?<=(-+)/ )(?!\1)|(?=\b(1+))(?<!\2 )
O%`\S* 
¶

((-)|1)*/? 
$2$#1 
 $

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

R, 64 바이트

cat(unlist(lapply(split(x<-scan(),cumsum(c(F,diff(x)>0))),rev)))

stdin에서 입력을 읽습니다. 입력 split()을 그룹화하는 요인 변수가 필요한 벡터 목록으로 입력을 분할합니다 . 차이가 양수인 논리 벡터의 누적 합을 취하여 인수를 만듭니다.

벡터를 고려하십시오.

x=c(5, 2, 7, 6, 4, 1, 3)

이제 차이를 가져 와서 F실행 y=c(F,diff(x)>0)하여 다음과 같은 논리 벡터를 생성합니다.

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

누적 합을 취하면 cumsum(y)각 그룹이 split함수 와 결합 할 수있는 고유 한 요인으로 표시되는 벡터가 생성 됩니다.

[1] 0 0 1 1 1 1 2

옥타브, 75 44 바이트

@LuisMendo의 MATL 답변 기반

@(a)sortrows([cumsum([1;diff(a)>0]),a])(:,2)

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

이전 답변

@(a)[fliplr(mat2cell(f=fliplr(a),1,diff(find([1,diff(f)<0,numel(a)])))){:}]

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

배열을 반대로

f=fliplr(a)

첫번째 차이를 취하다 f

d = diff(f);

다음 요소가 이전 요소보다 작은 위치 찾기

p=find([1,diff(f)<0,numel(a)])

위치의 첫 번째 차이는 각 하위 배열의 길이를 반환합니다.

len=diff(p)

각 하위 배열의 길이를 mat2cell 하여 배열을 중첩 된 배열 목록으로 분할

nest = mat2cell(f,1,len);

중첩 된 목록을 반대로

rev_nest = fliplr(nest) 

중첩 된 목록을 평평하게하다

[rev_nest{:}]

Pyth-15 바이트

s_McQf<@QtT@QTU

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

펄 6 , 59 바이트

{map |+«*.[0].reverse,m/:s([(\-?\d+)<?{[>=] $0}>] +)+/[0]}

정규식 기반 솔루션. 스파르타 펄
이기 때문에 !!

• m/ /: 입력 배열을 문자열 화하고 정규식과 일치시킵니다.
• (\-? \d+): 숫자를 일치시키고로 캡처합니다 $0.
• <?{ [>=] $0 }>: $0현재 하위 일치에서 지금까지 캡처 된 모든 항목이 오름차순이 아닌 경우에만 일치하는 폭이 0 인 어설 션입니다 .
• ([ ] +)+: 가능한 한 마지막 두 단계를 반복하고, 그렇지 않으면 새로운 하위 경기를 시작하십시오.
• map , [0]: 하위 일치를 반복합니다.
• |+«*.[0].reverse: 각각에 대해 일치하는 값 목록을 가져 와서 $0반대로 +«바꾸고 값을 숫자로 강제 변환하고 ( |) 외부 목록으로 미끄러 뜨 립니다 ( ).

펄 6 , 63 바이트

sub f(\a){flat $_,f a[+$_..*]with first {[<=] $_},:end,[\R,] a}

재귀 목록 처리 솔루션.
내가 기대했던 것보다 더 힘들었습니다.
이 언어에는 편리한 내장 기능이 많이 있지만 목록 분할 (예 : Ruby 's slice_when또는 Haskell 's takeWhile)은 없습니다.

스택 된 비경쟁, 34 바이트

이 언어를 계속 개발하고 있습니다.

{e.b:e b last<}chunkby$revmap flat

인수는 TOS에 있습니다. 여기 사용해보십시오!

chunkby함수를 취하고 함수를 만족시키는 연속적인 데이터 배열을 수집합니다. 기능은 다음과 같습니다.

{e.b:e b last<}
{e.b:         }  function with arguments [e, <unused>, b]--the element, <the index>, and the
                 chunk being built
     e       <   check if e is less than
       b last    the last element of b

이것은 엄격하게 감소하는 배열을 제공합니다.

$revmap기본적으로 [rev]map각 항목을 반대로합니다.

flat 마지막으로 배열을 평평하게합니다.

실제로 배열을 정렬하는 재미 :

[{e.b:e b last<}chunkby$revmap flat] @:sortstep
[$sortstep periodloop] @:sort

10:> @arr
arr out
arr shuf @arr
arr out
arr sort out

예를 들어 다음과 같이 출력됩니다.

(0 1 2 3 4 5 6 7 8 9)
(4 5 1 0 6 7 2 8 9 3)
(0 1 2 3 4 5 6 7 8 9)

파이썬 151 139 바이트

@ Flp.Tkc 덕분에 12 바이트를 절약했습니다!

@ Flp.Tkc 근처에는 아무 것도 없습니다.

def s(l):
 r=[];i=j=0
 while j<len(l)-1:
  if l[j+1]>l[j]:r+=l[i:j+1][::-1],;i=j+1
  j+=1
 r+=l[i:j+1][::-1],;return[i for s in r for i in s]

파이썬 2, 74 바이트

b=[];c=[];a+=9e9,
for i in a[:-1]:
 b=[a.pop(0)]+b
 if b[0]<a[0]:c+=b;b=[]

입력 a, 출력c

파이썬 3, 191 바이트

a=[int(i)for i in input().split()]
while a!=sorted(a):
 b=[[]]
 for i,j in enumerate(a):
  if a[i-1]<j:b+=[[j]]
  else:b[-1]+=[j]
 a=[]
 for l in[k[::-1]for k in b]:a+=[k for k in l]
print(a)

확인 sorted하기 위해 함수를 사용할 수 있는지 확실하지 않지만 그에 대한 합당한 이유를 생각할 수 없었으며 바이트 수가 ~ 30 바이트 줄었습니다.

클로저, 105 바이트

#(filter number?(mapcat reverse(partition-by not(mapcat(fn[[a b]][a(< b a)])(partition 2 1(conj % 1))))))

연속 번호, 풋에 쌍으로 파티션 true또는 false그들 사이는의 파티션 not에 true와 숫자가 false와 false true, 반전 파티션 및 숫자 값을 유지합니다.