Daily Challenge (May 4): A challenge in the spirit of "May the fourth be with you".

Chart the production budget against the release date of the Star Wars movies (from the WL EntityClass "StarWarsFranchise"). Which movie had the lowest production budget?

You can register for study groups at https://www.wolfram.com/wolfram-u/special-event/study-groups/

For this week specifically: sign up here

Hi Abrita,

Hope, I understood correctly the challenge.

My PieChart[]:

PieChart[EntityClass["Movie", "StarWarsFranchise"][
  EntityProperty["Movie", "ProductionBudget"]], 
 ChartLabels -> 
  Placed[EntityClass["Movie", "StarWarsFranchise"][
    EntityProperty["Movie", "ReleaseDate"]], "RadialCallout"]]

The movie with the lowest production budget:

In[2]:= data = EntityClass["Movie", "StarWarsFranchise"][{EntityProperty["Movie", "ProductionBudget"], EntityProperty["Movie", "ReleaseDate"]}]; Select[data, #[[1]] == Min[data[[All, 1]]] &][1]

Out[2]= {Quantity[8.5`6.*^6, "USDollars"], DateObject[{2008, 8, 15}, "Day", "Gregorian", 3.]}

Hi Valeriu, I had a DateListPlot in mind. But the fun of using the Wolfram Language is that there are so many ways of doing the same thing. And your chart highlights the information just as well. Thanks for sharing.

I wanted to upload my Notebook, but I can't because I have to log in to my Wolfram Cloud account. I am logged in another tab in my browser, but I don't know how to link that to this group, can you help me please?

Perfectly ok to copy paste code snippets. Notebook not needed.

You should receive the links in the daily reminder email for the webinars. If you are not receiving those emails kindly write to wolfram-u@wolfram.com.

An actual analysis or comparison of production costs should include the time value of money referenced to some date, otherwise the comparison is invalid... right?

Q: (I'm new to Wolfram curated datasets) Is there a document or notebook associated with each curated dataset that describes how the data was curated? And, like the "daily challenge" problem, how would we know if the money values are referenced to some year's dollars or are just the time value of money for the given date? Besides a document/notebook describing the curation process and source for datasets, it would be nice to have a separate document/notebook that describes the particulars of a given dataset (like how money values should be interpreted), etc.

Looking at the coding on this page for the daily challenge from yesterday, many of these things are far more advanced than what was covered in the first lecture yesterday. I think these long pieces of code can bamboozle people, it certainly does for me.

I feel like we went from fairly basic concepts to the multiple lines of code very quickly. For me there needs to be a bit more of a smooth transition.

Good point.

So the the entities are part of the continuously updated Wolfram Knowledgebase also used in Wolfram|Alpha. Here are some of the data sources used for the knowledgebase: https://reference.wolfram.com/language/ref/entity/Source.html

You'll find more information about each entity on its associated documentation page. For e.g. https://reference.wolfram.com/language/ref/entity/Movie.html. The curated data can be a result of pulling in information from multiple sources and the specifics of the curation process are not usually included.

Meanwhile for the datasets on the Wolfram Data Repository you will find the "Source Metadata" at the bottom of each data resource that gives you more detailed information.

Bare Bones Star Wars Manipulation

A desktop version of the previous post:

Manipulate[
 Column[{Row[{Column[{Style["Release Title:", color], 
       EntityList[EntityClass["Movie", "StarWarsFranchise"]][[
        releaseNumber]]}], "  ",
     Column[{Style["Director:", color], 
       EntityList[EntityClass["Movie", "StarWarsFranchise"]][[
          releaseNumber]][EntityProperty["Movie", "Director"]][[1]]}],
      "   ",
     Column[{Style["Producer:", color], 
       EntityList[EntityClass["Movie", "StarWarsFranchise"]][[
          releaseNumber]][EntityProperty["Movie", "Producers"]][[1]]}],
     "   ",
     Column[{Style["Production Budgent:", color], 
       EntityClass["Movie", "StarWarsFranchise"][
         EntityProperty["Movie", "ProductionBudget"]][[
        releaseNumber]]}]}],
   Style["Cast and Roles:", color], 
   Grid@Partition[
     Column /@ 
      Transpose[{Keys[
         EntityList[EntityClass["Movie", "StarWarsFranchise"]][[
           releaseNumber]][EntityProperty["Movie", "CastAndRoles"]]], 
        First /@ 
         Values[EntityList[
             EntityClass["Movie", "StarWarsFranchise"]][[
            releaseNumber]][
           EntityProperty["Movie", "CastAndRoles"]]]}], 4]}],
 {releaseNumber, Range@10, ControlType -> Setter}, {releaseNumber, 
  Range@10, Slider}, {color, Purple}]

Hi! Is it possible to watch the earlier lessons from this week? Thanks, Garfield

Daily Challenge (Day 3): Give "Pig Latin" a shot https://challenges.wolfram.com/challenge/pig-latin

Here is a class that can be used to get the inflation-adjusted values of production budget at a single valuation date so the resulting comparison is fair:

Now after extracting and massaging the data from this class it can be visualized and compared on a DateHistogram:

Here is a comparison using the value of the dollar, based on Today:

Here is a comparison using the value of the dollar at the time of the release of Mathematica:

My god, the dollar has lost 55% of its value in the past 31 years!

Hi Abrita,

To initiate the challenge, let's start with the following code:

PigLatin[text_String] := 
 Block[{vowels = {"a", "e", "i", "o", "u"}, consonants},
  consonants = Complement[Alphabet[], vowels];
  consonants = Join[consonants, ToUpperCase@consonants];
  StringReplace[text,
   {
    x__ /; 
      StringMatchQ[x, 
       Flatten[{consonants, ToUpperCase@vowels}] .. ~~ vowels ~~ 
        LetterCharacter ...] :> 
     StringTake[x, StringPosition[x, vowels][[1, 1]] ;; -1] <> 
      StringTake[x, StringPosition[x, vowels][[1, 1]] - 1] <> "ay",
    x__ /; 
      StringMatchQ[x, 
       Flatten@{consonants, ToUpperCase[Alphabet[]]} ~~ 
        LetterCharacter ...] :> x,
    x__ /; StringMatchQ[x, vowels ~~ LetterCharacter ...] :> x <> "way"
    }
   ]
  ]

Hi Abrita, Here's my code. It works!

PigLatin[x_] :=

 Block[{lowerVowels = {"a", "e", "i", "o", "u"}, consonants}, 
  consonants = {"B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N",
     "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z", "b", "c", "d", 
    "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", 
    "v", "w", "x", "y", "z", "A", "E", "I", "O", "U"};
  StringRiffle[Map[If[StringFreeQ[#, lowerVowels], #,
      If[StringContainsQ[StringTake[#, 1], lowerVowels],
       If[
        Total[Boole[
           StringContainsQ[Characters[#], PunctuationCharacter]]] == 0,
        # <> "way", 
        StringJoin[Drop[Characters[#], -1]] <> "way" <> 
         Last[Characters[x]]],
       If[
        Total[Boole[
           StringContainsQ[Characters[#], PunctuationCharacter]]] == 0,
        StringJoin[Reverse[TakeDrop[Characters[#],

            LengthWhile[
             Boole[StringContainsQ[Characters[#], consonants]], #1 == 
               1 &]
            ]]] <> "ay",
        StringJoin[Reverse[TakeDrop[Drop[Characters[#], -1],

            LengthWhile[
             Boole[StringContainsQ[Characters[#], consonants]], #1 == 
               1 &]
            ]]] <> "ay" <> Last[Characters[#]]]]] &, StringSplit[x]]]]

Cloud version of the code

PigLatin[x_] :=

 Block[{lowerVowels = {"a", "e", "i", "o", "u"}, consonants}, 
  consonants = {"B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N",
     "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z", "b", "c", "d", 
    "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", 
    "v", "w", "x", "y", "z", "A", "E", "I", "O", "U"};
  StringRiffle[Map[If[StringFreeQ[#, lowerVowels], #,
      If[StringContainsQ[StringTake[#, 1], lowerVowels],
       If[
        Total[Boole[
           StringContainsQ[Characters[#], PunctuationCharacter]]] == 0,
        # <> "way", 
        StringJoin[Drop[Characters[#], -1]] <> "way" <> 
         Last[Characters[x]]],
       If[
        Total[Boole[
           StringContainsQ[Characters[#], PunctuationCharacter]]] == 0,
        StringJoin[Reverse[TakeDrop[Characters[#],

        LengthWhile[
         Boole[StringContainsQ[Characters[#], consonants]], #1 == 
           1 &]
        ]]] <> "ay",
    StringJoin[Reverse[TakeDrop[Drop[Characters[#], -1],

        LengthWhile[
         Boole[StringContainsQ[Characters[#], consonants]], #1 == 
           1 &]
        ]]] <> "ay" <> Last[Characters[#]]]]] &, StringSplit[x]]]]

Cloud version of the code

Hi Stuart,

There are a few cases that your solution does not handle correctly. If you take pigTests from my solution above and run your code against those tests there are three failures.

pigTests // 
 KeyValueMap[
  If[(r = PigLatin[#1]) == #2, True, Print["Expected: ", #2, " Got:", r]; False] &]

Expected: eOchray Got:Ochre

Expected: eeAgray Got:Agree

Expected: If ethay ordway ontainscay onay owercaselay owelsvay, othingnay isway angedchay. Got:If ethay ordway ontainscay onay owercaselay owelsvay othingnay isway angedchay

Hi Aaron,

Languages that use a Lisp-like syntax (Lisp, Scheme, Racket, Clojure, WL, ...) suffer from "bracket/parenthesis hell". I find it hard to understand deeply nested expressions. Good formatting and indenting helps, but you still have to comprehend it from "inside out".

In WL you can use Postfix (//), Composition (@*), RightComposition (/*) and operator forms of functions to write expressions in a left to right order that I find easier to understand..

Consider: "Which of the first 100 prime numbers have digits whose sum is also prime?" Here is one way to answer it using infix notation

Select[Table[Prime[n], {n, 100}], PrimeQ[Total[IntegerDigits[#]]] &]

I find this to be much easier to understand

Table[Prime[n], {n, 100}] // Select[IntegerDigits /* Total /* PrimeQ]

From left to right I read this as "From the first 100 primes select those whose digits when totaled is prime".

Experiment with both styles and see what works best for you.

Thanks for the posts folks. We'll continue the discussion on the "Pig Latin" challenge here.

Follow the Wolfram Study Group discussions for "Programming Fundamentals Week 2" at https://community.wolfram.com/groups/-/m/t/1970834

My final attempt at the PigLatin challenge. The code is much improved since my last submission. It passes all of the tests on the specification, including preserving punctuation + Rohit NamJoshi's Test procedure. I haven't tried to submit to the challenge web page, but will do so later. Any comments welcome: Having never really had a need to process strings before, I found this to be a difficult task...

PigLatin[text_String] := Module[{s = text},

  vlclst = {"a", "e", "i", "o", "u"};
  vuclst = {"A", "E", "I", "O", "U"};
  punclist = {".", ",", ";", ":", "!"};
  lst = StringExtract[s, All];

  StrngReorder[strRO_] :=
   StringInsert[
    StringTake[strRO, 1 - StringLength[strRO]],
    StringPart[strRO, 1],
    If[StringEndsQ[strRO, punclist], -2, -1]
    ];

  StrngStartConsonant[strSC_] :=
   StringFreeQ[
    StringPart[strSC, 1],
    vlclst,
    IgnoreCase -> True
    ];

  StrngAddWay[strAW_] :=
   StringInsert[strAW,
    "way",
    If[StringEndsQ[strAW, punclist], -2, -1]
    ];

  StrngAddAy[strAY_] :=
   StringInsert[
    NestWhile[StrngReorder[#] &, strAY, StrngStartConsonant[#] &],
    "ay",
    If[StringEndsQ[strAY, punclist], -2, -1]
    ];

  StrngMoveFirstVowel[strFV_] :=
   StringInsert[
    StringTake[strFV, 1 - StringLength[strFV]],
    StringTake[strFV, 1],
    If[StringEndsQ[str, punclist], -2, -1]
    ];

  StrngAddAy2[strAY2_] := Module
    [{str = strAY2},
    str = StrngMoveFirstVowel[strAY2];
    StrngAddAy[str]
    ];

  StrngRule2[str2_] := If[
    StringStartsQ[str2, vlclst],
    StrngAddWay[str2],
    str2];

  StrngRule3[str3_] := If[
    StrngStartConsonant[str3],
    StrngAddAy[str3],
    str3];

  StrngRule4[str4_] := If[
    StringStartsQ[str4, vuclst] && 
     StringContainsQ[StringTake[str4, {2, StringLength[str4]}], 
      vlclst],
    StrngAddAy2[str4],
    str4
    ];

  lst = StrngRule4 /@ StrngRule3 /@ StrngRule2 /@ lst;

  StringRiffle[lst]
  ]

Thank you. I fixed the code to account for punctuation and cleaned everything up a bit.

Attachments:

PigLatin.nb

Links to various resources shared during week 1:

Manipulate

• Building an App in 60 Seconds
• Introduction to Manipulate

Functional Programming

• Functional Programming Quick Start
• Functional Programming Guide Page

Working with Data

• Handling Different Types of Data
• Restructuring Data
• Dealing with Messy Data

Tips for Coding in WL

• Writing Good Code
• Tips for Writing Fast Code
• Fast Introduction for Programmers

Can we download the notebooks in this series? If so where can we find the links too the notebooks?