Bir grafik dizisi , her biri basit bir grafikteki bir düğüm için kenar sayısını belirten bir pozitif tamsayı dizisidir . Örneğin dizi 2 1 1, biri 2 kenarı, diğeri bir bağlantısı olan 3 düğümü olan bir grafiği belirtir.

Tüm diziler grafik diziler değildir. Örneğin 2 1, bir grafik dizisi değildir çünkü iki düğümü birleştirmenin bir yolu yoktur, böylece bunlardan biri iki kenara sahiptir.

Görev

Herhangi bir makul yöntemle bir tamsayı dizisi alacaksınız . Bu , bir tam sayı dizisini ve boyutunu, işaretsiz tam sayıların bağlantılı bir listesini ve iki katına ait bir vektörü içerir, ancak bunlarla sınırlı değildir . Girişte sıfır olmayacağını varsayabilirsiniz. Ayrıca girdinin en azdan en büyüğe veya en büyüğünden en küçüğe sıralandığını varsayabilirsiniz.

Sekansın bir grafik sekansı olup olmadığını çıktılamalısınız. Aksi takdirde yanlış bir değerse gerçek bir değer.

Hedef

Bu kod-golf amacı programınızdaki bayt sayısını en aza indirmektir

testcases

Büyükten küçüğe sıralandı

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

<<Combinatorica`
GraphicQ

Evet, başka bir yapı. (Girdiyi pozitif tamsayıların listesi olarak alır.) CombinatoricaPaketin yüklenmesini gerektirir .

Python 2 (çıkış kodu), 53 bayt

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

Çevrimiçi deneyin!

Çıkış kodu üzerinden çıkışlar.

Havel-Hakimi algoritmasının bir sürümünü kullanır. Bu derecelerle iki köşe arasında bir kenar atanmasına karşılık gelen hem en büyük elemanı khem de k'en büyük elemanı ( kkendini saymaz ) sürekli olarak azaltır . Liste tamamen sıfır olduğunda başarıyla sonlandırılır. Aksi takdirde, sınırların dışında bir dizin varsa, hata ile başarısız olur. Oluşturulan negatif değerler de sonunda sınırların dışında bir hataya neden olur.

CJam (20 bayt)

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

Bazı deneme girişimlerimdeki hataları yakalamak için eklediğim birkaç test içeren çevrimiçi test paketi .

Bu, yığın üzerinde ve yapraklarda 0veya yığın üzerinde bir dizi tamsayı alan anonim bir bloktur (işlev) 1. Girişin artan şekilde sıralandığını varsayar.

Giriş dizisi boş olmayabilir, ancak OP'nin boş girdiler konusundaki sorgusuma verdiği cevaba göre sıfırlar içerebilir.

teşrih

Bu OP'nin Havel-Hakimi algoritmasını uygulamadaki cevabını takip eder .

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

İşte Python'daki uygulamam. Eminim daha deneyimli bir golfçü veya matematikçi tarafından yenilebilir. Havel-Hakimi algoritmasını uygular.

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

Çevrimiçi deneyin!

Haskell , 102 98 95 94 bayt

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

Çevrimiçi deneyin! Kullanımı:, f [3,3,2,2,1,1]döner Trueveya False. Girdinin sıfır içermediğini ve sınamada izin verildiği şekilde azalan sırada sıralandığını varsayar .

Açıklama:

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

Düzenleme: Bu cevap yazarken bu algoritmayı bilmiyordum rağmen, diğer cevaplarda belirtilen Havel-Hakimi takip gibi görünüyor.

Jöle , 12 bayt

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

1Yanıtların aksi takdirde tutarlı olması durumunda sonuç veren bir listeyi kabul eden monadik bir Bağlantı 0.

Çevrimiçi deneyin! Veya test takımına bakın .

Nasıl?

ṢṚḢ-€+ƊƊƬ>-Ȧ - 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 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

ETHproductions'a çok bayt tasarrufu için teşekkürler!

kullanım

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

Çıktı

1

R , 20 bayt

igraph::is_graphical

Mathematica, yerleşik olan tek dil değildir! ;-)

igraphPaket yüklenmesi gerekiyor. Girdiyi tamsayıların bir vektörü olarak alır.

Ruby , 90 bayt

Bu sorunun bir kopyası olduğu ortaya çıktı.Havel-Hakimi'yi bu soruda bahsedilenlerden beri kullanır.

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

Çevrimiçi deneyin!

05AB1E , 19 bayt

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

Port of JonathanAlan'ın Jelly cevabı , bu yüzden onu onayladığınızdan emin olun !!

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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

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

Çalıştır ve hata ayıkla

Bu program boş ve ayrılmamış girdileri işler.