What is a genetic algorithm (GA)?

To begin with, let’s talk about what a genetic algorithm is, on its most basic level. The word genetic suggests something to do with biology, and if you can reach way back when in your high school science classes you might remember the basic genetic process: plants and animals are born, mate with one another, and create new generations. Over time, these generations tend to emphasize certain traits essential to survival, while downplaying the weaker (recessive) traits. A genetic algorithm works much the same way. We come up with a population of possible solutions to a problem, “mate” them together, and look at our new solutions to see if they are any better. Over time, we can create solutions that converge to better and better values. This is useful when a problem is too complex to search all possibilities. Below you will see an image describing how a simple GA works.

Crossovers, fitness, mutation, oh my!

Before moving on, it would be useful to define some of the terms used above.

• chromosome:  a proposed “solution” to the problem at hand. This is usually represented by a bitstring, that is to say, a list of 0′s and 1′s. It can also hold any other information that is crucial to our problem.

• population: a collection of these “chromosomes” that we use to combine together and make new generations. The population represents the set of all the ideas that we have about this problem at the moment

• fitness: the fitness of a chromosome is a number representing how good it is. That is, the fitness represents how good this solution is at solving our problem. Are there glaring errors in this design? It will show through in the fitness calculation. Or maybe this solution is a really good one, after all, in which case it would have a good fitness. An example of this is say you were trying to find the shortest route to get somewhere. Fitness for a problem like this would be a number representing the distance it takes for each path you could choose. In the end, you want to find the path with the shortest distance (and the lowest fitness).

• mutation: mutation is the random entering of new data into the gene pool. Just like in biology, sometimes mutations occur and create things that were never intended. However, sometimes this inadvertent change can be to our advantage if we’re getting stuck. A common example of a mutation is to just change a small part of the chromosome, and move on.

• crossover: the “crossover function” represents the operations that we do in order to “mate” two (or sometimes more) of our chromosomes. There are many different types of crossover techniques, some better for certain situations than others, but at the heart of it a crossover just represents a way to combine the “traits” of two or more chromosomes into a new “baby” chromosome to be inserted into our population. This is the bulk of a genetic algorithms’ work, because as the population evolves and new generations of solutions are created, the goal is to keep around the solutions with “good” fitness, and get rid of the chromosomes that aren’t doing so well.

• termination condition: all good things must come to an end. While we in theory could just leave our algorithm running forever, that would not be very helpful because as I will discuss later in this post, solutions can’t keep getting better forever. In addition, sometimes you won’t actually get to the “best solution” and instead will converge on what’s called a “local minima/maxima”. When this happens, it means you’ve found an “okay” solution, but the population got flooded with many similar chromosomes and couldn’t really improve itself after that point. Think of it this way: if everyone in the world were exactly the same, would you expect any different from their children? Common terminating conditions are:
  • a) finding the best solution (ideal)
  • b) running a preset number of generations and using that as a cutoff point
  • c) quitting after every member of the population falls within a certain similarity range (this means that no new/better solutions are likely to be produced)

But why would I want to do all this?

I know this seems like a pretty complicated process. Why not just use a computer to figure out the real solution instead of dancing around it in this complicated manner? I hear you saying. Well, it turns out that’s not always possible…

Enter the Traveling Salesman Problem (TSP). While there are many problems that are still very hard for us to solve with computers, this is one of the best known and most studied, and it turns out that using a genetic algorithm is actually a pretty good approach and is much quicker than running an exhaustive search of all paths possible. Remember when I used the example of finding the shortest distance to go somewhere? That’s pretty much what this is. I’ve done a blog post on this before (see here). In the traveling salesman problem, there is a man that needs to visit a list of different cities on his route, but he wants to get there and back as quickly as possible. Therefore, you need to find the shortest route to hit all the cities and return home. This isn’t always as easy as it sounds, and as the number of cities grows, so too does the time it takes to find the right one. Very quickly it becomes implausible to check every possible path, so we use a genetic algorithm to help us weed out the bad ones.

Another example of how we would use a genetic algorithm is for graph theory problems that also have a huge number of possible solutions. You can see how I applied a genetic algorithm to the problem of Ramsey numbers here.

Okay, so how do I use this in my project?

It’s pretty simple. I know, I know, it looks complicated, but once you get everything apportioned out correctly its not that bad. Things to think about when applying a GA to a hard problem (we will use the Traveling Salesman Problem as an example here):

• First decide what your “chromosomes” will look like. These are the meat of your population, and these are what will be mutated and crossovered in order to create better solutions. For the TSP, we will use a a sequence of numbers denoting what cities to visit and in what order. (For example, “1 5 4 2 3″ describes a way you could make a circuit through 5 cities).

• Decide on how fitness will be evaluated, this is important, because members with better fitness will be the ones that stick around in your population and (hopefully) make your solutions better. In our problem, fitness refers to how far our chosen path takes us. The lower the fitness score, the shorter our travel is. We want to minimize this number with our algorithm.

• Next we need to figure out what our crossover will be. This is very important to consider, because we want something that will take parts of both of our “parents” and combine them together in some way to make a “baby”. For traveling salesman, we can’t just grab some from one parent and some from the other, because we run the risk of duplicates. (we don’t want a path to look like “1 2 2 3 4″, city 2 is visited twice and we never get to city 5). Therefore, we have to use more sophisticated methods. I won’t go into them here, but if you’re interested check out this wikipedia page for more info on crossover techniques.

What are the downsides?

“Every rose has its thorn,” as they say, and genetic algorithms are no different. What seems like a cure-all for all our intractable problem needs can have hindrances as well. As I mentioned before, GAs have a problem of converging too early to a “not quite value”. Often this takes many repetitions of running the program and fine tuning things such as population size and mutation rate. Sometimes happening upon the “best” solution is a product of randomness. But in a GA, we use this randomness to our advantage as much as we can. Another inherent problem is the fact that we have to program all this framework around it. Using a GA is only viable if its an extremely complex problem that cannot be solved more efficiently. For example, using a GA to solve a 5 city TSP would be foolish. We can run through all those possibilities very quickly. On the other hand, bumping that up to 50 or 500 cities proves a much harder challenge.

In addition, using a genetic algorithm means you have to find a type of chromosome, fitness function, population size, and crossover that works for you. Pick the wrong values for these, and the program will behave less than optimally. Even in some genetic algorithms, the fitness function for even one chromosome can take quite a while to compute, and as such it also becomes very slow to use on highly computational problems.

Where can I learn more?

I hope this has covered the basics of genetic algorithms and interested you in learning more. If you would like to see a project I have done involving GAs you can read A Genetic Algorithm Approach to Ramsey Theory, and for a broader range of discussion about the theory and applications of GAs check out the book An Introduction To Genetic Algorithms by Melanie Mitchell.

Hope you enjoyed this introduction to the wide world of genetic programming; if you have questions or suggestions please leave them in the comments below!

3D-DEF code is a three-dimensional boundary-element model that allows the calculation of stresses, strains, and displacements within and on the surface of an elastic half-space (it means, there is no bottom to the model). The power of the model comes from the ability to a) solve for a variety of deformation quantities on a variety of faults and planes simultaneously, and b) to drive the deformation in relatively realistic (and therefore potentially complex) ways.

So, I just downloaded the package few days ago. However, I found that the package you can download from here will not compile at your first try using default linux-installed gfortran compiler. Some modifications were necessary, which are minimal but related to the length of lines (a constrain of fortran codes). Another problem was the order of compilation of the subprograms, even after correcting this. Compilation will fail due to some preexisting .mod files, producing some errors. So I have worked around those little problems, and I have uploaded a mild corrected version of the package here (well due to restriction on the file extensions in wordpress, it’ll require that you remove the “_removepdfextension.pdf” before uncompress the tarball file). In this package, in addition to the slightly modified code, I have added a simple compile.me script that can be executed and will create the 3d program for you.

Finally, I also typeset the manual from the website in latex to generate the documentation in an amenable and print-able friendly way. There are two documents, the manual and the tutorial. Those documents provide essentially the same information as in the website, but I cannot discard typos during the translation. So, I encourage to visit the on-line documentation.

So I hope those modifications will be of some help.

An iterative method is simply a method that begins with a fixed value, and by plugging that fixed value into the method, we are able to calculate the next value. Doing this over and over again, the method converges to the solution to the equation. Hence the name iterative method.

Newton’s method, is one such method, and works the following way: suppose we have some function and we are trying to find such that (i.e. we want to find the root of the function). We can start with some guess , draw the tangent line to the curve at the point . Now, where the tangent line crosses the x-axis is our next guess , and we repeat (see the animation for a depiction of how this converges to a root).

The equation of Newton’s method is: .

Animation of Newton method (Photo credit: Wikipedia)

It is easy to see that one obvious downfall of Newton’s method is that you must be able to differentiate the function that you are using. One way to get around this would be to use the Secant method which works very similarly to Newton’s method, but does not require the function to be differentiable.

In order to implement Newton’s method, we need an initial guess (which is of course dependent on the function) and a given tolerance that we should stop within (since this is a convergent method, it would need to loop infinitely for an exact solution).

double newtons_method(double x_0, double tol){
    // It is assumed that f() and f_prime() are
    // functions that are elsewhere declared

    // declare and initiate parameters
    double x_new = x_0;
    double x_old = x_0 - 1;

    // now we perform the iterative Newton's method
    do{
        x_old = x_new; // store the old x value
        x_new = x_old - f(x_old)/f_prime(x_old); // calculate the new x value
    }while(fabs(x_old - x_new) > tol); // loop until within the given tolerance

    return x_new;
}

Using the above code with an implemented Black-Scholes model, we would be able to calculate the implied volatility of an option by setting the function , where is the BS value of the option for a given volatility , is the market price of the option, and refers to the Vega of the option.

SqlBulkCopy is useful especially to import bulk data ( ~= 600,000, e.g.) records from a SQL or another source to a designated table in a SQL server.

BUT if you do this in a EntityFramework environment in .NET framework, then you might want to have this structure for faster performance.

{
// set db config properties to false to disable all the auto-detect and auto-validation
dbContext.Configuration.AutoDetectChangesEnabled = false;
dbContext.Configuration.ValidateOnSaveEnabled = false;

// perform bulk copy to SQL
using(SqlBulkCopy myCopy = SqlBulkCopy(sqlConnStr))
{
…
myCopy.BatchSize = 100; // row number to send to the server as a batch proc.
myCopy.WriteToServer(your data here);
…
}
// Re-set db configuration properties to true.
dbContext.Configuration.AutoDetectChangesEnabled = true;
dbContext.Configuration.ValidateOnSaveEnabled = true;
}

For details re how to use SqlBulkCopy, pls refer to the MSDN page link at the top of this article. Hope this helps.

Here i decided a for loop, in each iteration use regular expression to get the first index of the first digit, then, extract the name, and then extract the next 3 elements in the element, and eliminate the white spaces if exist, then, check if is bigger than the maximum previously stored. When the for loop ends, remove the white spaces in the beginning of the result and at the end, and then return the result.

Here the problem statement:

Our student data is a mess! Each student is described with one string. At least a student’s data always starts with her name, then her age, and then her address, and none of these is ever missing. The name and age are separated by one or more spaces and the age is separated from the address by one or more spaces. There may be leading and trailing spaces in a student’s data.

A student’s name always consists only of uppercase letters ‘A’-'Z’ and embedded (not leading or trailing) spaces. A student’s age always consists of exactly 1, 2, or 3 digits, and its leading digit is not a zero. A student’s address always contains at least one non-space character.

We need to find the name of the oldest student. If there are several, we want the one that appears earliest in the data. The name should include its embedded spaces (even if there are several consecutive embedded spaces), but no leading spaces and no trailing spaces.

Create a class OldestOne that contains a method oldest that is given a string[] data where each element is the data for a student, and that returns the name of the oldest student. 

Here my code:

public class OldestOne
    {
        public string oldest(string[] data)
        {
            string pattern = "[1234567890]";
            string res = "";
            int max = 0;
            for (int i = 0; i < data.Length; i++)
            {
                Regex r = new Regex(pattern);
                string name = data[i].Substring(0, r.Match(data[i]).Index - 1);
                string age = data[i].Substring(r.Match(data[i]).Index, 3);
                if (age[2] == ' ')
                    age = age.Remove(2, 1);
                if (age[1] == ' ')
                {
                    if(age.Length > 2)
                        age = age.Remove(1, 2);
                    else
                        age = age.Remove(1, 1);
                }
                if (int.Parse(age) > max)
                {
                    max = int.Parse(age);
                    res = name;
                }
            }
            while (res[0] == ' ')
                res = res.Remove(0, 1);
            while(res[res.Length - 1] == ' ')
                res = res.Remove(res.Length - 1,1);
            return res;
        }
    }

If you have another approach, please share with me in a comment!

Thank you very much

1- run `roscore‘
2- in a new tab check the existing nodes: `rosnode list‘
3- for checking the information about the nodes use : `rosnode info /rosout‘
4- to run a node from inside a package we use: rosrun [packagename] [nodename]
e.g. rosrun turtlesim turtlesim_node
5- open a new tab check again the existing nodes: `rosnode list‘ it should include a new one
6- you can kill a running rosnode by using ctrl+c
7- create another node by a specific name: rosrun turtlesim turtlesim_node __name:=new_name
8- then if you check `rosnode list‘ there will be a new rosnode by the name new_name
9- if the previous rosnode still exist when you run rosnode list, then you can use `rosnode cleanup‘ to clean the dead rosnodes
10- you can check the activity of the rosnode using : `rosnode ping rosnode_name‘

######################## SO FAR  ######################
roscore : runs the core of the ros
rosrun : runs a node from inside a package (e.g. turtlesim_node node inside turtlesim package)
#################################################

11 – start `roscore‘
12 – start `rosrun turtlesim turtlesim_node‘
13 – start something (a node) to control the turtle `rosrun turtlesim turtle_teleop_key‘
14 – The turtlesim_node and the turtle_teleop_key nodes are communicating with each other over a ROS Topic.
15 – so topic is something to  communicate between nodes, if we consider nodes as exe/dll files then the topics are the embedded functions inside those
16- use `rosrun rqt_graph rqt_graph‘ to show the graph between the nodes
17- we use rostopic command to work with topics
18 – type rostopic -h
rostopic bw     display bandwidth used by topic
rostopic echo   print messages to screen
rostopic hz     display publishing rate of topic
rostopic list   print information about active topics
rostopic pub    publish data to topic
rostopic type   print topic type

19- rostopic echo shows the data published on the topic
rostopic echo topic_name
`rostopic echo /turtle1/command_velocity‘
20 – to see rostopic list use : `rostopic list‘
`rostopic list -v‘
21 – Communication on topics happens by sending ROS messages between nodes.
rostopic type  /turtle1/command_velocity
22 – then you can find information about the detail of that message:
`rosmsg show turtlesim/Velocity‘
23 – we can send a single message to turtlesim package and tell it to move with a velocity and angular velocity:
`rostopic pub -1 /turle1/command_velocity turtlesim/Velocity — 2.0 1.8‘
24 – rostopic(use a function)+publish(give input to the function)+topic_name+msg_name(variable name)+inputs(assign input to the variables)

################################ SO FAR  ##############
rosnode is a dll/exe
rostopic is a function embedded inside the dll/exe
rostopic list -v   –> find the list of messages
rostopic type  /turtle1/command_velocity  —> find the type of messages (data)
now we can publish on a topic:
rostopic(use a function)+publish(give input to the function)+topic_name+msg_name(variable name)+inputs(assign input to the variables)
in detail:
rostopic pub : publish messages to a given topic
-1 : causes rostopic to use when pubishing one message then exit
/turtle1/command_velocity : name of the topic to publish to
turtlesim/Velocity : the message type to use when publishing the topic
– : says the arguments are not options
2.0 1.8 : two inputs to publish

###################################################

25 – `rostopic hz [topicname]‘ reports the rate at which data is published

26 – for using rqt_plot you sould run it as a node: rosrun rqt_plot rqt_plot
then in the new plot window enter: /turtle1/pose/x and /turtle1/pose/y

27 – services are another way that nodes can communicate with each other. services allow nodes to send request and receive a response. `rosservice‘

rosservice list         print information about active services
rosservice call         call the service with the provided args
rosservice type         print service type
rosservice find         find services by service type
rosservice uri          print service ROSRPC uri

28 – use ‘rosservice list‘ to get a list of services

29 – to find the type of a service use : rosservice type [servicename]
(e.g. rosservice type clear)

30 – to call a service with arguments : rosservice call [servicename] [args]
(e.g. rosservice call clear)
(e.g rosservice type spawn| rossrv show)
(then rosservice call spawn 2 2 0.2 “”)

• If none of that made sense, this seems to be a dominant git workflow, and it helped me get started.  But, again, I don’t like no-ff merges and like to rebase before merging back into the main branches (this preference is not necessarily apparent if you go to my GitHub page…)
• These two posts, by Benjamin Sandofsky and Isaac Schlueter, describe rebase well and make me really think that I need to start using git-bisect.
• Linus Torvald’s email on git workflow for the Linux Kernel is really helpful too.

This post is really an excuse for me to have a place to put these links. obviously.

Creating a website in the early-to-mid-nineties was different than it is now. There weren’t the variety of tools available that we see today. You were much more on your own to get it developed. I began with an HTML program called HoTMetaL Pro and not only programmed my own website, but also the first one for my employer Presbyterian Homes where I worked as the Marketing Manager until retirement. It was a bit of a learning curve, but as I was doing it all on my own time in the evenings, I was able to slowly figure it out.  HoTMetaL Pro eventually disappeared and I turned to Macromedia Dreamweaver as the next big thing.  Having already used a rather simplistic program, by today’s standards, I learned to use Dreamweaver without too much trouble.  Those were the days when tables were used as a basic layout tool.  Now they are discouraged, why? I don’t know, because they are a lot easier to use than the so-called “layers.”

Dreamweaver is now an Adobe product, and when time came to revise my website , I dutifully upgraded to the latest version and got to work.  OMG!!!!  Was I in for a surprise! With CSS6 as its basis, it has gotten so complicated that I could barely handle it. No wonder huge teams of programmers get paid actual money to develop websites! I searched the web for an easier alternative, and found that there are many out there. The problem was that I knew what I wanted, and none of the alternatives gave me the freedom to develop my web message my own way.

So I returned to my paid-for Dreamweaver upgrade, and after a month of eat-breathe and sleeping CSS and HTML, I uploaded my newly revised website.  Please take a look at

http://halleson.com/index.html.

The code is a bit messy, the look is sort of homemade-ish, but it’s all mine. No fancy high-paid web designer nerds. No slick templates. As a retired person trying to build a platform as a writer, it’s the best I could do for the moment.

If you, the reader, are a dedicated HTML/CSS6 user, you’ll probably look at the code, and let your mouth drop open in horror.  Sorry about that. I used the W3c validator.  I really did, but when I tried to fix the code violations, it gave me a lot of “This HTML is obsolete, use CSS instead.” Yeah, right! So tell me HOW to do that, you young whippersnapper programmers!!!

Nevertheless, my website is up there for all the world to see.  What’s more important than it looking like a streamlined corporate look-alike, is the message that it conveys.  At least that’s what I’m believing at this moment. This is who I am. This is what I write. This is my take on the world we live in.

Please buy my books and contribute to my helping children and grandchildren get through college and/or paying off their loans.  I’d appreciate it so very much.

Leave a comment and let me know your thoughts.

RZ

Under its 50 Parks Initiative, 53 sites for new parks have been acquired by the city – taking advantage of the real estate downturn and bulldozing foreclosed homes in some cases – and are being developed into parks, playgrounds and recreation areas.  A quarter of the 50 parks are smaller than an acre in size.

“With the addition of the 50 Parks Initiative, about 20% of the parks established during this department’s long history will be the work of the last seven years,” says Barry Sanders, Recreation and Parks Commission President.  One important partner in this initiative has been the Los Angeles Parks Foundation, founded in 2008 and just hitting its stride.

“Probably thirty years of thinking preceded the creation of the foundation,” says Judith Kieffer, Executive Director of the Foundation.  But like many successful start-ups, it took the convergence of some good leaders – including Sanders – and Jon Kirk Mukri, General Manager for the Recreation and Parks Department.  Sanders now wears two hats as head of the Parks Commission and chair of the Foundation.  “Barry is absolutely the right person for the job – and probably the only one who can make this dual-hat role work,” says Kieffer.

The Foundation’s mission is all about a partnership with RAP.  They are not leading but listening, doing things with and for the department as a support organization, not a policy advocate with a “distinct and bright line of separation” between them so as to be independent enough to bring real value.  They promote the department, raise funds for parks and develop a broader constituency for the fate of public parks.

It Takes Two
“We have a good working relationship and we communicate constantly – one of the keys to making our partnership work.”

It worked well when the Republic of Korea came to the Mayor with a request to restore the Korean Friendship Bell, a gift from the Republic to the city in 1976.  The bell sits high on a hillside in Angel’s Gate Park and had become so rusty that it had stopped ringing.  Korea wanted to provide funds so that the bell would be fixed. The Foundation accepted the funds and then hired an expert to repair the bell which now once again rings for ceremonies and services.

Typically there is some re-energized interest in projects that drive their joint interest; there is no formal priority setting.  The Foundation receives donations designated for a specific purpose that the RAP is interested in and the Foundation acts as a record-keeper.  In other cases, they will take the lead and take on the role of general contractor while working closely with the department. They have helped to construct huge projects, especially ones that have been in the system for years lacking the funding to move forward – and including the 50 Parks initiative.

The 50 Parks Initiative was generated by the department and may be the largest urban park expansion in the country.  RAP spearheaded all the initial fundraising and the Foundation supported them.  Together, everybody was cranking to find sources of funding from numerous public and private not for profit sources.  The Foundation hosted meetings with major donors and local banks; teamed with RAP while they pitched the idea to other city agencies, like Housing; and secured funding from philanthropic foundations that only give to nonprofit corporations.

As of May of this year, 45 sites are now publicly owned and ready to be developed as parks.  RAP has built 13 of the sites already.  Once again, the Foundation plays a role in helping with site development, often taking possession and then hiring a contractor to build, working with the city at every step.  “We get a right of entry from the city to take ‘temporary ownership’ of a park, hire developers, get the park built and then turn the site back over to the city.”

Corporate Partners
One way that the Foundation has provided value is by building a reputation with the corporate community, with new partners stepping up for the parks in big and small ways.  The challenge is to gain their support for not only the upfront capital expense but the long term maintenance of a new facility.  “The sustainability issue is probably the key thing in making the partnerships work. No one wants to do anything that is a downstream maintenance issue for the city.”

So for any capital project or program where the parks department sees a need, the Foundation raises additional funds – as they did for the restoration of the mounted patrol horse unit, where they identified funds for the ongoing need for trainers, feed, vets, etc.  Originally created in the early 1970′s, the Ranger Mounted Unit was established to provide services to the users of Griffith Park’s extensive bridle trails. The Foundation, as one of its first projects, provided the funding to restore the unit and add more horses to the fold.

In another case, the Foundation is raising funds for the planned nature conservancy in Griffith Park and the goal will include a $5 million endowment, thanks to their outreach efforts in helping donors understand the value of an ongoing reserve.

Along with corporate support comes the issue of donor recognition.  The Foundation is finding ways to work with the city on signage that recognizes donors, such as plaques on benches – trying to reflect corporate support without compromising the public park experience.  Recently the city had its first ‘naming’ request and is learning the importance of a program and policies to recognize donors.  More requests are coming, too, from promoters, regarding events in the park that can provide value to both to themselves and the city.

A Business Model Taking Shape
The LA Parks Foundation is small.  They currently have two half time employees who provide help with bookkeeping, communications, the website and membership.  Judith herself works three quarter time.  And this year, a new full time project manager has been hired which they share with the department.

They share that staffer with RAP so both can take advantage of his expertise.  RAP, like many other city park departments across the nation, has seen both cutbacks (30% of their operations budget in the last 4 years) and the retirement of some of its most seasoned staffers.

“Typically we don’t do fundraising for city staffing – this has been a baseline issue for us.  As much as we work well with the department, we know we can’t underwrite their staffing.  We try to be sensitive about the best place we can provide value.”

The Foundation has just crossed the $6.5 million level in fundraising since 2008.  They have exceeded their budget every year since forming as the community embraces the idea of a private entrepreneurial partner committed to the city and its goals for parks.  Their success is linked to a 15-member board that uses its own gifts to leverage more – their giving provides a floor for the Foundation’s operations.  When the Foundation takes on a larger role in construction projects, they work with donors and the city on support for their administrative efforts.

“I also needed to understand and see how the city worked in order to figure out how we could work together,” said Judith. There are no weekly staff meetings between the two organizations, but Judith is talking all the time with the department, and she is out in the parks – a lot.  She also attends meetings with park advisory boards, other city departments, city council members and potential donors.

“We team up all the time and represent each other as needed on the same mission. This integrating of our resources around a common mission has absolutely been the key ingredient to our success.”  The City now embraces the partnership and sees how the Foundation can serve the department – and the staff sees it as a tool for them to have more success around their initiatives. “Everything we do is collaborative; we are hand in glove to get where we need to be.”

As the organization grows and takes on additional projects with the city and with friends of the parks groups around the city, they are looking more thoughtfully at their own future.  “We have always had an annual strategic plan which we revisit regularly with the board.  We are poised for a longer term view to help us identify where the next growth spurt will come from.  The fact that we have exceeded our budget expectations every year – that’s a good sign.”

Lessons learned?  “It was so critical that I work very carefully and slowly to integrate the foundation into the city system; building good relations with the city was key.  We slowly built trust as a reliable partner who wanted to work on their behalf – because the city can take money from donors and offer tax benefits without a foundation.  But RAP knew that money was being left on the table by donors not comfortable with giving money to the city for any number of reasons.”

Los Angeles already has a library and a police foundation.  The LA Parks Foundation is the third of its kind, and one more example of the importance of a private partner playing the role of a go-between, adding value with its flexibility and business-like approach.

Kathy Blaha writes about parks and other urban green spaces, and the role of public-private partnerships in their development and management. When she’s not writing for the blog, she consults on advancing park projects and sustainable land use solution

Write a program which iterates from 0 to 100 and does one of the following:

1. Prints out “Fizz” if the number is divisible by 3
2. Prints out “Buzz” if the number is divisible by 5
3. Prints out “Fizz Buzz” if the number is divisible by 3 and 5

You should put this operation in its own function.

Code:

Function Modulo(a, b)
    Modulo = a - (b * (a \ b))
End Function

Public Sub FizzBuzz(n as Integer)
   Dim i as Integer
   For i = 0 To n
      If Modulo(i, 5) = 0 And Modulo(i, 3) = 0 Then
         MsgBox("Fizz Buzz")
      Else If Modulo(i, 3) = 0 Then
         MsgBox("Fizz")
      Else If Modulo(i, 5) = 0 Then
         MsgBox("Buzz")
      End If
   Next
End Sub

Topics to include Treatment-Free Models, Bee Breeding, Queen Rearing, Langstroth Management, Top Bar Hive Management, Honeybee Microbes, Flower Nectaries, and more!

Write a program which iterates from 0 to 100 and does one of the following:

1. Prints out “Fizz” if the number is divisible by 3
2. Prints out “Buzz” if the number is divisible by 5
3. Prints out “Fizz Buzz” if the number is divisible by 3 and 5

You should put this operation in its own function.

Code:

def fizzbuzz(n)
   for i in (0..n)
      if i % 5 == 0 and i % 3 == 0
         puts "Fizz buzz!"
      elsif i % 3 == 0
         puts "Fizz!"
      elsif i % 5 == 0
         puts "Buzz!"
      end
   end
end

fizzbuzz(101)

This is a tricky problem.  The first tricky part is figuring out an efficient way to store the dictionary so that we can quickly identify whether a particular substring is a prefix of a word in the dictionary.  This is a well-studied problem, and the right data structure is a trie.  Suppose we’re working with a small dictionary containing the words a, aac, acb, baa, bbc, bc, caba, caab.  We’ll start our trie with an empty node, and then keep adding words until we’re finished.  We start by adding the word a.  We link a node with the letter a to the root, and then link a marker node to that to show that this is the end of a word.

Next, we’ll add in the word aac. We already have the letter a linked to the root, so we go there and add more letters to that node.

And we repeat this until all the words are in the tree. For each letter in the new word, if that letter is already a child of the current node, we walk to that child. If not, we create a new child. Once we’re at the end of the word, we add a marker child to the last node denoting the end of the word. After we’re finished with our small dictionary, we end up with this:

Each of the red nodes marks the end of a word, so we can see that we have all eight words in the trie.

Now that we have our data stored in an easily-accessible manner, let’s start with a simpler problem than the one asked.  Suppose that there was no garbling, just spaces removed, and we’re given some string, say, aacaabbc.  How can we use this structure to quickly find out whether this string could be divided up into words from our dictionary?  Start at the root of the tree and look at the first letter a of the string.  a is a child of our current node, so we’ll walk to that node and move to the next letter.  Here we see an end node as a child, marking that we’ve now finished a possible node.  So we know we can split off the word a from our string, leaving acaabbc behind.  This split will produce a valid word separation for the whole string if and only if acaabbc can itself be divided up into words from our dictionary.

First, though, we need to finish walking down and make sure we’ve found the only possible split.  The next letter is a, which is a child of our current node, so we move there.  This node has no end node as a child, so it’s not a possible word separation.  The third letter is c, which is a child of this node, so we’ll move there next.  This node is another word separation, giving us aac as the first word and aabbc as the remainder of the string.  There are no other children of this node, so these are the only possible word separations.

So we now know that aacaabbc is divisible into words if and only if at least one of its two suffixes acaabbc and aabbc are divisible into words.  This suggests that we might be able to use dynamic programming for our problem.  We can create an array of boolean variables telling us whether each suffix of our string can be divided into words.  We can look at the suffixes of our string in order of increasing size and calculate whether each of them is divisible.  The larger suffixes can then use the calculations previously done on the smaller suffixes to quickly calculate whether they themselves are divisible.

Starting with the smallest suffix, c, we quickly find that it is not a word, so we mark that index as False.  bc, the next smallest, so we mark it as True, and similarly for bbc.  abbc gives a potential split at a|bbc, and we know that bbc is True, so abbc must be True as well.  We then keep working backwards until we reach the beginning of the string, and then the final answer is simply the result in the first element of our array.  Doing this we quickly find that aacaabba is in fact divisible.

So this works for messages where there is no garbling at all.  Now let’s add the garbling in and see if we can work out a solution.  We’ll simplify the problem slightly, though, by allowing any character in the string to be garbled, ignoring the constraints on how close the garbled characters are allowed to be.  Suppose we have the string abbbcbba.  We can work backwards, just as before, from smaller to larger suffixes.  This time, though, instead of only storing whether or not a suffix is divisible into words, we’ll store how many changes are needed to make it divisible.

c alone, for instance, isn’t a word, but we can change it into a with a single substitution, so our answer is one.  The next two suffixes, bc and bbc, are both words, so they get values of zero.  cbbc isn’t valid, but if we swap it to abbc we can split it at a|bbc, giving us two valid words, for an answer of one.  We keep working backwards just as before, looking for all possible words we can construct at the start of our suffix, splitting it, and then putting the minimum changes required into our array.  Once we’re finished, the final answer is just the result in the first element of our array.  So we find that abbbcbbc can be made divisible with only a single character swap.

Finally, we want to incorporate the closeness requirements for our garbled characters – changes must have at least four non-garbled characters between them.  Now for each suffix we want to store five different values, giving the minimum changes required for this suffix when the first x characters are required to match perfectly, with x ranging between 0 and 4 inclusive.  Let’s look at this array for the string abbbcbba.

Here N is marking divisions that are not possible at all.  Otherwise, we fill the array with the number of changes required.  Again, let’s start at the back and move towards the front of the string.  a, the last suffix, is a word itself, so we fill its column with zeros.  ba is not a word, but could be divisible if we change one of the characters, to either bc or a|a.  The bottom three rows require us to keep the first two characters unchanged, so those entries are marked as N.  Both of the top two are possible with only a single change.  bba is valid only if changed into bbc, which requires no more than two characters held unchanged, so we mark up the column appropriately.  We continue in the same manner, looking for potential word divisions and marking down the minimum changes required that allow the required distance between changes.  Then, just as with the simpler problems, we read off our final answer as the entry in the first column and the first row.  

def precalculate():
    #We're going to load the dictionary into a trie
    global tree
    global end
    tree = {}
    end = ''

    def add_branch(tree, word):
        for char in word:
            if not char in tree:
                tree[char] = {}
            tree = tree[char]
        tree[end] = True

    infile = open('./garbled_email_dictionary.txt')
    for line in infile.readlines():
        add_branch(tree, line.strip())
    infile.close()

def match_words(S, prefix, index, required):
    suffix = S[index:]

    #Walk down the tree to find the right branch
    branch = tree
    for char in prefix:
        branch = branch[char]

    if suffix == '':
        if end in branch:
            return 0
        else:
            return -1

    def check(best, new, inc=0):
        if new == -1:
            return best
        if best is None:
            best = new + inc
        else:
            best = min(best, new + inc)
        return best

    best = None

    char = suffix[0]
    if char in branch: #valid match
        if end in branch[char]: #end of a word
            best = check(best, mincosts[index + 1, max(0, required - 1)])
        best = check(best, match_words(S, prefix + char, index + 1, max(0, required - 1)))
    if required == 0:
        for this in branch:
            if this == end or this == char:
                continue
            if end in branch[this]:
                best = check(best, mincosts[index + 1, 4], 1)
            if best is None or best > 1: #Don't bother checking if best is already good enough
                best = check(best, match_words(S, prefix + this, index + 1, 4), 1)

    if best is None:
        return -1
    else:
        return best

def solve_case(S):
    global mincosts

    mincosts = np.zeros((len(S) + 1, 5), dtype=int)

    for index in range(len(S))[::-1]:
        for required in range(5):
            mincosts[index, required] = match_words(S, '', index, required)
    return mincosts[0,0]

Write a program which iterates from 0 to 100 and does one of the following:

1. Prints out “Fizz” if the number is divisible by 3
2. Prints out “Buzz” if the number is divisible by 5
3. Prints out “Fizz Buzz” if the number is divisible by 3 and 5

You should put this operation in its own function.

Code:

def fizzbuzz(n):
   for i in range(n):
      if i % 5 == 0 and i % 3 == 0:
         print "Fizz Buzz"
      elif i % 3 == 0:
         print "Fizz"
      elif i % 5 == 0:
         print "Buzz"
fizzbuzz(101)

Write a program which iterates from 0 to 100 and does one of the following:

1. Prints out “Fizz” if the number is divisible by 3
2. Prints out “Buzz” if the number is divisible by 5
3. Prints out “Fizz Buzz” if the number is divisible by 3 and 5

You should put this operation in its own function.

Code:

#include <stdio.h>

void fizzbuzz(int n) {
   int i;
   for (i = 0; i < n; ++i) {
      if (i % 5 == 0 && i % 3 == 0) {
         printf("Fizz Buzz!\n");
      }
      else if (i % 3 == 0) {
         printf("Fizz\n");
      }
      else if (i % 5 == 0) {
         printf("Buzz\n");
      }
   }
}

int main(void) {
   fizzbuzz(101);
   return 0;
}

Meet us at the Fenway Victory Gardens from 12:30-3pm for Picnic Inflation!

Write a sub-routine which displays the text, “Hello, World”, in a message box to the user.

Code:

Public Sub Hello()
   MsgBox("Hello, World!")
End Sub

Write a program to write the string literal, “Hello, World”, to the terminal or standard output location. This should be completed in one line.

Code:

puts "Hello, World"

Write a program that displays the string literal, “Hello World”, to the terminal or standard output location. This program should consist of only a single line.

Code:

print("Hello, World")

Write a C program to output the string literal, “Hello, World”, to the standard output location.

Code:

#include <stdio.h>

int main(void) {
   printf("Hello, World!\n");
   return 0;
}

Write a program in C++ which simply outputs the string literal “Hello, World” to standard output.

Code:

#include <iostream>

int main() {
   std::cout << "Hello, World" << std::endl;
   return 0;
}

Here i decided to create an array with all the possibilities and use a counter to go throught them, then with a for loop, check if the first[i] and second[i] are equal, if they are, then put in the result the same, and if not check if the elements in the array are != to first[i] and second[i], then add the other possibilitie to the result. At the end of each iteration of the for loop, increment the counter +3.

Here the problem statement:

You are playing a game in which you have to find sets of three cards that share certain characteristics. Each card has some symbols on it. Each symbol is either a circle, a squiggle, or a diamond. Each symbol is either colored blue, red, or green. Each symbol is either solid, striped, or empty. And finally each card has either one, two, or three occurrences of the same symbol. A set is formed by three cards, and each characteristic is either the same on all three cards or different on all three cards.

For example, a card with one solid blue diamond, a card with two solid green diamonds, and a card with three solid red diamonds all form a set. The symbols on each card have the same shape and the same shading, and none of the cards has the same number or the same color. Any two cards will form a set with exactly one other card. You want to know, given two cards, what is the other card that completes the set. Create a class Matching with a method findMatch that takes two string[]s, first and second, representing the characteristics of two cards, and returns a string[] representing the characteristics of the third card.

first and second will both contain exactly four elements. The first element of each will denote the shape of the symbols on the card and will be either “CIRCLE”, “SQUIGGLE”, or “DIAMOND”. The second element will denote the color and will be either “RED”, “BLUE”, or “GREEN”. The third element of each will denote the shading and will be either “SOLID”, “STRIPED”, or “EMPTY”. The fourth element of each will denote the number of symbols, and will be either “ONE”, “TWO”, or “THREE”. The return element should contain exactly four elements, and should follow the same format as the input. 

Here my code:

public class Matching
    {
        public string[] findMatch(string[] first, string[] second)
        {
            string[] temp1 = { "DIAMOND", "CIRCLE", "SQUIGGLE", "GREEN", "BLUE", "RED", "SOLID", "EMPTY", "STRIPED", "ONE", "TWO", "THREE" };
            string[] res = new string[4];
            int index = 0;
            for (int i = 0; i < first.Length; i++)
            {
                if (first[i] == second[i])
                    res[i] = first[i];
                else
                {
                    for (int a = index; a < temp1.Length; a++)
                    {
                        if (temp1[a] != first[i] && temp1[a] != second[i])
                        {
                            res[i] = temp1[a];
                            break;
                        }
                    }
                }
                index += 3;
            }
            return res;
        }
    }

If you have another approach, please share with me in a comment!

Thank you very much