그래픽 서열 A의 노드에 대한 에지의 개수를 나타내는 양의 정수 각각의 서열이다 간단한 그래프 . 예를 들어, 순서 2 1 1는 2 개의 모서리가있는 노드 3 개와 하나의 연결이있는 노드 2 개가있는 그래프를 나타냅니다.

모든 시퀀스가 ​​그래픽 시퀀스 인 것은 아닙니다. 예를 들어 2 1두 노드를 연결하는 방법이 없어서 노드 중 하나에 두 개의 모서리가 있으므로 그래픽 시퀀스가 ​​아닙니다.

직무

합리적인 방법 으로 정수 시퀀스를 가져옵니다 . 여기에는 정수 배열과 크기, 부호없는 정수의 연결된 목록 및 복식 벡터 가 포함 되지만 이에 국한되지는 않습니다 . 입력에 0이 없다고 가정 할 수 있습니다. 입력이 최소에서 최대로 또는 최대에서 최소로 정렬되었다고 가정 할 수도 있습니다.

시퀀스가 그래픽 시퀀스인지 여부를 출력해야합니다. 그렇지 않으면 거짓 값이면 진실한 값입니다.

골

이것은 코드 골프 목표는 프로그램의 바이트 수를 최소화하는 것입니다.

테스트 케이스

최소에서 최대로 정렬

                  -> True
3 3 3 2 2 2 1 1 1 -> True
3 3 2 2 1 1       -> True
3 3 2             -> False
8 1 1 1 1 1 1 1 1 -> True
1 1 1 1           -> True
1 1 1             -> False
9 5 4             -> False

Mathematica, 25 바이트

<<Combinatorica`
GraphicQ

예, 또 다른 내장. (입력을 양의 정수 목록으로 가져옵니다.) Combinatorica패키지를 로드해야 합니다.

Python 2 (종료 코드), 53 바이트

l=input()
while any(l):l.sort();l[~l[-1]]-=1;l[-1]-=1

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

종료 코드를 통해 출력합니다.

Havel-Hakimi 알고리즘 버전을 사용합니다. 가장 큰 요소 k와 k가장 큰 요소 ( k자체를 세지 않음 )를 반복적으로 감소시킵니다 . 이는 두 정점 사이의 모서리를 해당 각도로 할당하는 것에 해당합니다. 목록이 모두 0이되면 성공적으로 종료됩니다. 그렇지 않으면 인덱스가 범위를 벗어난 경우 오류와 함께 실패합니다. 생성 된 음수 값은 결국 범위를 벗어난 오류로 이어집니다.

CJam (20 바이트)

{{W%(Wa*.+$_0a<!}g!}

몇 가지 추가 테스트를 포함하여 온라인 테스트 스위트를 사용 하여 일부 시도에서 버그를 발견했습니다.

이것은 익명 블록 (함수)으로 스택에서 정수 배열을 가져와 스택 0또는 1스택에서 가져옵니다. 입력이 오름차순으로 정렬되어 있다고 가정합니다.

입력 배열은 비어 있지 않을 수 있지만 빈 입력의 주제에 대한 내 쿼리에 대한 OP의 답변에 따라 0을 포함 할 수 있습니다.

해부

이것은 Havel-Hakimi 알고리즘 구현에 대한 OP의 답변을 따릅니다 .

{          e# Define a block
  {        e#   Do-while loop (which is the reason the array must be non-empty)
           e#     NB At this point the array is assumed to be non-empty and sorted
    W%     e#     Reverse
    (Wa*.+ e#     Pop the first element and subtract 1 from that many subsequent
           e#     elements. If there aren't enough, it adds -1s to the end. That's
           e#     the reason for using W (i.e. -1) and .+ instead of 1 and .-
    $      e#     Sort, restoring that part of the invariant
    _0a<!  e#     Continue looping if array >= [0]
           e#     Equivalently, break out of the loop if it starts with a negative
           e#     number or is empty
  }g
  !        e#   Logical not, so that an empty array becomes truthy and an array
           e#   with a negative number becomes falsy
}

파이썬 2 , 108 바이트

다음은 Python으로 구현 한 것입니다. 더 숙련 된 골퍼 나 수학자가 이길 수 있다고 확신합니다. Havel-Hakimi 알고리즘을 구현합니다.

def f(x):p=x[0]+1;x=sorted(x+[0]*p)[::-1];return~x[-1]and(p<2or f(sorted([a-1for a in x[1:p]]+x[p:])[::-1]))

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

하스켈 , 102 98 95 94 바이트

import Data.List
f(x:r)=length r>=x&&x>=0&&(f.reverse.sort$take x(pred<$>r)++drop x r)
f x=1<3

온라인으로 사용해보십시오! 사용법 : f [3,3,2,2,1,1], 리턴 True또는 False. 챌린지에 허용 된대로 입력 에 0이없고 내림차순으로 정렬 되었다고 가정합니다 .

설명:

import Data.List          -- import needed for sort
f (x:r) =                 -- x is the first list element, r the rest list
  length r >= x           -- the rest list r must be longer or equal x
  && x >= 0               -- and x must not be negative
  && (f .                 -- and the recursive call of f
      reverse . sort $    --    with the descendingly sorted list
      take x(pred<$>r)    --    of the first x elements of r subtracted by 1
      ++ drop x r         --    and the rest of r
     )                    -- must be true
f [] = True               -- if the list is empty, return True

편집 : 이것은 답변을 작성할 때이 알고리즘을 몰랐지만 다른 답변에서 언급 한 Havel-Hakimi를 따르는 것 같습니다.

젤리 , 12 바이트

ṢṚḢ-€+ƊƊƬ>-Ȧ

1답변이 다른 경우 일관성을 유지 하는 목록을 허용하는 모나드 링크 0.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

ṢṚḢ-€+ƊƊƬ>-Ȧ - Link: list of integers
        Ƭ    - collect up while results change:
       Ɗ     -   last three links as a monad i.e. f(L):
Ṣ            -     sort                      [min(L),...,max(L)]
 Ṛ           -     reverse                   [max(L),...,min(L)]
      Ɗ      -     last three links as a monad i.e. f([a,b,c,...,x]):
  Ḣ          -       pop head                          a
   -€        -       -1 for each                       [-1,-1,...,-1] (length a)
     +       -       add to head result (vectorises)   [b-1,c-1,...,x-1,-1,-1,...]
         >-  - greater than -1? (vectorises)
           Ȧ - Any and all? (0 if empty or contains a 0 when flattened, else 1)

05AB1E , 26 25 바이트

D0*«¹v{R¬U¦X¹gn‚£`s<ì}0QP

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

설명

D0*«                       # extend the input list with as many zeroes as it has elements
    ¹v                     # len(input) times do:
      {R                   # sort in descending order
        ¬U¦X               # extract the first element of the list
            ¹gn‚           # pair it with len(input)^2
                £          # partition the list in 2 parts, the first the size of the 
                           # extracted element, the second containing the rest of the list
                 `         # split these list to stack (the second on top)
                  s<       # decrement the elements of the first list by 1
                    ì      # prepend it to the rest of the list
                     }     # end loop
                      0Q   # compare each element in the resulting list with 0
                        P  # reduce list by multiplication

자바 스크립트 (ES6), 82 80 76 바이트

f=([$,..._])=>1/$?_.length>=$&$>=0&f(_.map(a=>a-($-->0)).sort((a,b)=>b-a)):1

많은 바이트를 절약 한 ETHproductions에 감사합니다!

용법

f=([$,..._])=>1/$?_.length>=$&$>=0&f(_.map(a=>a-($-->0)).sort((a,b)=>b-a)):1
f([3,3,3,2,2,2,1,1,1])

산출

1

R , 20 바이트

igraph::is_graphical

Mathematica는 내장 언어 만있는 것은 아닙니다! ;-)

igraph패키지를 설치해야합니다. 입력을 정수 벡터로 취합니다.

루비 , 90 바이트

이 질문에서 나온 것은 이것의 사본으로 판명되었습니다. 그 질문에 언급 된 이후 Havel-Hakimi를 사용합니다.

->a{b=1;(a.sort_by!(&:-@);i=a.shift;a.map!{|e|i>0&&e>0?(i-=1;e-1):e};b&&=i<1)while[]!=a;b}

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

05AB1E , 19 바이트

[D{RćD1‹#Å0<0ζO})dW

포트 JonathanAllan 의 젤리 대답 하기 때문에 그를 찬성해야합니다!

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오. .

설명:

[            # Start an infinite loop:
 D           #  Duplicate the current list
             #  (which is the implicit input-list in the first iteration)
  {R         #  Sort it from highest to lowest
    ć        #  Extract the head; pop and push the remainder and head
     D1‹     #  If the head is 0 or negative:
        #    #   Stop the infinite loop
     Å0<     #  Create a list of the head amount of -1
        0ζ   #  Zip/transpose it with the remainder list, with 0 as filler
          O  #  Sum each pair
})           # After the loop: wrap everything on the stack into a list
  d          # Check for each value if it's non-negative (>= 0)
             # (resulting in 1/0 for truthy/falsey respectively)
   W         # Get the flattened minimum (so basically check if none are falsey)
             # (which is output implicitly as result)

Stax , 14 12 바이트

ε▼ü*æε<%)4‼♂

실행 및 디버깅

이 프로그램은 비어 있고 정렬되지 않은 입력을 처리합니다.