En la teoría de conjuntos, los números naturales $\mathbb{N} = \{0, 1, 2, 3, ...\}$ generalmente se codifican como conjuntos puros , es decir, conjuntos que solo contienen el conjunto vacío u otros conjuntos que son puros. Sin embargo, no todos los conjuntos puros representan números naturales. Este desafío consiste en decidir si un conjunto puro dado representa una codificación de número natural o no.

La codificación de números naturales funciona de la siguiente manera ¹ :

• Cero es el conjunto vacío: $Set(0) = \{\}$
• Para un número $n > 0$ : $Set(n) = Set(n-1) \cup \{Set(n-1)\}$

Por lo tanto, las codificaciones de los primeros números naturales son

• $0 \leadsto \{\}$
• $1 \leadsto \{0\} \leadsto \{\{\}\}$
• $2 \leadsto \{0,1\} \leadsto \{\{\},\{\{\}\}\}$
• $3 \leadsto \{0,1,2\} \leadsto \{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}$
• $4 \leadsto \{0,1,2,3\} \leadsto \{\{\},\{\{\}\},\{\{\},\{\{\}\}\},\{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}\}$

La tarea

• Dada una cadena que representa un conjunto puro, determine si este conjunto codifica un número natural de acuerdo con la construcción anterior.
• Sin embargo, tenga en cuenta que los elementos de un conjunto no están ordenados, por lo que $\{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}$ no es la única representación válida de $3$ ya que, por ejemplo, $\{\{\{\}\},\{\},\{\{\{\}\},\{\}\}\}$ representa el mismo conjunto.
• Puede usar [], ()o en <>lugar de {}.
• Puede suponer que los conjuntos se proporcionan sin el ,separador as.
• Puede suponer que no habrá elementos duplicados en la entrada, por ejemplo, {{},{}}no es una entrada válida, y que la entrada está bien formada, por ejemplo {{},, no , {,{}}o similar.

Casos de prueba

Cierto:

{}
{{}}
{{},{{}}}
{{{}},{}}
{{},{{}},{{},{{}}}}
{{{},{{}}},{},{{}}}
{{{{}},{}},{{}},{}}
{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
{{{{{}},{}},{{}},{}},{{}},{},{{},{{}}}}
{{},{{}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{{}},{}},{{},{{}},{{},{{}}}}}
{{{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}}

Falso:

{{{}}}
{{{{}}}}
{{{{}},{}}}
{{},{{}},{{{}}}}
{{{},{{}}},{{}}}
{{{{{}}},{}},{{}},{}}
{{},{{}},{{},{{}}},{{},{{}},{{{}}}}}
{{{{{}},{}},{{{}}},{}},{{}},{},{{},{{}}}}
{{{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}}

^{Relacionado: Construcción natural (genera la codificación de conjunto de un número natural dado).
1 Consulte https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers}

JavaScript (Node.js) , 53 48 44 bytes

f=a=>(a=eval(a)).every(e=>a[e.length]&&f(e))

Pruébalo en línea! Los casos de prueba fueron robados descaradamente de la respuesta de @ Arnauld. Explicación: Si un conjunto representa un número natural, entonces el número natural que representa debe ser igual al tamaño del conjunto y (dado que los elementos están garantizados distintos) los elementos deben ser las representaciones de los números naturales menores que él, y estos por lo tanto deben tener longitudes más cortas. Esto es trivialmente cierto del conjunto vacío, por supuesto. Editar: Guardado 5 bytes gracias a @Arnauld. Guardado 4 bytes gracias a @Cowsquack.

Python 3 , 69 58 44 bytes

11 bytes gracias a Erik the Outgolfer.

14 bytes gracias al Sr. Xcoder.

f=lambda s:all(len(e)<len(s)*f(e)for e in s)

Pruébalo en línea!

Wolfram Language (Mathematica) , 60 59 bytes

E!=(If[Sort@#===Range[t=Tr[1^#]]-1,t,E]&//@ToExpression@#)&

Pruébalo en línea!

El núcleo de esta solución es la función.

If[Sort@#===Range[t=Tr[1^#]]-1,t,E]&

que convierte una lista de la forma {0,1,2,...,n-1}en cualquier orden en la salida n(en particular, se convierte {}a 0), y convierte cualquier otra cosa en el número real E.

Llama a esta función f. Dada una entrada como "{{{}},{}}", hacemos lo siguiente:

1. Convierta la cadena en una expresión de Mathematica.
2. Aplicar fen todos los niveles, obteniendo f[{f[{f[{}]}], f[{}]}].
3. La evaluación de todos los f's producirá un número natural para una entrada que lo represente. Por ejemplo, f[{f[{f[{}]}], f[{}]}]= f[{f[{0}], 0}]= f[{1, 0}]= 2. Cualquier otra cosa producirá E.
4. Probamos si el resultado es un número natural comprobando si no lo es E.

Brachylog (v2), 9 bytes

↰ᵐo.t~k|Ė

Pruébalo en línea!

Como de costumbre para un problema de decisión , este es un programa completo. Entrada desde entrada estándar, usando corchetes. Salida a salida estándar como true.versus false..

Explicación

Aunque dije anteriormente que este es un programa completo, en realidad es más interesante que eso; Es a la vez un programa completo y una función. Cuando se usa como un programa completo, imprime true.si el conjunto es un número natural o false.si no lo es. Cuando se usa como una función, "normaliza" un número natural (es decir, normaliza todos sus elementos y los ordena en orden por valor; este programa usa listas internamente, no conjuntos), o "arroja una excepción" (en realidad un error, ya que esto es Prolog) si la entrada no es un número natural.

El comportamiento completo del programa es bastante fácil de explicar: está puramente implícito en el tratamiento de Brachylog de los programas completos que no contienen instrucciones de E / S. El comportamiento en cuestión es "ejecutar la función, tomando su entrada de la entrada estándar y afirmando que su salida coincide con la descripción dada por el primer argumento de la línea de comando; si la afirmación falla o el programa arroja una excepción, imprime false., de lo contrario imprime true." . En este caso, falta el argumento de la línea de comandos (es decir, "todo vale"), por lo que el comportamiento de excepción / sin excepción de la función proporciona el resultado.

En cuanto al comportamiento de la función:

↰ᵐo.t~k|Ė
↰ᵐ          Map a recursive call to this function over the list
  o         Sort the list
   .   |    Assert that the following operation need not change the list:
    t         Take the last (i.e. greatest) element of the list
     ~k       Append an arbitrary element to the resulting list
   .   |    Output the unchanged list
       |    Exception handler: if the above threw an exception,
        Ė     Assert that the input is empty, and output an empty list

Un número natural se define como el que contiene dos partes: los elementos del número natural a continuación, unidos con el número mismo. Por lo tanto, todos sus elementos también son números naturales. Podemos reconocer un número natural a) verificando que todos sus elementos son números naturales, b) verificando que el elemento más grande del conjunto es idéntico al conjunto sin su elemento más grande.

Cuando usamos listas en lugar de conjuntos (por lo tanto, corchetes), debemos ponerlos en un orden consistente para que funcionen las comparaciones de igualdad (en este caso, ordenadas por "valor"). El orden de clasificación predeterminado de Brachylog ordenará un prefijo de una lista antes de la lista misma, lo que convenientemente significa que ordenará los números naturales por valor numérico. Entonces podemos ordenar recursivamente todos nuestros números para ponerlos en un orden consistente. De hecho, a través de la función que estamos definiendo recursivamente, podemos lograr ambos resultados al mismo tiempo: ordenando recursivamente los elementos del número y verificando que sea un número natural.

La función tiene cuatro partes principales. ↰ᵐes la llamada recursiva, asegurando que cada elemento sea un número natural, y convirtiéndolo en una forma normalizada. onormaliza el número en sí (sus elementos ya están normalizados, por lo que todo lo que tenemos que hacer es ordenarlo). Luego se .t~k|asegura de que tenemos la estructura que queremos al verificar que el elemento más grande y otros elementos son iguales. Una lista vacía (es decir, 0) no tiene un último elemento, por lo que obtendrá un error de aserción con t; El |Ėmaneja este caso, al dar un respaldo explícito en el caso donde la lista de entrada está vacía.

K (ngn / k) , 26 24 27 bytes

~^{$[#(!#x)^o'x;0N;#x]}@`j@

Pruébalo en línea!

input es una cadena json analizada por `j@(sintaxis específica de ngn / k)

{ }Es una función recursiva con argumento x. devuelve el número natural representado por el conjunto x, o nulo ( 0N) si no representa uno.

$[ ; ; ]es if-then-else. 0 es falsey, otros enteros son verdaderos

!#xlos enteros desde 0 (inclusive) hasta la longitud de x(exclusivo)

^ sin

o'xrecursividad ( o) en cada ( ') elemento dex

# longitud

^ ¿es nulo?

~ no

@actúa como un maniquí última verbo de manera que ~y ^conseguir compuesta con { }lugar de ser aplicado a ella

Jalea , 10 bytes

ẈṢ‘⁼Jȧ@ßƇƑ

Pruébalo en línea!

Japt , 9 bytes

Solución JS del puerto de Neil . Vota eso si estás votando esto.

e@Ê>XÊ©ßX

Pruébalo o ejecuta todos los casos de prueba

              :Implicit input of array U
e             :Does every element in U return true
 @            :When passed through the following function as X
  Ê           :Length of U
   >          :Greater than
    XÊ        :Length of X
      ©       :Logical AND with
       ßX     :A recursive call of the programme with X passed as the new value of U

Rojo , 81 bytes

func[a][p: 1 foreach e to-block a[p: p *(pick[1 0](length? e)< length? a)* f e]p]

Pruébalo en línea!

Respuesta similar a Python 3 de Leaky Nun

Jalea , 8 bytes

߀Ṣ
ÇṖƤƑ

Dado que la entrada debe ser una cadena, este envío solo es válido como un programa completo.

Pruébalo en línea! o verificar todos los casos de prueba

Cómo funciona

߀Ṣ   Helper link. Argument: A (array)

߀    Recursively map the helper link over A.
  Ṣ   Sort the result.

Esto produce una representación canónica de la entrada, que consta únicamente de matrices ordenadas.

ÇṖƤƑ  Main link. Argument: A (array)

Ç     Call the helper link to canonicalize the array.
   Ƒ  Fixed; call the link to the left and test if it returns its argument unchanged.
 ṖƤ       Pop prefix; for each non-empty prefix of the result, remove its last element.

Jalea , 7 bytes

Ẉ<La߀Ạ

Este es un puerto de la respuesta Python de Leaky Nun .

Dado que la entrada debe ser una cadena, este envío solo es válido como un programa completo.

Pruébalo en línea! o verificar todos los casos de prueba

Cómo funciona

Ẉ<La߀Ạ  Main link. Argument: A (array)

Ẉ        Width; compute the length of A's elements.
  L      Yield the length of A.
 <       Compare them, yielding an array of Booleans.
    ߀   Recursively map the main link over A.
   a     Take the logical AND of the Booleans and the results of the map.
      Ạ  All; yield 1 if and only if all ANDs yielded 1.

Wolfram Language (Mathematica) , 52 bytes

If[Max[#0/@#]<(l=2Length@#),l]&@*ToExpression/*EvenQ

Pruébalo en línea!