How to take the beginning and end parts of a list with simpler syntax?Calling Table with custom iteratorExpectation over a list with nested-mapped expressionsDeleting powers of a common prime except the highest one from a list with further only primesChange orientation of GradientOrientationFilter from high value to lowHow to return the unevaluated variable names from a list of variables which have been declaredHow can I make ListPlot use my iteration as the x coord?Build a list from applying a recursive function on another listHow to split list into segments based on first element of sublist, and remove ineligible segments

What does buying a wish in Sega's Aladdin do?

What is the relationship between taxes and annual liquidation of the markets?

The quietest classical orchestra instrument to play at home

Mostly pluses and minuses: says Grandpa

Is there a text editor that can run shell scripts?

SQL Server - Snapshot is useful in production environments?

How to respond to requests to retest, in hope that the bug is gone?

How do HK restaurants keep wok-fried scallops white, with no visible sear marks?

"An animal and an animal" or "An animal and animal", which is correct?

When does "The Mandalorian" take place?

Intonation of string instruments in chamber music

What is the metal that was melted in episode 1?

Can I wire this light fixture set with the plate mounted directly to the stud?

Size Does Matter (at least referring to bottles)

Questions about go around safety

Is it bad style to ask for why a previous candidate was not hired?

Booking for intra-EU trains

Why were some early PC 3D cards unsuitable for 2D graphics?

What is the last point where one can throw away fruits if one has indicated "not bringing any fruit" on the US customs form when flying to the US?

Heavy condensation inside car during winter. Tried multiple things, but no results!

What would be the price of Adamantine Plate armor?

Why don't we shield existing CPUs from radiation instead of designing new ones?

grep extract number range

Why does Rome municipality seem to have a hard time maintaining the city?



How to take the beginning and end parts of a list with simpler syntax?


Calling Table with custom iteratorExpectation over a list with nested-mapped expressionsDeleting powers of a common prime except the highest one from a list with further only primesChange orientation of GradientOrientationFilter from high value to lowHow to return the unevaluated variable names from a list of variables which have been declaredHow can I make ListPlot use my iteration as the x coord?Build a list from applying a recursive function on another listHow to split list into segments based on first element of sublist, and remove ineligible segments






.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty
margin-bottom:0;

.everyonelovesstackoverflowposition:absolute;height:1px;width:1px;opacity:0;top:0;left:0;pointer-events:none;








10














$begingroup$


So basically you have a table of some values, let's call it a:



a=Table[n,n,10];
(*1, 2, 3, 4, 5, 6, 7, 8, 9, 10*)


And you want to take the beginning and end parts of the table, within the same line, and do something with them. It is my intention to change them all to 0, but really you could change them to some other variable, say b. We want the parts of the list that do not include some inner values, we'll do 4,5,6 which happen to correspond to the indexes 4 through 6, convenient, no?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]] = b; a
(*b, b, b, 4, 5, 6, b, b, b, b*)


What's a simpler syntax for this? How can we call the end and beginning values of a list in a simpler manner?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]]
(*1, 2, 3, 7, 8, 9, 10*)


The ideal input would be, to me, something like



a[[1;;3;7;;10]]
(*1, 2, 3, 7, 8, 9, 10*)


But this gives



(*7, 8, 9, 10*)


As expected.



How can we simplify the syntax to call the beginning and end parts of a list, leaving out some chosen middle portion?










share|improve this question










$endgroup$










  • 1




    $begingroup$
    Select[ a, ! MemberQ[ 4, 5, 6, #] & ]
    $endgroup$
    – LouisB
    Aug 11 at 19:23






  • 3




    $begingroup$
    Complement[ a, 4, 5, 6 ]
    $endgroup$
    – LouisB
    Aug 11 at 20:02






  • 3




    $begingroup$
    Cheating a little, we could write (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10.
    $endgroup$
    – WReach
    Aug 11 at 20:39






  • 1




    $begingroup$
    If it's the values, then in Table[n^2,n,10] the initial segment would be the span 1 ;; 1 and the final segment would be 3 ;; 10 and the excluded segment (the positions not to be changed) would be 2 ;; 2, if the excluded values were 4, 5, 6 -- no?
    $endgroup$
    – Michael E2
    Aug 11 at 22:48






  • 1




    $begingroup$
    Thanks. I posted an answer. See if I understood correctly.
    $endgroup$
    – Michael E2
    Aug 11 at 23:10

















10














$begingroup$


So basically you have a table of some values, let's call it a:



a=Table[n,n,10];
(*1, 2, 3, 4, 5, 6, 7, 8, 9, 10*)


And you want to take the beginning and end parts of the table, within the same line, and do something with them. It is my intention to change them all to 0, but really you could change them to some other variable, say b. We want the parts of the list that do not include some inner values, we'll do 4,5,6 which happen to correspond to the indexes 4 through 6, convenient, no?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]] = b; a
(*b, b, b, 4, 5, 6, b, b, b, b*)


What's a simpler syntax for this? How can we call the end and beginning values of a list in a simpler manner?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]]
(*1, 2, 3, 7, 8, 9, 10*)


The ideal input would be, to me, something like



a[[1;;3;7;;10]]
(*1, 2, 3, 7, 8, 9, 10*)


But this gives



(*7, 8, 9, 10*)


As expected.



How can we simplify the syntax to call the beginning and end parts of a list, leaving out some chosen middle portion?










share|improve this question










$endgroup$










  • 1




    $begingroup$
    Select[ a, ! MemberQ[ 4, 5, 6, #] & ]
    $endgroup$
    – LouisB
    Aug 11 at 19:23






  • 3




    $begingroup$
    Complement[ a, 4, 5, 6 ]
    $endgroup$
    – LouisB
    Aug 11 at 20:02






  • 3




    $begingroup$
    Cheating a little, we could write (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10.
    $endgroup$
    – WReach
    Aug 11 at 20:39






  • 1




    $begingroup$
    If it's the values, then in Table[n^2,n,10] the initial segment would be the span 1 ;; 1 and the final segment would be 3 ;; 10 and the excluded segment (the positions not to be changed) would be 2 ;; 2, if the excluded values were 4, 5, 6 -- no?
    $endgroup$
    – Michael E2
    Aug 11 at 22:48






  • 1




    $begingroup$
    Thanks. I posted an answer. See if I understood correctly.
    $endgroup$
    – Michael E2
    Aug 11 at 23:10













10












10








10


2



$begingroup$


So basically you have a table of some values, let's call it a:



a=Table[n,n,10];
(*1, 2, 3, 4, 5, 6, 7, 8, 9, 10*)


And you want to take the beginning and end parts of the table, within the same line, and do something with them. It is my intention to change them all to 0, but really you could change them to some other variable, say b. We want the parts of the list that do not include some inner values, we'll do 4,5,6 which happen to correspond to the indexes 4 through 6, convenient, no?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]] = b; a
(*b, b, b, 4, 5, 6, b, b, b, b*)


What's a simpler syntax for this? How can we call the end and beginning values of a list in a simpler manner?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]]
(*1, 2, 3, 7, 8, 9, 10*)


The ideal input would be, to me, something like



a[[1;;3;7;;10]]
(*1, 2, 3, 7, 8, 9, 10*)


But this gives



(*7, 8, 9, 10*)


As expected.



How can we simplify the syntax to call the beginning and end parts of a list, leaving out some chosen middle portion?










share|improve this question










$endgroup$




So basically you have a table of some values, let's call it a:



a=Table[n,n,10];
(*1, 2, 3, 4, 5, 6, 7, 8, 9, 10*)


And you want to take the beginning and end parts of the table, within the same line, and do something with them. It is my intention to change them all to 0, but really you could change them to some other variable, say b. We want the parts of the list that do not include some inner values, we'll do 4,5,6 which happen to correspond to the indexes 4 through 6, convenient, no?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]] = b; a
(*b, b, b, 4, 5, 6, b, b, b, b*)


What's a simpler syntax for this? How can we call the end and beginning values of a list in a simpler manner?



a[[Cases[a, (Except[Alternatives @@ Range[4, 6]])]]]
(*1, 2, 3, 7, 8, 9, 10*)


The ideal input would be, to me, something like



a[[1;;3;7;;10]]
(*1, 2, 3, 7, 8, 9, 10*)


But this gives



(*7, 8, 9, 10*)


As expected.



How can we simplify the syntax to call the beginning and end parts of a list, leaving out some chosen middle portion?







list-manipulation syntax






share|improve this question














share|improve this question











share|improve this question




share|improve this question










asked Aug 11 at 18:42









CA TrevillianCA Trevillian

8611 gold badge2 silver badges17 bronze badges




8611 gold badge2 silver badges17 bronze badges










  • 1




    $begingroup$
    Select[ a, ! MemberQ[ 4, 5, 6, #] & ]
    $endgroup$
    – LouisB
    Aug 11 at 19:23






  • 3




    $begingroup$
    Complement[ a, 4, 5, 6 ]
    $endgroup$
    – LouisB
    Aug 11 at 20:02






  • 3




    $begingroup$
    Cheating a little, we could write (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10.
    $endgroup$
    – WReach
    Aug 11 at 20:39






  • 1




    $begingroup$
    If it's the values, then in Table[n^2,n,10] the initial segment would be the span 1 ;; 1 and the final segment would be 3 ;; 10 and the excluded segment (the positions not to be changed) would be 2 ;; 2, if the excluded values were 4, 5, 6 -- no?
    $endgroup$
    – Michael E2
    Aug 11 at 22:48






  • 1




    $begingroup$
    Thanks. I posted an answer. See if I understood correctly.
    $endgroup$
    – Michael E2
    Aug 11 at 23:10












  • 1




    $begingroup$
    Select[ a, ! MemberQ[ 4, 5, 6, #] & ]
    $endgroup$
    – LouisB
    Aug 11 at 19:23






  • 3




    $begingroup$
    Complement[ a, 4, 5, 6 ]
    $endgroup$
    – LouisB
    Aug 11 at 20:02






  • 3




    $begingroup$
    Cheating a little, we could write (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10.
    $endgroup$
    – WReach
    Aug 11 at 20:39






  • 1




    $begingroup$
    If it's the values, then in Table[n^2,n,10] the initial segment would be the span 1 ;; 1 and the final segment would be 3 ;; 10 and the excluded segment (the positions not to be changed) would be 2 ;; 2, if the excluded values were 4, 5, 6 -- no?
    $endgroup$
    – Michael E2
    Aug 11 at 22:48






  • 1




    $begingroup$
    Thanks. I posted an answer. See if I understood correctly.
    $endgroup$
    – Michael E2
    Aug 11 at 23:10







1




1




$begingroup$
Select[ a, ! MemberQ[ 4, 5, 6, #] & ]
$endgroup$
– LouisB
Aug 11 at 19:23




$begingroup$
Select[ a, ! MemberQ[ 4, 5, 6, #] & ]
$endgroup$
– LouisB
Aug 11 at 19:23




3




3




$begingroup$
Complement[ a, 4, 5, 6 ]
$endgroup$
– LouisB
Aug 11 at 20:02




$begingroup$
Complement[ a, 4, 5, 6 ]
$endgroup$
– LouisB
Aug 11 at 20:02




3




3




$begingroup$
Cheating a little, we could write (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10.
$endgroup$
– WReach
Aug 11 at 20:39




$begingroup$
Cheating a little, we could write (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10.
$endgroup$
– WReach
Aug 11 at 20:39




1




1




$begingroup$
If it's the values, then in Table[n^2,n,10] the initial segment would be the span 1 ;; 1 and the final segment would be 3 ;; 10 and the excluded segment (the positions not to be changed) would be 2 ;; 2, if the excluded values were 4, 5, 6 -- no?
$endgroup$
– Michael E2
Aug 11 at 22:48




$begingroup$
If it's the values, then in Table[n^2,n,10] the initial segment would be the span 1 ;; 1 and the final segment would be 3 ;; 10 and the excluded segment (the positions not to be changed) would be 2 ;; 2, if the excluded values were 4, 5, 6 -- no?
$endgroup$
– Michael E2
Aug 11 at 22:48




1




1




$begingroup$
Thanks. I posted an answer. See if I understood correctly.
$endgroup$
– Michael E2
Aug 11 at 23:10




$begingroup$
Thanks. I posted an answer. See if I understood correctly.
$endgroup$
– Michael E2
Aug 11 at 23:10










7 Answers
7






active

oldest

votes


















9
















$begingroup$

Update: You can also try MapAt:



a = Range[10];
a = MapAt[b &, a, ;; 3, 7 ;;]



b, b, b, 4, 5, 6, b, b, b, b




Or ReplaceAll



a = Range[10];
a /. Alternatives @@ Drop[a, 4;;6] -> b



b, b, b, 4, 5, 6, b, b, b, b




Original answer: Try Drop:



Drop[Range @ 10, 4, 6]



1, 2, 3, 7, 8, 9, 10




Drop[Range @ 10, 4 ;; 6]




1, 2, 3, 7, 8, 9, 10





Drop[CharacterRange["a", "j"], 4, 6]



"a", "b", "c", "g", "h", "i", "j"







share|improve this answer












$endgroup$










  • 1




    $begingroup$
    Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
    $endgroup$
    – CA Trevillian
    Aug 11 at 19:01










  • $begingroup$
    I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
    $endgroup$
    – CA Trevillian
    Aug 17 at 2:29


















7
















$begingroup$

If it is okay to perform two assignments instead of one, then we can write:



(a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10


Scan is probably better since it does not bother constructing the result list that we are just going to discard anyway:



Scan[(a[[#]] = b) &, 1 ;; 3, 7 ;; 10]





share|improve this answer










$endgroup$














  • $begingroup$
    Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
    $endgroup$
    – CA Trevillian
    Aug 11 at 20:59


















6
















$begingroup$

Perhaps this?:



ReplacePart[Range@10, i_ /; Not[4 <= i <= 6] :> b]
(* b, b, b, 4, 5, 6, b, b, b, b *)





share|improve this answer










$endgroup$














  • $begingroup$
    Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
    $endgroup$
    – CA Trevillian
    Aug 11 at 23:20






  • 2




    $begingroup$
    @CATrevillian Yes, it depends only on the index (part/position), not the value.
    $endgroup$
    – Michael E2
    Aug 11 at 23:23


















5
















$begingroup$

By far the simplest way is to do it in two lines:



a = Table[RandomReal[], n, 10];
a[[1 ;; 3]] = b;
a[[7 ;; 10]] = b;
a


This gives the output:




b, b, b, 0.378846, 0.475894, 0.533768, b, b, b, b







share|improve this answer












$endgroup$






















    4
















    $begingroup$

    We can use Union[] to perform this operation in a simpler manner:



    a[[Range[1, 3] [Union] Range[7, 10]]]
    (*1, 2, 3, 7, 8, 9, 10*)


    But this is still decently messy, and the readability is not too high. Perhaps someone else has a better method?



    a[[Range[1, 3] [Union] Range[7, 10]]] = b; a
    (*b, b, b, 4, 5, 6, b, b, b, b*)





    share|improve this answer










    $endgroup$






















      3
















      $begingroup$

      For me, the least fussy approach involves using ArrayPad[] twice:



      ArrayPad[ArrayPad[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -3, -4], 3, 4, b]
      b, b, b, 4, 5, 6, b, b, b, b





      share|improve this answer










      $endgroup$














      • $begingroup$
        Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
        $endgroup$
        – CA Trevillian
        Aug 12 at 13:07






      • 1




        $begingroup$
        "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
        $endgroup$
        – J. M. will be back soon
        Aug 15 at 5:06


















      3
















      $begingroup$

      How about



      Range[10] // #[[;; 3]]~Join~#[[7 ;;]] &





      share|improve this answer










      $endgroup$
















        Your Answer








        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/4.0/"u003ecc by-sa 4.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%2f203601%2fhow-to-take-the-beginning-and-end-parts-of-a-list-with-simpler-syntax%23new-answer', 'question_page');

        );

        Post as a guest















        Required, but never shown


























        7 Answers
        7






        active

        oldest

        votes








        7 Answers
        7






        active

        oldest

        votes









        active

        oldest

        votes






        active

        oldest

        votes









        9
















        $begingroup$

        Update: You can also try MapAt:



        a = Range[10];
        a = MapAt[b &, a, ;; 3, 7 ;;]



        b, b, b, 4, 5, 6, b, b, b, b




        Or ReplaceAll



        a = Range[10];
        a /. Alternatives @@ Drop[a, 4;;6] -> b



        b, b, b, 4, 5, 6, b, b, b, b




        Original answer: Try Drop:



        Drop[Range @ 10, 4, 6]



        1, 2, 3, 7, 8, 9, 10




        Drop[Range @ 10, 4 ;; 6]




        1, 2, 3, 7, 8, 9, 10





        Drop[CharacterRange["a", "j"], 4, 6]



        "a", "b", "c", "g", "h", "i", "j"







        share|improve this answer












        $endgroup$










        • 1




          $begingroup$
          Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
          $endgroup$
          – CA Trevillian
          Aug 11 at 19:01










        • $begingroup$
          I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
          $endgroup$
          – CA Trevillian
          Aug 17 at 2:29















        9
















        $begingroup$

        Update: You can also try MapAt:



        a = Range[10];
        a = MapAt[b &, a, ;; 3, 7 ;;]



        b, b, b, 4, 5, 6, b, b, b, b




        Or ReplaceAll



        a = Range[10];
        a /. Alternatives @@ Drop[a, 4;;6] -> b



        b, b, b, 4, 5, 6, b, b, b, b




        Original answer: Try Drop:



        Drop[Range @ 10, 4, 6]



        1, 2, 3, 7, 8, 9, 10




        Drop[Range @ 10, 4 ;; 6]




        1, 2, 3, 7, 8, 9, 10





        Drop[CharacterRange["a", "j"], 4, 6]



        "a", "b", "c", "g", "h", "i", "j"







        share|improve this answer












        $endgroup$










        • 1




          $begingroup$
          Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
          $endgroup$
          – CA Trevillian
          Aug 11 at 19:01










        • $begingroup$
          I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
          $endgroup$
          – CA Trevillian
          Aug 17 at 2:29













        9














        9










        9







        $begingroup$

        Update: You can also try MapAt:



        a = Range[10];
        a = MapAt[b &, a, ;; 3, 7 ;;]



        b, b, b, 4, 5, 6, b, b, b, b




        Or ReplaceAll



        a = Range[10];
        a /. Alternatives @@ Drop[a, 4;;6] -> b



        b, b, b, 4, 5, 6, b, b, b, b




        Original answer: Try Drop:



        Drop[Range @ 10, 4, 6]



        1, 2, 3, 7, 8, 9, 10




        Drop[Range @ 10, 4 ;; 6]




        1, 2, 3, 7, 8, 9, 10





        Drop[CharacterRange["a", "j"], 4, 6]



        "a", "b", "c", "g", "h", "i", "j"







        share|improve this answer












        $endgroup$



        Update: You can also try MapAt:



        a = Range[10];
        a = MapAt[b &, a, ;; 3, 7 ;;]



        b, b, b, 4, 5, 6, b, b, b, b




        Or ReplaceAll



        a = Range[10];
        a /. Alternatives @@ Drop[a, 4;;6] -> b



        b, b, b, 4, 5, 6, b, b, b, b




        Original answer: Try Drop:



        Drop[Range @ 10, 4, 6]



        1, 2, 3, 7, 8, 9, 10




        Drop[Range @ 10, 4 ;; 6]




        1, 2, 3, 7, 8, 9, 10





        Drop[CharacterRange["a", "j"], 4, 6]



        "a", "b", "c", "g", "h", "i", "j"








        share|improve this answer















        share|improve this answer




        share|improve this answer








        edited Aug 12 at 4:52

























        answered Aug 11 at 18:50









        kglrkglr

        226k10 gold badges256 silver badges515 bronze badges




        226k10 gold badges256 silver badges515 bronze badges










        • 1




          $begingroup$
          Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
          $endgroup$
          – CA Trevillian
          Aug 11 at 19:01










        • $begingroup$
          I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
          $endgroup$
          – CA Trevillian
          Aug 17 at 2:29












        • 1




          $begingroup$
          Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
          $endgroup$
          – CA Trevillian
          Aug 11 at 19:01










        • $begingroup$
          I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
          $endgroup$
          – CA Trevillian
          Aug 17 at 2:29







        1




        1




        $begingroup$
        Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
        $endgroup$
        – CA Trevillian
        Aug 11 at 19:01




        $begingroup$
        Hah, shot myself in the foot with my end question...That works to get the values, but I'm unsure of the readability when we do a[[Drop[Range@10, 4, 6]]] = b; a. Though, it is a nice implementation and one I had not considered. I'm hoping to find something that is not too over-encumbered, in order to sit in a publication. This is much nicer than the original try of mine, and it only uses the definition of the neglected characters. Quite nice, actually, the more I debate it! Much more general of an approach. +1
        $endgroup$
        – CA Trevillian
        Aug 11 at 19:01












        $begingroup$
        I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
        $endgroup$
        – CA Trevillian
        Aug 17 at 2:29




        $begingroup$
        I've accepted your answer based on these parameters: generality of implementation, multiple versions, & the number of votes. Thank you!
        $endgroup$
        – CA Trevillian
        Aug 17 at 2:29













        7
















        $begingroup$

        If it is okay to perform two assignments instead of one, then we can write:



        (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10


        Scan is probably better since it does not bother constructing the result list that we are just going to discard anyway:



        Scan[(a[[#]] = b) &, 1 ;; 3, 7 ;; 10]





        share|improve this answer










        $endgroup$














        • $begingroup$
          Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
          $endgroup$
          – CA Trevillian
          Aug 11 at 20:59















        7
















        $begingroup$

        If it is okay to perform two assignments instead of one, then we can write:



        (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10


        Scan is probably better since it does not bother constructing the result list that we are just going to discard anyway:



        Scan[(a[[#]] = b) &, 1 ;; 3, 7 ;; 10]





        share|improve this answer










        $endgroup$














        • $begingroup$
          Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
          $endgroup$
          – CA Trevillian
          Aug 11 at 20:59













        7














        7










        7







        $begingroup$

        If it is okay to perform two assignments instead of one, then we can write:



        (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10


        Scan is probably better since it does not bother constructing the result list that we are just going to discard anyway:



        Scan[(a[[#]] = b) &, 1 ;; 3, 7 ;; 10]





        share|improve this answer










        $endgroup$



        If it is okay to perform two assignments instead of one, then we can write:



        (a[[#]] = b) & /@ 1 ;; 3, 7 ;; 10


        Scan is probably better since it does not bother constructing the result list that we are just going to discard anyway:



        Scan[(a[[#]] = b) &, 1 ;; 3, 7 ;; 10]






        share|improve this answer













        share|improve this answer




        share|improve this answer










        answered Aug 11 at 20:52









        WReachWReach

        56.5k2 gold badges125 silver badges224 bronze badges




        56.5k2 gold badges125 silver badges224 bronze badges














        • $begingroup$
          Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
          $endgroup$
          – CA Trevillian
          Aug 11 at 20:59
















        • $begingroup$
          Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
          $endgroup$
          – CA Trevillian
          Aug 11 at 20:59















        $begingroup$
        Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
        $endgroup$
        – CA Trevillian
        Aug 11 at 20:59




        $begingroup$
        Well aaactually--that was the original reason for this question, and I probably could have written that....but I can't remember what cup of coffee I was on at that point! Regardless, this is a great implementation of a pure function applied to an index being used in a functional reassignment. This is technically in one line too, which satisfied my original criteria! Very cool. I wonder if this can be shorted at all for some sort-of code-golf-like...thing...answer? (Hint-hint, but it'd require some user thought) Oooooh scan, yessiree this is a great one, Scan needs more use these days, imo.
        $endgroup$
        – CA Trevillian
        Aug 11 at 20:59











        6
















        $begingroup$

        Perhaps this?:



        ReplacePart[Range@10, i_ /; Not[4 <= i <= 6] :> b]
        (* b, b, b, 4, 5, 6, b, b, b, b *)





        share|improve this answer










        $endgroup$














        • $begingroup$
          Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
          $endgroup$
          – CA Trevillian
          Aug 11 at 23:20






        • 2




          $begingroup$
          @CATrevillian Yes, it depends only on the index (part/position), not the value.
          $endgroup$
          – Michael E2
          Aug 11 at 23:23















        6
















        $begingroup$

        Perhaps this?:



        ReplacePart[Range@10, i_ /; Not[4 <= i <= 6] :> b]
        (* b, b, b, 4, 5, 6, b, b, b, b *)





        share|improve this answer










        $endgroup$














        • $begingroup$
          Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
          $endgroup$
          – CA Trevillian
          Aug 11 at 23:20






        • 2




          $begingroup$
          @CATrevillian Yes, it depends only on the index (part/position), not the value.
          $endgroup$
          – Michael E2
          Aug 11 at 23:23













        6














        6










        6







        $begingroup$

        Perhaps this?:



        ReplacePart[Range@10, i_ /; Not[4 <= i <= 6] :> b]
        (* b, b, b, 4, 5, 6, b, b, b, b *)





        share|improve this answer










        $endgroup$



        Perhaps this?:



        ReplacePart[Range@10, i_ /; Not[4 <= i <= 6] :> b]
        (* b, b, b, 4, 5, 6, b, b, b, b *)






        share|improve this answer













        share|improve this answer




        share|improve this answer










        answered Aug 11 at 23:09









        Michael E2Michael E2

        163k13 gold badges221 silver badges523 bronze badges




        163k13 gold badges221 silver badges523 bronze badges














        • $begingroup$
          Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
          $endgroup$
          – CA Trevillian
          Aug 11 at 23:20






        • 2




          $begingroup$
          @CATrevillian Yes, it depends only on the index (part/position), not the value.
          $endgroup$
          – Michael E2
          Aug 11 at 23:23
















        • $begingroup$
          Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
          $endgroup$
          – CA Trevillian
          Aug 11 at 23:20






        • 2




          $begingroup$
          @CATrevillian Yes, it depends only on the index (part/position), not the value.
          $endgroup$
          – Michael E2
          Aug 11 at 23:23















        $begingroup$
        Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
        $endgroup$
        – CA Trevillian
        Aug 11 at 23:20




        $begingroup$
        Wow nice!! I like the use of RuleDelayed, am I correct in understanding that you could use either Table[n,n,10] or Table[n^2,n,10] and we should see the 4th-6th indexed values preserved, as ReplacePart replaces the ith index? The use of Not provides a good deal of readability as well.
        $endgroup$
        – CA Trevillian
        Aug 11 at 23:20




        2




        2




        $begingroup$
        @CATrevillian Yes, it depends only on the index (part/position), not the value.
        $endgroup$
        – Michael E2
        Aug 11 at 23:23




        $begingroup$
        @CATrevillian Yes, it depends only on the index (part/position), not the value.
        $endgroup$
        – Michael E2
        Aug 11 at 23:23











        5
















        $begingroup$

        By far the simplest way is to do it in two lines:



        a = Table[RandomReal[], n, 10];
        a[[1 ;; 3]] = b;
        a[[7 ;; 10]] = b;
        a


        This gives the output:




        b, b, b, 0.378846, 0.475894, 0.533768, b, b, b, b







        share|improve this answer












        $endgroup$



















          5
















          $begingroup$

          By far the simplest way is to do it in two lines:



          a = Table[RandomReal[], n, 10];
          a[[1 ;; 3]] = b;
          a[[7 ;; 10]] = b;
          a


          This gives the output:




          b, b, b, 0.378846, 0.475894, 0.533768, b, b, b, b







          share|improve this answer












          $endgroup$

















            5














            5










            5







            $begingroup$

            By far the simplest way is to do it in two lines:



            a = Table[RandomReal[], n, 10];
            a[[1 ;; 3]] = b;
            a[[7 ;; 10]] = b;
            a


            This gives the output:




            b, b, b, 0.378846, 0.475894, 0.533768, b, b, b, b







            share|improve this answer












            $endgroup$



            By far the simplest way is to do it in two lines:



            a = Table[RandomReal[], n, 10];
            a[[1 ;; 3]] = b;
            a[[7 ;; 10]] = b;
            a


            This gives the output:




            b, b, b, 0.378846, 0.475894, 0.533768, b, b, b, b








            share|improve this answer















            share|improve this answer




            share|improve this answer








            edited Aug 12 at 5:04

























            answered Aug 12 at 1:54









            axsvl77axsvl77

            8715 silver badges16 bronze badges




            8715 silver badges16 bronze badges
























                4
















                $begingroup$

                We can use Union[] to perform this operation in a simpler manner:



                a[[Range[1, 3] [Union] Range[7, 10]]]
                (*1, 2, 3, 7, 8, 9, 10*)


                But this is still decently messy, and the readability is not too high. Perhaps someone else has a better method?



                a[[Range[1, 3] [Union] Range[7, 10]]] = b; a
                (*b, b, b, 4, 5, 6, b, b, b, b*)





                share|improve this answer










                $endgroup$



















                  4
















                  $begingroup$

                  We can use Union[] to perform this operation in a simpler manner:



                  a[[Range[1, 3] [Union] Range[7, 10]]]
                  (*1, 2, 3, 7, 8, 9, 10*)


                  But this is still decently messy, and the readability is not too high. Perhaps someone else has a better method?



                  a[[Range[1, 3] [Union] Range[7, 10]]] = b; a
                  (*b, b, b, 4, 5, 6, b, b, b, b*)





                  share|improve this answer










                  $endgroup$

















                    4














                    4










                    4







                    $begingroup$

                    We can use Union[] to perform this operation in a simpler manner:



                    a[[Range[1, 3] [Union] Range[7, 10]]]
                    (*1, 2, 3, 7, 8, 9, 10*)


                    But this is still decently messy, and the readability is not too high. Perhaps someone else has a better method?



                    a[[Range[1, 3] [Union] Range[7, 10]]] = b; a
                    (*b, b, b, 4, 5, 6, b, b, b, b*)





                    share|improve this answer










                    $endgroup$



                    We can use Union[] to perform this operation in a simpler manner:



                    a[[Range[1, 3] [Union] Range[7, 10]]]
                    (*1, 2, 3, 7, 8, 9, 10*)


                    But this is still decently messy, and the readability is not too high. Perhaps someone else has a better method?



                    a[[Range[1, 3] [Union] Range[7, 10]]] = b; a
                    (*b, b, b, 4, 5, 6, b, b, b, b*)






                    share|improve this answer













                    share|improve this answer




                    share|improve this answer










                    answered Aug 11 at 18:42









                    CA TrevillianCA Trevillian

                    8611 gold badge2 silver badges17 bronze badges




                    8611 gold badge2 silver badges17 bronze badges
























                        3
















                        $begingroup$

                        For me, the least fussy approach involves using ArrayPad[] twice:



                        ArrayPad[ArrayPad[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -3, -4], 3, 4, b]
                        b, b, b, 4, 5, 6, b, b, b, b





                        share|improve this answer










                        $endgroup$














                        • $begingroup$
                          Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
                          $endgroup$
                          – CA Trevillian
                          Aug 12 at 13:07






                        • 1




                          $begingroup$
                          "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
                          $endgroup$
                          – J. M. will be back soon
                          Aug 15 at 5:06















                        3
















                        $begingroup$

                        For me, the least fussy approach involves using ArrayPad[] twice:



                        ArrayPad[ArrayPad[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -3, -4], 3, 4, b]
                        b, b, b, 4, 5, 6, b, b, b, b





                        share|improve this answer










                        $endgroup$














                        • $begingroup$
                          Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
                          $endgroup$
                          – CA Trevillian
                          Aug 12 at 13:07






                        • 1




                          $begingroup$
                          "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
                          $endgroup$
                          – J. M. will be back soon
                          Aug 15 at 5:06













                        3














                        3










                        3







                        $begingroup$

                        For me, the least fussy approach involves using ArrayPad[] twice:



                        ArrayPad[ArrayPad[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -3, -4], 3, 4, b]
                        b, b, b, 4, 5, 6, b, b, b, b





                        share|improve this answer










                        $endgroup$



                        For me, the least fussy approach involves using ArrayPad[] twice:



                        ArrayPad[ArrayPad[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -3, -4], 3, 4, b]
                        b, b, b, 4, 5, 6, b, b, b, b






                        share|improve this answer













                        share|improve this answer




                        share|improve this answer










                        answered Aug 12 at 9:07









                        J. M. will be back soonJ. M. will be back soon

                        103k11 gold badges320 silver badges479 bronze badges




                        103k11 gold badges320 silver badges479 bronze badges














                        • $begingroup$
                          Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
                          $endgroup$
                          – CA Trevillian
                          Aug 12 at 13:07






                        • 1




                          $begingroup$
                          "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
                          $endgroup$
                          – J. M. will be back soon
                          Aug 15 at 5:06
















                        • $begingroup$
                          Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
                          $endgroup$
                          – CA Trevillian
                          Aug 12 at 13:07






                        • 1




                          $begingroup$
                          "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
                          $endgroup$
                          – J. M. will be back soon
                          Aug 15 at 5:06















                        $begingroup$
                        Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
                        $endgroup$
                        – CA Trevillian
                        Aug 12 at 13:07




                        $begingroup$
                        Can this be used to rip out the middle portion and present just the edge parts? I suspect so, but I don’t understand this well enough on the surface. Thanks in advance! Very nice usage :)
                        $endgroup$
                        – CA Trevillian
                        Aug 12 at 13:07




                        1




                        1




                        $begingroup$
                        "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
                        $endgroup$
                        – J. M. will be back soon
                        Aug 15 at 5:06




                        $begingroup$
                        "rip out the middle portion and present just the edge parts" - for that case, I would be using Take[]/Part[] instead. ArrayPad[] is designed to act on both ends of a list, either by adding or removing elements (depending on the signs of the integers used in the second argument).
                        $endgroup$
                        – J. M. will be back soon
                        Aug 15 at 5:06











                        3
















                        $begingroup$

                        How about



                        Range[10] // #[[;; 3]]~Join~#[[7 ;;]] &





                        share|improve this answer










                        $endgroup$



















                          3
















                          $begingroup$

                          How about



                          Range[10] // #[[;; 3]]~Join~#[[7 ;;]] &





                          share|improve this answer










                          $endgroup$

















                            3














                            3










                            3







                            $begingroup$

                            How about



                            Range[10] // #[[;; 3]]~Join~#[[7 ;;]] &





                            share|improve this answer










                            $endgroup$



                            How about



                            Range[10] // #[[;; 3]]~Join~#[[7 ;;]] &






                            share|improve this answer













                            share|improve this answer




                            share|improve this answer










                            answered Aug 12 at 17:56









                            user2757771user2757771

                            1463 bronze badges




                            1463 bronze badges































                                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%2f203601%2fhow-to-take-the-beginning-and-end-parts-of-a-list-with-simpler-syntax%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

                                Tamil (spriik) Luke uk diar | Nawigatjuun

                                Align equal signs while including text over equalitiesAMS align: left aligned text/math plus multicolumn alignmentMultiple alignmentsAligning equations in multiple placesNumbering and aligning an equation with multiple columnsHow to align one equation with another multline equationUsing \ in environments inside the begintabularxNumber equations and preserving alignment of equal signsHow can I align equations to the left and to the right?Double equation alignment problem within align enviromentAligned within align: Why are they right-aligned?

                                Training a classifier when some of the features are unknownWhy does Gradient Boosting regression predict negative values when there are no negative y-values in my training set?How to improve an existing (trained) classifier?What is effect when I set up some self defined predisctor variables?Why Matlab neural network classification returns decimal values on prediction dataset?Fitting and transforming text data in training, testing, and validation setsHow to quantify the performance of the classifier (multi-class SVM) using the test data?How do I control for some patients providing multiple samples in my training data?Training and Test setTraining a convolutional neural network for image denoising in MatlabShouldn't an autoencoder with #(neurons in hidden layer) = #(neurons in input layer) be “perfect”?