Growth Mindset, Fixed Mindset, And Problem-Solving Algorithms

The following course learning outcomes are assessed by completing this assessment:
• K1. Explain fundamental strategies for problem solving
• K2. Relate goal-setting and plan formulation to problem solving
• K3. Compare and contrast commonly used problem solving strategies
• K4. Describe tools and techniques that can be used to model and describe problems
• K5. Describe the value of reflection, attitude and self-efficacy towards success in problem solving
• S1. Decompose a problem and create goals and plans to solve that problem
• S2. Devise and implement problem solving strategies which can be applied to a range of IT problems
• S3. Develop and verify algorithms based on conceptual models used in programming
• S4. Construct documentation describing how to solve a problem
• A1. Apply problem solving strategies, tools and techniques to solve problems in a variety of domains

The Concept of Growth Mindset and Fixed Mindset

The video describes about the growth mindset of the people. A great focus has been given on the comparison between growth mindset and fixed mindset. In the video the speaker describes the growth mindset claim that failure after all is not actually a failure in a sense. It is in fact establishment of the fact that it is one of the process that would not hence, the individual can reach the success state a little quick after the establishment of the fact.

How this applies / does not apply to you

The speaker also describes about the fixed mindset that stops a person from growing. The fixed mindset arises when a person thinks that there is nothing more to achieve or he cannot go further than he has gone right now. This has helped me in a great way.

The impact this has on you

The story about the chess player has inspired me a great deal and helped me realize that there are many fields in which I cannot excel and hence I choose the field of education and I am planning to try hard and excel at this field.

Measures	0.38	0.27	0.3	0.05	1
Percentage	38%	27%	30%	5%	100%
Option	Protein	Fat	Carbohydrate	others	Score
Omlette	6	3	8	5	5.74
Chicken Stew	10	2	6	7	6
Chicken salami	10	10	5	8	8
green vegetables	9	10	9	9	9.27
vegetable soup	9	10	7	5	8.47
Pizza	3	1	8	6	4.11
Chicken Burger	5	2	7	7	4.89
Potato chips	0	0	7	9	2.55

The best option is the one that has the highest score that is obtained by the analysis. The excel will provide the value of the best option.

Each and every solution to the problem starts with a plan to provide the solution to the plan. For example we can consider the problem of Pick and Plant. In the problem a rabbit starts at 0, 0 on a graph with no carrots in its mouth. Now, the carroty is located at (3, 2) on the graph that is two dimensional. The only solution to the problem is that the rabbit reaches the point 3, 2 on the graph.

The carrot is exactly three spaces ahead of the rabbit.

The Rabbit is to finish in the 3,2 position.

At first we are required to develop a matrix and the place the carrot in a 2D matrix. After the matrix have been developed we need to initialize an element as the rabbit and also the place it on 0, 0 the algorithm stop when the element reaches the carrot.

The Scenario that is to be assumed is that of the book borrowing system. An individual borrows a book required by him from a store and the store stores the data of borrowing in the system. While returning the book the borrower makes the payment or rent of the book.

The Impact of Growth Mindset and Fixed Mindset

The most trivial solution to this problem would be to run over the full range of years and months and create a date object to retrieve the actual day of week to count all Sundays. The following algorithm would give the solution to us.

function solution() {

  int n = 0;

  for (int y = 1901; y <= 2000; y++) {

    for (int m = 0; m < 12; m++) {

      if (new Date(y, m, 1).getDay() === 0) {

        n++;

      }

    }

  }

  return n;

}

However after analysis of the solution it was found that the solution could be solved faster and hence the following formula could be incorporated into our solution.

h= (q+⌊13(m+1)5⌋+K+⌊K4⌋+⌊J4⌋−2J)mod7=(q+⌊13(m+1)5⌋+K+⌊K4⌋+⌊J4⌋+5J)mod7

Here,

h is the day of the week (0 = Saturday, 1 = Sunday, 2 = Monday, ..., 6 = Friday)

q is the day of the month

m is the month (3 = March, 4 = April, 5 = May, ..., 14 = February)

K the year of the century

J is the zero-based century

Hence, the modified solution is:

function solution() {

  int n = 0, dow = 2;

  int months = [31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

  for (int y = 1901; y <= 2000; y++) {

    months[1] = 28 + (y % 4 === 0 && y % 100 !== 0 || y % 400 === 0);

    for (month = 0; months < = month; month ++) {

    dow+= month % 7;

    if (dow % 7 === 0) {

        n++;

      }

    }

  }

  return n;

}

If we know the first day, adding 7 days results in the same day of week and so on. As we go not day by day, but add the number days per month, we progress much faster. However, since we have 7 days per week and we're interested in one day exactly (Sunday), we sum under the modular congruence modulo 7. The formula implemented here was (d+m) = (d mod 7 + m mod 7) (mod 7).

For the Noughts and crosses we assume that the computer is the second player and second player should never loose. The following algorithm can be implemented for the solution to this problem.

determineNextMove(currentStateOfBoard)

    currentBestMove= null

    currentBestScore= - veryLargeNumber

    for each legalMove

        score=getFutureScoreOfMove(stateOfBoardAfterLegalMove , AI’sMove)

        if score>currentBestScore

            currentBestMove=legalMove

            currentBestScore=score

        end

    end

    make currentBestMove

end

getFutureScoreOfMove(stateOfBoard, playersTurn)

    if no LegalMoves

       return 1 if Computer wins, 0 if draw, -1 if user wins

Problem-Solving Algorithm: Pick and Plant

    end

    if playersTurn=Computer’sTurn

        currentBestScore= - veryLargeNumber

    else

        currentBestScore= + veryLargeNumber

    end

    for each legalMove

        score=getFutureScoreOfMove(stateOfBoardAfterLegalMove , INVERT playersTurn)

        if playersTurn ==Computer’sTurn AND score>currentBestScore

           currentBestScore=score

        end

        if playersTurn ==Users’sTurn AND score<currentBestScore

           currentBestScore=score

        end

     end

     return currentBestScore

end

With the implementation of this pseudo code the computer would be able to detect the next legal move of the computer, the next legal move of the user and visualize the board after the next rounds.

This is where the computer gets better of the human. These type of visualization would not be possible for human and human might play a wrong move and loose.

Let there be six spies with names A,B, C, D, E and F having information a, b, c. d, e, f. Hence, a number of rounds are required for the spies. The two tables below can be used to find out the number of meetings required by the spies.

Round1	A meets B	C meets D	E meets F
Round 2	A meets D	B meets E	C meets F
Round 3	A meets C	B meets F	D meets E

	A Knows	B knows	C knows	D Knows	E knows	F knows
Round 1	a,b	a,b	c,d	c,d	e,f	e,f
Round 2	a,b,c,d	a,b,e,f	c,d,e,f	a,b,c,d	a,b,e,f	c,d,e,f
Round 3	a,b,c,d,e,f	a,b,c,d,e,f	a,b,c,d,e,f	a,b,c,d,e,f	a,b,c,d,e,f	a,b,c,d,e,f

Hence, after the three rounds all the spies can know all the information.

The algorithm provided below would provide the solution for Sudoku. The strategy is checking the grid. In the checking process the grid is used for evaluation if the grid is correct the machine makes the traversals and then prints the values of the travels and provides the correct result to the users.

#include <stdio.h>

#define N 9

#define UNASSIGNED 0

int is_exist_row(int grid[N][N], int row, int num){

for (int col = 0; col < 9; col++) {

if (grid[row][col] == num) {

return 1;

}

}

return 0;

}

int is_exist_col(int grid[N][N], int col, int num) {

for (int row = 0; row < 9; row++) {

if (grid[row][col] == num) {

return 1;

}

}

return 0;

}

int is_exist_box(int grid[N][N], int startRow, int startCol, int num) {

for (int row = 0; row < 3; row++) {

for (int col = 0; col < 3; col++) {

if (grid[row + startRow][col + startCol] == num) {

return 1;

}

}

}

return 0;

}

int is_safe_num(int grid[N][N], int row, int col, int num) {

return !is_exist_row(grid, row, num)

&& !is_exist_col(grid, col, num)

&& !is_exist_box(grid, row - (row % 3), col - (col %3), num);

}

int find_unassigned(int grid[N][N], int *row, int *col) {

for (*row = 0; *row < N; (*row)++) {

for (*col = 0; *col < N; (*col)++) {

if (grid[*row][*col] == 0) {

return 1;

}

}

}

return 0;

}

int solve(int grid[N][N]) {

int row = 0;

int col = 0;

if (!find_unassigned(grid, &row, &col)){

return 1;

}

for (int num = 1; num <= N; num++ ) {

if (is_safe_num(grid, row, col, num)) {

grid[row][col] = num;

if (solve(grid)) {

return 1;

}

grid[row][col] = UNASSIGNED;

}

}

return 0;

}

void print_grid(int grid[N][N]) {

for (int row = 0; row < N; row++) {

for (int col = 0; col < N; col++) {

printf("%2d", grid[row][col]);

}

printf("n");

}

}

int main() {

int grid[N][N] = {{0,0,0, 0,0,3, 2,9,0},

 {0,8,6, 5,0,0, 0,0,0},

 {0,2,0, 0,0,1, 0,0,0},

 {0,0,3, 7,0,5, 1,0,0},

 {9,0,0, 0,0,0, 0,0,8},

 {0,0,2, 9,0,8, 3,0,0},

 {0,0,0, 4,0,0, 0,8,0},

 {0,4,7, 1,0,0, 0,0,0}};

if (solve(grid)) {

print_grid(grid);

} else {

printf("no solution");

}

return 0;

}

With the above algorithm the computer can find out the errors in the initial grid at first evaluation but the humans would be inefficient in this aspect as it is very easy to traverse through the grid with the help of a for loop but in case of a manual process it takes up a long time and involves the use of trial and error methods.

Cagan, J., & Kotovsky, K. (2015). Robust Decision Making: The Cognitive and Computational Modeling of Team Problem Solving for Decision Making under Complex and Dynamic Conditions. CARNEGIE-MELLON UNIV PITTSBURGH PA.

Goetsch, D. L., & Davis, S. B. (2014). Quality management for organizational excellence. Upper Saddle River, NJ: pearson.

Kaydalova, A. V., & Kanzh, B. M. (2014). Problem solving and decision making.

Schoenfeld, A. H. (2014). Mathematical problem solving. Elsevier.