графічна послідовність є послідовністю позитивних цілих чисел , що позначають кожен число ребер для вузла в простому графіку . Наприклад, послідовність 2 1 1позначає графік з 3 вузлами, один з 2 ребрами і 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

Математика, 25 байт

<<Combinatorica`
GraphicQ

Так, ще один вбудований. (Приймає введення як список натуральних чисел.) Необхідно завантажити Combinatoricaпакет.

Python 2 (код виходу), 53 байти

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

Спробуйте в Інтернеті!

Виводи за допомогою коду виходу.

Використовується версія алгоритму Гавела-Хакімі. Неодноразово зменшується як найбільший елемент, так kі k'найбільший елемент (не рахуючи kсебе), що відповідає призначенню краю між двома вершинами з цими ступенями. Успішно припиняється, коли у списку стають усі нулі. В іншому випадку, якщо індекс не виходить за межі, виходить з помилки. Будь-які створені негативні значення також врешті-решт призводять до помилки поза межами.

CJam (20 байт)

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

Інтернет-тестовий набір включаючи пару додаткових тестів, які я додав, щоб знайти помилок у деяких своїх спробах.

Це анонімний блок (функція), який приймає масив цілих чисел на стеку та листя 0або 1на стеку. Він передбачає, що вхід сортується за зростанням.

Масив введення може бути не порожнім, але може містити нулі, відповідно до відповіді ОП на мій запит щодо теми порожніх входів.

Розсічення

З цього випливає відповідь ОП у впровадженні алгоритму Гавела-Хакімі .

{          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. Я впевнений, що це може перемогти більш досвідчений гольфіст або математик. Він реалізує алгоритм Гавела-Хакімі.

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

Редагувати: Це, мабуть, слідує за згадуваним Гавелом-Хакімі в інших відповідях, хоча я не знав про цей алгоритм при написанні відповіді.

Желе , 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

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 байт

Походить з цього питання, який виявився його дублікатом. Використовує Гавела-Хакімі, оскільки саме це було згадане в цьому питанні.

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

Відповідь Желета Порта ДжонатанаАллана , тому обов'язково підтримайте його !!

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

[            # 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)

Стакс , 14 12 байт

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

Запустіть і налагоджуйте його

Ця програма обробляє порожні та несортовані входи.