Una secuencia gráfica es una secuencia de enteros positivos, cada uno de los cuales denota el número de aristas para un nodo en un gráfico simple . Por ejemplo, la secuencia 2 1 1denota un gráfico con 3 nodos, uno con 2 aristas y 2 con una conexión.

No todas las secuencias son secuencias gráficas. Por ejemplo, 2 1no es una secuencia gráfica porque no hay forma de conectar dos nodos para que uno de ellos tenga dos bordes.

Tarea

Tomarás una secuencia de enteros por cualquier método razonable . Esto incluye, entre otros , una matriz de enteros y su tamaño, una lista vinculada de enteros sin signo y un vector de dobles. Puede suponer que no habrá ceros en la entrada. También puede suponer que la entrada se ordena de menor a mayor o de mayor a menor.

Debe mostrar si la secuencia es o no una secuencia gráfica. Un valor verdadero si es un valor falso de lo contrario.

Objetivo

Este es el código de golf, el objetivo es minimizar el número de bytes en su programa

Casos de prueba

Ordenado de mayor a menor

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

<<Combinatorica`
GraphicQ

Sí, otro incorporado. (Toma la entrada como una lista de enteros positivos). Requiere cargar el Combinatoricapaquete.

Python 2 (código de salida), 53 bytes

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

Pruébalo en línea!

Salidas a través del código de salida.

Utiliza una versión del algoritmo Havel-Hakimi. Disminuye repetidamente tanto el elemento más grande kcomo el k'elemento más grande (sin contarlo k), lo que corresponde a asignar un borde entre los dos vértices con esos grados. Termina con éxito cuando la lista se convierte en todos ceros. De lo contrario, si hay un índice fuera de límites, falla con un error. Cualquier valor negativo creado también eventualmente conduce a un error fuera de los límites.

CJam (20 bytes)

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

Conjunto de pruebas en línea que incluye un par de pruebas adicionales que agregué para detectar errores en algunos de mis intentos.

Este es un bloque anónimo (función) que toma una matriz de enteros en la pila y se va 0o 1en la pila. Se supone que la entrada se ordena de forma ascendente.

La matriz de entrada puede no estar vacía, pero puede contener ceros, de acuerdo con la respuesta de OP a mi consulta sobre el tema de las entradas vacías.

Disección

Esto sigue la respuesta de OP al implementar el algoritmo 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 bytes

Aquí está mi implementación en Python. Estoy seguro de que puede ser superado por un golfista o matemático más experimentado. Implementa el algoritmo 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]))

Pruébalo en línea!

Haskell , 102 98 95 94 bytes

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

Pruébalo en línea! Uso:, f [3,3,2,2,1,1]devoluciones Trueo False. Asume que la entrada no contiene ceros y está ordenada en orden descendente, según lo permitido en el desafío.

Explicación:

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

Editar: Esto parece seguir el Havel-Hakimi mencionado en otras respuestas, aunque no conocía este algoritmo al escribir la respuesta.

Jalea , 12 bytes

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

Un enlace monádico que acepta una lista que produce 1si las respuestas son consistentes de lo contrario 0.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

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

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

Pruébalo en línea!

Explicación

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 bytes

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

¡Gracias a ETHproductions por guardar muchos bytes!

Uso

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

Salida

1

R , 20 bytes

igraph::is_graphical

¡Mathematica no es el único idioma con funciones integradas! ;-)

El igraphpaquete necesita ser instalado. Toma la entrada como un vector de enteros.

Rubí , 90 bytes.

Portado de esta pregunta que resultó ser un duplicado de esto. Utiliza Havel-Hakimi ya que ese fue el mencionado en esa pregunta.

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

Pruébalo en línea!

05AB1E , 19 bytes

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

Port of Jonathan : La respuesta de Allan Jelly , ¡así que asegúrate de votarlo!

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

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

Ejecutar y depurarlo

Este programa maneja entradas vacías y sin clasificar.