Một chuỗi đồ họa là một chuỗi các số nguyên dương từng biểu thị số cạnh cho một nút trong một đồ thị đơn giản . Ví dụ: chuỗi 2 1 1biểu thị một đồ thị có 3 nút một có 2 cạnh và 2 có một kết nối.

Không phải tất cả các chuỗi là trình tự đồ họa. Ví dụ 2 1không phải là một chuỗi đồ họa vì không có cách nào để kết nối hai nút để một trong số chúng có hai cạnh.

Bài tập

Bạn sẽ lấy một chuỗi các số nguyên bằng bất kỳ phương pháp hợp lý nào . Điều này bao gồm, nhưng không giới hạn ở một mảng các số nguyên và kích thước của nó, một danh sách các số nguyên không dấu được liên kết và một vectơ nhân đôi. Bạn có thể cho rằng sẽ không có số không trong đầu vào. Bạn cũng có thể giả sử đầu vào được sắp xếp từ ít nhất đến lớn nhất hoặc lớn nhất đến ít nhất.

Bạn phải xuất ra liệu chuỗi đó có phải là chuỗi đồ họa hay không. Một giá trị trung thực nếu nó là một giá trị giả mạo khác.

Mục tiêu

Đây là môn đánh gôn , mục tiêu là giảm thiểu số lượng byte trong chương trình của bạn

Tủ thử

Sắp xếp lớn nhất đến ít nhất

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

Toán học, 25 byte

<<Combinatorica`
GraphicQ

Vâng, một nội dung khác. (Lấy đầu vào dưới dạng danh sách các số nguyên dương.) Yêu cầu tải Combinatoricagói.

Python 2 (mã thoát), 53 byte

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

Hãy thử trực tuyến!

Đầu ra thông qua mã thoát.

Sử dụng một phiên bản của thuật toán Havel-Hakimi. Liên tục giảm cả phần tử lớn nhất kvà phần tử klớn nhất (không tính kchính nó), tương ứng với việc gán một cạnh giữa hai đỉnh với các độ đó. Chấm dứt thành công khi danh sách trở thành tất cả các số không. Mặt khác, nếu có một chỉ số nằm ngoài giới hạn, sẽ không có lỗi. Bất kỳ giá trị âm nào được tạo ra cuối cùng cũng dẫn đến lỗi ngoài giới hạn.

CJam (20 byte)

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

Bộ kiểm tra trực tuyến bao gồm một vài thử nghiệm bổ sung mà tôi đã thêm để bắt lỗi trong một số nỗ lực của mình.

Đây là một khối ẩn danh (hàm) lấy một mảng các số nguyên trên ngăn xếp và rời khỏi 0hoặc 1trên ngăn xếp. Nó giả định rằng đầu vào được sắp xếp tăng dần.

Mảng đầu vào có thể không trống, nhưng có thể chứa các số 0, theo câu trả lời của OP cho truy vấn của tôi về chủ đề đầu vào trống.

Mổ xẻ

Điều này tuân theo câu trả lời của OP trong việc thực hiện thuật toán 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 byte

Đây là triển khai của tôi trong Python. Tôi chắc chắn rằng nó có thể bị đánh bại bởi một tay golf hoặc nhà toán học giàu kinh nghiệm hơn. Nó thực hiện thuật toán 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]))

Hãy thử trực tuyến!

Haskell , 102 98 95 94 byte

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

Hãy thử trực tuyến! Cách sử dụng : f [3,3,2,2,1,1], trả về Truehoặc False. Giả sử rằng đầu vào không chứa số không và được sắp xếp theo thứ tự giảm dần, như được phép trong thử thách.

Giải trình:

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

Chỉnh sửa: Điều này dường như tuân theo Havel-Hakimi được đề cập trong các câu trả lời khác, mặc dù tôi không biết thuật toán này khi viết câu trả lời.

Thạch , 12 byte

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

Một liên kết đơn âm chấp nhận một danh sách mang lại 1nếu câu trả lời là nhất quán khác 0.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

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

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

Cảm ơn ETHproductions đã lưu nhiều byte!

Sử dụng

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

Đầu ra

1

R , 20 byte

igraph::is_graphical

Mathematica không phải là ngôn ngữ duy nhất có sẵn! ;-)

Các igraphgói cần phải được cài đặt. Lấy đầu vào là một vectơ số nguyên.

Ruby , 90 byte

Chuyển từ câu hỏi này hóa ra là một bản sao của câu hỏi này. Sử dụng Havel-Hakimi vì đó là người được nhắc đến trong câu hỏi đó.

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

Hãy thử trực tuyến!

05AB1E , 19 byte

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

Cảng Câu trả lời Jelly Jonathan ALLan , vì vậy hãy đảm bảo nâng cao anh ấy !!

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

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

Chạy và gỡ lỗi nó

Chương trình này xử lý các đầu vào trống và chưa sắp xếp.