문제는 정말 간단합니다. 숫자가 주어지면 숫자가 더 작은 숫자의 배열로 나뉘어 결과 숫자가 줄어들지 않습니다. 캐치는 배열 길이가 최대가되도록 분할해야한다는 것입니다.

혼란 스러운가?

• 편리하고 명확한 입력 형식의 STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 양의 정수가 제공됩니다.
• 숫자의 10 진수를 연속 된 분리 된 그룹으로 분할해야합니다.
• 이 숫자 그룹으로 표시되는 숫자 배열은 그룹을 재 배열하지 않고 정렬해야합니다 (일반적인, 감소 하지 않는 순서로) .
• 그러한 파티션이 둘 이상 존재하는 경우 입력을 가능한 한 많은 수로 분할해야합니다. 동점 인 경우 하나의 결과를 반환하십시오.
• 배열을 STDOUT (또는 가장 가까운 대안)으로 또는 함수 반환 값으로 출력 할 수 있습니다. STDOUT (또는 가장 가까운 대안)의 경우, 배열은 편리하고 명확한 목록 형식으로 인쇄되어야합니다.
• 분할 숫자는 앞에 0이 없어야합니다. 따라서 예를 들어 또는 로만 1002003인쇄 할 수 없으며 유효한 대답은 입니다.[1, 002, 003][1, 2, 3][100, 2003]

테스트 사례 :

123456 -> [1, 2, 3, 4, 5, 6]
345823 -> [3, 4, 5, 8, 23]
12345678901234567890 -> [1, 2, 3, 4, 5, 6, 7, 8, 90, 123, 456, 7890]
102 -> [102]
302 -> [302]
324142 -> [3, 24, 142] OR [32, 41, 42]
324142434445 -> [32, 41, 42, 43, 44, 45]
1356531 -> [1, 3, 5, 6, 531]
11121111111 -> [1, 1, 1, 2, 11, 11, 111]
100202003 -> [100, 202003]

채점

이것은 코드 골프이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

피스, 34

FNyUz#aYmv:zhdedC,+0N+NlzB)efqSTTY

여기에서 온라인으로 사용해보십시오 . 이것은 시간과 공간의 복잡성을 O (n)로한다. 따라서 12345678901234567890온라인 컴파일러에서 테스트 케이스 가 너무 오래 걸립니다. 대신 오프라인을 사용하십시오 (노트북에서 1 분).

이것은 나의 첫 번째 시도 일뿐입니다. 개선의 여지가있을 수 있습니다.

먼저 내 알고리즘이 어떻게 작동하는지 몇 가지 아이디어가 있습니다.

• 입력을 숫자가 아닌 문자열로 해석합니다.
• 그런 다음 가능한 모든 하위 집합을 만듭니다. [0, 1, 2, ..., len(n-1)]
• 이러한 각 하위 집합 (lets [1, 4, 5])에 대해이 숫자를 사용하여 입력 문자열을 부분으로 나눕니다. [input[0:1], input[1, 4], input[4,5], input[5,len(input)]].
• 나중에이 숫자를 문자열로 변환하려고합니다. 두 가지 문제가있을 수 있습니다. Pyth (또는 Python)는 빈 문자열과로 시작하는 숫자 문자열에 대해 예외를 발생 0시킵니다. 따라서 try - catch블록 (즉시 휴식과 함께 실제로 무한 루프)을 사용합니다. 변환에 성공하면 결과를 list에 추가합니다 Y.
• 모든 하위 집합을 처리 한 후 Y이미 정렬 된 결과 목록 을 필터링 하고 마지막 항목 (마지막 그룹이 가장 많은 그룹)을 인쇄합니다.

이제 자세한 설명 :

                            Implicit: z = input() (z is a String!)
                                      Y = empty list
FNyUz                       for each subset N of [0, 1, 2, ..., len(z)-1]:

     #                         start try-catch block (actually an infinite loop, 
                               but the Python implementation uses a try catch. 

      aY                          append to Y:
                C,+0N+Nlz            zip([0] + N, N + [len(z)])
        m                            map each element d to
          :zhded                     z[d[0]:d[-1]]
         v                           evaluated
                         B        if this didn't throw an exception already, end the infinite loop
                          ) end for loop   

 f    Y      filter Y for elements T, for which
  qSTT           sorted(T) == T
e            and print the last one (the subsets generated with yUz are sorted 
             by length, so the last one has the most groups)

매쓰, 134 127 바이트

유효한 파티션보다 훨씬 많은 파티션을 생성하기 때문에 이는 매우 비효율적 입니다. 324142434445테스트 케이스는 몇 초에서 실행,하지만 난 노력하지 것이다 12345678901234567890.

f/@Last@Select[Needs@"Combinatorica`";f=FromDigits;SetPartitions[d=IntegerDigits@#],0<=##&@@f/@#&&Join@@#==d&&#~FreeQ~{0,__}&]&

정수를 사용하고 정수 목록을 반환하는 명명되지 않은 함수를 정의합니다.

설명

이 코드의 읽기 순서는 모든 곳에서 조금씩 읽히므로 읽 히려는 순서대로 세분화합니다 (대부분 평가).

• d=IntegerDigits@#입력의 10 진수를 구하고이 목록을에 할당하십시오 d.

• SetPartitions(필요한 Needs@"Combinatorica`";)이 모든 파티션을 제공합니다. 그러나 입력을 set 으로 취급하기 때문에 실제로 원하는 것보다 훨씬 더 많이 반환합니다 . 이것이 비효율적이지만 모든 목록 파티션을 얻는 가장 짧은 방법이 훨씬 길기 때문에 이것을 사용하고 있습니다. 예를 들어,리스트가 {1, 2, 3}함수 인 경우 다음 을 리턴합니다.

  {{{1, 2, 3}}, {{1}, {2, 3}}, {{1, 2}, {3}}, {{1, 3}, {2}}, {{1}, {2}, {3}}}
  

  a) 연속 파티션은 모두 올바른 순서이며 b) 파티션은 가장 거친 것부터 가장 좋은 것까지 정렬됩니다.

• Select[...,...&] 그런 다음 두 번째 인수로 전달 된 익명 함수로이 목록을 필터링합니다.
  • Join @@ # == d 실제로 일반 설정 파티션 대신 목록 파티션이 있는지 확인합니다.
  • #~FreeQ~{0, __} 파티션이 선행 0으로 시작하지 않는지 확인합니다.
  • 0 <= ## & @@ f /@ #좀 더 모호합니다. 먼저 FromDigits파티션의 각 목록에 매핑 하여 숫자로 표시되는 숫자를 복구합니다. 그런 다음 0 <= ##해당 숫자에 적용 합니다. 여기서 ##모든 숫자를 나타냅니다. 파티션이 {1, 23, 45}다음으로 확장 0 <= 1 <= 23 <= 45되면 배열이 정렬되었는지 확인합니다.
• Last@그런 다음 필터링 후 마지막으로 남은 파티션을 제공합니다.이 기능은 SetPartitions이미 파티션을 정렬 했기 때문에 작동하므로 가장 좋은 파티션은 끝납니다.
• 마지막으로 f/@숫자 목록에서 숫자를 복구합니다.

파이썬 3, 134 바이트

def f(s,n=0,L=[],R=[],i=0):
 while s[i:]:i+=1;m=int(s[:i]);R=max([f(s[i:],m,L+[m]),R][m<n or"1">s[i:]>"":],key=len)
 return[L,R][s>""]

조금 지저분하지만 오. 프로그램은 모든 유효한 파티션을 재귀 적으로 생성합니다. 흥미로운 부분은 선행 제로를 허용하지 않기 위해 필요한 모든 추가 or "1">s[i:]>""조건이었습니다.

입력을 좋아 f("12345678901234567890")하고 정수 목록을 리턴합니다.

피스, 62 61 60

JlzKkef&qJsml`dTqTSTolNmmibTcjKsC,z+m>Ndt>+*J]0jk2_JKNU^2-J1

설명

이 알고리즘은 입력 길이 인 0(포함)과 2^(n-1)(제외) 사이의 모든 이진수를 생성하여 작동 n합니다.

그런 다음 각각의 이진수 N는 1의 경우 구분 기호 ( )에 매핑되고 0의 경우 아무 것도 매핑 되지 않습니다.

그런 다음 이러한 문자를 각 입력 문자 사이에 삽입하고 결과를 N로 나누면 목록이 생성됩니다.

그런 다음 목록의 값을 정수로 구문 분석하고 목록을 길이별로 정렬합니다. 그런 다음 남은 것은 정렬되지 않은 항목과 선행 0으로 분할 된 항목을 필터링하는 것입니다. 그 후 가장 긴 목록이 선택됩니다.

Jlz                                                   set J to len(input)
Kk                                                    set K to ""
e                                                     take the last of:
 f&                                                    only take lists where:
   qJsml`dT                                             sum of string lengths of items
                                                        is equal to length of input and
           qTST                                         list is in order
               olN                                       sort by length
                  m                                       map k over...
                   mibT                                    convert items to int (base-10)
                       c                        N           split by N
                        jK                                   join by ""
                          s                                   sum to combine tuples
                           C,z                                 zip input with
                              +                K                append [""] for equal lengths
                               m>Nd                              replace 1 with N, 0 with ""
                                   t                              take all but first
                                    >        _J                    take len(input) last values
                                     +                              pad front of binary with
                                      *J]0                           [0] times input's length
                                          jk2                        current k in binary
                                                 U^2-J1  range 0..2^(len(input)-1)-1

(비경쟁) Pyth, 25 바이트

ef&&Fmnhd\0T.A<V=NsMTtN./

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

작동 방식 :

ef&&Fmnhd\0T.A<V=NsMTtN./  Q = eval(input())
                         ./  all partitions of Q
 f                       ./  filter all partitions of Q where:
  &                            both:
   &Fmnhd\0T                     neither substring starts with "0"
                               and:
            .A<V=NsMTtN          all entries are less than their proceeding ones
e                            returns the last amongst the filtered partitions

J, 109 바이트

매우 길지만 적어도 O (n * (2n)!) 메모리와 O (n * log (n) * (2n)!) 시간을 차지합니다. 여기서 n은 입력 길이입니다. (5 자리 이상으로 실행하지 마십시오.)

f=.3 :0
>({~(i.>./)@:(((-:/:~)@(#$])*#)@>))<@".(' 0';' _1')rplc"1~(#~y-:"1' '-."#:~])(i.!2*#y)A.y,' '#~#y
)

이 함수는 입력을 문자열로 사용합니다.

예 :

   f every '5423';'103';'1023'
  5 423
103   0
 10  23

방법:

• 길이와 동일한 수의 공백을 입력에 추가하십시오.
• 가능한 모든 방법으로 그것을 퍼밋하십시오.
• 공백없는 문자열이 입력과 같은지 확인하십시오 (즉, 파티션 임).
• 선행 0 솔루션을 무효화하려면 '0'을 '_1'로 바꾸십시오.
• 각 문자열을 평가하십시오.
• 정렬 된 가장 긴 목록을 찾으십시오. 이것이 반환 값입니다.

하스켈, 161 바이트

(#)=map
f[x]=[[[x]]]
f(h:t)=([h]:)#f t++(\(a:b)->(h:a):b)#f t
g l=snd$maximum[(length x,x::[Int])|x<-[read#y|y<-f l,all((/='0').head)y],and$zipWith(>=)=<<tail$x]

시운전 :

*Main> mapM_ (print . g) ["123456","345823","12345678901234567890","102","302","324142","324142434445","1356531","11121111111","100202003"]
[1,2,3,4,5,6]
[3,4,5,8,23]
[1,2,3,4,5,6,7,8,90,123,456,7890]
[102]
[302]
[32,41,42]
[32,41,42,43,44,45]
[1,3,5,6,531]
[1,1,1,2,11,11,111]
[100,202003]

작동 방식 : 도우미 기능 f은 입력 목록을 가능한 모든 하위 목록으로 분할합니다. g먼저 하위 목록이있는 사람과 0올바른 순서가없는 사람을 버립니다 . 나머지 모든 목록을 길이와 쌍을 이루고 최대 값을 취한 후 길이 부분을 다시 버립니다.