甲图形序列是各自是正整数，表示边缘的数目用于在一个节点的序列简单图。例如，序列2 1 1表示一个具有3个节点的图形，其中一个具有2个边，而两个具有一个连接。

并非所有序列都是图形序列。例如，2 1这不是图形序列，因为无法连接两个节点，以使其中一个具有两个边缘。

任务

您将通过任何合理的方法获取整数序列。这包括但不限于整数数组及其大小，无符号整数的链表和双精度向量。您可以假设输入中不会有零。您还可以假设输入从最小到最大或从最大到最小排序。

您必须输出该序列是否为图形序列。真值，否则为假值。

目标

这是代码高尔夫球，目标是最大程度地减少程序中的字节数

测试用例

从大到小排序

                  -> 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第n个最大元素（k自身不计数），这对应于在两个顶点之间使用这些度分配一条边。当列表变为全零时，成功终止。否则，如果索引超出范围，则会因错误而失败。创建的任何负值最终也会导致越界错误。

CJam（20字节）

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

在线测试套件包括一些额外的测试，我添加了一些额外的测试来捕获某些尝试中的错误。

这是一个匿名块（函数），它在堆栈上接受整数数组并离开 0或1在堆栈上。假定输入按升序排序。

根据OP对我关于空输入主题的查询的回答，输入数组可能不为空，但可能包含零。

解剖

这是OP在实施Havel-Hakimi算法时的回答。

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

Python 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]))

在线尝试！

Haskell，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。假设输入不包含零，并且按照质询所允许的降序排列。

说明：

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 字节

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

一个Monadic链接接受一个列表，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

JavaScript（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）的果冻港（Jelly）答案，所以请确保对他进行投票！！

在线尝试或验证所有测试用例。

说明：

[            # 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‼♂

运行并调试

该程序处理空的和未排序的输入。