Nella teoria degli insiemi, i numeri naturali sono generalmente codificati come insiemi puri , ovvero insiemi che contengono solo l'insieme vuoto o altri insiemi che sono puri . Tuttavia, non tutti gli insiemi puri rappresentano numeri naturali. Questa sfida consiste nel decidere se un determinato set puro rappresenta o meno una codifica del numero naturale.$\mathbb{N} = \{0, 1, 2, 3, ...\}$

La codifica dei numeri naturali funziona nel modo seguente ¹ :

• Zero è l'insieme vuoto:$Set(0) = \{\}$
• Per un numero :$n > 0$$Set(n) = Set(n-1) \cup \{Set(n-1)\}$

Quindi, le codifiche dei primi pochi numeri naturali sono

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

L'obiettivo

• Data una stringa che rappresenta un set puro, determinare se questo set codifica un numero naturale in base alla costruzione precedente.
• Nota, tuttavia, che gli elementi di un set non sono ordinati, quindi $\{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}$ non è l'unica rappresentazione valida di $3$ , ad esempio $\{\{\{\}\},\{\},\{\{\{\}\},\{\}\}\}$ rappresenta lo stesso set.
• È possibile utilizzare [], ()o <>al posto di {}.
• Si può presumere che i set siano dati senza il ,separatore come.
• Si può presumere che non ci sarà alcun gli elementi duplicati in ingresso, ad esempio, {{},{}}non è un input valido, e che l'ingresso è ben formato, ad esempio, nessun {{},, {,{}}o simili.

Casi test

Vero:

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

falso:

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

^{Correlati: Natural Construction (emette la codifica impostata di un determinato numero naturale.)
1 Vedi https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers}

JavaScript (Node.js) , 53 48 44 byte

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

Provalo online! Casi di prova per lo più svergognati rubati dalla risposta di @ Arnauld. Spiegazione: se un set rappresenta un numero naturale, il numero naturale che rappresenta deve essere uguale alla dimensione dell'insieme e (dato che gli elementi sono garantiti distinti) gli elementi devono essere le rappresentazioni dei numeri naturali inferiori ad esso, e questi devono quindi avere lunghezze più brevi. Questo è banalmente vero per l'insieme vuoto ovviamente. Modifica: salvato 5 byte grazie a @Arnauld. Salvato 4 byte grazie a @Cowsquack.

Python 3 , 69 58 44 byte

11 byte grazie a Erik the Outgolfer.

14 byte grazie a Mr. Xcoder.

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

Provalo online!

Wolfram Language (Mathematica) , 60 59 byte

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

Provalo online!

Il cuore di questa soluzione è la funzione

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

che converte un elenco del modulo {0,1,2,...,n-1}in qualsiasi ordine nell'output n(in particolare, si converte {}in 0) e converte qualsiasi altra cosa nel numero reale E.

Chiama questa funzione f. Dato un input come "{{{}},{}}", facciamo quanto segue:

1. Converti la stringa in un'espressione Mathematica.
2. Applicare fa tutti i livelli, ottenendo f[{f[{f[{}]}], f[{}]}].
3. La valutazione di tutti fgenererà un numero naturale per un input che lo rappresenta. Ad esempio, f[{f[{f[{}]}], f[{}]}]= f[{f[{0}], 0}]= f[{1, 0}]= 2. Qualsiasi altra cosa produrrà E.
4. Testiamo se il risultato è un numero naturale controllando se non lo è E.

Brachylog (v2), 9 byte

↰ᵐo.t~k|Ė

Provalo online!

Come al solito per un problema decisionale , questo è un programma completo. Input da input standard, usando parentesi quadre. Uscita allo standard output come true.contro false..

Spiegazione

Anche se ho detto sopra che questo è un programma completo, in realtà è più interessante di così; è sia un programma completo che una funzione. Se utilizzato come programma completo, stampa true.se il set è un numero naturale o false.se non lo è. Se usato come una funzione, "normalizza" un numero naturale (cioè normalizza tutti i suoi elementi e li ordina in ordine di valore; questo programma utilizza gli elenchi internamente, non gli insiemi), o "genera un'eccezione" (in realtà un errore, poiché questo è Prolog) se l'ingresso non è un numero naturale.

Il comportamento completo del programma è abbastanza semplice da spiegare: è puramente implicito nel trattamento di Brachylog di programmi completi che non contengono istruzioni I / O. Il comportamento in questione è "eseguire la funzione, prendendo il suo input dall'input standard e affermando che il suo output corrisponde alla descrizione fornita dal primo argomento della riga di comando; se l'asserzione fallisce o il programma genera un'eccezione, stampa false., altrimenti stampa true." . In questo caso, l'argomento della riga di comando è mancante (vale a dire "tutto va bene"), quindi il comportamento eccezione / nessuna eccezione della funzione fornisce l'output.

Per quanto riguarda il comportamento della funzione:

↰ᵐ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 numero naturale è definito come contenente due parti: gli elementi del numero naturale in basso, uniti al numero stesso. Pertanto, tutti i suoi elementi sono anche numeri naturali. Possiamo riconoscere un numero naturale a) verificando che tutti i suoi elementi siano numeri naturali, b) verificando che l'elemento più grande dell'insieme sia identico all'insieme senza il suo elemento più grande.

Quando utilizziamo elenchi anziché insiemi (quindi le parentesi quadre), dobbiamo inserirli in un ordine coerente affinché i confronti di uguaglianza funzionino (in questo caso, ordinati per "valore"). L'ordinamento predefinito di Brachylog ordinerà un prefisso di un elenco prima dell'elenco stesso, il che significa convenientemente che ordinerà i numeri naturali per valore numerico. Quindi possiamo semplicemente ordinare in modo ricorsivo tutti i nostri numeri per metterli in un ordine coerente. In effetti, tramite la funzione che stiamo definendo in modo ricorsivo, possiamo ottenere entrambi i risultati contemporaneamente: ordinare in modo ricorsivo gli elementi del numero e verificare che si tratti di un numero naturale.

La funzione ha quindi quattro parti principali. ↰ᵐè la chiamata ricorsiva, garantendo che ogni elemento sia un numero naturale e convertendolo in un modulo normalizzato. onormalizza il numero stesso (i suoi elementi sono già normalizzati, quindi tutto ciò che dobbiamo fare è ordinarlo). Quindi .t~k|ci assicuriamo di avere la struttura che desideriamo verificando che l'elemento più grande e altri siano gli stessi. Un elenco vuoto (ovvero 0) non ha un ultimo elemento, quindi otterrà un errore di asserzione con t; la |Ėgestisce questo caso, tramite dando un fallback esplicita nel caso in cui la lista di input è vuoto.

K (ngn / k) , 26 24 27 byte

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

Provalo online!

input è una stringa json analizzata da `j@(sintassi specifica di ngn / k)

{ }è una funzione ricorsiva con argomento x. restituisce il numero naturale rappresentato dall'insieme x, oppure null ( 0N) se non rappresenta uno.

$[ ; ; ]è if-then-else. 0 è falso, altri numeri interi sono veri

!#xi numeri interi da 0 (incluso) alla lunghezza di x(esclusivo)

^ senza

o'xrecursion ( o) su ciascun 'elemento ( ) dix

# lunghezza

^ è zero?

~ non

@agisce come una falsa forma verbo modo che ~e ^ottenere composti con { }invece di essere applicato ad esso

Gelatina , 10 byte

ẈṢ‘⁼Jȧ@ßƇƑ

Provalo online!

Japt , 9 byte

La soluzione JS di Port of Neil . Si prega di votare che se si sta votando questo.

e@Ê>XÊ©ßX

Provalo o esegui tutti i casi di test

              :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

Rosso , 81 byte

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

Provalo online!

Simile alla risposta Python 3 di Leaky Nun

Gelatina , 8 byte

߀Ṣ
ÇṖƤƑ

Poiché l'input deve essere una stringa, questo invio è valido solo come programma completo.

Provalo online! o verifica tutti i casi di test

Come funziona

߀Ṣ   Helper link. Argument: A (array)

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

Ciò produce una rappresentazione canonica dell'input, costituito esclusivamente da array ordinati.

ÇṖƤƑ  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.

Gelatina , 7 byte

Ẉ<La߀Ạ

Questa è una porta della risposta Python di Leaky Nun .

Poiché l'input deve essere una stringa, questo invio è valido solo come programma completo.

Provalo online! o verifica tutti i casi di test

Come funziona

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

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

Provalo online!