Dans ce défi, vous devez analyser une liste de listes, dans un format de liste plus simple.

Ce défi est basé sur mon analyseur sadflak. Dans mon analyseur sadflak, tous les () ont été supprimés, remplacés par la somme des () au début de la liste, pour accélérer le programme.

Pour analyser dans une Sad-List, vous devez faire ceci (chose d'implémentation python, utilise un tuple de tuples):

def sadlistfunc(list):
    new-sadlist = [0]
    for i in list:
        if i == ():
            new-sadlist[0]+=1
        else:
            new-sadlist.append(sadlistfunc(i))

Il s'agit d'une fonction récursive. Pour une liste, commencez une nouvelle liste, en commençant par le nombre de () de l'entrée de liste, puis le reste de cette liste est des versions de liste triste de chaque liste qui n'était pas un () de l'entrée de liste, dans l'ordre. retourner la liste.

Contribution:

vous pouvez prendre des entrées dans plusieurs formats différents:

• vous pouvez le prendre comme une liste
• vous pouvez le prendre comme un tuple
• vous pouvez le prendre comme une chaîne

si vous le prenez comme une chaîne, vous devez utiliser un ensemble de crochets, comme indiqué dans brain-flak. vous ne pouvez pas utiliser les caractères 1 et 2

soyez juste raisonnable

L'entrée sera toujours dans une liste, mais votre programme peut supposer une couche de liste implicite en dehors de l'entrée, c'est-à-dire () () () = (() () ()), ou il peut choisir de ne pas le faire. Les exemples seront avec une liste extérieure explicite

production:

peut être une liste ou un tuple ou une chaîne, ou autre. vous pouvez utiliser n'importe quel format de sortie raisonnable, tout comme le méta consensus.

Exemple:

(()()()) = [3]
(((()))) = [0,[0,[1]]]
((())()(())) = [1, [1], [1]]
() = invalid input, if the outside bracket is explicit.
((((())())())(())()) = [1, [1, [1, [1]]], [1]]

notez que la saisie n'est pas stricte. ces entrées pourraient être:

[[],[],[]]
[[[[]]]]
[[[]],[],[[]]]
[]
[[[[[]],[]],[]],[[]],[]]

ou un autre format raisonnable

cas de test expliqué:

(()()((())())())

pour "sadifier" cela, on compte d'abord le nombre de ()

 ()()        ()
(    ((())())  )

3. ensuite nous les supprimons et ajoutons un 3 au début

(3,((())()))

il y a une liste dans cette liste. nous sadifions cela

((())())

combien ()?

     ()
((())  )

1. nous supprimons et ajoutons un 1 au début

(1,(()))

cela contient une liste

(())

compter

 ()
(  )

supprimer et ajouter le nombre

(1)

puis nous avons remis cela dans sa liste

(1,(1))

puis nous avons remis cela dans sa liste

(3,(1,(1)))

terminé

C'est du golf de code , donc plus c'est court, mieux c'est

Pyth , 13 octets

L+]/bYyM-b]Yy

Suite de tests .

Comment ça fonctionne

L+]/bYyM-b]Yy
L               define a function y with argument b:
   /bY              list 1: count how many [] can be found in b
  ]                         wrap into singleton
        -b]Y        list 2: filter out [] from b
      yM                    apply y (this function) to each
 +                  concatenate the two lists above
            y   apply y to the input

CommonLisp, 49 octets

(defun s(l)(cons(count()l)(mapcar's(remove()l))))

prendre l'entrée comme liste de listes.

Essayez-le en ligne!

Brachylog , 21 octets

;[[]]x{↰₀}ᵐA&{∋∅}ᶜg,A

Essayez-le en ligne!

Mathematica, 42 octets

{#~Count~{0},##&@@#~DeleteCases~{0}}&//@#&

Évite la récursivité explicite en utilisant //@( MapAll) qui mappe une fonction sur chaque nœud dans une arborescence. Cela signifie également que les fonctions sont exécutées à partir des feuilles vers le haut. Cependant, elle sera également appliquée à {}laquelle se transformera dans {0}le processus. C'est pourquoi nous comptons et supprimons à la {0}place {}.

Rétine , 42 octets

+`(({()|}(?<-3>))*)(?!\3){}
1$1
{(1*)
{$.1

Essayez-le en ligne!

Clojure, 59 octets

(fn f[i](conj(map f(remove #{[]}i))(count(filter #{[]}i))))

Pas très différent de la réponse CommonLisp . Son countet removesemblent accepter une construction un peu plus agréable, ici j'ai dû utiliser des ensembles.

En fait , 12 octets

;[]@c@;░Q£Mo

Essayez-le en ligne!

Prend l'entrée comme une liste de crochets séparés par des virgules avec des crochets externes explicites.

Explication:

;[]@c@;░Q£Mo
;[]@c         count the number of empty lists
     @;░      filter out empty lists
        Q£Mo  recurse with filtered list and append result

Python 2 , 69 46 45 octets

f=lambda l:[l.count([])]+map(f,filter(len,l))

Essayez-le en ligne!

Gelée , 10 octets

Tị߀;@ċ“”$

Essayez-le en ligne!

Prend la saisie sous forme de liste de listes de listes ...

Bien sûr, il utilise l'algorithme utilisé par les autres réponses. ;)

Haskell , 102 octets

data L=I Int|T[L]deriving Show
(I n:r)#m=r#(n+m)
(x:r)#m=x:r#m
_#m=[I m]
f(T[])=I 1
f(T t)=T$map f t#0

Essayez-le en ligne!

Étant donné que Haskell est strictement typé, il n'existe aucune liste imbriquée arbitrairement. En guise de remède, data L=I Int|T[L]deriving Showdes listes imbriquées arborescentes sont déclarées avec Ints ou des listes vides comme feuilles.

L' entrée est comme dans le deuxième exemple de format, avec un constructeur supplémentaire Tavant chaque entretoise d'ouverture: T[T[T[]],T[],T[T[]]]. Il en va de même pour la sortie, chaque numéro étant précédé d'un constructeur I. La fonction fexécute le chagrin .

Sorties pour les cas de test:

T [I 3]
T [T [T [I 1],I 0],I 0]
T [T [I 1],T [I 1],I 1]
T [T [T [T [I 1],I 1],I 1],T [I 1],I 1]

Javascript (ES6), 77 octets

Golfé:

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

Non golfé:

const traverse = arr => !arr.length || arr
    .map(traverse)
    .reduce(
        (accum, val) => (val.length ? accum.push(val) : accum[0]++, accum),
        [0]
    );

Démo

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

o.innerHTML = [
    JSON.stringify(m([[],[],[]])),
    JSON.stringify(m([[[[]]]])),
    JSON.stringify(m([[[]],[],[[]]])),
    JSON.stringify(m([])),
    JSON.stringify(m([[[[[]],[]],[]],[[]],[]]))
].join('\n')

<pre id=o></pre>