Una sequenza grafica è una sequenza di numeri interi positivi che indicano ciascuno il numero di spigoli di un nodo in un semplice grafico . Ad esempio la sequenza 2 1 1indica un grafico con 3 nodi uno con 2 bordi e 2 con una connessione.

Non tutte le sequenze sono sequenze grafiche. Ad esempio, 2 1non è una sequenza grafica perché non esiste un modo per collegare due nodi in modo che uno di essi abbia due bordi.

Compito

Prenderai una sequenza di numeri interi con qualsiasi metodo ragionevole . Ciò include, ma non è limitato a , un array di numeri interi e le sue dimensioni, un elenco collegato di numeri interi senza segno e un vettore di doppi. Si può presumere che non ci saranno zeri nell'input. Si può anche supporre che l'input sia ordinato dal minimo al massimo o dal massimo al minimo.

È necessario generare se la sequenza è o meno una sequenza grafica. Un valore veritiero se è un valore falso altrimenti.

Obbiettivo

Questo è code-golf l'obiettivo è ridurre al minimo il numero di byte nel programma

Casi test

Ordinati dal più grande al meno

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

<<Combinatorica`
GraphicQ

Sì, un altro incorporato. (Accetta l'input come un elenco di numeri interi positivi.) Richiede il caricamento del Combinatoricapacchetto.

Python 2 (codice di uscita), 53 byte

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

Provalo online!

Uscite tramite codice di uscita.

Utilizza una versione dell'algoritmo Havel-Hakimi. Decrementa ripetutamente, l'elemento più grande ke il k'esimo elemento più grande (non contando kstesso), che corrisponde ad assegnare un arco tra i due vertici con tali gradi. Termina correttamente quando l'elenco diventa tutti zeri. Altrimenti, se c'è un indice fuori limite, fallisce con errore. Eventuali valori negativi creati alla fine portano anche a un errore fuori limite.

CJam (20 byte)

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

Suite di test online che include un paio di test extra che ho aggiunto per rilevare bug in alcuni dei miei tentativi.

Questo è un blocco (funzione) anonimo che accetta un array di numeri interi nello stack e lascia 0o 1nello stack. Presuppone che l'ingresso sia ordinato in modo crescente.

L'array di input potrebbe non essere vuoto, ma può contenere zero, in conformità con la risposta di OP alla mia query sull'argomento di input vuoti.

Dissezione

Ciò segue la risposta di OP nell'implementazione dell'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 byte

Ecco la mia implementazione in Python. Sono sicuro che può essere battuto da un golfista o un matematico più esperto. Implementa l'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]))

Provalo online!

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

Provalo online! Uso: f [3,3,2,2,1,1], rendimenti Trueo False. Presuppone che l'input non contenga zero e sia ordinato in ordine decrescente, come consentito dalla sfida.

Spiegazione:

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

Modifica: questo sembra seguire Havel-Hakimi menzionato in altre risposte, anche se non sapevo di questo algoritmo quando scrivevo la risposta.

Gelatina , 12 byte

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

Un collegamento monadico che accetta un elenco che produce 1se le risposte sono coerenti altrimenti 0.

Provalo online! Oppure vedi la suite di test .

Come?

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

Provalo online!

Spiegazione

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

Grazie a ETHproductions per aver salvato molti byte!

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

Produzione

1

R , 20 byte

igraph::is_graphical

Mathematica non è l'unica lingua con incorporati! ;-)

Il igraphpacchetto deve essere installato. Accetta input come vettore di numeri interi.

Rubino , 90 byte

Portato da questa domanda che si è rivelata un duplicato di questo. Usa Havel-Hakimi poiché quello era quello menzionato in quella domanda.

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

Provalo online!

05AB1E , 19 byte

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

Port of Jonathan : la risposta di Allan Jelly , quindi assicurati di votarlo !!

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Esegui ed esegui il debug

Questo programma gestisce input vuoti e non ordinati.