How to invert MapIndexed on a ragged structure? How to construct a tree from rules? The Next CEO of Stack OverflowFrom a list to a list of rulesHow to partition a list according to a nested table structure?Visualize a tree structure using TreeGraphExplore a nested listDrop selection of columns from a ragged arrayHow to check if two nested lists have the same structure?Rule-based branching construction of listsHow to convert a tree in a list?Replacement Rule for “flattening” list whilst adding attributesRagged Transpose

How to Reset Passwords on Multiple Websites Easily?

How to count occurrences of text in a file?

Non-deterministic sum of floats

Written every which way

How to make a variable always equal to the result of some calculations?

How to add tiny 0.5A 120V load to very remote split phase 240v 3 wire well house

Why do we use the plural of movies in this phrase "We went to the movies last night."?

Interfacing a button to MCU (and PC) with 50m long cable

Why do airplanes bank sharply to the right after air-to-air refueling?

How does the mv command work with external drives?

Return the Closest Prime Number

How to solve a differential equation with a term to a power?

What does "Its cash flow is deeply negative" mean?

Why did we only see the N-1 starfighters in one film?

Rotate a column

Is it ever safe to open a suspicious html file (e.g. email attachment)?

Why does the UK parliament need a vote on the political declaration?

MessageLevel in QGIS3

Why does standard notation not preserve intervals (visually)

Anatomically Correct Strange Women In Ponds Distributing Swords

Several mode to write the symbol of a vector

Can we say or write : "No, it'sn't"?

What can we do to stop prior company from asking us questions?

Are there any unintended negative consequences to allowing PCs to gain multiple levels at once in a short milestone-XP game?



How to invert MapIndexed on a ragged structure? How to construct a tree from rules?



The Next CEO of Stack OverflowFrom a list to a list of rulesHow to partition a list according to a nested table structure?Visualize a tree structure using TreeGraphExplore a nested listDrop selection of columns from a ragged arrayHow to check if two nested lists have the same structure?Rule-based branching construction of listsHow to convert a tree in a list?Replacement Rule for “flattening” list whilst adding attributesRagged Transpose










4












$begingroup$


I have an arbitrary ragged nested list-of-lists (a tree) like



A = a, b, c, d, e, f, g, h, i, j, k, l, m, n;


Its structure is given by the rules



B = Flatten[MapIndexed[#2 -> #1 &, A, -1]]



1, 1 -> a, 1, 2 -> b, 2, 1 -> c, 2, 2 -> d, 3, 1, 1, 1 -> e, 3, 1, 1, 2 -> f, 3, 1, 1, 3 -> g, 3, 1, 1, 4 -> h, 3, 1, 1, 5 -> i, 3, 1, 2, 1 -> j, 3, 1, 2, 2 -> k, 3, 1, 2, 3 -> l, 3, 2 -> m, 4 -> n




How can I invert this operation? How can I construct A solely from the information given in B?










share|improve this question









$endgroup$
















    4












    $begingroup$


    I have an arbitrary ragged nested list-of-lists (a tree) like



    A = a, b, c, d, e, f, g, h, i, j, k, l, m, n;


    Its structure is given by the rules



    B = Flatten[MapIndexed[#2 -> #1 &, A, -1]]



    1, 1 -> a, 1, 2 -> b, 2, 1 -> c, 2, 2 -> d, 3, 1, 1, 1 -> e, 3, 1, 1, 2 -> f, 3, 1, 1, 3 -> g, 3, 1, 1, 4 -> h, 3, 1, 1, 5 -> i, 3, 1, 2, 1 -> j, 3, 1, 2, 2 -> k, 3, 1, 2, 3 -> l, 3, 2 -> m, 4 -> n




    How can I invert this operation? How can I construct A solely from the information given in B?










    share|improve this question









    $endgroup$














      4












      4








      4





      $begingroup$


      I have an arbitrary ragged nested list-of-lists (a tree) like



      A = a, b, c, d, e, f, g, h, i, j, k, l, m, n;


      Its structure is given by the rules



      B = Flatten[MapIndexed[#2 -> #1 &, A, -1]]



      1, 1 -> a, 1, 2 -> b, 2, 1 -> c, 2, 2 -> d, 3, 1, 1, 1 -> e, 3, 1, 1, 2 -> f, 3, 1, 1, 3 -> g, 3, 1, 1, 4 -> h, 3, 1, 1, 5 -> i, 3, 1, 2, 1 -> j, 3, 1, 2, 2 -> k, 3, 1, 2, 3 -> l, 3, 2 -> m, 4 -> n




      How can I invert this operation? How can I construct A solely from the information given in B?










      share|improve this question









      $endgroup$




      I have an arbitrary ragged nested list-of-lists (a tree) like



      A = a, b, c, d, e, f, g, h, i, j, k, l, m, n;


      Its structure is given by the rules



      B = Flatten[MapIndexed[#2 -> #1 &, A, -1]]



      1, 1 -> a, 1, 2 -> b, 2, 1 -> c, 2, 2 -> d, 3, 1, 1, 1 -> e, 3, 1, 1, 2 -> f, 3, 1, 1, 3 -> g, 3, 1, 1, 4 -> h, 3, 1, 1, 5 -> i, 3, 1, 2, 1 -> j, 3, 1, 2, 2 -> k, 3, 1, 2, 3 -> l, 3, 2 -> m, 4 -> n




      How can I invert this operation? How can I construct A solely from the information given in B?







      list-manipulation data-structures trees






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked 3 hours ago









      RomanRoman

      3,9661022




      3,9661022




















          3 Answers
          3






          active

          oldest

          votes


















          2












          $begingroup$

          Here's a procedural way:



          Block[
          Nothing,
          Module[
          m = Max[Length /@ Keys[B]], arr,
          arr = ConstantArray[Nothing, Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]];
          Map[Function[arr[[Sequence @@ #[[1]]]] = #[[2]]], B];
          arr
          ]
          ]

          a, b, c, d, e, f, g, h, i, j, k, l, m, n





          share|improve this answer









          $endgroup$




















            1












            $begingroup$

            Here's an inefficient but reasonably simple way:



            groupMe[rules_] :=
            If[Head[rules[[1]]] === Rule,
            Values@GroupBy[
            rules,
            (#[[1, 1]] &) ->
            (If[Length[#[[1]]] === 1, #[[2]], #[[1, 2 ;;]] -> #[[2]]] &),
            groupMe
            ],
            rules[[1]]
            ]

            groupMe[B]

            a, b, c, d, e, f, g, h, i, j, k, l, m, n





            share|improve this answer









            $endgroup$




















              1












              $begingroup$

              Here's a convoluted way using pattern replacements:



              DeleteCases[
              With[m = Max[Length /@ Keys[B]],
              Array[
              List,
              Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]
              ] /.
              Map[
              Fold[
              Insert[
              #, ___,
              _,
              Append[ConstantArray[1, #2], -1]] &,
              #[[1]],
              Range[m - Length[#[[1]]]]
              ] -> #[[2]] &,
              B
              ]
              ],
              __Integer,
              Infinity
              ]

              a, b, c, d, e, f, g, h, i, j, k, l, m, n





              share|improve this answer









              $endgroup$













                Your Answer





                StackExchange.ifUsing("editor", function ()
                return StackExchange.using("mathjaxEditing", function ()
                StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix)
                StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
                );
                );
                , "mathjax-editing");

                StackExchange.ready(function()
                var channelOptions =
                tags: "".split(" "),
                id: "387"
                ;
                initTagRenderer("".split(" "), "".split(" "), channelOptions);

                StackExchange.using("externalEditor", function()
                // Have to fire editor after snippets, if snippets enabled
                if (StackExchange.settings.snippets.snippetsEnabled)
                StackExchange.using("snippets", function()
                createEditor();
                );

                else
                createEditor();

                );

                function createEditor()
                StackExchange.prepareEditor(
                heartbeatType: 'answer',
                autoActivateHeartbeat: false,
                convertImagesToLinks: false,
                noModals: true,
                showLowRepImageUploadWarning: true,
                reputationToPostImages: null,
                bindNavPrevention: true,
                postfix: "",
                imageUploader:
                brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                allowUrls: true
                ,
                onDemand: true,
                discardSelector: ".discard-answer"
                ,immediatelyShowMarkdownHelp:true
                );



                );













                draft saved

                draft discarded


















                StackExchange.ready(
                function ()
                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f194217%2fhow-to-invert-mapindexed-on-a-ragged-structure-how-to-construct-a-tree-from-rul%23new-answer', 'question_page');

                );

                Post as a guest















                Required, but never shown

























                3 Answers
                3






                active

                oldest

                votes








                3 Answers
                3






                active

                oldest

                votes









                active

                oldest

                votes






                active

                oldest

                votes









                2












                $begingroup$

                Here's a procedural way:



                Block[
                Nothing,
                Module[
                m = Max[Length /@ Keys[B]], arr,
                arr = ConstantArray[Nothing, Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]];
                Map[Function[arr[[Sequence @@ #[[1]]]] = #[[2]]], B];
                arr
                ]
                ]

                a, b, c, d, e, f, g, h, i, j, k, l, m, n





                share|improve this answer









                $endgroup$

















                  2












                  $begingroup$

                  Here's a procedural way:



                  Block[
                  Nothing,
                  Module[
                  m = Max[Length /@ Keys[B]], arr,
                  arr = ConstantArray[Nothing, Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]];
                  Map[Function[arr[[Sequence @@ #[[1]]]] = #[[2]]], B];
                  arr
                  ]
                  ]

                  a, b, c, d, e, f, g, h, i, j, k, l, m, n





                  share|improve this answer









                  $endgroup$















                    2












                    2








                    2





                    $begingroup$

                    Here's a procedural way:



                    Block[
                    Nothing,
                    Module[
                    m = Max[Length /@ Keys[B]], arr,
                    arr = ConstantArray[Nothing, Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]];
                    Map[Function[arr[[Sequence @@ #[[1]]]] = #[[2]]], B];
                    arr
                    ]
                    ]

                    a, b, c, d, e, f, g, h, i, j, k, l, m, n





                    share|improve this answer









                    $endgroup$



                    Here's a procedural way:



                    Block[
                    Nothing,
                    Module[
                    m = Max[Length /@ Keys[B]], arr,
                    arr = ConstantArray[Nothing, Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]];
                    Map[Function[arr[[Sequence @@ #[[1]]]] = #[[2]]], B];
                    arr
                    ]
                    ]

                    a, b, c, d, e, f, g, h, i, j, k, l, m, n






                    share|improve this answer












                    share|improve this answer



                    share|improve this answer










                    answered 2 hours ago









                    b3m2a1b3m2a1

                    28.3k358163




                    28.3k358163





















                        1












                        $begingroup$

                        Here's an inefficient but reasonably simple way:



                        groupMe[rules_] :=
                        If[Head[rules[[1]]] === Rule,
                        Values@GroupBy[
                        rules,
                        (#[[1, 1]] &) ->
                        (If[Length[#[[1]]] === 1, #[[2]], #[[1, 2 ;;]] -> #[[2]]] &),
                        groupMe
                        ],
                        rules[[1]]
                        ]

                        groupMe[B]

                        a, b, c, d, e, f, g, h, i, j, k, l, m, n





                        share|improve this answer









                        $endgroup$

















                          1












                          $begingroup$

                          Here's an inefficient but reasonably simple way:



                          groupMe[rules_] :=
                          If[Head[rules[[1]]] === Rule,
                          Values@GroupBy[
                          rules,
                          (#[[1, 1]] &) ->
                          (If[Length[#[[1]]] === 1, #[[2]], #[[1, 2 ;;]] -> #[[2]]] &),
                          groupMe
                          ],
                          rules[[1]]
                          ]

                          groupMe[B]

                          a, b, c, d, e, f, g, h, i, j, k, l, m, n





                          share|improve this answer









                          $endgroup$















                            1












                            1








                            1





                            $begingroup$

                            Here's an inefficient but reasonably simple way:



                            groupMe[rules_] :=
                            If[Head[rules[[1]]] === Rule,
                            Values@GroupBy[
                            rules,
                            (#[[1, 1]] &) ->
                            (If[Length[#[[1]]] === 1, #[[2]], #[[1, 2 ;;]] -> #[[2]]] &),
                            groupMe
                            ],
                            rules[[1]]
                            ]

                            groupMe[B]

                            a, b, c, d, e, f, g, h, i, j, k, l, m, n





                            share|improve this answer









                            $endgroup$



                            Here's an inefficient but reasonably simple way:



                            groupMe[rules_] :=
                            If[Head[rules[[1]]] === Rule,
                            Values@GroupBy[
                            rules,
                            (#[[1, 1]] &) ->
                            (If[Length[#[[1]]] === 1, #[[2]], #[[1, 2 ;;]] -> #[[2]]] &),
                            groupMe
                            ],
                            rules[[1]]
                            ]

                            groupMe[B]

                            a, b, c, d, e, f, g, h, i, j, k, l, m, n






                            share|improve this answer












                            share|improve this answer



                            share|improve this answer










                            answered 3 hours ago









                            b3m2a1b3m2a1

                            28.3k358163




                            28.3k358163





















                                1












                                $begingroup$

                                Here's a convoluted way using pattern replacements:



                                DeleteCases[
                                With[m = Max[Length /@ Keys[B]],
                                Array[
                                List,
                                Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]
                                ] /.
                                Map[
                                Fold[
                                Insert[
                                #, ___,
                                _,
                                Append[ConstantArray[1, #2], -1]] &,
                                #[[1]],
                                Range[m - Length[#[[1]]]]
                                ] -> #[[2]] &,
                                B
                                ]
                                ],
                                __Integer,
                                Infinity
                                ]

                                a, b, c, d, e, f, g, h, i, j, k, l, m, n





                                share|improve this answer









                                $endgroup$

















                                  1












                                  $begingroup$

                                  Here's a convoluted way using pattern replacements:



                                  DeleteCases[
                                  With[m = Max[Length /@ Keys[B]],
                                  Array[
                                  List,
                                  Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]
                                  ] /.
                                  Map[
                                  Fold[
                                  Insert[
                                  #, ___,
                                  _,
                                  Append[ConstantArray[1, #2], -1]] &,
                                  #[[1]],
                                  Range[m - Length[#[[1]]]]
                                  ] -> #[[2]] &,
                                  B
                                  ]
                                  ],
                                  __Integer,
                                  Infinity
                                  ]

                                  a, b, c, d, e, f, g, h, i, j, k, l, m, n





                                  share|improve this answer









                                  $endgroup$















                                    1












                                    1








                                    1





                                    $begingroup$

                                    Here's a convoluted way using pattern replacements:



                                    DeleteCases[
                                    With[m = Max[Length /@ Keys[B]],
                                    Array[
                                    List,
                                    Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]
                                    ] /.
                                    Map[
                                    Fold[
                                    Insert[
                                    #, ___,
                                    _,
                                    Append[ConstantArray[1, #2], -1]] &,
                                    #[[1]],
                                    Range[m - Length[#[[1]]]]
                                    ] -> #[[2]] &,
                                    B
                                    ]
                                    ],
                                    __Integer,
                                    Infinity
                                    ]

                                    a, b, c, d, e, f, g, h, i, j, k, l, m, n





                                    share|improve this answer









                                    $endgroup$



                                    Here's a convoluted way using pattern replacements:



                                    DeleteCases[
                                    With[m = Max[Length /@ Keys[B]],
                                    Array[
                                    List,
                                    Max /@ Transpose[PadRight[#, m] & /@ Keys[B]]
                                    ] /.
                                    Map[
                                    Fold[
                                    Insert[
                                    #, ___,
                                    _,
                                    Append[ConstantArray[1, #2], -1]] &,
                                    #[[1]],
                                    Range[m - Length[#[[1]]]]
                                    ] -> #[[2]] &,
                                    B
                                    ]
                                    ],
                                    __Integer,
                                    Infinity
                                    ]

                                    a, b, c, d, e, f, g, h, i, j, k, l, m, n






                                    share|improve this answer












                                    share|improve this answer



                                    share|improve this answer










                                    answered 2 hours ago









                                    b3m2a1b3m2a1

                                    28.3k358163




                                    28.3k358163



























                                        draft saved

                                        draft discarded
















































                                        Thanks for contributing an answer to Mathematica Stack Exchange!


                                        • Please be sure to answer the question. Provide details and share your research!

                                        But avoid


                                        • Asking for help, clarification, or responding to other answers.

                                        • Making statements based on opinion; back them up with references or personal experience.

                                        Use MathJax to format equations. MathJax reference.


                                        To learn more, see our tips on writing great answers.




                                        draft saved


                                        draft discarded














                                        StackExchange.ready(
                                        function ()
                                        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f194217%2fhow-to-invert-mapindexed-on-a-ragged-structure-how-to-construct-a-tree-from-rul%23new-answer', 'question_page');

                                        );

                                        Post as a guest















                                        Required, but never shown





















































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown

































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown







                                        Popular posts from this blog

                                        Андора Зьмест Гісторыя | Палітыка | Адміністрацыйны падзел | Геаграфія | Эканоміка | Дэмаграфія | Крыніцы | Вонкавыя спасылкі | Навігацыйнае мэню"CIA World Factbook entry: Andorra"."Andorra 2008, Departament d'estadística d'Andorra"Андорарр

                                        J. J. Abrams Índice Traxectoria | Filmografía | Premios | Notas | Véxase tamén | Menú de navegacióne"J.J. Abrams: Biography"Arquivado"'Star Trek' sequel on track"Arquivado"J.J. Abrams Producing Samurai Jack Movie"Arquivado"EXCLUSIVE: J.J. Abrams Goes Into Warp Speed with Star Trek and Beyond"Arquivado"David Semel To Direct Jonah Nolan/J.J. Abrams' CBS Pilot 'Person Of Interest'"Arquivado"Fox orders J.J. Abrams pilot 'Alcatraz'"ArquivadoJ. J. AbramsJ. J. AbramsWorldCat81800131p24091041000XX116709414031616ma11226833654496ID052246713376222X511412nm00091900000 0001 1772 5428no98124254ID0000002883100650044xx0054597000141374297344064w64f2mjx14255303415344

                                        Сэнт-Люіс Вонкавыя спасылкі | Навігацыйнае мэню38°37′38″ пн. ш. 90°11′52″ з. д. / 38.62722° пн. ш. 90.19778° з. д. / 38.62722; -90.1977838°37′38″ пн. ш. 90°11′52″ з. д. / 38.62722° пн. ш. 90.19778° з. д. / 38.62722; -90.19778stlouis-mo.govСэнт-ЛюісAnnual Estimates of the Resident Population for Incorporated Places – U.S. Census Bureau, Population Division