Dada una triangulación de la superficie de un poliedro p, calcule su Característica de Euler-Poincaré χ(p) = V-E+F, donde Vestá el número de vértices, Eel número de aristas y Fel número de caras.

Detalles

Los vértices se enumeran como 1,2,...,V. La triangulación se da como una lista, donde cada entrada es una lista de los vértices de una cara, dada en el sentido horario o antihorario.

A pesar del nombre, la triangulación también puede contener caras con más de 3 lados. Se puede suponer que las caras están simplemente conectadas, lo que significa que el límite de cada cara se puede dibujar utilizando un bucle cerrado que no se cruza automáticamente.

Ejemplos

Tetraedro : este tetraedro es convexo y tiene χ = 2. Una posible triangulación es

[[1,2,3], [1,3,4], [1,2,4], [2,3,4]]

Cubo : Este cubo es convexo y tiene χ = 2. Una posible triangulación es

[[1,2,3,4], [1,4,8,5], [1,2,6,5], [2,3,7,6], [4,3,7,8],  [5,6,7,8]]

Donut : Esta forma de rosquilla / toroide tiene χ = 0. Una posible triangulación es

[[1,2,5,4], [2,5,6,3], [1,3,6,4], [1,2,7,9], [2,3,8,7], [1,9,8,3], [4,9,8,6], [4,5,7,9], [5,7,8,6]]

Doble Donut : Este doble donut debería tener χ = -2. Se construye usando dos copias del donut de arriba e identificando los lados [1,2,5,4]del primero con el lado [1,3,6,4]del segundo.

[[2,5,6,3], [1,3,6,4], [1,2,7,9], [2,3,8,7], [1,9,8,3], [4,9,8,6], [4,5,7,9], [5,7,8,6], [1,10,11,4], [10,11,5,2], [1,10,12,14], [10,2,13,12], [1,14,13,2], [4,14,13,5], [4,11,12,14], [11,12,13,5]]

(Ejemplos verificados usando este programa Haskell ).

Haskell , 49 46 bytes

u=length
f x|j<-x>>=id=maximum j+u x-u j`div`2

Pruébalo en línea!

Obtengo el número de vértices al concatenar las caras y encontrar el máximo. Encuentro el número de caras tomando la longitud. Encuentro el número de aristas sumando las longitudes de las caras y dividiendo por 2.

Haskell , 42 bytes

f m=maximum(id=<<m)-sum[0.5|_:_:l<-m,x<-l]

Pruébalo en línea!

Combina los términos de cara y borde restando 0,5 por cada borde en una cara más allá de los dos primeros.

Alt 42 bytes:

f m=maximum(id=<<m)-sum(0.5<$(drop 2=<<m))

Pruébalo en línea!

APL (Dyalog Classic) , 13 bytes

⌈/∘∊+≢-2÷⍨≢∘∊

Pruébalo en línea!

Gelatina , 18 17 11 10 9 bytes

1 byte gracias a Erik the Outgolfer, y 1 más por contarme Ɗ.

FṀ_FLHƊ+L

Pruébalo en línea!

Utiliza la solución realmente inteligente no pirateada que probablemente todos los demás estén usando. (Crédito a @totallyhuman por la única otra solución que pude entender lo suficiente como para volver a implementarla).

Solución anterior (17 bytes)

ṙ€1FżFṢ€QL
;FQL_Ç

Pruébalo en línea!

Espero tener todo bien. Asume que todas las caras contienen al menos 3 vértices y que no hay dos caras que tengan los mismos vértices; No soy lo suficientemente bueno en topología como para encontrar algo que rompa el código.

Solución alternativa de 17 bytes:

ṙ€1FżFṢ€,;F$QL$€I

Explicación

;FQL_Ç    Main link. Argument: faces
            e.g. [[1,2,3],[1,3,4],[1,2,4],[2,3,4]]
 F          Flatten the list. We now have a flat list of vertices.
            e.g. [1,2,3,1,3,4,1,2,4,2,3,4]
;           Append this to the original list.
            e.g. [[1,2,3],[1,3,4],[1,2,4],[2,3,4],1,2,3,1,3,4,1,2,4,2,3,4]
  Q         Remove duplicates. We now have a list of faces and vertices.
            e.g. [[1,2,3],[1,3,4],[1,2,4],[2,3,4],1,2,3,4]
   L        Get the length of this list. This is equal to V+F.
            e.g. 8
     Ç      Call the helper link on the faces to get E.
            e.g. 6
    _       Subtract the edges from the previous result to get V-E+F.
            e.g. 2

ṙ€1FżFṢ€QL    Helper link. Argument: faces
                e.g. [[1,2,3],[1,3,4],[1,2,4],[2,3,4]]
ṙ€1             Rotate each face 1 position to the left.
                e.g. [[2,3,1],[3,4,1],[2,4,1],[3,4,2]]
   F            Flatten this result.
                e.g. [2,3,1,3,4,1,2,4,1,3,4,2]
     F          Flatten the original faces.
                e.g. [1,2,3,1,3,4,1,2,4,2,3,4]
    ż           Pair the items of the two flattened lists.
                e.g. [[2,1],[3,2],[1,3],[3,1],[4,3],[1,4],[2,1],[4,2],[1,4],[3,2],[4,3],[2,4]]
      Ṣ€        Order each edge.
                e.g. [[1,2],[2,3],[1,3],[1,3],[3,4],[1,4],[1,2],[2,4],[1,4],[2,3],[3,4],[2,4]]
        Q       Remove duplicates. We now have a list of edges.
                e.g. [[1,2],[2,3],[1,3],[3,4],[1,4],[2,4]]
         L      Get the length of the list to get E.
                e.g. 6

Perl 5 -a , 29 bytes

Este está hecho a medida para la -aopción perl que ya hace casi todo el trabajo

#!/usr/bin/perl -a
@V[@F]=$e+=@F}{say$#V+$.-$e/2

Pruébalo en línea!

Python 2 , 47 bytes

-1 byte gracias a ... user56656 (originalmente fue Wheat Wizard).

lambda l:len(l)-len(sum(l,[]))/2+max(sum(l,[]))

Pruébalo en línea!

Stax , 9 bytes

ÑF4╨Ω◙╜#├

Ejecute y depure en línea

Es un puerto directo de la solución de Python totalmente humana .

%   length of input (a)
x$Y flatten input and store in y
%h  half of flattened length (b)
-   subtract a - b (c)
y|M maximum value in y (d)
+   add c + d and output

Ejecute este

Pari / GP , 28 bytes

x->#x+#Set(y=concat(x))-#y/2

Pruébalo en línea!

Wolfram Language (Mathematica) , 27 bytes

Max@#-Tr[Tr@#/2-1&/@(1^#)]&

Pruébalo en línea!

05AB1E , 10 9 bytes

ZsgI˜g;-+

Pruébalo en línea!

Explicación

Z          # push number of vertices (V)
 sg        # push number of faces (F)
   I˜g;    # push number of edges (E)
       -   # subtract (F-E)
        +  # add (F-E+V)

Pyth , 12 bytes

+-eSsQ/lsQ2l

Pruébalo aquí

Ruby , 35 bytes

->a{a.size+a.flatten!.max-a.size/2}

Pruébalo en línea!

Protón , 35 bytes

l=>max(f=sum(l,[]))-len(f)/2+len(l)

Pruébalo en línea!

JavaScript (ES6), 60 bytes

a=>a.map(b=>(v=Math.max(v,...b),d+=b.length/2-1),d=v=0)&&v-d

Explicación: recorre cada cara, realiza un seguimiento del vértice más grande que se ve vy rastrea el número de bordes menos el número de caras dsegún la respuesta de @ xnor.