Thanks for pointing this out, Lori! When I updated the question, the number of answer choices changed and messed up the key—but I'd failed to notice it. It should be fixed soon.

Could you please advise if this program would be suitable for me if I only know how to set up and configure development environments and have just started learning programming languages?

Understood, thank you for the advice. Special thanks for "Most importantly, have fun! Write original code about things you know and things you're interested in."

I would do something like this

Cases[listA, x_List /; First[x] == b]

{{b, a, a}, {b, a, b, a}, {b, b, a}, {b, a, b, a, b}}

Cases[listA, x_List /; First[x] == b] /. {a -> b, b -> a}

{{a, b, b}, {a, b, a, b}, {a, a, b}, {a, b, a, b, a}}

Thanks Doug. Works great.

I wonderful (and sometimes confusing) to see in how many different ways something can be coded in Wolfram.

Yes but it is still confusing

listA /. x_List /; First[x] == b :> ReplaceAll[x , {a -> b, b -> a}]

{{a, b, a}, {a, b, b}, {a, b, a, b}, {a, b, b, a, a}, {a, b, a, 
  b}, {a, a, b}, {a, b, a, b}, {a, b, a, b, a}, {a, a, a, a}}

works
but

listA /. x_List /; First[x] == b :> x /. {a -> b, b -> a}

{{b, a, b}, {a, b, b}, {b, a, b, a}, {b, a, a, b, b}, {a, b, a, 
  b}, {a, a, b}, {b, a, b, a}, {a, b, a, b, a}, {b, b, b, b}}

does not .......

Maybe Arben can tell us why ?????

Thanks Arbin

Yes it is the Parenthesis (good to know )

listA /. x_List /; First[x] == b :> (x /. {a -> b, b -> a})

{{a, b, a}, {a, b, b}, {a, b, a, b}, {a, b, b, a, a}, {a, b, a, 
  b}, {a, a, b}, {a, b, a, b}, {a, b, a, b, a}, {a, a, a, a}}

The issue is here:

/; _First

The /; means that you write some test afterward—not only is _First not a component of a test, but it's not the correct pattern syntax. Recall that what follows a Blank (_) should be a head to be matched; i.e. you can't put an arbitrary function there and take it to be acting on whatever the blank is.

If you have

listA= {{a, b, a}, {b, a, a}, {a, b, a, b}, {a, b, b, a, a}, {b, a, b, a}, {b, b, a}, {a, b, a, b}, {b, a, b, a, b},{ a, a, a, a}} (*i removed the errant comma*)

and want to do {a -> b, b -> a} on any sublist that starts with b, you could do something like

listA /. l_List /; First[l] == b :> (l /. {a -> b, b -> a})

if you wanted to use Condition. Better yet, just match the pattern directly:

listA /. {b, rest__} :> ({b, rest} /. {a -> b, b -> a})

Hi Updating Name (Rohit?),

I suspected that I did not use First correctly :-)

Your solution works excellent. Also if I nest the sublists deeper and irregular (different nesting levels). That is great.

Do I understand it correctly, if I say :

{b, rest__} looks at all the innermost sublists and if there is such a sublist that starts with a 'b' and has one or more elements, then the replacement takes place?

Thanks again for your valuable help,

Best, Bert

You reply faster than I can edit. Wow :-)

Hey Mike, we'll get back to you soon about this. In the meantime, please don't worry about any timeline issues—as far as we're concerned, you've submitted your project within the deadline and that's that.

Hey Michael—I'm sorry about that! I finished grading it 2-3 weeks ago; I'm not sure what got blocked up in the process but we're on it. (Spoiler: you passed)

Edit: you should have it later today.

Right, thanks Arben :-)

I just got my first connection through a chat Nb with chatGPT and asked the same question. After two misses, and restating my question more precise (and partly double), I gotv a working answer :

Map[If[First[#] === b, # /. {a -> b, b -> a}, #] &, listA]

It's nice to see it work, although your solution is more refined, I think, and probably faster :-)

But the A.I. solution shows me again the pure function, which I understand in theory, but in practice I often seem to do it wrong. It will come, some day.

Also, in the If statement (which I also used, I first used == instead of what I should have done : ===. I dodged my error by using SameQ[]. So I think this A.I. coding help can be useful in the learning process.

Arben, I tried using Timing[...] and AbsoluteTiming [...] on 3 different instructions to accomplish the same thing: Power, an anonymous function using Keys, and an anonymous function using indexing. I used a large enough list of associations so that Timing was non-zero. All three had Timing between about 2.1 and 2.8 seconds, and AbsoluteTiming between about 3.7 and 3.9 seconds. I ran this in Mathematica 14 on an HP Envy running Windows 11 Home 64-bit OS. My notebook is attached as file TimingExample_1mar24.nb .

I expected Power to be clearly faster but it wasn't. Please explain these timing results.

Hi Arben,

I could not properly formulate my question in The Office Hours Session as I had only joined in at the very end (a miscalculation on my part). So thank you for suggesting I pose my question here.

I am trying to make a kind o’f Rhythm Evolver’ by means of an Evolutionary process. One thing is that I need to detect the degree of ‘regularity’ in a rhythm as a fitness score parameter.

This way I also try to find out if Nesting as a ‘regularity’ in music is easily, or at all recognised by listeners. Nesting is the most complicated and hidden regularity. Repetitions are much easier recognised.

Let’s just talk about just one line (one rhythm instrument, e.g. Kick drum), as I think it is already difficult enough.

A hit is 1, no hit is 0.

1. I have already been given a way to detect ‘Repetition’, ‘Symmetry’ and ‘Permutations’ of parts (also here in the Community :-)

Now I am looking for a way to detect ‘Nesting’.

E.g. The following 3 parts : {1,0,0,1} {1,0,0,1,0,1,1,0} {1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1}
all come from the nesting Rule : 1->{1,0}. and 0-> {0,1} starting with {1,0} and applied respectively 1x, 2x and 3x.

I want to go the other way, and see if in a rhythm line, that has been evolved , there is any sort of Nesting as regularity. Not with these specific rules and specific initial condition. I want to detect ANY Nesting (any rules, any initial condition).

So, given the line { 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1}, I should detect that the bold part (1, 0, 0, 0, 1, 1, 0, 1, 1) is a nested part from:

               Initial conditions {1,0} with the rules : {1 -> {0, 1, 1}, 0 -> {1, 0, 0}}

It is no really important that I detect what rules and which initial condition, but I want to detect which part of my Rhythm Line is a Nested part in any form.

I am not sure if it is possible, without trying all the rules. This due Stephen Wolfram’s ‘Computational Irreducibility’ .

What are your thoughts?

Thanks, Bert

Thanks Arben. Do you mean by "if the cases are 1:1 . . ." that the rules are of equal length?

So {1->{1,0,1} and 0->{0,0,1}} is 1:1 and {1->{1,0,1} and 0->{0,1}} is Not?

Reverse the nesting rules is not quite possible, I guess, as I do not know which rules might have been used. Also, the nesting might be 2 or 3 deep, so I do not know the length to parse. It feels a bit like backwards running a C.A., which is possible in some cases, but not very often.

Checking for repetitions in a rhythm line is easy, but this Nesting looks like a different animal :-)

As the computation comes into a repeated process of measuring the amount of Nesting in a rhythm ( so thousands of these detection measurements), it might be an idea to create a lookUp table with all the possible nestings for two elements (0 and 1). If a take as a max of number of initial elements, as well max number of elements in a rule to be 3 (which I think servers my purpose) then there would be 14 possible initial conditions and 12 rules for 0 and twelve rules for 1. As these rules are 'mirrored, I need only to take into account half of them. Then I create the lookup table for all Nestings from level 1 to say 3, which should be enough. From there on I could use SequenceCases or SequencePositions.

This will still leave the challenge for detecting Nesting in a complete rhythm, where I use 16 possible values for the possible simultaneous occurances of hits from 4 instruments together. This will explode with lookUp tables, I am afraid.

Best, Bert

What is the deadline for using the Level 2 discount code I received? (I took the first WSG24 this year)

I have a project idea but haven't had much time since the course ended and probably won't for a couple weeks longer.

Never mind, (content removed)

Today's lecture should do you well :).

In[53]:= 
listA = {{{{1, 2}, {3, 4}}, {{5, 8}, {9, 12}, {14, 17}}}, {{{11, 13}, {15, 17}}, {{18, 20}, {22, 24}}, {{26, 31}}}};
listA /. {x_Integer, y_Integer} :> {y - x}

Out[54]= {{{{1}, {1}}, {{3}, {3}, {3}}}, {{{2}, {2}}, {{2}, {2}}, {{5}}}}

More to the style you'd imagined—and faster for a large list—is:

In[57]:= Map[{-Subtract @@ #} &, listA, {-2}]

Out[57]= {{{{1}, {1}}, {{3}, {3}, {3}}}, {{{2}, {2}}, {{2}, {2}}, {{5}}}}

And the best version, I think:

``` In[69]:= Apply[{#2 - #1} &, listA, {-2}]

Out[69]= {{{{1}, {1}}, {{3}, {3}, {3}}}, {{{2}, {2}}, {{2}, {2}}, {{5}}}}```

Hi Bert—I thought you wanted the extra braces still for some reason, so I had added them back in! They disappear with Apply because Subtract (and indeed -) wants two arguments provided as a sequence, not as a list—that's why we use Apply, because Apply[Subtract,{a,b}]===Subtract[a,b]. Hence, you can see the difference between Apply[Subtract[#2,#1]&,...] and Apply[{Subtract[#2,#1]}&,...].

I see why writing the Subtract out is helpful for clarity, though I would say that getting an intuitive sense of what something like #2-#1&@@ is really doing is indispensable to working efficiently with Apply and its siblings. I would say you can think of it as "an operation which strips out the second and first arguments of ANY structure and gives me their difference". It works on lists, it works on sums and products, it works on any arbitrary g[a,b] with the action that #2-#1&@@g[a,b]===b-a.

Also, you can type code between backticks here, like `hello_` in order to prevent any unwanted markdown formatting. You can start a new line with 3 backticks, press enter, then type/paste code and do another new line with 3 backticks in order to get the formatted boxes you see in my previous reply.

Since you're Apply-ing, you get rid of the List structure. In that context, what does #[[2]] or #[[1]] mean?

Suppose there is an external database or other data source. Unfortunately, in this external data source, the keys are in lower case with underscores ("snake_case"), e.g. company_name. To work properly in Wolfram Language, the keys must be in camel case, e.g. companyName.

Here is an example that works on a List of Associations:

AssociationThread[
   StringReplace[Keys[#], 
     MapApply[Rule, 
      Transpose@{"_" <> # & /@ Alphabet[], 
        ToUpperCase[Alphabet[]]}]] -> Values[#]] & /@ data

To be honest, from my perspective it looks ugly, especially the "Transpose" part. Any ideas on how to make this transformation more concise?

... or is there a built-in function for this that I don't know about? I saw this resource function https://resources.wolframcloud.com/FunctionRepository/resources/ToCamelCase/, but I wasn't able to make it run in this "key of association" problem.

Notebook with sample data attached.

Thank you, Arben, for your super-fast reply.

Interesting - so it works with quotation marks. - Thank you!

Thank you very much, R, impressive! I was looking for something like that.

I think you just do exactly what you said you want to do, i.e. assign the variables before you take the derivative:

D[
Log[x^2 + y^2 + z^2] /. {x -> Sin[t], y -> Cos[t], z -> Tan[t]}
, t]

Or even before you take the Log, but I think that gives you the same answer:

D[Log[(x^2 + y^2 + z^2) /. {x -> Sin[t], y -> Cos[t], z -> Tan[t]}],
  t]

Take Rohit's answer, but also note that if you were to write x'[t] and so on—that is, explicitly note the time dependence—D will take those derivatives symbolically and you can plug in values for the time-dependent functions after the fact, at which point the derivatives will be evaluated.

I've noticed in other people's examples that you can stick the /. operation all over the place. What is wrong with that? (my own answer would be that if you are writing longer code, it gets hard to read and understand - I'm just asking a more generic question about WL grammar rules) Carl

My suggestion is to use the standard functional call (ReplaceAll[], etc.) until you thoroughly understand them. You should always -- always -- be able to see and say the long form when the shortcut is being used. IMHO, it's a big problem to use shortcuts if you don't always have the formal name of the function call on the tip of your tongue. Note: even things like _x have a standard form: Blank[x]. Computers have the ability to expand any shortcut within a microsecond; we should be ability to translate either way with a similar amount of minimal computational overhead.

You want to be able to rattle off a spell with the ease of Hermione Granger and avoid the clumsiness of Neville Longbottom. You should have no "lost in translation" moments between a shortcut and its normal form.

I kinda wish that the Notebook editor would have a means of flipping something to its normal form (and vice versa). I also wish that the Help documentation would always show both forms on examples; it tends to be prejudiced towards the shortcuts. I like to verbalize the normal form when I look up something in the docs.

Will there be another one of these classes?

Thanks for the useful reference. Fills in some of the blanks in Arden's excellent lectures. I always like several points of view.

Have a look at https://www.math.unl.edu/~tshores1/Public/Math208F07/Math208DifferentialsHandout.pdf

https://solitaryroad.com/c353.html

etc. Google is your best friend here.

Use Partition. It can be done in one instruction, but to make it clearer, I break it down:

lst = {1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0};

par = Partition[lst, 3, 1]

Cases[par, {0, 1, 0}]