Project Euler - Largest prime factor

The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?
https://projecteuler.net/problem=3

public class LargestPrimeFactor
    {
        List factorsList = new List();
        bool isPrime = true;
         
        public long FactorNumber(long number)
        {
            double sqroot = Math.Sqrt(number);
            for (long i = 1; i < sqroot; i++)
            {
                if (number % i == 0) 
                {
                    for (long j = 2; j < i; j++)
                    {
                        if (i % j == 0) 
                        {
                            isPrime = false;
                            break;
                        } 
                    }

                    if (isPrime == true) 
                    {
                        factorsList.Add(i);

                        bool secondaryIsPrime = true;
                        for (int k = 2; k < (number / i); k++)
                        {
                            if ((number / i) % k == 0) 
                            {
                                secondaryIsPrime = false;
                                break;                            
                            } 
                        }
                        if (secondaryIsPrime == true) factorsList.Add(number / i);
                        secondaryIsPrime = true;
                    } 
                    isPrime = true;
                } 
            }

            factorsList.Sort();
            long[] factorsArray = factorsList.ToArray();
            return factorsArray[factorsArray.Length - 1];
        }
    }

My comments: So, this was a very interesting problem to do. Solving the problem for small numbers took me about 2 minutes. HOWEVER, realizing that my computer was brute forcing it and trying to deal with the larger number and NOT coming to a solution withing a reasonable time (10+ mins is about when I gave up on waiting) made me realize I needed to change how it was working. By making it iterate fewer times the brute force gives a "instant" answer if you only have to iterate up to the square root of the number in question. So for example, let's say we have a number 64. The square root is 8. So we can iterate only up to 8 and find out that 1, 2, 4, and 8 are the only factors.. and we can get the other side of the factor by diving the number (64) over those 4 values. So we know that 1 goes with 64, 2 goes with 32, 4 goes with 16, and 8 goes with 8.. and then from there we can only take the ones of those that are prime. As opposed to just iterating from 1 to n, which takes a very very long time and is extremely inefficient.

Good practice: Abstract class vs. Interface

Abstract class: Like a Noun! A group of similar things you can group together with one word. Can have implementation of methods and/or declared non-implemented methods. May or may not include abstract methods. However, if you have an abstract method, it does have to be inside of an abstract class (Got it? Just like rectangle is a square, but square is not a rectangle). A non-abstract class derived from an abstract class (abstract class itself cannot be instantiated) must include actual implementations of all inherited abstract methods and accessors.

Abstract Class Example

    abstract class Pokemon
    {  
        // Properties
        protected int myLevel;
        public abstract int Level {get; set;}
        
        // Going to make this an abstract int just to show the difference
        protected int myHP;
        public abstract int HP {get; set;}

        // Can have methods that are DECLARED but NOT IMPLEMENTED
        abstract public int HPCalculator();

        // Can have methods that are IMPLEMENTED. These two are also NON-ABSTRACT
        public int Attack()
        {
            return enemyHP - attackDamage;
        }     
               
        public int Heal(object potion)
        {
            return myHP + potionAmount; 
        }
    }    

    class Pikachu : Pokemon
    {
        public override int Level
        {
            get 
            {
                return myLevel;
            }
            set 
            {
                myLevel = value;
            }
        }

        public override int HP
        {
            get 
            {
                return myHP;
            }
            set 
            {
                myHP = value;
            }
        }

        public override int HPCalculator()
        {
            return Level * 5;
        }
    }

    static void Main(string[] args)
    {
        // You can nickname your Pikachu! Let's call him KetchumChu.
        Pikachu KetchumChu = new Pikachu();
        
        // Set Level property
        KetchumChu.Level = 34;

        // His HP is going to end up being 34*5 = 170 HP.
        KetchumChu.HP = HPCalculator();

        // BATTLE!!! 
        KetchumChu.Attack();
        KetchumChu.Heal(purplePotion);
    }

Interface: Like a Verb (Action)! Things that your class can do. The whole Interface must be implemented in the classes that implement it, you cannot pick an choose pieces you have to take the whole thing (all or nothing!)

Bare minimum blueprint instructions of what has to be inherited at a minimum. NO IMPLEMENTATION. You want a house? You need a floor, 4 walls, and a roof. You do have to implement every single thing mentioned in the interface. So don't put a chimney and fireplace in your interface if you live in Florida.

Interface Example:

interface IAmCuteInterface
{
    // These are DECLARED but NOT IMPLEMENTED in the interface.
    void MakeCuteFace();
}

interface IAmThunderTypeInterface
{
    // These are DECLARED but NOT IMPLEMENTED in the interface.
    void Thundershock();
}

// this new class can implement as many interfaces as it wants!! You HAVE TO implement everything from both interfaces now. 
class Pikachu : IAmCuteInterface, IAmThunderTypeInterface
{
    // Explicit interface member implementation:  
    void IAmCuteInterface.MakeCuteFace()
    {
        // Method implementation.
    }

    void IAmThunderTypeInterface.Thundershock(object potion)
    {
        // Method implementation. Zzzzzap. 
    }

    static void Main()
    {
        // Declare an interface instance.
        Pikachu KetchumChu= new ImplementationClass();

        // Using the thundershock method. 
        KetchumChu.Thundershock();

        // Cheeky ain't he?
        KetchumChu.MakeCuteFace();
    }
}

Don't put in extra stuff that some things will need and other won't, put in things that you know every single thing would need. For a car to work.. you need tires, an engine, and brakes. Don't add an electric motor to your IDriveable, you don't have to have an electric motor. You can specify that later. You know you don't want to ever instantiate a "car" as no one really has just "generic car" they have their Ford Mustang, Tesla, Corvette, whatever.

You can inherit many interfaces! As many as you like! You can make many separate interfaces for different components and inherit what you need out of it. Let's say we have multiple interfaces.. one each for hands, feet, head, ears, fur, tail, scales, wings:

• Lizard implements hands, feet, head, tail, scales
• Cat implements hands, feet, head, ears, fur, tail
• Bird implements feet, tail, and wings
• Fire breathing dragon implements hands, feet, head, ears, tail, scales, wings

Summary: You use abstract classes and interfaces to add functionality, increase code re-useability/reduce repetitive code, and streamline functionality. Yes you could avoid using these completely, but your code would eventually get very repetitive and you will find yourself doing a lot of extra and unnecessary work. Don't put in extra stuff into either, just the bare minimum that has to fit into whatever inherit/implements the abstract class/interface. If you find yourself wanting to only take pieces of an abstract class or an interface, try breaking them up into difference classes/interfaces, there was probably a better way to design (plan ahead :) ?). Use an abstract class as a base when you are making many similar things that you can group together (i.e. mammals) and use interfaces (as many as you want!) for small functional parts.

Takeaway from examples: Based on my example.. Pokemon makes a great base class. Every type of Pokemon from Pikachu to Charizard will have HP and be able to Attack() and can Heal(). However, NOT every Pokemon is considered cute or a thunder type.. so these make great Interfaces. Some Pokemon are BOTH cute and thunder type like Pikachu and thus can inherit both interfaces. Pikachu can take the one base class Pokemon, plus both interfaces as seen below:

class Pikachu : Pokemon, IAmCuteInterface, IAmThunderTypeInterface

Project Euler - Sum Even Fibonacci

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.
https://projecteuler.net/problem=2

public class EvenFib
    {
        int oldi, fibNum, oldNum = 0, newNum = 1;

        List sequenceList = new List();

        public int Solve()
        {
            for (int i = 1; i < 100; i++)
            {
                if (i == 1) fibNum = 1;
                else
                {
                    fibNum = oldNum + newNum;
                    oldNum = newNum;
                    newNum = fibNum;
                }

                if (fibNum > 4000000) i = 100;
                else 
                {
                    Console.WriteLine(fibNum);
                    if(fibNum % 2 == 0)sequenceList.Add(fibNum);
                }
            }

            Console.WriteLine("The sum of the even numbers is: " + sequenceList.Sum());

            return sequenceList.Sum();
        }
    }

The answer is: 4613732

React JS - Lifecycle and Overview

React JS is a JavaScript library put out by Facebook. I highly recommend taking advantage of using their .JSX files and using their shortcuts and possibly using the Sublime text editor (which has a great free version you can utilize). I will try and share my working knowledge of React JS in hopes it will clear up some things and that I can give someone a basic understanding and "English translation" with practical reasons on using it. This was very different from traditional web layouts and can be hard at first, but you will get used to it! It is very different from a static normal HTML page using CSS and that has some scripts hooked into it. React gives you an entire way to re-design your page around it. You essentially smash all of your HTML and JavaScript together into one JSX file.. call classes from your CSS for styling, and you can most certainly utilize jQuery and other plugins (datetime JS, Charts JS, etc etc..) inside of it. There may be some challenges in working with other plugins because they may work more linearly, and React JS follows a lifecycle with extreme conformity to it, and you have to work everything else around this lifecycle (this, by far, is the most complicated part of using React). This is an extremely long tutorial and will give you all of my experience in using React JS.

React is all about Components. You will build components and put your site together out of these. Think of a component like a reusable block.. maybe even like Minecraft. Minecraft is made entirely out of little blocks. Well, your site too can be made entirely out of little Components (blocks). You have to make a website (Minecraft creation) and it needs things like forms, category drop downs, admin tools, etc (Minecraft grass, wood, trees, etc) so you make ONE form component that has your whole form.. so you build that carefully.. and then whenever you need that form again, all you have to do is place that component in the new spot. So its like making a reusable stamp, or Minecraft block that can be used over and over again and will have the same functionality. By the way.. if you have Razer and model ViewBags and such on your page.. say bye bye to those.. React JS will replace those with its own faster methods of getting data.

The render function is the only REQUIRED function and is essentially the html you will put on your page. Each component can only return (in its render function) one main section/div/container of some kind with many others inside of it (basically.. you HAVE to wrap all your stuff in one bigger container) so React can handle it properly. This is the example off the the React JS main page:

var HelloMessage = React.createClass({
  render: function() {
    return 
Hello {this.props.name}
;
  }
});

React.render(, mountNode);

The actual component is called HelloMessage here. You can see where the component is used like a stamp/Minecraft block here (think of the part putting a whole component name into brackets as the "stamp" that calls this reusable thing):

Reusability! Not only that, but there's flexibility. You can note that there is a "name" property here. You can pass in different things. This is where you want to be careful when constructing your component/stamp/Minecraft block to be as general as you need it and to take in different types of values for properties and be able to deal with it. Passing in functions or values for properties gives you flexibility to utilize or turn on/off features in React.

Let me give you a more practical example of this as a dashboard component example. High level: You have a dashboard and it has a bunch of chart widgets on the dashboard. Dashboard = mommy component. Little charts = individual little baby components. Little baby components only are on the page because dashboard exists, and they can get information (genetics???) from their parent. There will be a parent MyDashboard component which adds child ChartWidget components onto the page. The parent MyDashboard will do an API call to get the attributes of the child (for ex. id/name, size, order etc) Each child component is responsible for its own contents, so based on the id/name its grabbed by from the parent, it will know its identity and do its own API call to get its data (chart or whatever functionality you want). I have taken out much of the nitty gritty functionality of this code to simplify the example and replaced everything with very generic info for the sake of the example.

This is the parent MyDashboard component:

/** @jsx React.DOM **/

var MyDashboard = React.createClass({
    getInitialState: function(){
        return {
            Charts: []
        };
     },
     componentDidUpdate: function(){
         // The debugger statement will let you hit the break point on the browser's developer tools. VERY USEFUL. 
         debugger;
    
         // Just some if else logic to deal with the multiple re-renders
         if (this.initialSetup === true){
            this.funFunction();
            this.initialSetup = false;
         }

         if (this.rerenderCharts === true){
            this.funFunction();
            this.rerenderCharts = false;
         }
    
         if (this.resetCharts === true){
            this.rerenderCharts = true;
            this.resetCharts = false;
            this.forceUpdate();
         }
     },
    funFunction: function(){
        // Function work here
    },
    componentDidMount: function(){
        this.updateFunctions = {};
        this.resetCharts = false;
        this.initialSetup = true;

        // Most of your initial API calls for loading the page will go under componentDidMount 
        $.get('/api/YAYapi', {}, function(graphlist){
            var charts = graphlist.map(function(result){
                return (
                        
                );
             }.bind(this));
        // setting state will cause "charts" to be put into the state variable and then the page will re-render (hit the render function)
        this.setState({Charts: charts});
        }.bind(this));
    },
    render: function(){
        return (
            

                

                    
                         Add Chart
                    
                            
                                Chocobos
                                Moogles
                            
                        
                    
                
                

                    {this.resetCharts === false ? (
{this.state.Charts}
) : }
                
            
        );
    },
    handleAddChartOnClick: function(){
        // functionality for adding a chart
    },
    addWidgetObject: function(widgetName){
        var title = "";
        var type = "";

        // create widget object here 
    },
    resetToDefault: function(){
        this.resetCharts = true;
        this.childCallbacks = [];
  
        $.get('/api/stuff', {}, function(graphlist){
        var charts = graphlist.map(function(result){
       
        return (
            
        );
        }.bind(this));
            this.setState({Charts: charts});
        }.bind(this));
    }
});

The following is the child ChartWidget component:

/** @jsx React.DOM **/

var ChartWidget = React.createClass({
    getInitialState: function(){
         return {
             ChartData: {}
         };
     },
    componentDidMount: function(){
        var start = this.props.result.start;
        var end = this.props.result.end;
  
        if(this.props.result.DateSelection){
        var dates = this.getDatesFromRange(this.props.result.DateSelection);
        start = dates.StartDate;
        end = dates.EndDate;
        }
  
        this.getChart(start, end, this.props.result.ChartName, this.props.result.ChartType);
    },
    render: function(){
        if (this.props.result.DateSelection){
        var dateRange = this.props.result.DateSelection;
        this.getDatesFromRange(dateRange);
        }
        
        return(
        

            

                
{this.props.result.ChartTitle}
                    
                        1 day
                        10 days
                        100 days
                    
                
            

SQL Overview / Study Guide

A little bit about everything in SQL! This is more of a study guide/collection of resources for developers with some resources I think are very good. I will give a outline / light overview and show some online resources with great examples. Friends who are new to development are not sure sometimes what the scope is to know about SQL. I would put a heavy importance on the SQL SELECT, UPDATE, INSERT, DELETE and Joins/Unions for a beginner and the rest is also useful but are more specific to certain tasks and depends on what type of development you do (i.e. some companies use SSAS .. others don't.. same for T-SQL and stored procedures).

Most common things you will do: Queries.
Queries let you manipulate data by fetching pieces you need, changing data, deleting it, adding tables.. basically everything you would think to do in an Excel sheet to your data but this is how to use the SQL language to do the manipulating for you.
Every possible (almost?) type of SELECT with table examples: https://technet.microsoft.com/en-us/library/bb264565(v=sql.90).aspx
INSERT, UPDATE, and DELETE: https://msdn.microsoft.com/en-us/library/bb243852%28v=office.12%29.aspx

If you are new to SQL and used to programming.. keep in mind Strings for column values are in 'single quotes', not "double quotes"!!!!

Some more basics.. how to put data together:
Join: Make a new table out of 2+ tables by finding something in common to "join" on.. and you get to pick the columns you want the new table to have. There are different types of Joins that will determine if you return a table that has matches on all the tables (inner join) or you want to have all the matches on one table to the other one and nulls on the table without data to fill in (outer join). Let's say you have a Person table and an Address table. The Person table has a name and an Id. The address table also has the corresponding Id. You want all of the people's zip code. You would do a join to make a new table that joins on the Id and then now you have access to each person's zip code in a new table.
http://blog.codinghorror.com/a-visual-explanation-of-sql-joins/
Union: Grab all the columns you want to make the new table, and find something in common between the 2+ tables to "join" on.

View in SQL. Its a virtual table based on a query you made before that you can save and be able to access easily.
http://www.w3schools.com/sql/sql_view.asp

Normalization: This is basically a design pattern for your SQL tables so you can increase your efficiency over the long term. There are different forms of it. You want to tend towards 3NF at most places, but of course it depends on your system and what it's for / size / etc.
http://www.studytonight.com/dbms/database-normalization.php

Indexing: Think of a book index.. much easier to find what you're looking for in your textbook? Same thing in SQL databses, indexes help you find things quicker!
http://www.w3schools.com/sql/sql_create_index.asp

Primary Key: Guarantees the unique identifier of your table. You don't have to put one, physically.. but you should put one every single time in the case you need it (which is likely). Just make a rule, always make a primary key.
https://msdn.microsoft.com/en-us/library/ms179610.aspx Foreign Key: the key that references a column (usually primary key) of another table and keeps integrity of table.
http://www.dotnet-tricks.com/Tutorial/sqlserver/TENc260912-Difference-between-Primary-Key-and-Foreign-Key.html

Stored Procedures: Reuseable code or queries you can pass parameters into. Common practical use is for data validation (integrated into the database) or access control mechanisms
http://www.mssqltips.com/tutorial.asp?tutorial=161

T-SQL: stands for Transact SQL. I think of this as a plugin to SQL.. kinda like how jQuery is to JavaScript or having a GPS built into your car.. y'know.. cool extras. This lets you setup local variables, do if/else statement, other very very very useful things...
http://en.wikipedia.org/wiki/Transact-SQL

SSAS: This is relatively complex to setup, but not bad to use. Usually used with a HUGE HUGE amount of data that could not be handled otherwise by other means. You basically import all of your data from your site.. clicks by date, number of registrations, unique users, anything you like..! You make "cubes" out of them which has dimensions like dates, the mentioned variables (like clicks etc). You can filter your results. And then off to deploy a query which can be plugged into a chart or other form of display.
http://www.mssqltips.com/sqlservertutorial/2000/sql-server-analysis-services-ssas/

Great site to practice (free to register, and you can work on practical word problems where you have to enter the correct SQL query!): http://www.sql-ex.com/