Visualiser le tableau imbriqué


15

Vous recevrez un tableau imbriqué. Votre programme doit visualiser le tableau.


Mais comment?

Par exemple, supposons que nous avons un tableau imbriqué, comme [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Ce tableau imbriqué peut être visualisé comme:

->1
->2
-->1
-->2
->3
>4
---->5
>6

Exemples

Input 1:
["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]
Output 1:
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Input 2:
[["1","2"],["3","4"]]
Output 2:
->1
->2
->3
->4

Règles

  • Vous pouvez utiliser une chaîne (ou d'autres types qui fonctionnent comme un tableau imbriqué) en entrée.
  • Le niveau maximum de "couches" est de 2 ^ 32-1.

Doit-il avoir cette visualisation exacte?
penalosa

@mnbvc Oui, sauf si je force à le faire, les gens commencent à tordre beaucoup les E / S. Croyez-moi, je l'ai essayé.
Matthew Roh

J'ai l'impression que la rétine gagnera cela.
Urne de poulpe magique

1
Existe-t-il des restrictions sur les caractères pouvant apparaître dans les chaînes?
Martin Ender

Questions connexes supplémentaires 1 , 2
AdmBorkBork

Réponses:


12

APL, 32 octets

{1=≡⍺:⎕←⍺,⍨⍵↑1↓⍵/'->'⋄⍺∇¨⍵+1}∘0

Tester:

      r
┌────┬─────────────────────────────────────────────────────────────────────────────────────────┐
│Atom│┌──────┬──────────────────────────────┬───────┬────────────────────────────────┬────────┐│
│    ││Proton│┌────────┬────────┬──────────┐│Neutron│┌────────┬──────────┬──────────┐│Electron││
│    ││      ││Up Quark│Up Quark│Down Quark││       ││Up Quark│Down Quark│Down Quark││        ││
│    ││      │└────────┴────────┴──────────┘│       │└────────┴──────────┴──────────┘│        ││
│    │└──────┴──────────────────────────────┴───────┴────────────────────────────────┴────────┘│
└────┴─────────────────────────────────────────────────────────────────────────────────────────┘
      {1=≡⍺:⎕←⍺,⍨⍵↑1↓⍵/'->'⋄⍺∇¨⍵+1}∘0 ⊢ r 
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Explication:

  • {... }∘0: exécutez la fonction suivante avec 0lié à :
    • 1=≡⍺:: si l'entrée a la profondeur 1 (ie un tableau qui ne contient pas d'autres tableaux):
      • ⍵/'->': créer une chaîne contenant -s et >s,
      • 1↓: déposez le premier élément,
      • ⍵↑: et prenez les premiers éléments. Il en résulte une chaîne contenant des ⍵-1tirets et un >.
      • ⍺,⍨: ajoutez-y l'entrée,
      • ⎕←: et sortie à l'écran
    • : autrement,
      • ⍺∇¨⍵+1: ajoutez 1 à et appliquez la fonction à chaque tableau imbriqué

5
Attendez, cela prend-il une contribution sous cette forme ascii-art?
Rɪᴋᴇʀ

4
@Riker: Non, cela prend un tableau imbriqué normal, mais c'est ainsi que Dyalog APL affiche un tableau imbriqué, et (je pensais) cela rend évident ce qui se passe. Vous pouvez le construire en écrivant par exemple ('Atom' ('Proton' ('Up Quark' 'Up Quark' 'Down Quark') 'Neutron' ('Up Quark' 'Down Quark' 'Down Quark') 'Electron')).
marinus

9
Ah ok. Cela clarifie les choses. Un peu déçu maintenant cependant ...
Rɪᴋᴇʀ


7

Mathematica, 58 57 56 octets

Merci à Greg Martin d'avoir économisé 1 octet.

Merci à ngenisis d'avoir sauvé 1 octet.

MapIndexed[Print[Table["-",Tr[1^#2]-1]<>">",#]&,#,{-1}]&

47
Bienvenue chez PPCG! Vous devez savoir que les réponses qui fournissent peu ou pas d'explications sont automatiquement signalées par le système et se retrouvent dans la file d'attente d'examen de faible qualité . Cela pourrait faire supprimer votre réponse. Notez que si vous avez supprimé plusieurs réponses, vous risquez d'obtenir une suspension temporaire. Juste un petit coup de tête!
Stewie Griffin

20
@StewieGriffin Merci pour l'accueil chaleureux, je garderai cela à l'esprit!
Martin Ender

6
@StewieGriffin accueillez-vous un sitemod? Qu'est-ce qui se passe ici? Est-ce une plaisanterie intérieure? #confused Et bon printemps pour vous si vous êtes dans le nord.
Mindwin

4
@Mindwin: Stack Exchange dispose d'un filtre conçu pour détecter les réponses qui ne sont probablement pas utiles. Ce type de message (titre + exemple de code court, pas de commentaire) est très susceptible de provoquer de faux positifs, car il ressemble beaucoup à un message à faible effort sur un ordinateur (et le commentaire de Stewie Griffin contient un lien vers une capture d'écran qui indique qu'un faux positif s'est effectivement produit; cela se moque de la situation). Voici un exemple d'un autre message qui a été pris dans le filtre.

8
@Titus J'adorerais en ajouter un mais je ne veux pas invalider le commentaire de Stewie. :(
Martin Ender

6

Java 7, 153 141 114 114 octets

String r="";<T,S>S c(S s,T o){for(T x:(T[])o)if(x instanceof Object[])c("-"+s,x);else r+=s+">"+x+"\n";return(S)r;}

-39 octets grâce à @ Barteks2x

Explication:

String r="";                         // Result String outside the method / on class-level
<T,S> S c(S s, T o){                 // Recursive Method with generic String and Object parameters and String return-type
  for(T x : (T[])o)                  //  Loop over the input-array
    if(x instanceof Object[])        //   If the current item is an array itself:
      c("-"+s, x);                   //    Recursive method-call with this array
    else                             //   Else:
      r += s+">"+x+"\n";             //    Append return-String with stripes String-input, ">", current item, and a new-line
                                     //  End of loop (implicit / single-line body)
  return (S)r;                       //  Return the result-String
}                                    // End of method

Code de test:

Essayez-le ici.

class M{
  String r="";<T,S>S c(S s,T o){for(T x:(T[])o)if(x instanceof Object[])c("-"+s,x);else r+=s+">"+x+"\n";return(S)r;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c("", new Object[]{new Object[]{1,2},new Object[]{new Object[]{1,2},3},4,new Object[]{new Object[]{new Object[]{new Object[]{5}}}},6}));
    m.r = "";
    System.out.println(m.c("", new Object[]{"Atom",new Object[]{"Proton",new Object[]{"Up Quark","Up Quark","Down Quark"}},new Object[]{"Neutron",new Object[]{"Up Quark","Up Quark","Down Quark"}},"Electron"}));
  }
}

Production:

->1
->2
-->1
-->2
->3
>4
---->5
>6

>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Up Quark
-->Down Quark
>Electron

1
Vous pouvez le raccourcir légèrement (143 ou même 142) en utilisant l'opérateur ternaire for(int j=i;j-->0;r+="-");pour faire aussi ce que fait la ligne suivante, et en utilisant un argument générique au lieu de Object []: String r="";<T>String c(int i,T[] o){for(T x:o)if(x instanceof Object[])c(i+1,(T[])x);else for(int j=i;j-->=0;r+=j<0?">"+x+"\n":"-");return r;} et même 1 caractère de moins si vous passez 1 au lieu de 0 comme premier l'argument est ok.
barteks2x

J'ai trouvé un moyen de le rendre encore plus court en supprimant le [] de l'argument générique, il enregistre 2 caractères supplémentaires (mais ne peut pas modifier le commentaire après> 5 minutes)
barteks2x

@ Barteks2x Merci! -12 octets grâce à vous. :) Btw, la suppression []du paramètre pour enregistrer 1 octet supplémentaire donne une erreur. Voir l'erreur ici sur > Debug après exécution.
Kevin Cruijssen

String r="";<T>String c(int i,T a){for(T x:(T[])a)if(x instanceof Object[])c(i+1,x);else for(int j=i;j-->0;r+=j<1?">"+x+"\n":"-");return r;}cela marche. Vous pouvez également effectuer une astuce générique similaire avec une chaîne pour enregistrer un octet supplémentaire, mais nécessite soit de stocker le résultat dans une variable avant de l'imprimer, soit une conversion explicite (appel de méthode ambigu):String r="";<T,S>S c(int i,T a){for(T x:(T[])a)if(x instanceof Object[])c(i+1,x);else for(int j=i;j-->0;r+=j<1?">"+x+"\n":"-");return(S)r;}
barteks2x

1
Je ne sais pas si cela est considéré comme autorisé, mais 114 octets ici, avec une chaîne vide comme argument au lieu de zéro (peut être 1 caractère de moins si ">" est autorisé comme argument) String r="";<T,S>S c(S p,T a){for(T x:(T[])a)if(x instanceof Object[])c("-"+p,x);else r+=p+">"+x+"\n";return(S)r;}Et l'exigence de transtypage de chaîne sur le type de retour lors de l'appel c'est parti.
barteks2x

6

PHP, 77 74 73 octets

4 octets enregistrés grâce à @manatwork.

function f($a,$p=">"){foreach($a as$e)"$e"!=$e?f($e,"-$p"):print"$p$e
";}

fonction récursive, nécessite PHP 7.1 ou plus récent pour l'index de chaîne négatif.
"$e"est Arraypour les tableaux; c'est "$e"!=$ela même chose que is_array($e).

  • commencer par le préfixe >
  • ajouter un -au préfixe pour chaque niveau
  • imprimer le préfixe + élément + nouvelle ligne pour les atomes

1
75 octets:function f($a,$p=""){foreach($a as$e)echo$p,is_array($e)?f($e,"-"):">$e\n";}
Ismael Miguel

1
s'il n'était pas nécessaire pour le formatage requis, print_r ($ array) serait encore plus petit :)
ivanivan

1
A fait juste un test rapide, mais semble is_array($e)pouvoir être remplacé par $e[-1]!=="".
manatwork

1
@manatwork C'est PHP <7.1 ... en PHP 7.1, cela peut être fait avec $e[-]==""... et avec la condition inversée $e[-1]>"". Belle trouvaille!
Titus

1
Peut-être que je manque quelques cas d'angle, mais pour l'instant, il semble $e[-1]>""pouvoir être remplacé par "$e"==$e. Au moins dans l'ancien PHP 5.6 que j'utilise.
manatwork

5

C99 (CCG), 201 187 140 112 109

f(char*a){for(long d=1,j;j=d+=*++a>90?92-*a:0;)if(*a<35){for(;j||*++a^34;)putchar(j?"->"[!--j]:*a);puts("");}}

forme développée:

f(char*a){
    for(long d=1,j;j=d+=*++a>90?92-*a:0;)
        if(*a<35){
            for(;j||*++a^34;)putchar(j?--j?45:62:*a);
            puts("");
        }
}

Cela prend une chaîne au format correct et se termine lors de la recherche de la dernière correspondance ].

Il n'utilise pas de récursivité et utilise des types longs pour réellement atteindre la deuxième règle: 2 ^ 32-1 niveaux . La plupart des langages de script ont une profondeur de récursivité limitée ou se bloquent simplement lors d'un débordement de pile.

Je n'ai pas l'habitude de jouer au golf en C, toute aide est appréciée :)

Merci à bolov pour ses conseils! Merci particulièrement à Titus qui est toujours partant pour une bonne partie de golf (même en do)!

Encore deux octets économisés par le fait que nous pouvons terminer une fois que nous correspondons au dernier ]et n'avons pas besoin de faire correspondre un caractère nul.

Il peut être testé sur Wandbox .



Pourriez-vous pas raccourcir la deuxième ligne à for(int d=1 ...? longa 4 caractères alors qu'il intn'en a que 3, et il n'y a aucune raison que vous deviez le faire dépasser le 2^32 - 1pour que votre soumission soit valide, vous économisant ainsi un seul octet.
Restioson

@Restioson int est signé et ne fonctionne donc que jusqu'à 2^31-1.
Christoph

Le défi a déclaré @ Christoph que vous ne devez aller plus loin que cela.
Restioson

@Restioson Le défi est la règle The maximum level of "layers" is 2^32-1.. 2^31-1est beaucoup moins que 2^32-1. 2^32-1ne correspond pas à un intmoment, il correspond à un unsignedou long(c'est sur la plupart des systèmes / compilateurs bien sûr). Par conséquent int, ne ferait pas une bonne réponse (comme la plupart des réponses ici ne le sont pas).
Christoph

4

JavaScript (ES6), 58 51 octets

f=(a,s='>')=>a.map(e=>e.map?f(e,'-'+s):s+e).join`
`

Edit: enregistré 7 octets lorsque @Arnauld a souligné que je pouvais combiner mes deux approches.


4

PHP, 129 123 112 112 109 95 93 91 octets

for(;a&$c=$argn[++$i];)$c<A?$c<"-"?a&$s?$s=!print"$p>$s
":0:$s.=$c:$p=substr("---$p",$c^i);

solution itérative prend chaîne de STDIN:
Exécuter avec echo '<input>' | php -nR '<code>'ou tester en ligne .

panne

for(;a&$c=$argn[++$i];)     // loop $c through input characters
    $c<A                        // not brackets?
        ?$c<"-"                     // comma or quote?
            ?a&$s?$s=!print"$p>$s\n":0  // if $s not empty, print and clear $s
            :$s.=$c                     // digit: append to $s
        :$p=substr("---$p",$c^i)    // prefix plus or minus one "-"
;

Heureux que les chiffres soient entre guillemets; donc je n'ai besoin que d'une action à la fois.

Violon ASCII

char    ascii   binary/comment
 "       34
 ,       44
 [       91     0101 1011
 ]       93     0101 1101

 A       65     $c<A    true for comma, quote and digits
 -       45     $c<"-"  true for comma and quote

                =0011 1010 -> 50 -> "2"
i^"["   105^91  ^0101 1011
 i      105      0110 1001
i^"]"   105^93  ^0101 1101
                =0011 0100 -> 52 -> "4"

Ajouter 3 tirets $pet en retirer 2 pour [, 4 pour en ]ajoute un pour[ et en supprime un pour ].


Bon travail encore!
Christoph

4

Python 2, 65 64 octets

f=lambda o,d=0:o<''and'\n'.join(f(e,d+1)for e in o)or'-'*d+'>'+o

À l'heure actuelle, ma réponse commence systématiquement sans tirets, tout ["foo", "bar"]comme:

>foo
>bar

import sys, pprint; pprint.pprint(sys.argv)est de 43 octets mais je ne sais pas si cela enfreint les règles du golf de code.
Carel

Cela économise un octet:f=lambda o,d=0:o<''and'\n'.join(f(e,d+1)for e in o)or'-'*d+'>'+o
Ben Frankel

@Carel ne peut pas faire `` importer pprint en tant que p '' ou peut-être (je ne sais pas si cela fonctionne) `` importer pprint.pprint en p '' (bonté, je n'arrive pas à trouver la coche arrière sur le clavier de mon téléphone)
Cole

@Cole Hmm .. import sys, pprint.pprint as p; p(sys.argv)est toujours 43 mais une bonne suggestion quand même; D Essayer en import sys.argv as vfait l'allonge quelque peu ~ 48 octets. Si l'on pouvait éliminer sys.argv, ils économiseraient beaucoup mais le programme devient alors tout à fait inutile. Une approche récursive est assez longue def p(L,d=0): [p(i,d+1) if isinstance(i,list) else print(">"*d + i) for i in L], ~ 80 octets.
Carel

3

Perl 5 , 55 octets

53 octets de code + -nldrapeaux.

/"/?print"-"x~-$v.">$_":/]/?$v--:$v++for/]|\[|".*?"/g

Essayez-le en ligne!

Pas optimal pour l'expression régulière en raison de certains cas énervés qui pourraient potentiellement se produire (en particulier, si un élément du tableau contient des crochets à l'intérieur).
Une fonction anonyme récursive serait à peine plus longue (61 octets):

sub f{my$v=pop;map{ref?f(@$_,$v+1):"-"x$v.">$_"}@_}sub{f@_,0}

Essayez-le en ligne!

Mais la façon dont Perl traite les paramètres n'est pas optimale pour les fonctions de golf: aucun paramètre facultatif signifie que je dois faire une deuxième fonction (anonyme) appelant la première, et je dois explicitement obtenir le dernier paramètre avec cette durée my$v=pop.


3

Rubis, 49 45 46 octets

f=->c,p=?>{c.map{|x|x==[*x]?f[x,?-+p]:p+x}*$/}

Exemple:

puts f[["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]]

>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Explication:

Fonction récursive: si x==[*x]alors x est un tableau, et nous itérons dessus. Sinon, indenter.


3

Haskell, 104 octets

l@(x:y)#(a:m)|[(h,t)]<-reads$a:m=y++h++l#t|a<'#'=l#m|a<'-'='\n':l#m|a>'['=y#m|q<-'-':l=q#m
l#_=""
(">"#)

Haskell n'a pas de listes imbriquées avec différentes profondeurs, donc je dois analyser la chaîne d'entrée par moi-même. Heureusement, la fonction de bibliothèque readspeut analyser les chaînes (c'est-à-dire la "séquence de caractères fermée), j'ai donc un peu d'aide ici.

Exemple d'utilisation:

*Main> putStrLn $ (">"#) "[[\"1\",\"2\"],[\"3\",\"4\"]]" 
->1
->2
->3
->4

Essayez-le en ligne! .

Comment ça fonctionne:

La fonction #passe par la chaîne char par char et conserve le niveau d'imbrication (le premier paramètre l) sous la forme d'une chaîne -avec une finale >. Si le début de la liste peut être analysé comme une chaîne, prenez let la chaîne suivie d'un appel récursif avec la chaîne supprimée. Si le premier caractère est un espace, sautez-le. Si c'est un ,, prenez une nouvelle ligne et continuez, si c'est le cas ], abaissez le niveau d'imbrication et continuez et sinon (seulement à [gauche) augmentez le niveau d'imbrication et continuez. La récursivité se termine avec la chaîne d'entrée vide. La fonction principale (">"#)définit le niveau d'imbrication sur ">"et appelle #.


2

SWI-Prolog, 115 octets

p(L):-p(L,[>]).
p([],_):-!.
p([H|T],F):-p(H,[-|F]),p(T,F),!.
p(E,[_|F]):-w(F),w([E]),nl.
w([]).
w([H|T]):-write(H),w(T).

Sauts de ligne ajoutés pour la lisibilité uniquement, non inclus dans le nombre d'octets.

pprédicat traverse récursivement les tableaux, en ajoutant un «-» au préfixe Florsque vous déplacez un niveau plus profondément. west utilisé pour écrire le tableau de préfixes ainsi que l'élément réel dans la sortie.

Exemple:

?- p(["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]).
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

2

Lot, 249 octets

@echo off
set/ps=
set i=
:t
set t=
:l
set c=%s:~,1%
set s=%s:~1%
if "%c%"=="[" set i=-%i%&goto l
if not "%c%"=="]" if not "%c%"=="," set t=%t%%c%&goto l
if not "%t%"=="" echo %i:~1%^>%t%
if "%c%"=="]" set i=%i:~1%
if not "%s%"=="" goto t

Batch ennuyeux a du mal à comparer les virgules. Exemple d'exécution:

[Atom,[Proton,[Up Quark,Up Quark,Down Quark],Neutron,[Up Quark,Down Quark,Down Quark],Electron]]
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

2

Rétine , 63 54 52 octets

Enregistré 2 octets grâce à Martin Ender

.*?".*?"
$`$&¶
T`[] -~`-]_`.(?=.*".*")
-]

-"
>
T`]"

Essayez-le en ligne!

Explication

.*?".*?"
$`$&¶

Tout d'abord, le tableau est divisé en remplaçant chaque chaîne entre guillemets par tout ce qui l'a précédé, plus lui-même, plus une nouvelle ligne. En le décomposant comme ceci, il est possible de trouver les crochets d'ouverture inégalés avant chaque chaîne.

T`[] -~`-]_`.(?=.*".*")

Cette translittération sera remplacée [par -, laissée ]inchangée et supprimera tout autre caractère (  -~est entièrement ASCII imprimable). Cependant, il remplace uniquement les caractères apparaissant avant la chaîne finale sur chaque ligne.

-]

Ensuite, toutes les instances de -]sont supprimées. Celles-ci correspondent à des paires de parenthèses correspondantes, et nous voulons uniquement des parenthèses inégalées. Une fois ceux-ci supprimés, chaque ligne a un nombre de -s égal au nombre de crochets d'ouverture inégalés qui l'ont précédée.

-"
>

Le dernier -avant a "est remplacé par >, pour former les flèches.

T`]"

Enfin, tous les ]s et "s restants sont supprimés.


Il semble que cela suppose qu'il n'y aura pas de guillemets (échappés) à l'intérieur des chaînes. Je ne sais pas si c'est légitime, mais j'ai demandé des éclaircissements.
Martin Ender

@MartinEnder Bonne prise, je garderai un œil dessus
Business Cat

1

Röda , 54 octets

f d=""{{|n|{n|f d=`$d-`}if[n is list]else[`$d>$n
`]}_}

Essayez-le en ligne!

C'est une fonction qui lit le tableau d'entrée du flux. Pour chaque élément, il s'appelle récursivement ou imprime l'élément.


1

Python 3, 80 octets

Les lambdas de Python prennent en charge la récursion, semble-t-il, qui savait?

p=lambda l,d=1:[p(i,d+1)if isinstance(i,list)else print("-"*d+">"+i)for i in l]

Ceci est un contre / compliment à la réponse d' orlp .


Bienvenue chez PPCG! Il semble que vous ayez compté un saut de ligne de fin ou quelque chose (parce que je ne compte que 80 octets) et que vous n'avez pas besoin des espaces autour du =. Je soupçonne également que vous pouvez supprimer tous les espaces après les trois ), mais je ne suis pas très familier avec le golf en Python.
Martin Ender


0

Empilé , 27 octets

[@.1-'-'*\'>'\,,out]deepmap

Essayez-le en ligne!

Prend l'entrée du haut de la pile et laisse la sortie sur STDOUT. C'est aussi simple que de faire une carte de profondeur, de répéter des - dtemps, de concaténer avec '>' et l'élément lui-même.


0

Gema, 63 caractères

\A=@set{i;-1}
[=@incr{i}
]=@decr{i}
"*"=@repeat{$i;-}>*\n
,<s>=

Comme les autres solutions d'analyse, suppose qu'il n'y aura pas de guillemets doubles échappés dans les chaînes.

Exemple d'exécution:

bash-4.3$ gema '\A=@set{i;-1};[=@incr{i};]=@decr{i};"*"=@repeat{$i;-}>*\n;,<s>=' <<< '[["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]'
->1
->2
-->1
-->2
->3
>4
---->5
>6

0

jq, 70 67 caractères

( 67 commande option de ligne 64 caractères de code + 3 caractères)

def f(i):if type=="array"then.[]|f("-"+i)else i+. end;.[]|f(">")

Exemple d'exécution:

bash-4.3$ jq -r 'def f(i):if type=="array"then.[]|f("-"+i)else i+. end;.[]|f(">")' <<< '[["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]'
->1
->2
-->1
-->2
->3
>4
---->5
>6

Test en ligne

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.